Modern Embedded Recipes · 142/152

ONNX Runtime 분석 — Execution Provider와 Cross-Platform 배포

2026년 4월 21일 · Hawk · 6분 읽기

#한 줄 요약

“ONNX는 모델 교환 format이고 ONNX Runtime은 Execution Provider 기반 inference engine입니다.” 같은 .onnx를 여러 backend에서 사용할 수 있지만 operator·version·EP 지원 범위와 graph partition을 확인해야 합니다.

#어떤 상황에서 쓰나

PyTorch 학습 → ONNX export → 다양한 device 배포가 가장 흔한 패턴입니다. 한 모델 file로 Windows ML, Linux GPU, macOS, Jetson, Android, iOS, embedded ARM 모두 가능합니다. TensorRT가 NVIDIA 전용이라면 ONNX Runtime은 cross-vendor 옵션입니다.

LLM serving (Phi, Llama via ONNX Runtime GenAI), audio model (Whisper), vision (YOLOv8) 모두 ONNX Runtime이 사실상 표준 deploy 옵션입니다.

#핵심 개념 — ONNX format

ONNX (Open Neural Network Exchange):

Protobuf 기반 그래프 representation
Operator set version (opset)
모델 = nodes (ops) + initializers (weights) + I/O

1
import torch
2

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

6
dummy = torch.randn(1, 3, 224, 224)
7
torch.onnx.export(model, dummy, "resnet50.onnx",
8
                  input_names=['input'],
9
                  output_names=['output'],
10
                  dynamic_axes={'input': {0: 'batch'},
11
                                'output': {0: 'batch'}},
12
                  opset_version=17)

resnet50.onnx 한 파일이 어디서나 동작.

#ONNX Runtime 기본

1
import onnxruntime as ort
2
import numpy as np
3

4
sess = ort.InferenceSession('resnet50.onnx',
5
                             providers=['CPUExecutionProvider'])
6

7
input = np.random.randn(1, 3, 224, 224).astype(np.float32)
8
out = sess.run(['output'], {'input': input})
9
print(out[0].shape)

C++:

1
#include <onnxruntime_cxx_api.h>
2

3
Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "test");
4
Ort::SessionOptions opts;
5
Ort::Session sess(env, "resnet50.onnx", opts);
6

7
std::vector<int64_t> shape = {1, 3, 224, 224};
8
std::vector<float> input(1*3*224*224);
9
auto mem = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
10
auto in_tensor = Ort::Value::CreateTensor<float>(mem, input.data(),
11
                                                  input.size(),
12
                                                  shape.data(), shape.size());
13

14
const char *in_name  = "input";
15
const char *out_name = "output";
16
auto outputs = sess.Run(Ort::RunOptions{}, &in_name, &in_tensor, 1, &out_name, 1);
17

18
float *out = outputs[0].GetTensorMutableData<float>();

#Execution Provider — Hardware별 backend

Provider	대상
`CPUExecutionProvider`	모든 platform, fallback
`CUDAExecutionProvider`	NVIDIA GPU
`TensorrtExecutionProvider`	NVIDIA + TensorRT (속도 ↑)
`DmlExecutionProvider`	DirectML (Windows GPU)
`CoreMLExecutionProvider`	Apple GPU/ANE
`OpenVINOExecutionProvider`	Intel CPU/GPU/NPU
`QNNExecutionProvider`	Qualcomm Hexagon
`NNAPIExecutionProvider`	Android NPU
`SnpeExecutionProvider`	Qualcomm SNPE
`ROCMExecutionProvider`	AMD GPU
`ACLExecutionProvider`	ARM Compute Library

같은 코드, provider만 바꿈:

1
# NVIDIA
2
sess = ort.InferenceSession('resnet50.onnx',
3
    providers=['TensorrtExecutionProvider', 'CUDAExecutionProvider', 'CPUExecutionProvider'])
4

5
# Apple
6
sess = ort.InferenceSession('resnet50.onnx',
7
    providers=['CoreMLExecutionProvider', 'CPUExecutionProvider'])
8

