Benchmark dei modelli con Ultralytics YOLO#
Visualizzazione dei benchmark#
Introduzione#
Una volta addestrato e convalidato il modello, il passo successivo è valutarne le prestazioni in diversi scenari reali. La modalità Benchmark di Ultralytics YOLO26 serve proprio a questo: offre un solido framework per valutare la velocità e la precisione del modello in diversi formati di esportazione.
Consulta l'anteprima non ancora rilasciata di YOLO27 per i benchmark preliminari della velocità.
Guarda: Benchmark dei modelli Ultralytics YOLO26 | Come confrontare le prestazioni dei modelli su hardware diversi?
Perché i benchmark sono fondamentali?#
- Decisioni consapevoli: Comprendi i compromessi tra velocità e precisione.
- Allocazione delle risorse: Scopri come si comportano i diversi formati di esportazione su hardware differenti.
- Ottimizzazione: Scopri quale formato di esportazione offre le migliori prestazioni per il tuo caso d'uso specifico.
- Efficienza dei costi: Sfrutta le risorse hardware in modo più efficiente in base ai risultati dei benchmark.
Metriche chiave nella modalità Benchmark#
- mAP50-95: Per il rilevamento di oggetti, la segmentazione di istanze, la stima della posa e OBB.
- mIoU: Per la segmentazione semantica.
- delta1: Per la stima della profondità.
- accuracy_top1: Per la classificazione delle immagini.
- Tempo di inferenza: Tempo impiegato per ciascuna immagine, in millisecondi.
Formati di esportazione supportati#
- ONNX: Per prestazioni ottimali su CPU
- TensorRT: Per la massima efficienza su GPU
- OpenVINO: Per l'ottimizzazione su hardware Intel
- CoreML, TensorFlow SavedModel e altri: Per diverse esigenze di distribuzione.
- Esporta in ONNX o OpenVINO per accelerare la CPU fino a 3 volte.
- Esporta in TensorRT per accelerare la GPU fino a 5 volte.
Esempi d'uso#
Installa Ultralytics con le dipendenze per l'esportazione prima di eseguire i benchmark, così da 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 qui sotto per l'elenco completo delle opzioni di esportazione.
from ultralytics.utils.benchmarks import benchmark
# Esegui il benchmark su GPU
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)
# Esegui il benchmark su un formato di esportazione specifico
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 adattare i benchmark alle proprie esigenze specifiche e di confrontare facilmente le prestazioni dei diversi formati di esportazione.
| Chiave | Valore predefinito | Descrizione |
|---|---|---|
model | None | Specifica il percorso del file del modello. Accetta sia i formati .pt che .yaml, ad esempio "yolo26n.pt" per i modelli preaddestrati o i file di configurazione. |
data | None | Percorso del file YAML del dataset per i benchmark, che in genere include i percorsi e le impostazioni dei dati di convalida. Esempio: "coco8.yaml". Per la classificazione, invece, accetta una directory del dataset o il nome di un dataset integrato (ad es. imagenet10). |
imgsz | 640 | Dimensione dell'immagine di input per il modello. Deve essere un singolo intero per le immagini quadrate (ad es. 640); benchmark() supporta solo dimensioni quadrate. |
quantize | None | Precisione richiesta: 16 (FP16) o 8 (INT8; gli schemi PTQ richiedono i dati di calibrazione data/fraction, quelli basati solo sui pesi no); 32/non impostato corrisponde a FP32 quando il formato lo supporta: un formato che non può esportare in FP32 rifiuta un 32 esplicito oppure ripiega sulla precisione richiesta. La riga PyTorch nativa non viene esportata: solo 16 la influenza, selezionando l'inferenza FP16 al di fuori della CPU; altrimenti, viene eseguita in FP32. Ogni formato esegue quindi l'inferenza alla propria precisione di runtime. Sostituisce i flag deprecati half/int8. |
device | None | Definisce il dispositivo di calcolo per i benchmark, ad esempio "cpu" o "cuda:0"; se non è impostato, viene usata la prima GPU disponibile, oppure la CPU. |
verbose | False | Se è impostato True o un valore float, gli errori dei benchmark (tranne le asserzioni) vengono sollevati invece di essere registrati come errori; un valore float come 0.25 verifica inoltre che la metrica di ogni formato eseguito correttamente superi tale soglia. |
eps | 0.001 | Piccolo epsilon (in millisecondi) aggiunto al tempo di inferenza per immagine prima di convertirlo in FPS, per evitare la divisione per zero. Modificato raramente. |
format | '' | Esegue il benchmark solo sul formato di esportazione specificato (ad es. format=onnx). Lascialo vuoto per testare automaticamente tutti i formati supportati. |
La funzione autonoma benchmark() (from ultralytics.utils.benchmarks import benchmark) usa i valori predefiniti della propria firma anziché quelli della tabella sopra, in particolare model="yolo26n.pt", imgsz=160 e device="cpu"; passa esplicitamente imgsz e device per ottenere gli stessi valori predefiniti della CLI yolo benchmark.
Formati di esportazione#
I benchmark proveranno a essere eseguiti automaticamente su tutti i formati di esportazione possibili elencati qui sotto. In alternativa, puoi eseguire i benchmark per un formato specifico usando l'argomento format, che accetta uno qualsiasi dei formati indicati qui sotto.
| Formato | Argomento format | Modello | Metadati | Argomenti |
|---|---|---|---|---|
| PyTorch | - | yolo26n.pt | ✅ | - |
| TorchScript | torchscript | yolo26n.torchscript | ✅ | imgsz, quantize, dynamic, nms, batch, device |
| ONNX | onnx | yolo26n.onnx | ✅ | imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device |
| OpenVINO | openvino | yolo26n_openvino_model/ | ✅ | imgsz, quantize, dynamic, nms, batch, data, fraction, device |
| TensorRT | engine | yolo26n.engine | ✅ | imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device |
| CoreML | coreml | yolo26n.mlpackage | ✅ | imgsz, dynamic, quantize, nms, batch, device |
| Apple Core AI | coreai | yolo26n.aimodel | ✅ | imgsz, batch, quantize |
| TF SavedModel | saved_model | yolo26n_saved_model/ | ✅ | imgsz, quantize, opset, nms, batch, data, fraction, device |
| TF GraphDef | pb | yolo26n.pb | ❌ | imgsz, opset, batch, device |
| TF Edge TPU | edgetpu | yolo26n_edgetpu.tflite | ✅ | imgsz, quantize, opset, data, fraction, device |
| LiteRT | litert | yolo26n.tflite | ✅ | imgsz, quantize, batch, data, fraction, device |
| PaddlePaddle | paddle | yolo26n_paddle_model/ | ✅ | imgsz, batch, device |
| MNN | mnn | yolo26n.mnn | ✅ | imgsz, batch, dynamic, quantize, simplify, opset, nms, device |
| NCNN | ncnn | yolo26n_ncnn_model/ | ✅ | imgsz, quantize, batch, device |
| IMX500 | imx | yolo26n_imx_model/ | ✅ | imgsz, quantize, data, fraction, nms, device |
| RKNN | rknn | yolo26n_rknn_model/ | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| ExecuTorch | executorch | yolo26n_executorch_model/ | ✅ | imgsz, batch, device |
| Axelera | axelera | yolo26n_axelera_model/ | ✅ | imgsz, batch, quantize, data, fraction, device |
| DEEPX | deepx | yolo26n_deepx_model/ | ✅ | imgsz, quantize, simplify, opset, data, optimize, device |
| Qualcomm QNN | qnn | yolo26n_qnn.onnx | ✅ | imgsz, batch, name, quantize, simplify, opset, data, fraction, device |
| Hailo | hailo | yolo26n_hailo_model/ | ✅ | imgsz, name, quantize, data, fraction, simplify, conf, iou, device |
| Huawei Ascend | ascend | yolo26n_ascend_model/ | ✅ | imgsz, batch, name, quantize, opset, simplify, nms, device |
| AMD Xilinx | xilinx | yolo26n_xilinx_model/ | ✅ | imgsz, name, quantize, data, fraction, opset, simplify, device |
nms=None restituisce per impostazione predefinita output grezzi per NMS esterno. Imposta nms=False per selezionare una head disponibile senza NMS; i formati non supportati utilizzano il proprio percorso di output nativo. Le voci nms qui sopra identificano i formati che possono integrare NMS con nms=True.
Consulta i dettagli completi di export nella pagina Esportazione.
Domande frequenti#
Ultralytics YOLO26 offre una modalità Benchmark per valutare le prestazioni del modello in diversi formati di esportazione. Questa modalità fornisce informazioni su metriche chiave come la precisione media media (mAP50-95), la precisione e il tempo di inferenza in millisecondi. Puoi eseguire i benchmark tramite comandi Python o CLI. Ad esempio, per eseguire il benchmark su una GPU:
Esempiofrom ultralytics.utils.benchmarks import benchmark # Esegui il benchmark su GPU benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)Per maggiori dettagli sugli argomenti dei benchmark, consulta la sezione Argomenti.
Esportare i modelli YOLO26 in formati diversi, come ONNX, TensorRT e OpenVINO, ti consente di ottimizzare le prestazioni in base all'ambiente di distribuzione. Per esempio:
- ONNX: Offre fino a 3 volte più velocità sulla CPU.
- TensorRT: Offre fino a 5 volte più velocità sulla GPU.
- OpenVINO: Ottimizzato specificamente per l'hardware Intel.
Questi formati migliorano la velocità di inferenza sull'hardware di destinazione, rendendo i modelli più efficienti per varie applicazioni reali. Visita la pagina Esportazione per tutti i dettagli.
Eseguire benchmark sui modelli YOLO26 è essenziale per diversi motivi:
- Decisioni consapevoli: Comprendi i compromessi tra velocità e precisione.
- Allocazione delle risorse: Valuta le prestazioni sulle diverse opzioni hardware.
- Ottimizzazione: Individua il formato di esportazione che offre le migliori prestazioni per casi d'uso specifici.
- Efficienza dei costi: Ottimizza l'uso dell'hardware in base ai risultati dei benchmark.
Metriche chiave come mAP50-95, la precisione Top-1 e il tempo di inferenza aiutano a effettuare queste valutazioni. Consulta la sezione Metriche chiave per maggiori informazioni.
YOLO26 supporta diversi formati di esportazione, ciascuno pensato per specifici hardware e casi d'uso:
- ONNX: Ideale per le prestazioni su CPU.
- TensorRT: Ideale per l'efficienza su GPU.
- OpenVINO: Ottimizzato per l'hardware Intel.
- CoreML e TensorFlow: Utili per iOS e per le applicazioni ML in generale.
Per l'elenco completo dei formati supportati e dei rispettivi vantaggi, consulta la sezione Formati di esportazione supportati.
Quando esegui i benchmark, puoi personalizzare diversi argomenti in base alle tue esigenze:
- model: Percorso del file del modello (ad es. "yolo26n.pt").
- data: Percorso del file YAML del dataset (ad es.
"coco8.yaml"); per la classificazione, invece, accetta una directory del dataset o il nome di un dataset integrato (ad es.imagenet10). - imgsz: Dimensione quadrata dell'immagine di input, espressa come singolo intero, ad esempio
640. La modalità Benchmark usa la stessa dimensione quadrata per le immagini in PyTorch e nei formati esportati, per garantire un confronto equo. - quantize: Precisione richiesta:
16per FP16,8per INT8 (utile per i dispositivi edge);32/non impostato corrisponde a FP32 quando il formato lo supporta: un formato che non può esportare in FP32 rifiuta un32esplicito oppure ripiega sulla precisione richiesta. La riga PyTorch nativa non viene esportata: solo16la influenza, selezionando l'inferenza FP16 al di fuori della CPU; altrimenti, viene eseguita in FP32. Ogni formato esegue quindi l'inferenza alla propria precisione di runtime. - device: Specifica il dispositivo di calcolo (ad es. "cpu", "cuda:0").
- verbose: Solleva un errore in caso di problemi con i benchmark anziché registrarli; passa un valore float per richiedere anche che la metrica di ciascun formato superi tale soglia.
Per l'elenco completo degli argomenti, consulta la sezione Argomenti.