Converter modelos faciais ONNX para TensorRT e OpenVINO
Guia orientado a produção para converter modelos ONNX no estilo InsightFace em engines TensorRT e OpenVINO IR, com validação, precisão, benchmark e checklist de implantação.
O que você vai construir
A maioria das implantações InsightFace começa com ONNX por ser portátil entre pesquisa, serviços Python e edge. Em produção, normalmente é preciso um runtime otimizado: TensorRT para GPUs NVIDIA e OpenVINO para CPU, iGPU e aceleradores Intel.
Este guia cobre um fluxo seguro: validar o grafo ONNX, simplificar formas estáticas, criar uma engine TensorRT, exportar OpenVINO IR, medir ambos os runtimes e comparar embeddings ou saídas de detecção com o ONNX original antes do release.
Antes de começar
- Um modelo ONNX testado com nome de entrada, layout e normalização conhecidos.
- Um servidor Linux x86_64, preferencialmente Ubuntu 22.04 LTS ou 24.04 LTS, com acesso sudo.
- Um driver NVIDIA e CUDA toolkit compatíveis com o pacote TensorRT ao mirar GPUs NVIDIA.
- Um conjunto pequeno de validação que represente tamanhos, demografia, iluminação e câmeras reais.
1. Instalar ferramentas de conversão em um servidor Linux
Comece com um servidor Linux x86_64 limpo. Ubuntu 22.04 LTS ou 24.04 LTS é um padrão prático porque wheels Python, OpenVINO, drivers NVIDIA, CUDA e ferramentas TensorRT têm bom suporte.
Instale utilitários ONNX em um ambiente virtual, OpenVINO via PyPI para CPU e dispositivos Intel, e TensorRT pelo pacote NVIDIA compatível com driver e CUDA do servidor. Guarde essas versões com os artefatos convertidos para tornar engines de produção reproduzíveis.
- Crie engines TensorRT com a mesma família CUDA, TensorRT e driver da produção.
- Isole ferramentas Python em um ambiente virtual para que dependências de conversão não afetem o serving stack.
- Execute os comandos de verificação antes de converter modelos de clientes ou produção.
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 numpysource .venv/bin/activate
python -m pip install openvino
ovc --help
benchmark_app --help# 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 --versionsource .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 --version2. Validar o grafo ONNX de origem
Antes da conversão, inspecione o modelo em vez de assumir nome ou shape de entrada. A entrada de modelos de reconhecimento facial geralmente é 1x3x112x112 em layout NCHW (batch, channels, height, width); detectores e swappers podem usar shapes dinâmicos maiores.
Registre exatamente o pré-processamento: ordem RGB/BGR, média e desvio padrão, layout de canais, alinhamento, tamanho de crop e pós-processamento. A conversão de runtime não corrige mismatch de pré-processamento.
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)
PY3. Simplificar e fixar shapes quando apropriado
TensorRT e OpenVINO têm melhor desempenho quando o grafo possui shapes claros. Para backbones de reconhecimento com tamanho fixo, congele o input shape. Para detectores, mantenha dimensões dinâmicas e defina perfis realistas depois.
Simplifique somente após validar que o modelo simplificado produz saídas numericamente próximas. Um teste de cosine similarity entre ONNX original e simplificado deve fazer parte do CI para modelos comerciais.
python -m onnxsim models/insightface.onnx models/insightface.simplified.onnx --overwrite-input-shape input:1,3,112,1124. Criar uma engine TensorRT
Engines TensorRT são específicas de hardware e versão. Gere-as na mesma classe de GPU e stack de drivers da produção, e armazene ONNX fonte, versão TensorRT, CUDA, precisão e perfil de otimização com o artefato.
FP16 é a escolha padrão para a maioria dos workloads de embeddings faciais e face swapping em GPUs NVIDIA modernas. INT8 pode ajudar detecção de alto throughput, mas requer dados de calibração e gates de acurácia mais rígidos.
- Use min/opt/max shapes alinhados a batch sizes reais, não limites teóricos extremos.
- Mantenha uma engine por família principal de entrada quando shapes de detector ou swapper variam muito.
- Rejeite qualquer engine cujo cosine similarity ou métricas de detecção ultrapassem o limite de release.
trtexec --onnx=models/insightface.simplified.onnx --saveEngine=engines/insightface_fp16.plan --minShapes=input:1x3x112x112 --optShapes=input:16x3x112x112 --maxShapes=input:32x3x112x112 --fp16 --workspace=4096 --verbosetrtexec --onnx=models/insightface.simplified.onnx --saveEngine=engines/insightface_int8.plan --minShapes=input:1x3x112x112 --optShapes=input:16x3x112x112 --maxShapes=input:32x3x112x112 --int8 --calib=calibration.cache5. Converter ONNX para OpenVINO IR
OpenVINO IR consiste em arquivos XML e BIN implantados via OpenVINO runtime. É uma boa opção para serviços CPU-heavy, inferência em Intel GPU e edge boxes onde simplicidade operacional importa.
Para modelos de reconhecimento, a compressão FP16 geralmente reduz memória e melhora throughput com pouco drift de embedding. Em sistemas sensíveis a compliance, mantenha artefatos FP32 para auditoria mesmo que produção use FP16.
ovc models/insightface.simplified.onnx --output_model openvino/insightface.xml --input "input[1,3,112,112]" --compress_to_fp16=Truebenchmark_app -m openvino/insightface.xml -d CPU -shape "input[16,3,112,112]" -hint throughput6. Rodar inferência com OpenVINO
Carregue o modelo OpenVINO compilado uma vez no startup do serviço e reutilize-o entre requests. Selecione CPU, GPU, AUTO ou HETERO conforme a política de hardware de produção.
Para reconhecimento facial, normalize os embeddings exatamente como no baseline ONNX antes de calcular cosine similarity ou thresholds de matching.
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. Validar acurácia e publicar com segurança
A conversão não termina quando a engine roda. Compare ONNX, TensorRT e OpenVINO em um validation set representativo. Para embeddings, acompanhe cosine similarity, distribuição de norma e impacto de threshold; para detectores, recall, falsos positivos, landmarks e NMS.
Promova o artefato apenas quando latência, throughput, memória e acurácia atingirem a meta de produção. Inclua metadata do artefato e instruções de rollback no pacote de release.
- Use seeds fixos e pré-processamento estável para comparações reproduzíveis.
- Faça benchmark de cold start separado da latência em steady-state.
- Monitore drift em produção porque qualidade de câmera e pose podem diferir do validation set.
Precisa de ajuda com implantação em produção?
Fale com a InsightFace sobre licenciamento de modelos, otimização de runtime e suporte para o hardware alvo.
Entrar em contato