← Retour aux guides
ONNXTensorRTOpenVINODéploiement

Convertir des modèles visage ONNX vers TensorRT et OpenVINO

Guide de production pour convertir des modèles ONNX de type InsightFace en moteurs TensorRT et OpenVINO IR, avec validation, choix de précision, benchmark et contrôles de déploiement.

•12 min de lecture

Ce que vous allez mettre en place

La plupart des déploiements InsightFace commencent par ONNX, portable entre recherche, services Python et edge. En production, un runtime optimisé est souvent nécessaire : TensorRT pour les GPU NVIDIA et OpenVINO pour CPU, iGPU et accélérateurs Intel.

Ce guide décrit un flux sûr : valider le graphe ONNX, simplifier les formes statiques, construire un moteur TensorRT, exporter OpenVINO IR, mesurer les deux runtimes et comparer embeddings ou sorties de détection au modèle ONNX d'origine avant publication.

Avant de commencer

  • Un modèle ONNX testé avec nom d'entrée, layout et normalisation connus.
  • Un serveur Linux x86_64, de préférence Ubuntu 22.04 LTS ou 24.04 LTS, avec accès sudo.
  • Un pilote NVIDIA et CUDA toolkit correspondant au package TensorRT pour les cibles NVIDIA GPU.
  • Un petit jeu de validation représentatif des tailles d'images, populations, lumières et caméras de production.

1. Installer les outils de conversion sur un serveur Linux

Commencez avec un serveur Linux x86_64 propre. Ubuntu 22.04 LTS ou 24.04 LTS est un choix pratique car les wheels Python, OpenVINO, les pilotes NVIDIA, CUDA et TensorRT y sont bien pris en charge.

Installez les utilitaires ONNX dans un environnement virtuel, OpenVINO depuis PyPI pour CPU et appareils Intel, puis TensorRT depuis le package NVIDIA correspondant au pilote et à CUDA du serveur. Conservez ces versions avec les artifacts convertis pour rendre les engines de production reproductibles.

  • Construisez les engines TensorRT avec la même famille CUDA, TensorRT et pilote que la production.
  • Isolez les outils Python dans un environnement virtuel afin que les dépendances de conversion n’affectent pas le serving stack.
  • Exécutez les commandes de vérification avant de convertir des modèles client ou production.
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. Valider le graphe ONNX source

Avant la conversion, inspectez le modèle au lieu de supposer le nom ou la forme d’entrée. L’entrée des modèles de reconnaissance faciale est généralement 1x3x112x112 en layout NCHW (batch, channels, height, width) ; les détecteurs et swappers peuvent utiliser des formes dynamiques plus grandes.

Consignez précisément le prétraitement : ordre RGB/BGR, moyenne et écart type, layout des canaux, alignement, taille de crop et post-traitement. La conversion runtime ne corrige pas une incohérence de prétraitement.

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. Simplifier et figer les formes si nécessaire

TensorRT et OpenVINO optimisent mieux quand les formes du graphe sont claires. Pour les backbones de reconnaissance à taille fixe, figez l’entrée. Pour les détecteurs, gardez les dimensions dynamiques et définissez ensuite des profils réalistes.

Ne simplifiez qu’après avoir validé que le modèle simplifié produit des sorties proches numériquement. Un contrôle cosine similarity entre ONNX original et simplifié doit faire partie du CI pour les modèles commerciaux.

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. Construire un moteur TensorRT

Les moteurs TensorRT dépendent du matériel et de la version TensorRT. Construisez-les sur la même classe de GPU et le même stack driver que la production, puis stockez ONNX source, versions TensorRT/CUDA, précision et profil avec l’artifact.

FP16 est le choix de production par défaut pour la plupart des workloads d’embeddings visage et face swapping sur GPU NVIDIA moderne. INT8 peut aider la détection à fort débit, mais exige des données de calibration et des seuils d’accuracy plus stricts.

  • Définissez min/opt/max shapes selon les batch sizes réels, pas les limites théoriques.
  • Gardez un moteur par grande famille d’entrée si les formes des détecteurs ou swappers varient fortement.
  • Rejetez tout moteur dont les embeddings ou métriques de détection dérivent au-delà du seuil de release.
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. Convertir ONNX en OpenVINO IR

OpenVINO IR comprend des fichiers XML et BIN déployables via OpenVINO runtime. C’est adapté aux services CPU, à l’inférence Intel GPU et aux boîtiers edge où la simplicité d’exploitation prime.

Pour les modèles de reconnaissance, la compression FP16 réduit souvent la mémoire et améliore le débit avec une dérive d’embedding limitée. Pour les systèmes sensibles à la conformité, conservez des artifacts FP32 pour audit même si la production utilise FP16.

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. Exécuter l’inférence avec OpenVINO

Chargez le modèle OpenVINO compilé une seule fois au démarrage du service et réutilisez-le entre les requêtes. Choisissez CPU, GPU, AUTO ou HETERO selon votre politique matérielle de production.

Pour la reconnaissance faciale, normalisez les embeddings exactement comme dans le baseline ONNX avant de calculer cosine similarity ou seuils de matching.

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. Valider l’accuracy et publier sans risque

La conversion n’est pas terminée parce que le moteur s’exécute. Comparez ONNX, TensorRT et OpenVINO sur un jeu représentatif. Pour les embeddings, suivez cosine similarity, distribution des normes et impact de seuil ; pour les détecteurs, recall, faux positifs, landmarks et NMS.

Ne promouvez l’artifact que lorsque latence, débit, mémoire et accuracy atteignent la cible de production. Ajoutez metadata et procédure de rollback au package de release.

  • Utilisez des seeds fixes et un prétraitement stable pour des comparaisons reproductibles.
  • Mesurez séparément cold start et latence steady-state.
  • Surveillez le drift en production car caméra et pose peuvent différer du jeu de validation.

Besoin d’aide pour le déploiement en production ?

Contactez InsightFace pour les licences de modèles, l’optimisation runtime et le support de déploiement sur votre matériel cible.

Nous contacter