Ultralytics YOLO27:

Benchmark dei modelli con Ultralytics YOLO#

Ultralytics YOLO ecosystem and integrations

Visualizzazione dei benchmark#

Introduzione#

Una volta addestrato e validato il tuo modello, il passo logico successivo è valutarne le prestazioni in vari scenari del mondo reale. La modalità Benchmark in Ultralytics YOLO26 serve a questo scopo fornendo un framework robusto per valutare la velocità e l'accuratezza del tuo modello su una gamma di formati di esportazione.

Consulta l' anteprima YOLO27 non rilasciata per i benchmark preliminari sulla velocità.



Watch: Benchmark Ultralytics YOLO26 Models | How to Compare Model Performance on Different Hardware?

Perché il benchmarking è cruciale?#

  • Decisioni informate: Ottieni informazioni sui compromessi tra velocità e accuratezza.
  • Allocazione delle risorse: Comprendi come diversi formati di esportazione si comportano su diversi tipi di hardware.
  • Ottimizzazione: Scopri quale formato di esportazione offre le migliori prestazioni per il tuo caso d'uso specifico.
  • Efficienza dei costi: Sfrutta in modo più efficiente le risorse hardware in base ai risultati dei benchmark.

Metriche chiave nella modalità Benchmark#

Formati di esportazione supportati#

  • ONNX: Per prestazioni CPU ottimali
  • TensorRT: Per la massima efficienza della GPU
  • OpenVINO: Per l'ottimizzazione dell'hardware Intel
  • CoreML, TensorFlow SavedModel e altro: Per diverse esigenze di distribuzione.
Suggerimento
  • Esporta in ONNX o OpenVINO per un'accelerazione della CPU fino a 3 volte.
  • Esporta in TensorRT per un'accelerazione della GPU fino a 5 volte.

Esempi di utilizzo#

Installazione consigliata

Installa Ultralytics con le dipendenze di esportazione prima di eseguire i benchmark per evitare pacchetti mancanti.

pip install ultralytics[export]

Esegui i benchmark di YOLO26n su tutti i formati di esportazione supportati (ONNX, TensorRT, ecc.). Consulta la sezione Argomenti sottostante per un elenco completo delle opzioni di esportazione.

Esempio
from ultralytics.utils.benchmarks import benchmark

# Benchmark on GPU
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)

# Benchmark specific export format
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, format="onnx")

Argomenti#

Argomenti come model, data, imgsz, quantize, device, verbose e format offrono agli utenti la flessibilità di mettere a punto i benchmark in base alle proprie esigenze specifiche e di confrontare facilmente le prestazioni di diversi formati di esportazione.

ChiaveValore predefinitoDescrizione
modelNoneSpecifica il percorso del file del modello. Accetta sia i formati .pt che .yaml, ad esempio "yolo26n.pt" per modelli pre-addestrati o file di configurazione.
dataNonePercorso del file YAML del dataset per il benchmarking, che in genere include percorsi e impostazioni per i dati di validazione. Esempio: "coco8.yaml". La classificazione richiede invece una directory del dataset o il nome di un dataset integrato (ad esempio, imagenet10).
imgsz640La dimensione dell'immagine di input per il modello. Deve essere un singolo intero per le immagini quadrate (ad esempio, 640); benchmark() supporta solo dimensioni di immagini quadrate.
quantizeNonePrecisione richiesta: 16 (FP16) o 8 (INT8; gli schemi PTQ richiedono la calibrazione data/fraction, quelli basati sui soli pesi no); 32/non impostato è FP32 laddove il formato lo supporta — un formato che non può esportare in FP32 rifiuta un esplicito 32 o ripiega sulla precisione richiesta. La riga nativa PyTorch non viene esportata: solo 16 la influenza, selezionando l'inferenza FP16, mentre 8, 32 e il valore non impostato eseguono FP32. Ciascun formato esegue quindi l'inferenza alla propria precisione di runtime. Sostituisce i flag deprecati half/int8.
device'cpu'Definisce il dispositivo o i dispositivi di calcolo per il benchmarking, come "cpu" o "cuda:0".
verboseFalseControlla il livello di dettaglio nell'output di log. Imposta verbose=True per log dettagliati.
eps0.001Piccolo epsilon (in millisecondi) aggiunto al tempo di inferenza per singola immagine prima di convertirlo in FPS, per prevenire la divisione per zero. Raramente modificato.
format''Esegue il benchmark solo del formato di esportazione specificato (ad esempio, format=onnx). Lascialo vuoto per testare automaticamente ogni formato supportato.
Valori predefiniti della funzione autonoma `benchmark()`

La funzione autonoma benchmark() (from ultralytics.utils.benchmarks import benchmark) utilizza i propri valori predefiniti di firma anziché i valori della tabella sopra, in particolare model="yolo26n.pt" e imgsz=160; passa imgsz in modo esplicito per corrispondere alla CLI di yolo benchmark.

Formati di esportazione#

I benchmark tenteranno di essere eseguiti automaticamente su tutti i possibili formati di esportazione elencati di seguito. In alternativa, puoi eseguire i benchmark per un formato specifico utilizzando l'argomento format, che accetta uno qualsiasi dei formati menzionati di seguito.

