Vai al contenuto

Utilizzo di Python

Benvenuti nella documentazione sull'utilizzo di Ultralytics YOLO con Python! Questa guida è progettata per aiutarti a integrare senza problemi Ultralytics YOLO nei tuoi progetti Python per il rilevamento di oggetti, la segmentazione e la classificazione. Qui imparerai come caricare e utilizzare modelli pre-addestrati, addestrare nuovi modelli ed eseguire previsioni sulle immagini. L'interfaccia Python facile da usare è una risorsa preziosa per chiunque desideri incorporare YOLO nei propri progetti Python, consentendoti di implementare rapidamente funzionalità avanzate di rilevamento oggetti. Iniziamo!



Guarda: Padroneggiare Ultralytics YOLO: python

Ad esempio, gli utenti possono caricare un modello, addestrarlo, valutarne le prestazioni su un set di convalida e persino esportarlo in formato ONNX con poche righe di codice.

Python

from ultralytics import YOLO

# Create a new YOLO model from scratch
model = YOLO("yolo11n.yaml")

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo11n.pt")

# Train the model using the 'coco8.yaml' dataset for 3 epochs
results = model.train(data="coco8.yaml", epochs=3)

# Evaluate the model's performance on the validation set
results = model.val()

# Perform object detection on an image using the model
results = model("https://ultralytics.com/images/bus.jpg")

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

Addestramento

La modalità Train viene utilizzata per addestrare un modello YOLO su un set di dati personalizzato. In questa modalità, il modello viene addestrato utilizzando il set di dati e gli iperparametri specificati. Il processo di addestramento prevede l'ottimizzazione dei parametri del modello in modo che possa prevedere accuratamente le classi e le posizioni degli oggetti in un'immagine.

Addestramento

from ultralytics import YOLO

model = YOLO("yolo11n.pt")  # pass any model type
results = model.train(epochs=5)

from ultralytics import YOLO

model = YOLO("yolo11n.yaml")
results = model.train(data="coco8.yaml", epochs=5)

model = YOLO("last.pt")
results = model.train(resume=True)

Esempi di addestramento

Valutazione

La modalità Val viene utilizzata per la convalida di un modello YOLO dopo che è stato addestrato. In questa modalità, il modello viene valutato su un set di convalida per misurare la sua precisione e le prestazioni di generalizzazione. Questa modalità può essere utilizzata per ottimizzare gli iperparametri del modello per migliorarne le prestazioni.

Valutazione

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate on training data
model.val()

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate on separate data
model.val(data="path/to/separate/data.yaml")

Esempi di convalida

Predizione

La modalità Predict viene utilizzata per fare previsioni utilizzando un modello YOLO addestrato su nuove immagini o video. In questa modalità, il modello viene caricato da un file checkpoint e l'utente può fornire immagini o video per eseguire l'inferenza. Il modello prevede le classi e le posizioni degli oggetti nelle immagini o nei video di input.

Predizione

import cv2
from PIL import Image

from ultralytics import YOLO

model = YOLO("model.pt")
# accepts all formats - image/dir/Path/URL/video/PIL/ndarray. 0 for webcam
results = model.predict(source="0")
results = model.predict(source="folder", show=True)  # Display preds. Accepts all YOLO predict arguments

# from PIL
im1 = Image.open("bus.jpg")
results = model.predict(source=im1, save=True)  # save plotted images

# from ndarray
im2 = cv2.imread("bus.jpg")
results = model.predict(source=im2, save=True, save_txt=True)  # save predictions as labels

# from list of PIL/ndarray
results = model.predict(source=[im1, im2])

# results would be a list of Results object including all the predictions by default
# but be careful as it could occupy a lot memory when there're many images,
# especially the task is segmentation.
# 1. return as a list
results = model.predict(source="folder")

# results would be a generator which is more friendly to memory by setting stream=True
# 2. return as a generator
results = model.predict(source=0, stream=True)

for result in results:
    # Detection
    result.boxes.xyxy  # box with xyxy format, (N, 4)
    result.boxes.xywh  # box with xywh format, (N, 4)
    result.boxes.xyxyn  # box with xyxy format but normalized, (N, 4)
    result.boxes.xywhn  # box with xywh format but normalized, (N, 4)
    result.boxes.conf  # confidence score, (N, 1)
    result.boxes.cls  # cls, (N, 1)

    # Segmentation
    result.masks.data  # masks, (N, H, W)
    result.masks.xy  # x,y segments (pixels), List[segment] * N
    result.masks.xyn  # x,y segments (normalized), List[segment] * N

    # Classification
    result.probs  # cls prob, (num_class, )

# Each result is composed of torch.Tensor by default,
# in which you can easily use following functionality:
result = result.cuda()
result = result.cpu()
result = result.to("cpu")
result = result.numpy()

Esempi di Predict

Esportazione

La modalità di esportazione viene utilizzata per esportare un modello YOLO in un formato che può essere utilizzato per la distribuzione. In questa modalità, il modello viene convertito in un formato che può essere utilizzato da altre applicazioni software o dispositivi hardware. Questa modalità è utile quando si distribuisce il modello in ambienti di produzione.

Esportazione

Esporta un modello YOLO ufficiale in ONNX con batch-size e image-size dinamici. 

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="onnx", dynamic=True)

Esporta un modello YOLO ufficiale in TensorRT su device=0 per l'accelerazione su dispositivi CUDA. 

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="engine", device=0)

Esempi di Export

Tracciamento

