Blog

10 min de leitura

Tirando o Python da inferência: YOLOv10s compilada e um engine próprio em C++

Compilei a mesma rede para AOTInductor, TensorRT, ONNX Runtime, OpenVINO e ncnn, e depois escrevi um engine de CPU do zero, sem nenhuma biblioteca de inferência. Medi latência, dependências e se as saídas continuavam as mesmas.

  • cpp
  • inferencia
  • yolo
  • tensorrt
  • openvino
  • enty

Na hora da inferência, uma rede neural é só um grafo de operações e um conjunto de pesos. Treinar precisa de todo o ecossistema do PyTorch. Rodar, em tese, não. Então a pergunta é simples: se eu compilar esse grafo para um artefato nativo e chamar de C++, quanto fica mais rápido, o que ainda sobra de dependência e as saídas continuam as mesmas?

Fui atrás disso por dois motivos. O primeiro é a Enty, uma linguagem que estou construindo e sobre a qual vou falar mais em outro post. Ela vai precisar de um runtime para rodar modelos, e eu queria saber, com números, quais caminhos existem antes de escolher um. O segundo é curiosidade mesmo: dá para otimizar uma rede escrevendo o engine na mão, em C++, e chegar perto dos runtimes prontos?

O experimento completo, com código, scripts e relatório, está no repositório compiled-cnn.

2,94 ms

TensorRT FP16 na RTX 3050: 340 FPS, 1,90× o PyTorch

14,91 ms

OpenVINO INT8 na CPU: 67 FPS, perdendo 0,31 ponto de mAP

93%

da velocidade do OpenVINO com o meu engine em FP32, sem nenhuma biblioteca

149 de 152

validações passaram; as 3 falhas têm causa conhecida

O que foi testado

O modelo é a YOLOv10s, da Ultralytics. Escolhi essa versão por um detalhe que facilita a comparação: o head dela já entrega as detecções finais, sem NMS. Então todo backend faz exatamente o mesmo trabalho, do pixel até a caixa.

Foram quatro rodadas com compiladores e runtimes existentes, mais um engine meu:

  • Rodada 0, webcam: o predict da Ultralytics, que é como a maioria das pessoas roda o modelo. É o ponto de partida.
  • Rodada 1, AOTInductor: o compilador ahead-of-time do próprio PyTorch. Gera um pacote .pt2 que o C++ carrega pela libtorch, sem Python.
  • Rodada 2, TensorRT: o compilador da NVIDIA. ONNX vira um engine .plan, e o runner em C++ nem usa libtorch.
  • Rodada 3, CPU: PyTorch eager, ONNX Runtime e OpenVINO, em FP32 e INT8.
  • Rodada 4, ncnn: sobre Vulkan, para ver o caminho que não depende de fabricante de GPU.
  • Engine próprio: um gerador de código que lê o ONNX e escreve C++ com kernels AVX2 e INT8 com AVX-VNNI. Sem biblioteca de inferência, sem BLAS.

Tudo rodou num notebook: RTX 3050 6 GB Laptop e Core i5-13450HX. Os números absolutos mudam em outra máquina. As comparações e os motivos por trás delas se mantêm em hardware com os mesmos recursos.

Alguns termos

  • Eager × compilado: no modo eager, o PyTorch executa o grafo operação por operação, a partir do Python. Um compilador enxerga o grafo inteiro antes, então consegue fundir operações, escolher o melhor kernel para cada formato e eliminar o interpretador.
  • ONNX: formato aberto para descrever o grafo e os pesos. É a ponte entre o PyTorch e quase todos os outros caminhos testados.
  • FP32, FP16 e INT8: formas de representar os números. FP16 usa metade da memória e, em hardware que suporta, dobra a vazão. INT8 usa inteiros de 8 bits e exige quantização.
  • Quantização e calibração: mapear valores reais para inteiros com uma escala. A escala das ativações vem da calibração: a rede roda sobre centenas de imagens reais e registra a faixa de valores de cada tensor.
  • AVX-VNNI: instruções da CPU que fazem produto escalar de 8 bits no hardware. É o que torna o INT8 rápido nesta máquina.

Como eu sei que as saídas são as mesmas

