Vitis AI 분석 — DPU·xmodel·VART

1
DPU = Deep Learning Processing Unit
2
- Xilinx의 IP block (RTL)
3
- FPGA fabric에 instantiate
4
- INT8 가속 (convolution, pool, FC, activation, ...)
5
- DPUCZDX8G: Zynq UltraScale+
6
- DPUCAHX8H: Alveo
7
- DPUCVDX8G: Versal

1
# PyTorch
2
from pytorch_nndct.apis import torch_quantizer
3

4
model = torchvision.models.resnet50(pretrained=True)
5
model.eval()
6

7
# input shape
8
input_shape = (1, 3, 224, 224)
9
dummy = torch.randn(input_shape)
10

11
# calibration
12
quantizer = torch_quantizer('calib', model, dummy, device='cpu')
13
quant_model = quantizer.quant_model
14

15
# calibration data 100~1000장 inference
16
for img in calib_loader:
17
    quant_model(img)
18

19
quantizer.export_quant_config()
20

21
# test mode로 다시
22
quantizer = torch_quantizer('test', model, dummy, device='cpu',
23
                            quant_config_file='quant_info.json')
24
quant_model = quantizer.quant_model
25

26
# verify accuracy
27
acc = evaluate(quant_model, val_loader)
28
print(f"Quantized accuracy: {acc}")
29

30
# export xmodel
31
quantizer.export_xmodel()

1
#include <vart/runner.hpp>
2
#include <xir/graph/graph.hpp>
3

4
int main() {
5
    // Load
6
    auto graph = xir::Graph::deserialize("compiled/resnet50.xmodel");
7
    auto subgraphs = graph->get_root_subgraph()->children_topological_sort();
8
    auto dpu_sg = std::find_if(subgraphs.begin(), subgraphs.end(),
9
        [](const auto *s) {
10
            return s->get_attr<std::string>("device") == "DPU";
11
        });
12

13
    auto runner = vart::Runner::create_runner(*dpu_sg, "run");
14

15
    // Input / output tensor info
16
    auto in_tensors  = runner->get_input_tensors();
17
    auto out_tensors = runner->get_output_tensors();
18

19
    // Allocate buffers
20
    int8_t *in_buf  = (int8_t*)malloc(in_tensors[0]->get_data_size());
21
    int8_t *out_buf = (int8_t*)malloc(out_tensors[0]->get_data_size());
22

23
    // Preprocess + load
24
    load_image("test.jpg", in_buf);
25

26
    // Run
27
    std::vector<vart::TensorBuffer*> ins  = { make_buf(in_buf, in_tensors[0]) };
28
    std::vector<vart::TensorBuffer*> outs = { make_buf(out_buf, out_tensors[0]) };
29
    auto job = runner->execute_async(ins, outs);
30
    runner->wait((int)job.first, -1);
31

32
    // Postprocess
33
    int top = argmax_int8(out_buf, 1000);
34
    printf("class %d\n", top);
35
}

1
import vart, xir
2
import numpy as np
3

4
g = xir.Graph.deserialize("compiled/resnet50.xmodel")
5
sg = next(s for s in g.get_root_subgraph().toposort_child_subgraph()
6
          if s.get_attr("device") == "DPU")
7
runner = vart.Runner.create_runner(sg, "run")
8

9
inputs  = [np.empty(t.dims, dtype=np.int8) for t in runner.get_input_tensors()]
10
outputs = [np.empty(t.dims, dtype=np.int8) for t in runner.get_output_tensors()]
11

12
inputs[0][:] = preprocess(img)
13

14
job = runner.execute_async(inputs, outputs)
15
runner.wait(job)
16

17
print("top:", outputs[0].argmax())

1
auto runner = vart::Runner::create_runner(dpu_sg, "run");
2

3
std::vector<std::thread> ts;
4
for (int i = 0; i < 4; i++) {
5
    ts.emplace_back([&]() {
6
        while (running) {
7
            auto img = queue_pop();
8
            std::vector<TensorBuffer*> ins{...}, outs{...};
9
            auto job = runner->execute_async(ins, outs);
10
            runner->wait(job.first, -1);
11
            result_push(outs);
12
        }
13
    });
14
}

1
from pytorch_nndct.apis import torch_quantizer
2
import torch
3

4
model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)
5
model.model[-1].export = True   # detect layer 분리
6

7
dummy = torch.randn(1, 3, 640, 640)
8
quantizer = torch_quantizer('calib', model, dummy)
9
quant_model = quantizer.quant_model
10

11
for img in calib_loader:
12
    quant_model(img)
13

14
quantizer.export_xmodel()

1
[CPU]  Preprocess (resize, normalize, BGR→RGB)
2
       ↓
3
[DPU]  Backbone, head (conv, pool, activation, ...)
4
       ↓
5
[CPU]  Postprocess (NMS, sigmoid, box decode)

1
ResNet-50 KV260:
2
1 thread: 150 fps, 6.6ms/frame
3
4 thread: 600 fps, 6.7ms/frame (latency 동일, throughput 4×)
4
8 thread: 750 fps, ~13ms (queue 적체)

1
quantizer = torch_quantizer('calib', model, dummy)
2
# WARNING: op 'LayerNorm' not supported by DPU → CPU subgraph

1
DPU: 6 ms inference
2
CPU: 20 ms preprocess + 10 ms NMS = 30 ms
3

4
total: 36 ms → 28 fps (DPU 6 ms는 의미 없음)