9
# Windows DirectX
10
sess = ort.InferenceSession('resnet50.onnx',
11
    providers=['DmlExecutionProvider', 'CPUExecutionProvider'])

Provider 순서대로 지원 op는 해당 provider, unsupported는 fallback.

#TensorRT EP — NVIDIA에서 최고 throughput

1
options = [
2
    ('TensorrtExecutionProvider', {
3
        'trt_fp16_enable': True,
4
        'trt_int8_enable': False,
5
        'trt_engine_cache_enable': True,
6
        'trt_engine_cache_path': './trt_cache',
7
    }),
8
    'CUDAExecutionProvider',
9
    'CPUExecutionProvider',
10
]
11
sess = ort.InferenceSession('model.onnx', providers=options)

첫 호출에 TensorRT가 engine을 build (수분), 이후는 cache에서 load. TensorRT 직접 쓰는 것 대비 약간 overhead. 편의성 vs 약간의 성능.

#CoreML EP — Apple Silicon

1
sess = ort.InferenceSession('model.onnx',
2
    providers=[('CoreMLExecutionProvider', {
3
        'COREML_FLAG_USE_CPU_ONLY': False,
4
        'COREML_FLAG_USE_NPU': True,
5
    })])

ANE (Apple Neural Engine)에 자동 dispatch. M2/M3 Mac에서 ResNet-50 ~1ms.

#QNN EP — Qualcomm Hexagon

1
sess = ort.InferenceSession('model.onnx',
2
    providers=[('QNNExecutionProvider', {
3
        'backend_path': '/path/to/libQnnHtp.so',
4
    })])

Snapdragon 디바이스의 Hexagon HTP (NPU)를 활용.

#Embedded / Minimal Build

1
ONNX Runtime 전체: ~50 MB
2
Mobile build (선택 op만): ~5 MB
3
Custom slim build: 더 작게

CMake로 직접:

1
git clone https://github.com/microsoft/onnxruntime.git
2
cd onnxruntime
3
./build.sh --config MinSizeRel \
4
           --minimal_build \
5
           --disable_ml_ops \
6
           --include_ops_by_config required_ops.config \
7
           --enable_reduced_operator_type_support

required_ops.config에 모델이 쓰는 op만 명시.

#모델 최적화 — ORT format

1
import onnxruntime as ort
2

3
sess_options = ort.SessionOptions()
4
sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
5
sess_options.optimized_model_filepath = 'model.opt.onnx'
6

7
sess = ort.InferenceSession('model.onnx', sess_options)

.opt.onnx는 최적화된 ORT format. Mobile build에서 더 빠르게 load.

#Quantization

1
from onnxruntime.quantization import quantize_dynamic, QuantType
2

3
quantize_dynamic('model.onnx', 'model.int8.onnx',
4
                 weight_type=QuantType.QInt8)

Dynamic quantization: weight만 INT8, activation은 runtime 변환. 빠르고 손실 적음.

Static quantization (calibration 필요):

1
from onnxruntime.quantization import quantize_static, CalibrationDataReader
2

3
class MyReader(CalibrationDataReader):
4
    def get_next(self):
5
        return {'input': next_batch()}
6

7
quantize_static('model.onnx', 'model.int8.onnx', MyReader(),
8
                quant_format=QuantFormat.QDQ)

#사례 — YOLOv8 multi-platform

같은 .onnx 한 파일로:

Platform	EP	성능
Server (NVIDIA T4)	TensorRT EP	250 fps
Workstation (RTX 4090)	CUDA EP	400 fps
Jetson Orin	TensorRT EP	80 fps
Mac M2	CoreML EP	60 fps
Windows + AMD GPU	DML EP	50 fps
Android (Qualcomm)	QNN EP	30 fps
Linux ARM (RPi5)	CPU	5 fps

PyTorch → ONNX export 한 번, 6 platform 배포.

#사례 — Whisper 음성 인식

1
import onnxruntime as ort
2

3
sess = ort.InferenceSession('whisper-tiny.onnx',
4
                             providers=['CoreMLExecutionProvider'])
5

