Vai al contenuto

Python Utilizzo

Benvenuto nella documentazione sull'uso di YOLOv8 Python ! Questa guida è stata pensata per aiutarti a integrare perfettamente YOLOv8 nei tuoi progetti Python per il rilevamento, la segmentazione e la classificazione degli oggetti. Qui imparerai a caricare e utilizzare i modelli pre-addestrati, ad addestrare nuovi modelli e a eseguire previsioni sulle immagini. L'interfaccia di Python , facile da usare, è una risorsa preziosa per chiunque voglia incorporare YOLOv8 nei propri progetti Python , consentendoti di implementare rapidamente funzionalità avanzate di rilevamento degli oggetti. Cominciamo!



Guarda: Mastering Ultralytics YOLOv8 : Python

Ad esempio, gli utenti possono caricare un modello, addestrarlo, valutarne le prestazioni su un set di validazione 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("yolov8n.yaml")

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolov8n.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")

Treno

La modalità Train è utilizzata per addestrare un modello YOLOv8 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 con precisione le classi e le posizioni degli oggetti in un'immagine.

Treno

from ultralytics import YOLO

model = YOLO("yolov8n.pt")  # pass any model type
results = model.train(epochs=5)
from ultralytics import YOLO

model = YOLO("yolov8n.yaml")
results = model.train(data="coco8.yaml", epochs=5)
model = YOLO("last.pt")
results = model.train(resume=True)

Esempi di treni

Val

La modalità Val è utilizzata per convalidare un modello YOLOv8 dopo che è stato addestrato. In questa modalità, il modello viene valutato su un set di validazione per misurarne l'accuratezza e le prestazioni di generalizzazione. Questa modalità può essere utilizzata per mettere a punto gli iperparametri del modello per migliorarne le prestazioni.

Val

from ultralytics import YOLO

# Load a YOLOv8 model
model = YOLO("yolov8n.yaml")

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

# Validate on training data
model.val()
from ultralytics import YOLO

# Load a YOLOv8 model
model = YOLO("yolov8n.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 val

Prevedere

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

Prevedere

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()

Prevedere gli esempi

Esportazione

La modalità di esportazione è utilizzata per esportare un modello YOLOv8 in un formato utilizzabile 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 per distribuire il modello in ambienti di produzione.

Esportazione

Esporta un modello ufficiale di YOLOv8n in ONNX con dimensioni dinamiche del lotto e dell'immagine.

from ultralytics import YOLO

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

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

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
model.export(format="onnx", device=0)

Esempi di esportazione

Traccia

La modalità Track è utilizzata per tracciare gli oggetti in tempo reale utilizzando un modello YOLOv8 . 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.

Traccia

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n.pt")  # load an official detection model
model = YOLO("yolov8n-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 tracce

Benchmark

La modalitĂ  Benchmark viene utilizzata per tracciare un profilo della velocitĂ  e della precisione dei vari formati di esportazione di YOLOv8. I benchmark forniscono informazioni sulle dimensioni del formato esportato, la sua velocitĂ  e la sua precisione. 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 nei 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 caso d'uso specifico, in base ai loro requisiti di velocitĂ  e accuratezza.

Benchmark

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

from ultralytics.utils.benchmarks import benchmark

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

Esempi di benchmark

Esploratore

L'API Explorer può essere utilizzata per esplorare set di dati con ricerca semantica avanzata, similitudine vettoriale e SQL, oltre ad altre funzioni. Inoltre, ha permesso di ricercare immagini in base al loro contenuto utilizzando il linguaggio naturale e sfruttando la potenza degli LLM. L'API Explorer ti permette di scrivere i tuoi quaderni di esplorazione dei dataset o gli script per ottenere approfondimenti sui tuoi dataset.

Ricerca semantica con Explorer

from ultralytics import Explorer

# create an Explorer object
exp = Explorer(data="coco8.yaml", model="yolov8n.pt")
exp.create_embeddings_table()

similar = exp.get_similar(img="https://ultralytics.com/images/bus.jpg", limit=10)
print(similar.head())

# Search using multiple indices
similar = exp.get_similar(
    img=["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/bus.jpg"], limit=10
)
print(similar.head())
from ultralytics import Explorer

# create an Explorer object
exp = Explorer(data="coco8.yaml", model="yolov8n.pt")
exp.create_embeddings_table()

similar = exp.get_similar(idx=1, limit=10)
print(similar.head())

# Search using multiple indices
similar = exp.get_similar(idx=[1, 10], limit=10)
print(similar.head())

Esploratore

Utilizzo dei formatori

YOLO La classe Model è un wrapper di alto livello per le classi Trainer. Ogni attività di YOLO ha il proprio trainer che eredita da BaseTrainer.

Esempio di addestramento al rilevamento

```python
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 = detect.DetectionTrainer(overrides=overrides)
```

Puoi personalizzare facilmente Trainers per supportare attivitĂ  personalizzate o per esplorare idee di ricerca e sviluppo. Per saperne di piĂš sulla personalizzazione Trainers, Validators e Predictors per soddisfare le esigenze del tuo progetto nella sezione Personalizzazione.

Tutorial di personalizzazione



Created 2023-11-12, Updated 2024-06-09
Authors: IvorZhu331 (1), glenn-jocher (12), AyushExel (1), RizwanMunawar (1), Laughing-q (1)

Commenti