Rilevamento degli oggetti con Ultralytics YOLO#
Il rilevamento degli oggetti è un’attività che consiste nell’identificare la posizione e la classe degli oggetti in un’immagine o in un flusso video.
Il risultato di un rilevatore di oggetti è un insieme di riquadri delimitatori che racchiudono gli oggetti nell’immagine, con le etichette di classe e i punteggi di confidenza per ciascun riquadro. Il rilevamento degli oggetti è una buona scelta quando devi identificare gli oggetti di interesse in una scena, ma non hai bisogno di conoscerne la forma esatta.
Guarda: Rilevamento di oggetti con un modello Ultralytics YOLO preaddestrato.
I modelli YOLO26 Detect sono i modelli YOLO26 predefiniti, ovvero yolo26n.pt, e sono preaddestrati su COCO.
Modelli#
Di seguito sono mostrati i modelli YOLO26 Detect preaddestrati sul dataset COCO.
I modelli vengono scaricati automaticamente dalla più recente release di Ultralytics al primo utilizzo.
| Modello | dimensione (pixel) | mAPval 50-95 | mAPval 50-95(e2e) | Velocità CPU ONNX (ms) | Velocità T4 TensorRT10 (ms) | parametri (M) | FLOPs (B) |
|---|---|---|---|---|---|---|---|
| YOLO26n | 640 | 40.9 | 40.1 | 38.9 ± 0.7 | 1.7 ± 0.0 | 2.4 | 5.5 |
| YOLO26s | 640 | 48.6 | 47.8 | 87.2 ± 0.9 | 2.5 ± 0.0 | 9.5 | 20.9 |
| YOLO26m | 640 | 53.1 | 52.5 | 220.0 ± 1.4 | 4.7 ± 0.1 | 20.4 | 68.4 |
| YOLO26l | 640 | 55.0 | 54.4 | 286.2 ± 2.0 | 6.2 ± 0.2 | 24.8 | 86.8 |
| YOLO26x | 640 | 57.5 | 56.9 | 525.8 ± 4.0 | 11.8 ± 0.2 | 55.7 | 194.4 |
- Valori mAPval per un singolo modello e una singola scala sul dataset COCO val2017.
Riproduci i risultati conyolo detect val data=coco.yaml device=0. Aggiunginms=Falseper riprodurre la colonna e2e. - Velocità media sulle immagini COCO val con ONNX su CPU e TensorRT10 su una GPU NVIDIA T4.
Riproduci i risultati conyolo detect val data=coco.yaml batch=1 device=0|cpu nms=False - I valori di Parametri e FLOPs si riferiscono ai modelli fusi dopo la fusione di Conv/BatchNorm e la rimozione del ramo di rilevamento inutilizzato. I checkpoint preaddestrati mantengono l’architettura di addestramento completa e possono riportare valori più elevati.
Consulta l’anteprima non ancora rilasciata di YOLO27 per i risultati preliminari del rilevamento su COCO.
Addestra#
Addestra YOLO26n sul dataset COCO8 per 100 epoche con una dimensione dell’immagine di 640. Per l’elenco completo degli argomenti disponibili, consulta la pagina Configurazione.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n.yaml") # crea un nuovo modello dal file YAML
model = YOLO("yolo26n.pt") # carica un modello preaddestrato (consigliato per l'addestramento)
model = YOLO("yolo26n.yaml").load("yolo26n.pt") # crea dal file YAML e trasferisci i pesi
# Addestra il modello
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)Consulta la pagina Addestramento per i dettagli completi sulla modalità train. Puoi addestrare i modelli di rilevamento anche con l’addestramento cloud di Ultralytics Platform.
Formato del dataset#
Per una descrizione dettagliata del formato dei dataset YOLO per il rilevamento, consulta la guida ai dataset. Per convertire un dataset COCO JSON esistente nel formato YOLO, usa la funzione integrata convert_coco descritta nella guida alla conversione da COCO a YOLO. Puoi anche annotare e gestire i dataset di rilevamento con gli strumenti di annotazione assistita dall’AI di Ultralytics Platform.
Convalida#
Convalida l’accuratezza del modello YOLO26n addestrato. Non servono argomenti, perché model conserva data usato per l’addestramento e gli argomenti come attributi del modello: path/to/best.pt dell’esempio di addestramento esegue la convalida su COCO8. I pesi ufficiali registrano un percorso al dataset di addestramento che non esiste sul tuo computer, quindi ripiegano sul valore predefinito dell’attività coco8.yaml e mostrano un avviso. Passa data per convalidare il modello su un altro dataset.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n.pt") # carica un modello ufficiale
model = YOLO("path/to/best.pt") # carica un modello personalizzato
# Convalida il modello
metrics = model.val() # non servono argomenti, il dataset e le impostazioni vengono ricordati
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # un elenco contenente mAP50-95 per ogni categoria
metrics.box.image_metrics # dizionario con le metriche per immagine: precisione, richiamo, F1, TP, FP e FNPredici#
Usa un modello YOLO26n addestrato per eseguire previsioni sulle immagini.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n.pt") # carica un modello ufficiale
model = YOLO("path/to/best.pt") # carica un modello personalizzato
# Esegui previsioni con il modello
results = model("https://ultralytics.com/images/bus.jpg") # esegui una previsione su un’immagine
# Accedi ai risultati
for result in results:
xywh = result.boxes.xywh # centro-x, centro-y, larghezza, altezza
xywhn = result.boxes.xywhn # normalized
xyxy = result.boxes.xyxy # alto-sinistra-x, alto-sinistra-y, basso-destra-x, basso-destra-y
xyxyn = result.boxes.xyxyn # normalized
names = [result.names[cls.item()] for cls in result.boxes.cls.int()] # nome della classe di ogni riquadro
confs = result.boxes.conf # punteggio di confidenza di ogni riquadroConsulta la pagina Previsione per i dettagli completi sulla modalità predict.
Output dei risultati#
Il rilevamento degli oggetti restituisce un oggetto Results per ogni immagine. Il campo principale delle previsioni è result.boxes, che contiene le coordinate dei riquadri, gli ID di classe e i punteggi di confidenza di ogni oggetto rilevato.
| Attributo | Tipo | Forma | Descrizione |
|---|---|---|---|
result.boxes | Boxes | (N) | Riquadri di rilevamento. |
result.boxes.data | torch.float32 | (N,6/7) | [x1,y1,x2,y2,conf,cls] grezzi, più l'ID di tracciamento opzionale. |
result.boxes.xyxy | torch.float32 | (N,4) | Riquadri in pixel xyxy. |
result.boxes.conf | torch.float32 | (N,) | Punteggi di confidenza. |
result.boxes.cls | torch.float32 | (N,) | ID delle classi; converti in int per ottenere i nomi. |
Per consultare i campi Results specifici di ogni attività, visita la sezione Risultati delle previsioni per attività.
Esporta#
Esporta un modello YOLO26n in un formato diverso, come ONNX, CoreML ecc.
from ultralytics import YOLO
# Carica un modello
model = YOLO("yolo26n.pt") # carica un modello ufficiale
model = YOLO("path/to/best.pt") # carica un modello personalizzato
# Esporta il modello
model.export(format="onnx")I formati di esportazione disponibili per YOLO26 sono elencati nella tabella seguente. Puoi esportare in qualsiasi formato usando l’argomento format, ovvero format='onnx' o format='engine'. Puoi eseguire previsioni o convalidare direttamente i modelli esportati, ad esempio con yolo predict model=yolo26n.onnx. Al termine dell’esportazione, vengono mostrati esempi di utilizzo per il tuo modello.
| 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#
Sì. La guida introduttiva a Ultralytics Platform illustra un flusso di lavoro basato su browser per annotare dataset, addestrare modelli di rilevamento su GPU cloud e distribuirli a endpoint di inferenza.
L’addestramento di un modello YOLO26 su un dataset personalizzato prevede alcuni passaggi:
- Prepara il dataset: assicurati che il dataset sia nel formato YOLO. Per le istruzioni, consulta la nostra guida ai dataset.
- Carica il modello: usa la libreria Ultralytics YOLO per caricare un modello preaddestrato o crearne uno nuovo da un file YAML.
- Addestra il modello: esegui il metodo
trainin Python o il comandoyolo detect trainnella CLI.
Esempiofrom ultralytics import YOLO # Carica un modello preaddestrato model = YOLO("yolo26n.pt") # Addestra il modello sul tuo dataset personalizzato model.train(data="my_custom_dataset.yaml", epochs=100, imgsz=640)Per le opzioni di configurazione dettagliate, visita la pagina Configurazione.
Ultralytics YOLO26 offre diversi modelli preaddestrati per il rilevamento degli oggetti, la segmentazione delle istanze, la segmentazione semantica, la stima della profondità, la classificazione, la stima della posa e i riquadri delimitatori orientati. Questi modelli sono preaddestrati sul dataset COCO, su Cityscapes per la segmentazione semantica, su una combinazione di più dataset per la stima della profondità, su ImageNet per la classificazione oppure su DOTAv1 per l’OBB. Ecco alcuni dei modelli disponibili:
Per un elenco dettagliato e le metriche di prestazione, consulta la sezione Modelli.
Per convalidare l’accuratezza del modello YOLO26 addestrato, puoi usare il metodo
.val()in Python o il comandoyolo detect valnella CLI. Otterrai metriche come mAP50-95, mAP50 e altre.Esempiofrom ultralytics import YOLO # Carica il modello model = YOLO("path/to/best.pt") # Convalida il modello metrics = model.val() print(metrics.box.map) # mAP50-95Per ulteriori dettagli sulla convalida, visita la pagina Convalida.
Ultralytics YOLO26 consente di esportare i modelli in diversi formati, come ONNX, TensorRT, CoreML e altri, per garantire la compatibilità con diverse piattaforme e dispositivi.
Esempiofrom ultralytics import YOLO # Carica il modello model = YOLO("yolo26n.pt") # Esporta il modello in formato ONNX model.export(format="onnx")Consulta l’elenco completo dei formati supportati e le relative istruzioni nella pagina Esportazione.
Ultralytics YOLO26 è progettato per offrire prestazioni all’avanguardia nel rilevamento degli oggetti, nella segmentazione delle istanze, nella segmentazione semantica e nella stima della posa. Ecco alcuni vantaggi principali:
- Modelli preaddestrati: sfrutta i modelli preaddestrati su dataset diffusi come COCO e ImageNet per accelerare lo sviluppo.
- Elevata accuratezza: raggiunge punteggi mAP notevoli, garantendo un rilevamento affidabile degli oggetti.
- Velocità: ottimizzato per l’inferenza in tempo reale, è ideale per le applicazioni che richiedono un’elaborazione rapida.
- Flessibilità: esporta i modelli in vari formati, come ONNX e TensorRT, per distribuirli su più piattaforme.
Esplora il nostro blog per scoprire casi d’uso e storie di successo che mostrano YOLO26 in azione.