6
mel = compute_mel_spectrogram(audio)  # (1, 80, 3000)
7
out = sess.run(None, {'input_features': mel})
8
tokens = greedy_decode(out[0])

Whisper-tiny의 real-time 성능과 ANE 사용 여부는 model·audio length·CoreML EP 설정에서 측정합니다.

#ONNX Runtime Web — Browser

1
import * as ort from 'onnxruntime-web';
2

3
const session = await ort.InferenceSession.create('model.onnx', {
4
    executionProviders: ['webgl', 'wasm']
5
});
6

7
const input = new ort.Tensor('float32', new Float32Array(...), [1, 3, 224, 224]);
8
const output = await session.run({input});

WASM + WebGL/WebGPU로 브라우저에서 inference. Server 없이 client에서.

#Profile

1
sess_options = ort.SessionOptions()
2
sess_options.enable_profiling = True
3
sess = ort.InferenceSession('model.onnx', sess_options)
4

5
# Run inference
6
sess.run(...)
7
profile_file = sess.end_profiling()
8
# Chrome Tracing format → chrome://tracing

각 op의 latency가 visualize됩니다. Bottleneck op를 찾아 optimize.

#자주 보는 함정

Provider 우선순위 잘못

1
providers=['CPUExecutionProvider', 'CUDAExecutionProvider']

CPU가 첫 번째면 CUDA가 무시됨. 빠른 것을 먼저.

Unsupported op로 fallback

1
Some nodes are not supported by TensorrtExecutionProvider
2
→ partition fallback to CUDA

EP 별로 지원 op가 다름. Verbose log로 어느 op가 어디로 가는지 확인.

ONNX opset 호환

TensorRT EP가 지원하는 ONNX opset은 설치된 TensorRT·ORT version마다 다릅니다. 모델 opset이 그보다 높으면 parse가 실패하거나 일부 node가 다른 EP로 넘어갑니다. 지원 범위는 해당 version 문서로 확인하고, ONNX export 시 target EP에 맞는 opset을 선택합니다.

Dynamic shape 미지원

1
dynamic_axes={'input': {0: 'batch'}}

지원되지만 TensorRT EP는 min/max shape 명시 필요. 그렇지 않으면 매 호출마다 engine rebuild.

Calibration data 부족

Static INT8 quantization의 accuracy 영향은 model·calibration data로 측정하며, representative set 크기는 target validation으로 결정합니다.

Mobile build에서 op 누락

1
Op 'GridSample' not found

Custom build에서 op를 빠뜨림. required_ops.config 재생성.

#정리

ONNX = 프레임워크 중립 모델 format.
ONNX Runtime = 그 모델을 어떤 hardware에서도 돌리는 inference 엔진.
Execution Provider만 바꿔서 CPU/CUDA/TensorRT/CoreML/DML/QNN/NNAPI 전환.
Provider 순서: 빠른 것 먼저, 마지막에 CPU fallback.
Minimal build로 5 MB까지 줄임. Embedded·mobile에 적합.
Dynamic INT8 quantization은 calibration 없이 빠르게.
ORT format으로 mobile loading 최적화.
Browser inference도 onnxruntime-web으로 가능.
모델 한 번 export로 다양한 platform 배포가 ONNX Runtime의 핵심 가치.

다음 편은 Series 마지막 — Modern Embedded Recipes 정리입니다.

#관련 항목

Modern Embedded Recipes · 143 of 152

Edge Thermal Management — Throttling·DVFS·Fan Curve·Sustained

Edge AI 보드의 sustained 성능을 결정하는 thermal 한계. throttle trip, DVFS, fan curve, nvpmodel, passive cooling 설계를 정리합니다.

2026년 4월 21일 · recipes

같은 시리즈에서 이어 읽기

NVIDIA Jetson 분석 — Nano·Xavier·Orin·Thor·JetPack·DLA·VPI

Jetson 라인업의 power·성능 trade-off, JetPack 구성, DLA·VPI·DeepStream을 묶어 자율주행·로봇 stack에서 쓰는 패턴을 정리합니다.