Inference Latency

La latenza di inferenza è il tempo che un modello di machine learning addestrato impiega per trasformare un singolo input, come un fotogramma della videocamera o un prompt testuale, in una previsione. Di solito si misura in millisecondi (ms) e determina la rapidità di reazione di un sistema: una videocamera che opera a 30 fotogrammi al secondo acquisisce un nuovo fotogramma ogni 33,3 ms, quindi un rilevatore che impiega più tempo accumula ritardo rispetto al flusso e non può più supportare l'inferenza in tempo reale. La latenza viene indicata per il solo passaggio forward o da un estremo all'altro, dall'input grezzo all'output utilizzabile; nei sistemi di produzione si monitorano percentili come la mediana (p50) e il 99º percentile (p99), perché poche risposte lente possono contare quanto la media.

Fattori che contribuiscono alla latenza di inferenza#

Una singola previsione attraversa diverse fasi. Il preprocessing decodifica, ridimensiona e normalizza l'input. Il passaggio forward esegue la rete; il suo costo cresce con i FLOPs del modello, la risoluzione dell'input e la precisione numerica, mentre la velocità dipende dal processore: CPU, GPU o unità di elaborazione neurale (NPU). Il postprocessing trasforma gli output grezzi in risultati; per un rilevatore, decodifica i riquadri ed esegue la soppressione dei massimi non locali (NMS). Una API cloud aggiunge il tempo di andata e ritorno della rete e quello che la richiesta trascorre in coda, motivo per cui l'IA edge esegue i modelli sul dispositivo che acquisisce i dati. Anche la prima chiamata è più lenta delle successive, perché i framework allocano memoria, caricano i pesi nelle cache e selezionano i kernel al primo utilizzo.

L'hardware e il runtime modificano il passaggio forward di un ordine di grandezza o più: Ultralytics YOLO26 nano impiega in media 38,9 ms per immagine COCO da 640 pixel con ONNX su CPU e 1,7 ms con TensorRT su una GPU NVIDIA T4. Ultralytics YOLO registra i tempi per fase di ogni predizione nell'attributo speed del risultato, e la modalità benchmark ripete la misurazione per ogni formato di esportazione:

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")

Il ciclo stampa i tempi di preprocessing, inferenza e postprocessing; la loro somma corrisponde alla latenza del modello per quell'immagine sul dispositivo corrente.

Misurare la latenza con precisione#

I valori di latenza sono confrontabili solo se vengono misurati nello stesso modo. Per ottenere misurazioni affidabili, si scartano alcune esecuzioni di riscaldamento, si cronometra un numero elevato di esecuzioni e si riportano la mediana e un percentile di coda anziché il risultato di una singola esecuzione. Sulle GPU il timer deve attendere il dispositivo, ad esempio con torch.cuda.synchronize(), perché i kernel vengono avviati in modo asincrono e una lettura anticipata dell'orologio interrompe la misurazione prima che il lavoro sia terminato. Dimensione dell'input, dimensione del batch, precisione e dispositivo devono corrispondere all'ambiente di distribuzione, perché la latenza di un modello su una GPU di un data center dice poco sulla sua latenza su un telefono. I FLOPs stimano il costo senza considerare l'hardware, ma modelli con lo stesso numero di FLOPs possono avere velocità molto diverse sullo stesso dispositivo.

Latenza di inferenza e throughput#

Il throughput è il numero di input elaborati da un sistema per unità di tempo, ad esempio immagini al secondo o token al secondo, e spesso varia in senso opposto alla latenza. Un batch più grande tiene l'hardware più occupato e aumenta il throughput, ma ogni input del batch deve attendere che l'intero batch venga elaborato, quindi aumenta anche il tempo necessario per rispondere a ogni richiesta:

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")

Su una CPU portatile, passando da un batch di dimensione 1 a uno di dimensione 8, il throughput è aumentato da 168 a 220 immagini al secondo, mentre il tempo per restituire un batch è passato da 6 ms a 36 ms. I sistemi interattivi, come l'assistenza alla guida e gli assistenti vocali, usano quindi batch di dimensione 1, mentre i processi offline, come l'indicizzazione di un archivio video, elaborano batch molto grandi. I server LLM usano il batching continuo, che aggiunge e rimuove richieste da un batch in esecuzione per mantenere alto il throughput senza far attendere ciascun utente per l'elaborazione di un batch intero.

Ridurre la latenza di inferenza#

I miglioramenti maggiori derivano in genere dalla riduzione dei calcoli: una variante di modello più piccola, una risoluzione di input più bassa o meno pesi grazie al pruning del modello. La quantizzazione del modello a FP16 o INT8 rende meno costosa ogni operazione rimanente sull'hardware dotato di unità rapide a bassa precisione. Esportare il modello in un motore di inferenza ottimizzato, come TensorRT, OpenVINO o ONNX Runtime, fonde i livelli e seleziona i kernel più veloci per il dispositivo. Eseguire il modello direttamente sul dispositivo elimina il tempo di andata e ritorno della rete, che con una connessione mobile spesso costa decine di millisecondi.

Dove conta la latenza#

• Modelli linguistici di grandi dimensioni (LLM): i servizi di chat monitorano il tempo al primo token, percepito dagli utenti come reattività, e il tempo per token di output, che determina la velocità di streaming. La decodifica speculativa riduce il secondo verificando diversi token proposti in un unico passaggio forward.
• Ispezione industriale: una videocamera sopra un nastro trasportatore deve classificare ogni pezzo prima che raggiunga il punto di scarto, quindi la latenza determina la velocità massima della linea.
• Veicoli autonomi: percezione, pianificazione e controllo condividono un budget ristretto; a 100 km/h un'auto percorre 2,8 metri durante ogni ritardo di 100 ms.