Medir velocidade é fácil. O difícil é garantir que o backend rápido está calculando a mesma coisa. Um runtime que ganha 2× e erra caixa não serve para nada.

  • Referência fixa. Antes de qualquer benchmark, gerei 8 imagens de referência (duas clássicas da Ultralytics e seis frames da minha webcam), pré-processadas uma única vez e passadas pelo PyTorch eager com TF32 desligado. Todo backend lê os mesmos arquivos.
  • Tolerâncias estritas. FP32: caixas a até 0,5 px e scores a até 0,001. FP16: caixas a até 2 px e scores a até 0,005. Nos dois, as detecções com score ≥ 0,25 precisam bater em quantidade, classe e IoU ≥ 0,95.
  • Pareamento por IoU. As detecções são pareadas por sobreposição, não pela posição na lista, porque o TopK pode ordenar empates de outro jeito.
  • INT8 julgado de dois jeitos. Pela concordância com o FP32 (IoU ≥ 0,80 e diferença de score ≤ 0,05) e pela acurácia: o mAP50-95 no COCO pode cair no máximo 1 ponto, medido em 500 imagens que não foram usadas na calibração.
  • Pré-processamento conferido. O comando detect de cada runner lê o JPEG e faz o letterbox em C++, então o pré-processamento também é testado.

As tolerâncias foram fixadas antes de cada rodada e nunca afrouxadas. Cada runner em C++ tem os mesmos três comandos (validate, bench e detect), e o validate só sai com código 0 se todas as imagens passarem.

Como medi

Uma passada da rede, batch 1, entrada estática de 640×640 e já na memória do dispositivo. Só o modelo, sem câmera e sem desenhar nada na tela.

  • GPU: 50 iterações de aquecimento e 500 medidas.
  • CPU: 20 e 200, com 60 s de resfriamento antes de cada execução, 3 rodadas com a ordem trocada entre elas e a mediana como resultado. Um monitor de carga descarta e repete a execução se outro processo usar a CPU.
  • Threads presas nos 6 P-cores com taskset. Num processador híbrido, uma thread que cai num E-core faz as outras esperarem em toda camada.

O protocolo térmico veio de um problema real: o notebook esquenta. Numa sequência de testes, o clock dos P-cores caiu de 4,2 para 3,1 GHz e penalizou quem rodava por último em até 25%.

GPU: TensorRT na frente

Latência na RTX 3050 por backend
  • FP32
  • FP16
PyTorch eager (Python)10,02 ms5,59 ms
AOTInductor (C++)8,46 ms3,92 ms
TensorRT (C++)7,39 ms2,94 ms
ncnn Vulkan (C++)18,55 ms9,69 ms

Latência em ms por inferência, menor é melhor

Uma sessão seguida, clocks não travados (±3% entre execuções). Em FP16, o TensorRT dá 1,90× sobre o eager, o AOTInductor 1,43× e o ncnn 0,58×.

O TensorRT em FP16 roda a 340 FPS e deixa o runtime mais enxuto: o binário final só precisa da libnvinfer e do runtime CUDA. O custo é cerca de um minuto para gerar o engine, e esse engine fica preso a esta GPU e a esta versão do TensorRT.

O AOTInductor tira o Python, mas não a libtorch. É um meio-termo bom quando o projeto já vive no PyTorch e o build precisa ser leve.

O Vulkan é portável, mas ficou bem atrás do CUDA nesta placa, mesmo usando os tensor cores via cooperative matrix. Na GPU integrada da Intel foi pior ainda: cerca de 230 ms em FP16. Parei esse benchmark de propósito, porque não fazia sentido para este modelo.

CPU: INT8 é a grande alavanca

Inferências por segundo no i5-13450HX
PyTorch eager FP3218,0
ncnn FP3217,6
ONNX Runtime FP3222,9
OpenVINO FP3224,9
OpenVINO INT867,1

FPS, maior é melhor (6 threads nos P-cores, mediana de 3 rodadas)

FP16 não ajuda nesta CPU. Ela tem F16C, que só converte entre FP16 e FP32; a conta continua em FP32. Não tem AVX-512 FP16 nem AMX.

O que muda o jogo é o AVX-VNNI. A instrução vpdpbusd faz 32 multiplicações e somas de 8 bits por instrução, contra 8 de um FMA em FP32.

O engine próprio

Depois de medir os runtimes prontos, veio a parte da curiosidade: um engine escrito do zero, especializado neste grafo, chega perto do OpenVINO?

Como funciona

A abordagem é de compilador, não de interpretador. Um interpretador lê o grafo a cada execução e decide o que fazer. O meu gerador faz isso uma vez, antes de compilar:

  • calcula a forma de cada tensor e confere com a inferência de formas do ONNX;
  • funde convolução, SiLU e soma residual numa chamada só;
  • transforma 15 concatenações em escrita direta no destino, sem cópia;
  • planeja todos os buffers numa única arena, reaproveitando o espaço de tensores que já não serão lidos (de 370 para 25 MB);
  • escreve um model.cpp com uma chamada por operação e formatos fixos.

