Zum Inhalt springen

Python Verwendung

Willkommen bei der YOLOv8 Python Nutzungsdokumentation! Diese Anleitung soll dir helfen, YOLOv8 nahtlos in deine Python Projekte zur Objekterkennung, Segmentierung und Klassifizierung zu integrieren. Hier erfĂ€hrst du, wie du bereits trainierte Modelle lĂ€dst und verwendest, neue Modelle trainierst und Vorhersagen fĂŒr Bilder machst. Die einfach zu bedienende Schnittstelle Python ist eine wertvolle Ressource fĂŒr alle, die YOLOv8 in ihre Python Projekte einbinden möchten, um schnell fortgeschrittene Objekterkennungsfunktionen zu implementieren. Los geht's!



Pass auf: Mastering Ultralytics YOLOv8 : Python

So können Nutzer/innen mit nur wenigen Zeilen Code ein Modell laden, es trainieren, seine Leistung auf einem Validierungsset bewerten und es sogar in das Format ONNX exportieren.

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

Zug

Der Train-Modus wird fĂŒr das Training eines YOLOv8 Modells auf einem benutzerdefinierten Datensatz verwendet. In diesem Modus wird das Modell mit dem angegebenen Datensatz und den Hyperparametern trainiert. Beim Training werden die Parameter des Modells so optimiert, dass es die Klassen und Positionen der Objekte in einem Bild genau vorhersagen kann.

Zug

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)

Beispiele fĂŒr ZĂŒge

Val

Der Val-Modus wird verwendet, um ein YOLOv8 Modell zu validieren, nachdem es trainiert worden ist. In diesem Modus wird das Modell anhand einer Validierungsmenge bewertet, um seine Genauigkeit und Generalisierungsleistung zu messen. In diesem Modus können die Hyperparameter des Modells angepasst werden, um seine Leistung zu verbessern.

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 Beispiele

Vorhersage

Der Modus "Vorhersage" wird verwendet, um mit einem trainierten YOLOv8 Modell Vorhersagen fĂŒr neue Bilder oder Videos zu treffen. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und der Nutzer kann Bilder oder Videos zur VerfĂŒgung stellen, um Schlussfolgerungen zu ziehen. Das Modell sagt die Klassen und Orte der Objekte in den eingegebenen Bildern oder Videos voraus.

Vorhersage

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

Beispiele vorhersagen

exportieren

Der Exportmodus wird verwendet, um ein YOLOv8 Modell in ein Format zu exportieren, das fĂŒr den Einsatz verwendet werden kann. In diesem Modus wird das Modell in ein Format umgewandelt, das von anderen Softwareanwendungen oder HardwaregerĂ€ten verwendet werden kann. Dieser Modus ist nĂŒtzlich, wenn das Modell in Produktionsumgebungen eingesetzt werden soll.

exportieren

Exportiere ein offizielles YOLOv8n Modell auf ONNX mit dynamischer LosgrĂ¶ĂŸe und BildgrĂ¶ĂŸe.

from ultralytics import YOLO

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

Exportiere ein offizielles YOLOv8n Modell nach TensorRT auf device=0 fĂŒr die Beschleunigung auf CUDA GerĂ€ten.

from ultralytics import YOLO

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

Beispiele exportieren

Track

Der Verfolgungsmodus wird fĂŒr die Verfolgung von Objekten in Echtzeit mit einem YOLOv8 Modell verwendet. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und der Nutzer kann einen Live-Videostream bereitstellen, um eine Objektverfolgung in Echtzeit durchzufĂŒhren. Dieser Modus ist nĂŒtzlich fĂŒr Anwendungen wie Überwachungssysteme oder selbstfahrende Autos.

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

Track Beispiele

Benchmark

Der Benchmark-Modus wird verwendet, um ein Profil der Geschwindigkeit und Genauigkeit verschiedener Exportformate fĂŒr YOLOv8 zu erstellen. Die Benchmarks liefern Informationen ĂŒber die GrĂ¶ĂŸe des exportierten Formats, seine mAP50-95 Metriken (fĂŒr Objekterkennung und Segmentierung) oder accuracy_top5 Metriken (fĂŒr die Klassifizierung) und die Inferenzzeit in Millisekunden pro Bild fĂŒr verschiedene Exportformate wie ONNX, OpenVINO, TensorRT und andere. Diese Informationen können den Nutzern helfen, das optimale Exportformat fĂŒr ihren speziellen Anwendungsfall zu wĂ€hlen, je nachdem, welche Anforderungen sie an Geschwindigkeit und Genauigkeit stellen.

Benchmark

Vergleiche ein offizielles YOLOv8n Modell mit allen Exportformaten.

from ultralytics.utils.benchmarks import benchmark

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

Benchmark Beispiele

Entdecker

Die Explorer API kann verwendet werden, um DatensĂ€tze mit erweiterten semantischen, VektorĂ€hnlichkeits- und SQL-Suchfunktionen zu untersuchen. Sie ermöglicht auch die Suche nach Bildern auf der Grundlage ihres Inhalts mit natĂŒrlicher Sprache, indem sie die Leistung von LLMs nutzt. Mit der Explorer-API kannst du deine eigenen NotizbĂŒcher oder Skripte zur Erforschung von DatensĂ€tzen schreiben, um Einblicke in deine DatensĂ€tze zu erhalten.

Semantische Suche mit dem 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())

Entdecker

Einsatz von Trainern

YOLO Model-Klasse ist eine High-Level-Verschalung fĂŒr die Trainer-Klassen. Jede YOLO Aufgabe hat ihren eigenen Trainer, der von BaseTrainer.

Beispiel fĂŒr einen Detection Trainer

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

Du kannst Trainer leicht anpassen, um eigene Aufgaben zu unterstĂŒtzen oder Ideen fĂŒr Forschung und Entwicklung zu entwickeln. Erfahre mehr ĂŒber die Anpassung Trainers, Validators und Predictors im Abschnitt "Anpassung" an die BedĂŒrfnisse deines Projekts anpassen.

Anpassungs-Tutorials



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

Kommentare