Ultralytics YOLO27:
Get Started

Rilevamento degli oggetti con Ultralytics YOLO#

Ultralytics YOLO object detection with bounding boxes

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.
Suggerimento

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.

Modellodimensione
(pixel)
mAPval
50-95
mAPval
50-95(e2e)
Velocità
CPU ONNX
(ms)
Velocità
T4 TensorRT10
(ms)
parametri
(M)
FLOPs
(B)
YOLO26n64040.940.138.9 ± 0.71.7 ± 0.02.45.5
YOLO26s64048.647.887.2 ± 0.92.5 ± 0.09.520.9
YOLO26m64053.152.5220.0 ± 1.44.7 ± 0.120.468.4
YOLO26l64055.054.4286.2 ± 2.06.2 ± 0.224.886.8
YOLO26x64057.556.9525.8 ± 4.011.8 ± 0.255.7194.4
  • Valori mAPval per un singolo modello e una singola scala sul dataset COCO val2017.
    Riproduci i risultati con yolo detect val data=coco.yaml device=0. Aggiungi nms=False per riprodurre la colonna e2e.
  • Velocità media sulle immagini COCO val con ONNX su CPU e TensorRT10 su una GPU NVIDIA T4.
    Riproduci i risultati con yolo 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.

Esempio
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.

Esempio
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 FN

Predici#

Usa un modello YOLO26n addestrato per eseguire previsioni sulle immagini.

Esempio
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 riquadro

Consulta 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.

AttributoTipoFormaDescrizione
result.boxesBoxes(N)Riquadri di rilevamento.
result.boxes.datatorch.float32(N,6/7)[x1,y1,x2,y2,conf,cls] grezzi, più l'ID di tracciamento opzionale.
result.boxes.xyxytorch.float32(N,4)Riquadri in pixel xyxy.
result.boxes.conftorch.float32(N,)Punteggi di confidenza.
result.boxes.clstorch.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.

Esempio
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.

FormatoArgomento formatModelloMetadatiArgomenti
PyTorch-yolo26n.pt✅-
TorchScripttorchscriptyolo26n.torchscript✅imgsz, quantize, dynamic, nms, batch, device
ONNXonnxyolo26n.onnx✅imgsz, quantize, dynamic, simplify, opset, nms, batch, data, fraction, device
OpenVINOopenvinoyolo26n_openvino_model/✅imgsz, quantize, dynamic, nms, batch, data, fraction, device
TensorRTengineyolo26n.engine✅imgsz, quantize, dynamic, simplify, opset, workspace, nms, batch, data, fraction, device
CoreMLcoremlyolo26n.mlpackage✅imgsz, dynamic, quantize, nms, batch, device
Apple Core AIcoreaiyolo26n.aimodel✅imgsz, batch, quantize
TF SavedModelsaved_modelyolo26n_saved_model/✅imgsz, quantize, opset, nms, batch, data, fraction, device
TF GraphDefpbyolo26n.pb❌imgsz, opset, batch, device
TF Edge TPUedgetpuyolo26n_edgetpu.tflite✅imgsz, quantize, opset, data, fraction, device
LiteRTlitertyolo26n.tflite✅imgsz, quantize, batch, data, fraction, device
PaddlePaddlepaddleyolo26n_paddle_model/✅imgsz, batch, device
MNNmnnyolo26n.mnn✅imgsz, 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.onnx✅imgsz, batch, name, quantize, simplify, opset, data, fraction, device
Hailohailoyolo26n_hailo_model/✅imgsz, name, quantize, data, fraction, simplify, conf, iou, device
Huawei Ascendascendyolo26n_ascend_model/✅imgsz, batch, name, quantize, opset, simplify, nms, device
AMD Xilinxxilinxyolo26n_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:

    1. Prepara il dataset: assicurati che il dataset sia nel formato YOLO. Per le istruzioni, consulta la nostra guida ai dataset.
    2. Carica il modello: usa la libreria Ultralytics YOLO per caricare un modello preaddestrato o crearne uno nuovo da un file YAML.
    3. Addestra il modello: esegui il metodo train in Python o il comando yolo detect train nella CLI.
    Esempio
    from 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 comando yolo detect val nella CLI. Otterrai metriche come mAP50-95, mAP50 e altre.

    Esempio
    from ultralytics import YOLO
    
    # Carica il modello
    model = YOLO("path/to/best.pt")
    
    # Convalida il modello
    metrics = model.val()
    print(metrics.box.map)  # mAP50-95

    Per 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.

    Esempio
    from 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:

    1. Modelli preaddestrati: sfrutta i modelli preaddestrati su dataset diffusi come COCO e ImageNet per accelerare lo sviluppo.
    2. Elevata accuratezza: raggiunge punteggi mAP notevoli, garantendo un rilevamento affidabile degli oggetti.
    3. Velocità: ottimizzato per l’inferenza in tempo reale, è ideale per le applicazioni che richiedono un’elaborazione rapida.
    4. 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.

Commenti