La modalità Track viene utilizzata per tracciare oggetti in tempo reale utilizzando un modello YOLO. In questa modalità, il modello viene caricato da un file di checkpoint e l'utente può fornire un flusso video in diretta per eseguire il tracciamento degli oggetti in tempo reale. Questa modalità è utile per applicazioni come i sistemi di sorveglianza o le auto a guida autonoma.

Tracciamento

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load an official detection model
model = YOLO("yolo11n-seg.pt")  # load an official segmentation model
model = YOLO("path/to/best.pt")  # load a custom model

# Track with the model
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")

Esempi di Track

Benchmark

Modalità benchmark viene utilizzato per profilare la velocità e l'accuratezza di vari formati di esportazione per YOLO. I benchmark forniscono informazioni sulla dimensione del formato esportato, la sua mAP50-95 metriche (per il rilevamento e la segmentazione degli oggetti) o accuracy_top5 metriche (per la classificazione) e il tempo di inferenza in millisecondi per immagine in vari formati di esportazione come ONNX, OpenVINO, TensorRT e altri. Queste informazioni possono aiutare gli utenti a scegliere il formato di esportazione ottimale per il loro specifico caso d'uso in base alle loro esigenze di velocità e accuratezza.

Benchmark

Esegui il benchmark di un modello YOLO ufficiale in tutti i formati di esportazione. 

from ultralytics.utils.benchmarks import benchmark

# Benchmark
benchmark(model="yolo11n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)

Esempi di Benchmark

Utilizzo dei Trainer

Il YOLO La classe model funge da wrapper di alto livello per le classi Trainer. Ogni task YOLO ha il suo trainer, che eredita da BaseTrainer. Questa architettura consente una maggiore flessibilità e personalizzazione nel tuo flussi di lavoro di machine learning.

Esempio di Detection Trainer

from ultralytics.models.yolo import DetectionPredictor, DetectionTrainer, DetectionValidator

# trainer
trainer = DetectionTrainer(overrides={})
trainer.train()
trained_model = trainer.best

# Validator
val = DetectionValidator(args=...)
val(model=trained_model)

# predictor
pred = DetectionPredictor(overrides={})
pred(source=SOURCE, model=trained_model)

# resume from last weight
overrides["resume"] = trainer.last
trainer = DetectionTrainer(overrides=overrides)

Puoi personalizzare facilmente i Trainer per supportare attività personalizzate o esplorare idee di ricerca e sviluppo. Il design modulare di Ultralytics YOLO ti consente di adattare il framework alle tue esigenze specifiche, sia che tu stia lavorando su una nuova attività di computer vision sia che tu stia perfezionando i modelli esistenti per ottenere prestazioni migliori.

Tutorial sulla personalizzazione

FAQ

Come posso integrare YOLO nel mio progetto Python per il rilevamento di oggetti?

Integrare Ultralytics YOLO nei tuoi progetti Python è semplice. Puoi caricare un modello pre-addestrato o addestrare un nuovo modello da zero. Ecco come iniziare:

from ultralytics import YOLO

# Load a pretrained YOLO model
model = YOLO("yolo11n.pt")

# Perform object detection on an image
results = model("https://ultralytics.com/images/bus.jpg")

# Visualize the results
for result in results:
    result.show()

Vedi esempi più dettagliati nella nostra sezione Modalità Predict.

Quali sono le diverse modalità disponibili in YOLO?

Ultralytics YOLO offre varie modalità per soddisfare diversi flussi di lavoro di machine learning. Questi includono:

  • Train: Addestra un modello utilizzando dataset personalizzati.
  • Val: Convalida le prestazioni del modello su un set di convalida.
  • Prevedi: Effettua previsioni su nuove immagini o flussi video.
  • Export: Esporta i modelli in vari formati come ONNX e TensorRT.
  • Track: Tracciamento di oggetti in tempo reale nei flussi video.
  • Benchmark: Prestazioni del modello di benchmark in diverse configurazioni.

Ogni modalità è progettata per fornire funzionalità complete per le diverse fasi di sviluppo e implementazione del modello.

Come posso addestrare un modello YOLO personalizzato utilizzando il mio dataset?

Per addestrare un modello YOLO personalizzato, devi specificare il tuo set di dati e altri iperparametri. Ecco un rapido esempio:

from ultralytics import YOLO

# Load the YOLO model
model = YOLO("yolo11n.yaml")

# Train the model with custom dataset
model.train(data="path/to/your/dataset.yaml", epochs=10)

Per maggiori dettagli sul training e sui collegamenti ipertestuali a esempi di utilizzo, visita la nostra pagina Modalità Train.

Come posso esportare i modelli YOLO per la distribuzione?

L'esportazione di modelli YOLO in un formato adatto alla distribuzione è semplice con la export funzione. Ad esempio, puoi esportare un modello in formato ONNX:

from ultralytics import YOLO

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

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

Per le varie opzioni di esportazione, consultare la documentazione sulla Modalità di esportazione.

Posso convalidare il mio modello YOLO su diversi dataset?

Sì, è possibile convalidare i modelli YOLO su diversi set di dati. Dopo l'addestramento, è possibile utilizzare la modalità di convalida per valutare le prestazioni:

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate the model on a different dataset
model.val(data="path/to/separate/data.yaml")

Consulta la pagina Val Mode per esempi dettagliati e utilizzo.



📅 Creato 1 anno fa ✏️ Aggiornato 5 mesi fa
glenn-jocher jk4e leonnil RizwanMunawar UltralyticsAssistant MatthewNoyce IvorZhu331 AyushExel Laughing-q

Commenti