← Zurück zu den Leitfäden
ONNXTensorRTOpenVINODeployment

ONNX-Gesichtsmodelle nach TensorRT und OpenVINO konvertieren

Ein produktionsnaher Leitfaden zur Konvertierung von InsightFace-ähnlichen ONNX-Modellen in TensorRT-Engines und OpenVINO IR inklusive Validierung, Präzision, Benchmarks und Release-Prüfungen.

•12 Min. Lesezeit

Was Sie umsetzen

Viele InsightFace-Deployments starten mit ONNX, weil es zwischen Forschung, Python-Services und Edge-Paketierung portabel ist. Für Produktion werden meist optimierte Laufzeiten benötigt: TensorRT für NVIDIA-GPUs und OpenVINO für Intel-CPU, iGPU und Edge-Beschleuniger.

Der Leitfaden beschreibt einen sicheren Ablauf: ONNX-Graph validieren, statische Eingabeformen vereinfachen, TensorRT-Engine bauen, OpenVINO IR exportieren, beide Laufzeiten benchmarken und vor dem Release Embeddings oder Detektionsausgaben gegen ONNX vergleichen.

Vor dem Start

  • Ein getestetes ONNX-Modell mit bekanntem Eingabenamen, Layout und Normalisierung.
  • Ein Linux-x86_64-Server, vorzugsweise Ubuntu 22.04 LTS oder 24.04 LTS, mit sudo-Zugriff.
  • Ein NVIDIA-Treiber und CUDA Toolkit, die zum TensorRT-Paket passen, wenn NVIDIA-GPUs Zielhardware sind.
  • Ein kleiner Validierungssatz mit produktionsnahen Bildgrößen, Demografie, Licht und Kameraqualität.

1. Konvertierungswerkzeuge auf einem Linux-Server installieren

Beginnen Sie mit einem sauberen Linux-x86_64-Server. Ubuntu 22.04 LTS oder 24.04 LTS ist eine praktische Standardwahl, weil Python-Wheels, OpenVINO-Pakete, NVIDIA-Treiber, CUDA und TensorRT-Werkzeuge gut unterstützt werden.

Installieren Sie ONNX-Werkzeuge in einer virtuellen Umgebung, OpenVINO aus PyPI für CPU- und Intel-Geräte-Konvertierung und TensorRT aus dem NVIDIA-Paket, das zu Treiber und CUDA passt. Speichern Sie diese Versionen mit den Artifacts, damit Production-Engines reproduzierbar bleiben.

  • Bauen Sie TensorRT-Engines mit derselben CUDA-, TensorRT- und Treiberfamilie wie in Produktion.
  • Isolieren Sie Python-Werkzeuge in einer virtuellen Umgebung, damit Konvertierungsabhängigkeiten den Serving-Stack nicht beeinflussen.
  • Führen Sie die Verifikationsbefehle aus, bevor Sie Kunden- oder Produktionsmodelle konvertieren.
Install Python ONNX tools
sudo apt-get update
sudo apt-get install -y python3 python3-venv python3-pip build-essential
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install onnx onnxsim onnxruntime numpy
Install OpenVINO CLI tools
source .venv/bin/activate
python -m pip install openvino
ovc --help
benchmark_app --help
Install TensorRT CLI tools
# Install an NVIDIA driver and CUDA version supported by your TensorRT package first.
# Then download the matching TensorRT tar package from NVIDIA Developer.
tar -xzf TensorRT-10.*.Linux.x86_64-gnu.cuda-12.*.tar.gz
export TENSORRT_HOME=$PWD/TensorRT-10.*
export PATH=$TENSORRT_HOME/bin:$PATH
export LD_LIBRARY_PATH=$TENSORRT_HOME/lib:$LD_LIBRARY_PATH
trtexec --version
Verify the conversion toolchain
source .venv/bin/activate
python - <<'PY'
import onnx
import onnxruntime
import openvino
print("onnx", onnx.__version__)
print("onnxruntime", onnxruntime.__version__)
print("openvino", openvino.__version__)
PY
trtexec --version

2. Den ONNX-Ausgangsgraph validieren

Prüfen Sie das Modell vor der Konvertierung, statt Eingabenamen oder Formen anzunehmen. Eingaben von Gesichtserkennungsmodellen sind normalerweise 1x3x112x112 im NCHW-Layout (batch, channels, height, width); Detektoren und Swapper können größere dynamische Formen verwenden.

Dokumentieren Sie Vorverarbeitung exakt: RGB/BGR-Reihenfolge, Mittelwert und Standardabweichung, Channel-Layout, Alignment, Crop-Größe und Postprocessing. Eine Runtime-Konvertierung behebt keine Preprocessing-Abweichung.

Inspect inputs and outputs
python - <<'PY'
import onnx
from onnx import checker

model_path = "models/insightface.onnx"
model = onnx.load(model_path)
checker.check_model(model)
print("IR version:", model.ir_version)
print("Inputs:")
for item in model.graph.input:
    shape = [dim.dim_value or dim.dim_param for dim in item.type.tensor_type.shape.dim]
    print(" ", item.name, shape)
print("Outputs:")
for item in model.graph.output:
    shape = [dim.dim_value or dim.dim_param for dim in item.type.tensor_type.shape.dim]
    print(" ", item.name, shape)