Os pesos já saem no layout que os kernels leem e vão embutidos no executável com .incbin. O compilador C++ otimiza cada chamada para os tamanhos exatos daquela camada. O binário final depende só de libc, libstdc++, libm e libgcc_s.

  • Convolução como GEMM. Cada convolução vira uma multiplicação de matrizes. Um micro-kernel AVX2 calcula um bloco de 6 canais por 16 posições inteiramente em registradores.
  • Threads próprias. Um pool com uma thread por P-core, fixadas com afinidade. Entre camadas, elas esperam umas às outras girando, sem dormir.
  • INT8. Pesos em 8 bits com uma escala por canal, ativações calibradas em 300 imagens do COCO e a conta feita com vpdpbusd.
  • Referência como oráculo. A versão com loops diretos continua no código e serve de base para os testes de cada kernel otimizado.

De 21 segundos para 47 ms

O trabalho foi em cinco marcos, todos validados com as mesmas referências e tolerâncias FP32 estritas.

Latência do engine próprio em FP32 a cada marco
M1 · loops diretos21.692 ms
M2 · GEMM com AVX2578 ms
M3 · fusões e arena348 ms
M4 · 6 threads79 ms
M5 · painéis empacotados46,67 ms

Latência em ms, escala logarítmica, menor é melhor

M1 a M4 são medições rápidas, sem controle térmico. M5 é o benchmark final.

MarcoO que entrouThreadsLatência
M1loops diretos de referência121.692 ms
M2convolução como GEMM, micro-kernel AVX2/FMA1578 ms
M3bias, SiLU e residual no epílogo, concat sem cópia, arena1348 ms
M4pool de threads fixado nos P-cores679 ms
M5painéis empacotados, kernel 6×16, grade por camada646,67 ms

Sair dos loops diretos para GEMM deu 37×. Fusões, threads e empacotamento levaram de 79 para 47 ms. Os últimos 10% até o OpenVINO são os mais caros: pedem kernels de convolução no nível do oneDNN.

Contra o OpenVINO

No benchmark final, o engine rodou na mesma sessão que o OpenVINO, para a comparação ser justa. Não consegui fechar o navegador e o app de chat nessa medição, então os números absolutos estão um pouco acima dos da seção de CPU.

Engine próprio contra OpenVINO, mesma sessão
  • Engine próprio
  • OpenVINO
FP3246,67 ms43,71 ms
INT820,94 ms17,01 ms

Latência em ms, menor é melhor (mediana de 3 rodadas)

Engine próprioOpenVINOVelocidade relativaPerda de mAP
FP3246,67 ms43,71 ms~93%—
INT820,94 ms17,01 ms~81%−0,26 contra −0,31

O que fica para a Enty

O melhor caminho muda com o hardware. TensorRT na GPU NVIDIA, OpenVINO INT8 na CPU x86, ncnn quando CUDA não é opção. Para a Enty, isso aponta para um backend em torno de um formato intermediário (ONNX) e de um runtime nativo trocável por alvo, em vez de amarrar a linguagem a um único runtime.

E o engine próprio mostrou que um único executável, sem nenhuma dependência, chega a ~93% do OpenVINO em FP32. Para fechar a distância no INT8, o próximo passo é manter as ativações em u8 entre convoluções INT8 seguidas, quantizando no epílogo de quem produz em vez de no empacotamento de quem consome.

Limites

  • Uma máquina, uma GPU, clocks não travados. Só batch 1 e entrada estática de 640×640.
  • Equivalência, não acurácia. As 8 imagens de validação conferem equivalência numérica. O mAP só foi medido nas comparações INT8 da CPU.
  • Artefatos presos ao hardware. Os engines do TensorRT e os pacotes do AOTInductor são específicos da arquitetura da GPU.
  • Carga externa no engine. O engine próprio foi medido com o navegador aberto. O OpenVINO rodou na mesma sessão, o que mantém a comparação justa, mas os números absolutos ficam um pouco acima do que seriam com a máquina ociosa.

Código e reprodução

O experimento inteiro está em github.com/nicolasfmelo/compiled-cnn:

  • Runners em C++ para AOTInductor, TensorRT, ncnn e o engine próprio, todos com validate, bench e detect.
  • Gerador do engine, kernels AVX2 e AVX-VNNI, calibração INT8 e os testes de cada kernel.
  • Scripts de benchmark com o protocolo térmico, e a validação contra a referência fixa.
  • Relatório completo em PDF e HTML, com um relatório técnico por rodada.

O README tem o passo a passo para reproduzir tudo do zero, e dá para rodar só os backends que interessam. A CPU e o engine próprio não precisam de nenhum pacote específico de GPU.