FormatoArgomento formatModelloMetadatiArgomenti
PyTorch-yolo26n.pt-
TorchScripttorchscriptyolo26n.torchscriptimgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n.onnximgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n_openvino_model/imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n.engineimgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n.mlpackageimgsz, dynamic, quantize, nms, batch, device
TF SavedModelsaved_modelyolo26n_saved_model/imgsz, keras, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n.pbimgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n_edgetpu.tfliteimgsz, quantize, opset, data, fraction, device
PaddlePaddlepaddleyolo26n_paddle_model/imgsz, batch, device
MNNmnnyolo26n.mnnimgsz, batch, dynamic, quantize, simplify, opset, nms, device
NCNNncnnyolo26n_ncnn_model/imgsz, quantize, batch, device
IMX500imxyolo26n_imx_model/imgsz, quantize, data, fraction, nms, device
RKNNrknnyolo26n_rknn_model/imgsz, batch, name, quantize, simplify, opset, data, fraction, device
ExecuTorchexecutorchyolo26n_executorch_model/imgsz, batch, device
Axeleraaxelerayolo26n_axelera_model/imgsz, batch, quantize, data, fraction, device
DEEPXdeepxyolo26n_deepx_model/imgsz, quantize, simplify, opset, data, optimize, device
Qualcomm QNNqnnyolo26n_qnn.onnximgsz, batch, name, quantize, simplify, opset, data, fraction, device
LiteRTlitertyolo26n.tfliteimgsz, quantize, batch, data, fraction, device
Hailohailoyolo26n_hailo_model/imgsz, name, quantize, data, fraction, simplify, conf, iou
Huawei Ascendascendyolo26n_ascend_model/imgsz, batch, name, quantize, opset, simplify, nms
Apple Core AIcoreaiyolo26n.aimodelimgsz, batch, quantize

nms=None utilizza i valori predefiniti per gli output grezzi per la NMS esterna. Imposta nms=False per selezionare una testa senza NMS disponibile; i formati non supportati ricorrono al loro percorso di output nativo. Le voci nms sopra indicano i formati che possono incorporare la NMS con nms=True.

Consulta la pagina Export per tutti i dettagli su export.

FAQ#

  • Ultralytics YOLO26 offre una modalità Benchmark per valutare le prestazioni del tuo modello su diversi formati di esportazione. Questa modalità fornisce informazioni su metriche chiave come la precisione media media (mAP50-95), l'accuratezza e il tempo di inferenza in millisecondi. Per eseguire i benchmark, puoi utilizzare comandi Python o da riga di comando (CLI). Ad esempio, per eseguire il benchmark su una GPU:

    Esempio
    from ultralytics.utils.benchmarks import benchmark
    
    # Benchmark on GPU
    benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)

    Per maggiori dettagli sugli argomenti dei benchmark, visita la sezione Argomenti.

  • L'esportazione dei modelli YOLO26 in formati diversi come ONNX, TensorRT e OpenVINO consente di ottimizzare le prestazioni in base al tuo ambiente di distribuzione. Ad esempio:

    • ONNX: Offre un'accelerazione della CPU fino a 3 volte.
    • TensorRT: Offre un'accelerazione della GPU fino a 5 volte.
    • OpenVINO: Specificamente ottimizzato per l'hardware Intel.

    Questi formati migliorano sia la velocità che l'accuratezza dei tuoi modelli, rendendoli più efficienti per varie applicazioni del mondo reale. Visita la pagina Esporta per i dettagli completi.

  • Il benchmarking dei tuoi modelli YOLO26 è essenziale per diversi motivi:

    • Decisioni informate: Comprendi i compromessi tra velocità e accuratezza.
    • Allocazione delle risorse: Misura le prestazioni su diverse opzioni hardware.
    • Ottimizzazione: Determina quale formato di esportazione offre le migliori prestazioni per casi d'uso specifici.
    • Efficienza dei costi: Ottimizza l'utilizzo dell'hardware in base ai risultati dei benchmark.

    Metriche chiave come mAP50-95, accuratezza Top-1 e tempo di inferenza aiutano a effettuare queste valutazioni. Fa' riferimento alla sezione Metriche chiave per ulteriori informazioni.

  • YOLO26 supporta una varietà di formati di esportazione, ciascuno su misura per specifici hardware e casi d'uso:

    • ONNX: Ideale per le prestazioni della CPU.
    • TensorRT: Ideale per l'efficienza della GPU.
    • OpenVINO: Ottimizzato per l'hardware Intel.
    • CoreML e TensorFlow: Utili per iOS e applicazioni di machine learning generali.

    Per un elenco completo dei formati supportati e dei rispettivi vantaggi, controlla la sezione Formati di esportazione supportati.

  • Durante l'esecuzione dei benchmark, è possibile personalizzare diversi argomenti per soddisfare esigenze specifiche:

    • model: Percorso del file del modello (ad esempio, "yolo26n.pt").
    • data: Percorso del file YAML del dataset (ad esempio, "coco8.yaml"); la classificazione richiede invece una directory del dataset o il nome di un dataset integrato (ad esempio, imagenet10).
    • imgsz: La dimensione dell'immagine di input quadrata come singolo intero, ad esempio 640. La modalità Benchmark utilizza la stessa dimensione di immagine quadrata sia in PyTorch che nei formati esportati per un confronto equo.
    • quantize: Precisione richiesta: 16 per FP16, 8 per INT8 (utile per dispositivi edge); 32/non impostato è FP32 laddove il formato lo supporta — un formato che non può esportare in FP32 rifiuta un esplicito 32 o ripiega sulla precisione richiesta. La riga nativa PyTorch non viene esportata: solo 16 la influenza, selezionando l'inferenza FP16, mentre 8, 32 e il valore non impostato eseguono FP32. Ciascun formato esegue quindi l'inferenza alla propria precisione di runtime.
    • device: Specifica il dispositivo di calcolo (ad esempio, "cpu", "cuda:0").
    • verbose: Controlla il livello di dettaglio dei log.

    Per un elenco completo degli argomenti, fa' riferimento alla sezione Argomenti.

Commenti