Overslaan naar inhoud

Python Gebruik

Welkom bij de YOLOv8 Python Gebruiksdocumentatie! Deze gids is ontworpen om je te helpen YOLOv8 naadloos te integreren in je Python projecten voor objectdetectie, segmentatie en classificatie. Je leert hier hoe je voorgetrainde modellen laadt en gebruikt, nieuwe modellen traint en voorspellingen uitvoert op afbeeldingen. De gebruiksvriendelijke Python interface is een waardevolle bron voor iedereen die YOLOv8 wil integreren in zijn Python projecten, zodat je snel geavanceerde mogelijkheden voor objectdetectie kunt implementeren. Laten we aan de slag gaan!



Kijken: Ultralytics YOLOv8 : Python

Gebruikers kunnen bijvoorbeeld een model laden, het trainen, de prestaties evalueren op een validatieset en het zelfs exporteren naar ONNX formaat met slechts een paar regels code.

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

Trein

De modus Trainen wordt gebruikt voor het trainen van een YOLOv8 model op een aangepaste dataset. In deze modus wordt het model getraind met behulp van de gespecificeerde dataset en hyperparameters. Tijdens het trainingsproces worden de parameters van het model geoptimaliseerd zodat het nauwkeurig de klassen en locaties van objecten in een afbeelding kan voorspellen.

Trein

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)

Trein Voorbeelden

Val

De modus Val wordt gebruikt voor het valideren van een YOLOv8 model nadat het is getraind. In deze modus wordt het model geƫvalueerd op een validatieset om de nauwkeurigheid en generalisatieprestaties te meten. Deze modus kan worden gebruikt om de hyperparameters van het model af te stemmen om de prestaties te verbeteren.

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

Val Voorbeelden

Voorspel

De modus Voorspellen wordt gebruikt om voorspellingen te doen met behulp van een getraind YOLOv8 model op nieuwe afbeeldingen of video's. In deze modus wordt het model geladen vanuit een controlebestand en kan de gebruiker afbeeldingen of video's aanleveren om de inferentie uit te voeren. Het model voorspelt de klassen en locaties van objecten in de ingevoerde afbeeldingen of video's.

Voorspel

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

Voorbeelden voorspellen

Exporteer

De exportmodus wordt gebruikt om een YOLOv8 model te exporteren naar een formaat dat gebruikt kan worden voor implementatie. In deze modus wordt het model geconverteerd naar een formaat dat kan worden gebruikt door andere softwaretoepassingen of hardwareapparaten. Deze modus is handig bij het uitrollen van het model naar productieomgevingen.

Exporteer

Exporteer een officieel YOLOv8n model naar ONNX met dynamische batchgrootte en afbeeldingsgrootte.

from ultralytics import YOLO

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

Exporteer een officieel YOLOv8n model naar TensorRT op device=0 voor versnelling op CUDA apparaten.

from ultralytics import YOLO

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

Voorbeelden exporteren

Track

De Trackmodus wordt gebruikt om objecten in real-time te volgen met behulp van een YOLOv8 model. In deze modus wordt het model geladen vanuit een checkpointbestand en kan de gebruiker een live videostream aanleveren om het volgen van objecten in real-time uit te voeren. Deze modus is handig voor toepassingen zoals bewakingssystemen of zelfrijdende auto's.

Track

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

Spoor Voorbeelden

Benchmark

De benchmarkmodus wordt gebruikt om de snelheid en nauwkeurigheid van verschillende exportformaten voor YOLOv8 te profileren. De benchmarks geven informatie over de grootte van het geƫxporteerde formaat, de mAP50-95 metriek (voor objectdetectie en segmentatie) of accuracy_top5 metriek (voor classificatie) en de inferentietijd in milliseconden per afbeelding in verschillende exportformaten zoals ONNX, OpenVINO, TensorRT en andere. Deze informatie kan gebruikers helpen om het optimale exportformaat te kiezen voor hun specifieke toepassing op basis van hun eisen voor snelheid en nauwkeurigheid.

