Inference Latency

A latência de inferência é o tempo que um modelo de aprendizado de máquina treinado leva para transformar uma entrada, como um quadro de câmera ou um prompt de texto, em uma previsão. Geralmente é expressa em milissegundos (ms) e determina a rapidez com que um sistema pode reagir: uma câmera que opera a 30 quadros por segundo fornece um novo quadro a cada 33,3 ms, então um detector que demora mais fica para trás do fluxo e deixa de oferecer inferência em tempo real. A latência é informada apenas para a passagem direta ou de ponta a ponta, desde a entrada bruta até a saída utilizável. Sistemas de produção acompanham percentis como a mediana (p50) e o 99º percentil (p99), pois algumas respostas lentas podem ser tão relevantes quanto a média.

O que aumenta a latência de inferência#

Uma única previsão passa por várias etapas. O pré-processamento decodifica, redimensiona e normaliza a entrada. A passagem direta executa a rede, e seu custo aumenta conforme os FLOPs do modelo, a resolução da entrada e a precisão numérica, enquanto sua velocidade depende do processador, seja uma CPU, uma GPU ou uma unidade de processamento neural (NPU). O pós-processamento converte as saídas brutas em resultados; em um detector, isso envolve decodificar caixas e executar a supressão não máxima (NMS). Uma API na nuvem acrescenta o tempo de ida e volta da rede e qualquer tempo de espera da solicitação na fila, por isso a IA de borda executa modelos no dispositivo que captura os dados. A primeira chamada também é mais lenta que as demais, pois as estruturas alocam memória, carregam pesos nos caches e selecionam kernels na primeira utilização.

O hardware e o ambiente de execução podem alterar o passe direto em uma ordem de magnitude ou mais: o Ultralytics YOLO26 nano leva, em média, 38,9 ms por imagem COCO de 640 pixels com ONNX em uma CPU e 1,7 ms com TensorRT em uma GPU NVIDIA T4. O Ultralytics YOLO registra os tempos de cada etapa de todas as predições no atributo speed do resultado, e o modo de benchmark repete a medição para cada formato de exportação:

from ultralytics import YOLO

# Load the smallest YOLO26 detection model
model = YOLO("yolo26n.pt")

# Predict on one image
results = model("https://ultralytics.com/images/bus.jpg")
result = results[0]

# Per-image time in milliseconds for each stage of the pipeline
for stage, ms in result.speed.items():
    print(f"{stage}: {ms:.1f} ms")

O loop imprime os tempos de pré-processamento, inferência e pós-processamento, cuja soma corresponde à latência do modelo para essa imagem no dispositivo atual.

Como medir a latência com precisão#

Os valores de latência só são comparáveis quando são medidos da mesma forma. Medições confiáveis descartam algumas execuções de aquecimento, medem muitas execuções e informam a mediana e um percentil de cauda, em vez de uma única execução. Em GPUs, o temporizador precisa aguardar o dispositivo, por exemplo, com torch.cuda.synchronize(), pois os kernels são iniciados de forma assíncrona e uma leitura antecipada do relógio termina antes da conclusão do trabalho. O tamanho da entrada, o tamanho do lote, a precisão e o dispositivo precisam corresponder à implantação, pois a latência de um modelo em uma GPU de centro de dados diz pouco sobre sua latência em um celular. Os FLOPs estimam o custo sem considerar nenhum hardware, mas modelos com o mesmo número de FLOPs podem operar em velocidades bem diferentes no mesmo dispositivo.

Latência de inferência e throughput#

Vazão é o número de entradas que um sistema processa por unidade de tempo, como imagens por segundo ou tokens por segundo, e muitas vezes varia em sentido contrário à latência. Um lote maior mantém o hardware mais ocupado e aumenta a vazão, mas cada entrada do lote precisa esperar até que o lote inteiro seja processado, aumentando também o tempo de resposta de cada solicitação:

import time

import torch
import torchvision

# A ResNet-18 image classifier in inference mode on the CPU
model = torchvision.models.resnet18().eval()

for batch in [1, 2, 4, 8]:
    x = torch.randn(batch, 3, 224, 224)
    with torch.inference_mode():
        model(x)  # warmup run, not timed
        times = []
        for _ in range(20):
            start = time.perf_counter()
            model(x)
            times.append(time.perf_counter() - start)
    latency = sorted(times)[len(times) // 2]  # median seconds per batch
    print(f"batch {batch}: {latency * 1e3:5.1f} ms per batch, {batch / latency:4.0f} images/s")

Em uma CPU de laptop, aumentar o lote de 1 para 8 elevou a vazão de 168 para 220 imagens por segundo, enquanto o tempo para retornar um lote aumentou de 6 ms para 36 ms. Por isso, sistemas interativos, como assistência ao motorista e assistentes de voz, operam com tamanho de lote 1, enquanto tarefas offline, como indexar um arquivo de vídeos, processam lotes maiores. Servidores de LLMs usam processamento contínuo em lotes, adicionando e removendo solicitações de um lote em execução para manter a vazão alta sem fazer cada usuário esperar pelo processamento de um lote inteiro.

Redução da latência de inferência#

Os maiores ganhos geralmente vêm da redução dos cálculos: uma variante menor do modelo, uma resolução de entrada mais baixa ou menos pesos por meio da poda de modelos. A quantização de modelos para FP16 ou INT8 torna cada operação restante mais barata em hardware com unidades rápidas de baixa precisão. Exportar para um mecanismo de inferência otimizado, como TensorRT, OpenVINO ou ONNX Runtime, funde camadas e escolhe os kernels mais rápidos para o dispositivo. Executar o modelo no próprio dispositivo elimina o tempo de ida e volta da rede, que costuma custar dezenas de milissegundos em uma conexão móvel.

Onde a latência é importante#

• Modelos de linguagem grandes (LLMs): os serviços de chat acompanham o tempo até o primeiro token, que os usuários percebem como capacidade de resposta, e o tempo por token de saída, que determina a velocidade de transmissão. A decodificação especulativa reduz o segundo ao verificar vários tokens propostos em um único passe direto.
• Inspeção industrial: Uma câmera acima de uma esteira precisa classificar cada peça antes que ela chegue ao portão de rejeição, então a latência determina a velocidade máxima da linha.
• Veículos autônomos: Percepção, planejamento e controle dividem um orçamento de tempo limitado, e a 100 km/h um carro percorre 2,8 metros durante cada atraso de 100 ms.