Inference Engine

Um mecanismo de inferência é o software que executa uma rede neural treinada para gerar previsões com novos dados. Ele recebe um modelo exportado de uma estrutura de treinamento, geralmente como um grafo computacional, por exemplo, um arquivo ONNX, otimiza esse grafo para um processador específico e o executa com o mínimo possível de latência de inferência e uso de memória. Há mecanismos para todas as classes de hardware, desde GPUs de centros de dados até celulares e microcontroladores. Na implantação de modelos, o mecanismo é o componente que calcula cada previsão.

Como os mecanismos de inferência aceleram os modelos#

Um modelo implantado nunca atualiza seus pesos, então um mecanismo pode descartar tudo o que o treinamento exige, como ativações armazenadas para a retropropagação, e reescrever o grafo livremente. Ele pré-calcula qualquer parte que dependa apenas de constantes, funde sequências de camadas, como convolução, normalização e ativação, em kernels únicos para que os resultados intermediários permaneçam na memória rápida do chip e planeja a memória para reutilizar buffers. Ele pode reduzir a precisão numérica para FP16 ou INT8 por meio da quantização de modelos, medindo intervalos de ativação em dados de amostra para INT8. Mecanismos como o TensorRT então medem o tempo de vários kernels candidatos para cada camada no dispositivo real e mantêm o mais rápido, vinculando o resultado àquele hardware:

Fundir a normalização em lotes com a convolução anterior é uma das reescritas mais comuns. Na inferência, a normalização apenas multiplica e soma valores fixos a cada canal, então esses números podem ser incorporados aos pesos e ao viés da convolução. O PyTorch disponibiliza a mesma transformação como fuse_conv_bn_eval:

import torch
from torch.nn.utils.fusion import fuse_conv_bn_eval

torch.manual_seed(0)

# A trained convolution followed by batch normalization (random statistics here)
conv = torch.nn.Conv2d(16, 32, kernel_size=3, padding=1).eval()
bn = torch.nn.BatchNorm2d(32).eval()
bn.running_mean.uniform_(-1, 1)
bn.running_var.uniform_(0.5, 2.0)

# Fold the normalization's scale and shift into the convolution's weights and bias
fused = fuse_conv_bn_eval(conv, bn)

# One layer now replaces two and produces the same output
x = torch.randn(1, 16, 64, 64)
with torch.inference_mode():
    diff = (bn(conv(x)) - fused(x)).abs().max().item()
print(f"Max difference after fusing: {diff:.1e}")

A saída mostra uma diferença máxima de 2.1e-06, causada pelo arredondamento de ponto flutuante: a camada fundida executa a mesma função que as duas camadas originais, com uma passagem pela memória em vez de duas.

Mecanismos de inferência comuns#

• TensorRT: mecanismo da NVIDIA para suas GPUs de centros de dados e módulos Jetson. Ele cria um plano para um modelo específico de GPU e uma versão específica do TensorRT, então os mecanismos precisam ser recriados quando qualquer um deles muda.
• OpenVINO: kit de ferramentas da Intel para suas CPUs, GPUs integradas e discretas e NPUs.
• ONNX Runtime: mecanismo multiplataforma da Microsoft para modelos ONNX, que encaminha o trabalho a back-ends de hardware chamados provedores de execução, incluindo CUDA, TensorRT, OpenVINO e Core ML.
• LiteRT: ambiente de execução do Google, anteriormente chamado TensorFlow Lite, para Android, Linux embarcado e microcontroladores, com delegados para GPUs e NPUs móveis.
• Core ML: estrutura da Apple para execução no dispositivo, que distribui o trabalho entre a CPU, a GPU e o Neural Engine.
• vLLM: mecanismo de código aberto para modelos de linguagem grandes que adiciona agendamento de solicitações e memória paginada para o cache de atenção, permitindo atender muitos usuários ao mesmo tempo.

A API Ultralytics YOLO escolhe o mecanismo com base no arquivo carregado. Assim, a mesma chamada predict executa um checkpoint .pt no PyTorch, um arquivo .onnx no ONNX Runtime, um arquivo .engine no TensorRT ou uma pasta OpenVINO no OpenVINO. Exportar o Ultralytics YOLO26 para OpenVINO e carregar o resultado troca o mecanismo sem exigir outras alterações no código:

from ultralytics import YOLO

# Exporta o modelo PyTorch para o formato do OpenVINO
model = YOLO("yolo26n.pt")
path = model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

# Carregar a pasta exportada executa as previsões pelo mecanismo OpenVINO
ov_model = YOLO(path)
results = ov_model("https://ultralytics.com/images/bus.jpg")
results[0].save(filename="bus_openvino.jpg")

Mecanismos de inferência vs. termos relacionados#

• PyTorch e outras estruturas de treinamento: Mantêm o grafo flexível e registram operações para calcular gradientes, permitindo projetar e treinar modelos. Também executam inferências, com mais sobrecarga do que um mecanismo criado para um dispositivo específico.
• ONNX: Formato de arquivo que descreve o grafo e os pesos de um modelo. O ONNX Runtime e o TensorRT são mecanismos que leem esse formato.
• Disponibilização de modelos: envolve um ou mais mecanismos em um serviço de rede com API, processamento de solicitações em lote e gerenciamento de versões, como faz o NVIDIA Dynamo-Triton, anteriormente chamado Triton Inference Server, para modelos TensorRT, ONNX Runtime e PyTorch.
• Mecanismo de inferência de sistemas especialistas: O significado mais antigo do termo, proveniente da IA baseada em regras, em que o mecanismo de inferência aplica regras se-então a uma base de conhecimento por encadeamento progressivo ou regressivo.