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
predictda 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
.pt2que 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
detectde 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
- FP32
- FP16
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
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.cppcom 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 em ms, escala logarítmica, menor é melhor
M1 a M4 são medições rápidas, sem controle térmico. M5 é o benchmark final.
| Marco | O que entrou | Threads | Latência |
|---|---|---|---|
| M1 | loops diretos de referência | 1 | 21.692 ms |
| M2 | convolução como GEMM, micro-kernel AVX2/FMA | 1 | 578 ms |
| M3 | bias, SiLU e residual no epílogo, concat sem cópia, arena | 1 | 348 ms |
| M4 | pool de threads fixado nos P-cores | 6 | 79 ms |
| M5 | painéis empacotados, kernel 6×16, grade por camada | 6 | 46,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
- OpenVINO
Latência em ms, menor é melhor (mediana de 3 rodadas)
| Engine próprio | OpenVINO | Velocidade relativa | Perda de mAP | |
|---|---|---|---|---|
| FP32 | 46,67 ms | 43,71 ms | ~93% | — |
| INT8 | 20,94 ms | 17,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,benchedetect. - 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.