Rilevamento di oggetti
Il rilevamento di oggetti è un'attività che implica l'identificazione della posizione e della classe degli oggetti in un'immagine o in un flusso video.
L'output di un rilevatore di oggetti è un insieme di bounding box che racchiudono gli oggetti nell'immagine, insieme alle etichette di classe e ai punteggi di confidenza per ogni box. Il rilevamento di oggetti è una buona scelta quando è necessario identificare oggetti di interesse in una scena, ma non è necessario sapere esattamente dove si trova l'oggetto o la sua forma esatta.
Guarda: Rilevamento di oggetti con modello YOLO Ultralytics pre-addestrato.
Suggerimento
I modelli di rilevamento YOLO11 sono i modelli YOLO11 predefiniti, cioè yolo11n.pt
e sono pre-addestrati su COCO.
Modelli
I modelli di rilevamento YOLO11 pre-addestrati sono mostrati qui. I modelli Detect, Segment e Pose sono pre-addestrati sul dataset COCO, mentre i modelli Classify sono pre-addestrati sul dataset ImageNet.
I modelli vengono scaricati automaticamente dall'ultima release di Ultralytics al primo utilizzo.
Modello | dimensione (pixel) |
mAPval 50-95 |
Velocità CPU ONNX (ms) |
Velocità T4 TensorRT10 (ms) |
parametri (M) |
FLOPs (B) |
---|---|---|---|---|---|---|
YOLO11n | 640 | 39.5 | 56.1 ± 0.8 | 1.5 ± 0.0 | 2.6 | 6.5 |
YOLO11s | 640 | 47.0 | 90.0 ± 1.2 | 2.5 ± 0.0 | 9.4 | 21.5 |
YOLO11m | 640 | 51.5 | 183.2 ± 2.0 | 4.7 ± 0.1 | 20.1 | 68.0 |
YOLO11l | 640 | 53.4 | 238.6 ± 1.4 | 6.2 ± 0.1 | 25.3 | 86.9 |
YOLO11x | 640 | 54.7 | 462.8 ± 6.7 | 11.3 ± 0.2 | 56.9 | 194.9 |
- mAPval i valori si riferiscono a un singolo modello single-scale su COCO val2017 dataset.
Riproduci tramiteyolo val detect data=coco.yaml device=0
- Velocità calcolata come media sulle immagini COCO val utilizzando un'istanza Amazon EC2 P4d instance.
Riproduci tramiteyolo val detect data=coco.yaml batch=1 device=0|cpu
Addestramento
Addestra YOLO11n sul dataset COCO8 per 100 epoche con una dimensione dell'immagine di 640. Per un elenco completo degli argomenti disponibili, consulta la pagina Configurazione.
Esempio
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n.yaml") # build a new model from YAML
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
model = YOLO("yolo11n.yaml").load("yolo11n.pt") # build from YAML and transfer weights
# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
# Build a new model from YAML and start training from scratch
yolo detect train data=coco8.yaml model=yolo11n.yaml epochs=100 imgsz=640
# Start training from a pretrained *.pt model
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640
# Build a new model from YAML, transfer pretrained weights to it and start training
yolo detect train data=coco8.yaml model=yolo11n.yaml pretrained=yolo11n.pt epochs=100 imgsz=640
Formato del set di dati
Il formato del dataset di rilevamento YOLO è descritto in dettaglio nella Guida al dataset. Per convertire il tuo dataset esistente da altri formati (come COCO ecc.) al formato YOLO, utilizza lo strumento JSON2YOLO di Ultralytics.
Valutazione
Convalida il modello YOLO11n addestrato accuratezza sul dataset COCO8. Non sono necessari argomenti poiché model
mantiene il suo training data
e gli argomenti come attributi del modello.
Esempio
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n.pt") # load an official model
model = YOLO("path/to/best.pt") # load a custom model
# Validate the model
metrics = model.val() # no arguments needed, dataset and settings remembered
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # a list contains map50-95 of each category
yolo detect val model=yolo11n.pt # val official model
yolo detect val model=path/to/best.pt # val custom model
Predizione
Utilizza un modello YOLO11n addestrato per eseguire previsioni sulle immagini.
Esempio
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n.pt") # load an official model
model = YOLO("path/to/best.pt") # load a custom model
# Predict with the model
results = model("https://ultralytics.com/images/bus.jpg") # predict on an image
# Access the results
for result in results:
xywh = result.boxes.xywh # center-x, center-y, width, height
xywhn = result.boxes.xywhn # normalized
xyxy = result.boxes.xyxy # top-left-x, top-left-y, bottom-right-x, bottom-right-y
xyxyn = result.boxes.xyxyn # normalized
names = [result.names[cls.item()] for cls in result.boxes.cls.int()] # class name of each box
confs = result.boxes.conf # confidence score of each box
yolo detect predict model=yolo11n.pt source='https://ultralytics.com/images/bus.jpg' # predict with official model
yolo detect predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model
Vedi tutti i predict
dettagli della modalità nella Predizione pagina.
Esportazione
Esporta un modello YOLO11n in un formato diverso come ONNX, CoreML, ecc.
Esempio
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n.pt") # load an official model
model = YOLO("path/to/best.pt") # load a custom trained model
# Export the model
model.export(format="onnx")
yolo export model=yolo11n.pt format=onnx # export official model
yolo export model=path/to/best.pt format=onnx # export custom trained model
I formati di esportazione YOLO11 disponibili sono nella tabella sottostante. Puoi esportare in qualsiasi formato usando l' format
argomento, ad esempio format='onnx'
oppure format='engine'
. Puoi prevedere o convalidare direttamente sui modelli esportati, ad esempio yolo predict model=yolo11n.onnx
. Esempi di utilizzo vengono mostrati per il tuo modello dopo che l'esportazione è stata completata.
Formato | format Argomento |
Modello | Metadati | Argomenti |
---|---|---|---|---|
PyTorch | - | yolo11n.pt |
✅ | - |
TorchScript | torchscript |
yolo11n.torchscript |
✅ | imgsz , half , dynamic , optimize , nms , batch , device |
ONNX | onnx |
yolo11n.onnx |
✅ | imgsz , half , dynamic , simplify , opset , nms , batch , device |
OpenVINO | openvino |
yolo11n_openvino_model/ |
✅ | imgsz , half , dynamic , int8 , nms , batch , data , fraction , device |
TensorRT | engine |
yolo11n.engine |
✅ | imgsz , half , dynamic , simplify , workspace , int8 , nms , batch , data , fraction , device |
CoreML | coreml |
yolo11n.mlpackage |
✅ | imgsz , half , int8 , nms , batch , device |
TF SavedModel | saved_model |
yolo11n_saved_model/ |
✅ | imgsz , keras , int8 , nms , batch , device |
TF GraphDef | pb |
yolo11n.pb |
❌ | imgsz , batch , device |
TF Lite | tflite |
yolo11n.tflite |
✅ | imgsz , half , int8 , nms , batch , data , fraction , device |
TF Edge TPU | edgetpu |
yolo11n_edgetpu.tflite |
✅ | imgsz , device |
TF.js | tfjs |
yolo11n_web_model/ |
✅ | imgsz , half , int8 , nms , batch , device |
PaddlePaddle | paddle |
yolo11n_paddle_model/ |
✅ | imgsz , batch , device |
MNN | mnn |
yolo11n.mnn |
✅ | imgsz , batch , int8 , half , device |
NCNN | ncnn |
yolo11n_ncnn_model/ |
✅ | imgsz , half , batch , device |
IMX500 | imx |
yolo11n_imx_model/ |
✅ | imgsz , int8 , data , fraction , device |
RKNN | rknn |
yolo11n_rknn_model/ |
✅ | imgsz , batch , name , device |
Vedi tutti i export
dettagli nella Esportazione pagina.
FAQ
Come posso addestrare un modello YOLO11 sul mio set di dati personalizzato?
L'addestramento di un modello YOLO11 su un dataset personalizzato prevede alcuni passaggi:
- Prepara il Dataset: Assicurati che il tuo dataset sia nel formato YOLO. Per maggiori informazioni, consulta la nostra Guida al Dataset.
- Carica il Modello: Utilizza la libreria Ultralytics YOLO per caricare un modello pre-addestrato o creare un nuovo modello da un file YAML.
- Addestra il Modello: Esegui il
train
metodo in python o ilyolo detect train
comando nella CLI.
Esempio
from ultralytics import YOLO
# Load a pretrained model
model = YOLO("yolo11n.pt")
# Train the model on your custom dataset
model.train(data="my_custom_dataset.yaml", epochs=100, imgsz=640)
yolo detect train data=my_custom_dataset.yaml model=yolo11n.pt epochs=100 imgsz=640
Per opzioni di configurazione dettagliate, visita la pagina Configurazione.
Quali modelli pre-addestrati sono disponibili in YOLO11?
Ultralytics YOLO11 offre diversi modelli pre-addestrati per il rilevamento di oggetti, la segmentazione e la stima della posa. Questi modelli sono pre-addestrati sul dataset COCO o ImageNet per attività di classificazione. Ecco alcuni dei modelli disponibili:
Per un elenco dettagliato e metriche di performance, consulta la sezione Modelli.
Come posso convalidare l'accuratezza del mio modello YOLO addestrato?
Per convalidare l'accuratezza del tuo modello YOLO11 addestrato, puoi utilizzare il .val()
metodo in python o il yolo detect val
comando nella CLI. Questo fornirà metriche come mAP50-95, mAP50 e altro.
Esempio
from ultralytics import YOLO
# Load the model
model = YOLO("path/to/best.pt")
# Validate the model
metrics = model.val()
print(metrics.box.map) # mAP50-95
yolo detect val model=path/to/best.pt
Per maggiori dettagli sulla convalida, visita la pagina Val.
In quali formati posso esportare un modello YOLO11?
Ultralytics YOLO11 consente di esportare modelli in vari formati come ONNX, TensorRT, CoreML e altri per garantire la compatibilità tra diverse piattaforme e dispositivi.
Esempio
from ultralytics import YOLO
# Load the model
model = YOLO("yolo11n.pt")
# Export the model to ONNX format
model.export(format="onnx")
yolo export model=yolo11n.pt format=onnx
Controlla l'elenco completo dei formati supportati e le istruzioni nella pagina Esporta.
Perché dovrei usare Ultralytics YOLO11 per il rilevamento di oggetti?
Ultralytics YOLO11 è progettato per offrire prestazioni all'avanguardia per il rilevamento di oggetti, la segmentazione e la stima della posa. Ecco alcuni vantaggi chiave:
- Modelli Pre-addestrati: Utilizza modelli pre-addestrati su dataset popolari come COCO e ImageNet per uno sviluppo più rapido.
- Elevata precisione: Raggiunge punteggi mAP impressionanti, garantendo un rilevamento degli oggetti affidabile.
- Velocità: Ottimizzato per l'inferenza in tempo reale, rendendolo ideale per applicazioni che richiedono un'elaborazione rapida.
- Flessibilità: Esporta modelli in vari formati come ONNX e TensorRT per l'implementazione su più piattaforme.
Esplora il nostro Blog per casi d'uso e storie di successo che mostrano YOLO11 in azione.