PY

3. Formen bei Bedarf vereinfachen und fixieren

TensorRT und OpenVINO optimieren besser, wenn Graphformen klar sind. Für feste Gesichtserkennungs-Backbones sollten Sie die Eingabeform fixieren; für Detektoren bleiben dynamische Dimensionen erhalten und werden später mit realistischen Profilen begrenzt.

Vereinfachen Sie nur, wenn das vereinfachte Modell numerisch nahe am ursprünglichen ONNX liegt. Ein Cosine-Similarity-Check sollte für kommerziell ausgelieferte Modelle Teil der CI sein.

Simplify a fixed-size recognition model
python -m onnxsim models/insightface.onnx models/insightface.simplified.onnx   --overwrite-input-shape input:1,3,112,112

4. Eine TensorRT-Engine bauen

TensorRT-Engines sind an Hardware und TensorRT-Version gebunden. Bauen Sie sie auf derselben GPU-Klasse und Treiberumgebung wie in Produktion und speichern Sie Quell-ONNX, TensorRT-Version, CUDA-Version, Präzision und Profil mit dem Artifact.

FP16 ist auf modernen NVIDIA-GPUs meist die Standardwahl für Face Embeddings und Face Swapping. INT8 kann für hochdurchsatzfähige Detektion nützlich sein, benötigt aber Kalibrierdaten und strengere Accuracy-Gates.

  • min/opt/max shapes sollten reale Batchgrößen statt theoretischer Extreme abbilden.
  • Verwenden Sie eine Engine pro wichtiger Eingabefamilie, wenn Detektor- oder Swapper-Formen stark variieren.
  • Verwerfen Sie Engines, deren Embedding- oder Detektionsmetriken über den Release-Grenzwert driften.
Build an FP16 TensorRT engine
trtexec   --onnx=models/insightface.simplified.onnx   --saveEngine=engines/insightface_fp16.plan   --minShapes=input:1x3x112x112   --optShapes=input:16x3x112x112   --maxShapes=input:32x3x112x112   --fp16   --workspace=4096   --verbose
Optional INT8 engine with calibration cache
trtexec   --onnx=models/insightface.simplified.onnx   --saveEngine=engines/insightface_int8.plan   --minShapes=input:1x3x112x112   --optShapes=input:16x3x112x112   --maxShapes=input:32x3x112x112   --int8   --calib=calibration.cache

5. ONNX nach OpenVINO IR konvertieren

OpenVINO IR besteht aus XML- und BIN-Dateien und wird über die OpenVINO Runtime bereitgestellt. Es eignet sich für CPU-lastige Services, Intel-GPU-Inferenz und Edge-Systeme, bei denen Betriebseinfachheit zählt.

Für Erkennungsmodelle reduziert FP16-Kompression meist Speicher und verbessert Durchsatz bei geringer Embedding-Abweichung. Für compliance-sensible Systeme sollten FP32-Artifacts für Audits erhalten bleiben.

Convert to OpenVINO IR
ovc models/insightface.simplified.onnx   --output_model openvino/insightface.xml   --input "input[1,3,112,112]"   --compress_to_fp16=True
Benchmark OpenVINO throughput
benchmark_app   -m openvino/insightface.xml   -d CPU   -shape "input[16,3,112,112]"   -hint throughput

6. Inferenz mit OpenVINO ausführen

Laden Sie das kompilierte OpenVINO-Modell einmal beim Service-Start und verwenden Sie es über Requests hinweg wieder. Wählen Sie CPU, GPU, AUTO oder HETERO gemäß Hardwarestrategie.

Normalisieren Sie Face-Recognition-Embeddings exakt wie im ONNX-Baseline, bevor Sie Cosine Similarity oder Matching-Schwellen berechnen.

Minimal OpenVINO Python inference
from openvino import Core
import numpy as np

core = Core()
compiled = core.compile_model("openvino/insightface.xml", "CPU")
input_layer = compiled.input(0)
output_layer = compiled.output(0)

batch = np.random.rand(16, 3, 112, 112).astype("float32")
embeddings = compiled([batch])[output_layer]
print(embeddings.shape)

7. Accuracy prüfen und sicher releasen

Die Konvertierung ist nicht abgeschlossen, nur weil die Engine läuft. Vergleichen Sie ONNX, TensorRT und OpenVINO auf einem repräsentativen Validierungssatz. Für Embeddings beobachten Sie Cosine Similarity, Normverteilung und Schwelleneinfluss; für Detektoren Recall, False Positives, Landmarks und NMS.

Promoten Sie das Artifact erst, wenn Latenz, Durchsatz, Speicher und Accuracy die Produktionsziele erfüllen. Legen Sie Metadata und Rollback-Anweisungen ins Release-Paket.

  • Nutzen Sie feste Seeds und stabilen Preprocessing-Code für reproduzierbare Vergleiche.
  • Benchmarken Sie Cold Start getrennt von Steady-State-Latenz.
  • Überwachen Sie Produktionsdrift, da Kameraqualität und Kopfpose vom Validierungssatz abweichen können.

Benötigen Sie Hilfe beim Produktions-Deployment?

Kontaktieren Sie InsightFace für Modelllizenzen, Runtime-Optimierung und Deployment-Support für Ihre Zielhardware.

Kontakt aufnehmen