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 Ultralytics YOLO Pre-addestrato.

Modelli

I modelli YOLO26 Detect 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.

• mAP^val i valori si riferiscono a un singolo modello single-scale su COCO val2017 dataset.
  Riproduci tramite yolo val detect data=coco.yaml device=0
• Velocità calcolata in media sulle immagini COCO val utilizzando un Amazon EC2 P4d instance.
  Riproduci tramite yolo val detect data=coco.yaml batch=1 device=0|cpu

Addestramento

Addestra YOLO26n sul dataset COCO8 per 100 epoche con dimensione immagine 640. Per un elenco completo degli argomenti disponibili, consulta la pagina Configurazione.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.yaml")  # build a new model from YAML
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n.yaml").load("yolo26n.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=yolo26n.yaml epochs=100 imgsz=640

# Start training from a pretrained *.pt model
yolo detect train data=coco8.yaml model=yolo26n.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=yolo26n.yaml pretrained=yolo26n.pt epochs=100 imgsz=640

Formato del set di dati

Il formato del dataset per il detection 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 YOLO26n addestrato accuratezza sul dataset COCO8. Non sono necessari argomenti poiché il model mantiene il suo training data e gli argomenti come attributi del modello.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.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 containing mAP50-95 for each category

yolo detect val model=yolo26n.pt      # val official model
yolo detect val model=path/to/best.pt # val custom model

Predizione

Usa un modello YOLO26n addestrato per eseguire previsioni sulle immagini.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.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=yolo26n.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 YOLO26n in un formato diverso come ONNX, CoreML, ecc.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.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=yolo26n.pt format=onnx      # export official model
yolo export model=path/to/best.pt format=onnx # export custom-trained model

I formati di esportazione YOLO26 disponibili sono nella tabella sottostante. Puoi esportare in qualsiasi formato usando il format argomento, cioè, format='onnx' oppure format='engine'. È possibile effettuare previsioni o validazioni direttamente sui modelli esportati, cioè, yolo predict model=yolo26n.onnx. Esempi di utilizzo vengono mostrati per il tuo modello dopo che l'esportazione è stata completata.

Vedi tutti i export dettagli nella Esportazione pagina.

FAQ

Come addestro un modello YOLO26 sul mio dataset personalizzato?

L'addestramento di un modello YOLO26 su un dataset personalizzato comporta alcuni passaggi:

1. Prepara il Dataset: Assicurati che il tuo dataset sia nel formato YOLO. Per maggiori informazioni, consulta la nostra Guida al Dataset.
2. Carica il Modello: Utilizza la libreria Ultralytics YOLO per caricare un modello pre-addestrato o creare un nuovo modello da un file YAML.
3. Addestra il Modello: Esegui il train metodo in python o il yolo detect train comando nella CLI.

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n.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=yolo26n.pt epochs=100 imgsz=640

Per opzioni di configurazione dettagliate, visita la pagina Configurazione.

Quali modelli pre-addestrati sono disponibili in YOLO26?

Ultralytics YOLO26 offre vari modelli pre-addestrati per il rilevamento di oggetti, la segmentazione e la stima della posa. Questi modelli sono pre-addestrati sul dataset COCO o su ImageNet per compiti di classificazione. Ecco alcuni dei modelli disponibili:

• YOLO26n
• YOLO26s
• YOLO26m
• YOLO26l
• YOLO26x

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 YOLO26 addestrato, puoi usare il .val() metodo in python o il yolo detect val comando nella CLI. Questo fornirà metriche come mAP50-95, mAP50 e altro.

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 YOLO26?

Ultralytics YOLO26 consente di esportare i modelli in vari formati come ONNX, TensorRT, CoreML e altri per garantire la compatibilità tra diverse piattaforme e dispositivi.

from ultralytics import YOLO

# Load the model
model = YOLO("yolo26n.pt")

# Export the model to ONNX format
model.export(format="onnx")

yolo export model=yolo26n.pt format=onnx

Controlla l'elenco completo dei formati supportati e le istruzioni nella pagina Esporta.

Perché dovrei usare Ultralytics YOLO26 per il rilevamento di oggetti?

Ultralytics YOLO26 è progettato per offrire prestazioni all'avanguardia per il rilevamento di oggetti, la segmentazione e la stima della posa. Ecco alcuni vantaggi chiave:

1. Modelli pre-addestrati: Utilizza modelli pre-addestrati su dataset popolari come COCO e ImageNet per uno sviluppo più rapido.
2. Elevata accuratezza: Raggiunge punteggi mAP impressionanti, garantendo un rilevamento oggetti affidabile.
3. Velocità: Ottimizzato per l'inferenza in tempo reale, rendendolo ideale per applicazioni che richiedono un'elaborazione rapida.
4. 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 YOLO26 in azione.

📅 Creato 2 anni fa ✏️ Aggiornato 2 giorni fa

Commenti