Benchmark

Benchmark een officieel YOLOv8n model in alle exportformaten.

from ultralytics.utils.benchmarks import benchmark

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

Benchmark voorbeelden

Verkenner

Explorer API kan worden gebruikt om datasets te verkennen met onder andere geavanceerde semantische, vector-gelijkenis en SQL zoekfuncties. Het maakt het ook mogelijk om afbeeldingen te zoeken op basis van hun inhoud met behulp van natuurlijke taal door gebruik te maken van de kracht van LLM's. Met de Explorer API kun je je eigen dataset verkenningsnotitieboeken of scripts schrijven om inzicht te krijgen in je datasets.

Semantisch zoeken met verkenner

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

Verkenner

Trainers gebruiken

YOLO De modelklasse is een omhulsel op hoog niveau van de Trainer-klassen. Elke YOLO taak heeft zijn eigen trainer die erft van BaseTrainer.

Voorbeeld detectietrainer

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

Je kunt Trainers eenvoudig aanpassen om aangepaste taken te ondersteunen of R&D-ideeƫn te onderzoeken. Meer informatie over aanpassen Trainers, Validators en Predictors aan de behoeften van je project in het gedeelte Aanpassingen.

Aanpassing tutorials

FAQ

Hoe kan ik YOLOv8 integreren in mijn Python project voor objectdetectie?

Het integreren van Ultralytics YOLOv8 in je Python projecten is eenvoudig. Je kunt een vooraf getraind model laden of een nieuw model vanaf nul trainen. Hier lees je hoe je kunt beginnen:

from ultralytics import YOLO

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

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

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

Bekijk meer gedetailleerde voorbeelden in onze Voorspelmodus sectie.

Wat zijn de verschillende modi op YOLOv8?

Ultralytics YOLOv8 biedt verschillende modi om tegemoet te komen aan verschillende workflows voor machinaal leren. Deze omvatten:

  • Trein: Train een model met aangepaste datasets.
  • Val: Valideer de modelprestaties op een validatieset.
  • Voorspel: Voorspellingen doen over nieuwe afbeeldingen of videostromen.
  • Exporteer: Modellen exporteren naar verschillende formaten zoals ONNX, TensorRT.
  • Track: Objecten in realtime volgen in videostromen.
  • Benchmark: Benchmark de prestaties van het model in verschillende configuraties.

Elke modus is ontworpen om uitgebreide functionaliteiten te bieden voor verschillende stadia van modelontwikkeling en -implementatie.

Hoe train ik een aangepast YOLOv8 model met mijn dataset?

Om een aangepast YOLOv8 model te trainen, moet je je dataset en andere hyperparameters opgeven. Hier is een snel voorbeeld:

from ultralytics import YOLO

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

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

Ga voor meer informatie over training en hyperlinks naar voorbeeldgebruik naar onze pagina Train Mode.

Hoe exporteer ik YOLOv8 modellen voor implementatie?

Het exporteren van YOLOv8 modellen in een formaat dat geschikt is voor implementatie is eenvoudig met het programma export functie. Je kunt bijvoorbeeld een model exporteren naar het formaat ONNX :

from ultralytics import YOLO

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

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

Raadpleeg de documentatie over de Exportmodus voor de verschillende exportopties.

Kan ik mijn YOLOv8 model valideren op verschillende datasets?

Ja, het valideren van YOLOv8 modellen op verschillende datasets is mogelijk. Na het trainen kun je de validatiemodus gebruiken om de prestaties te evalueren:

from ultralytics import YOLO

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

Bekijk de Val Mode pagina voor gedetailleerde voorbeelden en gebruik.



Aangemaakt 2023-11-12, Bijgewerkt 2024-07-04
Auteurs: glenn-jocher (13), IvorZhu331 (1), AyushExel (1), RizwanMunawar (1), Laughing-q (1)

Reacties