Python-Verwendung

Willkommen bei der Python-Verwendungsdokumentation für Ultralytics YOLO! Dieser Leitfaden hilft dir dabei, Ultralytics YOLO nahtlos in deine Python-Projekte für Objekterkennung, Segmentierung und Klassifizierung zu integrieren. Hier lernst du, wie du vortrainierte Modelle lädst und nutzt, neue Modelle trainierst und Vorhersagen auf Bildern durchführst. Die benutzerfreundliche Python-Schnittstelle ist eine wertvolle Ressource für jeden, der YOLO in seine Python-Projekte einbinden möchte, und ermöglicht es dir, fortgeschrittene Objekterkennungsfunktionen schnell zu implementieren. Lass uns anfangen!

Benutzer können beispielsweise mit nur wenigen Zeilen Code ein Modell laden, trainieren, dessen Leistung an einem Validierungsdatensatz bewerten und es sogar in das ONNX-Format exportieren.

from ultralytics import YOLO

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

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

Trainieren

Der Train-Modus wird zum Trainieren eines YOLO-Modells auf einem benutzerdefinierten Datensatz verwendet. In diesem Modus wird das Modell mithilfe des angegebenen Datensatzes und der Hyperparameter trainiert. Der Trainingsprozess umfasst die Optimierung der Modellparameter, damit es Klassen und Positionen von Objekten in einem Bild präzise vorhersagen kann.

from ultralytics import YOLO

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

Trainingsbeispiele

Val

Der Val-Modus wird zur Validierung eines YOLO-Modells nach dem Training verwendet. In diesem Modus wird das Modell an einem Validierungsdatensatz evaluiert, um seine Genauigkeit und Generalisierungsleistung zu messen. Dieser Modus kann genutzt werden, um die Hyperparameter des Modells anzupassen und dessen Leistung zu verbessern.

from ultralytics import YOLO

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

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

# Validate on training data
model.val()

Val-Beispiele

Vorhersage

Der Predict-Modus wird für Vorhersagen mit einem trainierten YOLO-Modell an neuen Bildern oder Videos verwendet. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen und der Benutzer kann Bilder oder Videos zur Inferenz bereitstellen. Das Modell sagt die Klassen und Positionen der Objekte in den Eingabebildern oder Videos voraus.

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

Predict-Beispiele

Exportieren

Der Export-Modus dient dazu, ein YOLO-Modell in ein Format zu exportieren, das für die Bereitstellung genutzt 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 bereitgestellt wird.

from ultralytics import YOLO

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

Export-Beispiele

Tracken

Der Track-Modus wird zum Verfolgen von Objekten in Echtzeit mit einem YOLO-Modell verwendet. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen und der Benutzer kann einen Live-Videostream bereitstellen, um die Objektverfolgung in Echtzeit durchzuführen. Dieser Modus ist nützlich für Anwendungen wie Überwachungssysteme oder selbstfahrende Autos.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official detection model
model = YOLO("yolo26n-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 Geschwindigkeit und Genauigkeit verschiedener Exportformate für YOLO zu profilieren. 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 Klassifizierung) sowie die Inferenzzeit in Millisekunden pro Bild über verschiedene Exportformate wie ONNX, OpenVINO, TensorRT und andere hinweg. Diese Informationen können Benutzern helfen, das optimale Exportformat für ihren spezifischen Anwendungsfall basierend auf ihren Anforderungen an Geschwindigkeit und Genauigkeit zu wählen.

from ultralytics.utils.benchmarks import benchmark

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

Benchmark-Beispiele

Verwendung von Trainern

Die YOLO-Modellklasse dient als High-Level-Wrapper für Trainer-Klassen. Jede YOLO-Aufgabe hat ihren eigenen Trainer, der von BaseTrainer erbt. Diese Architektur ermöglicht größere Flexibilität und Anpassbarkeit in deinen Workflows für maschinelles Lernen.

from ultralytics.models.yolo.detect 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)

Du kannst Trainer einfach anpassen, um benutzerdefinierte Aufgaben zu unterstützen oder Forschungs- und Entwicklungsideen zu erkunden. Das modulare Design von Ultralytics YOLO ermöglicht es dir, das Framework an deine spezifischen Bedürfnisse anzupassen, egal ob du an einer neuartigen Computer Vision-Aufgabe arbeitest oder bestehende Modelle für eine bessere Leistung feinabstimmst.

Anpassungs-Tutorials

FAQ

Wie kann ich YOLO in mein Python-Projekt zur Objekterkennung integrieren?

Die Integration von Ultralytics YOLO in deine Python-Projekte ist einfach. Du kannst ein vortrainiertes Modell laden oder ein neues Modell von Grund auf trainieren. So legst du los:

from ultralytics import YOLO

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

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

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

Detailliertere Beispiele findest du in unserem Abschnitt Predict Mode.

Welche verschiedenen Modi sind in YOLO verfügbar?

Ultralytics YOLO bietet verschiedene Modi, um unterschiedliche Workflows für maschinelles Lernen zu bedienen. Dazu gehören:

• Train: Trainiere ein Modell unter Verwendung benutzerdefinierter Datensätze.
• Val: Validiere die Modellleistung an einem Validierungsdatensatz.
• Predict: Führe Vorhersagen auf neuen Bildern oder Videostreams durch.
• Export: Exportiere Modelle in verschiedene Formate wie ONNX und TensorRT.
• Track: Echtzeit-Objektverfolgung in Videostreams.
• Benchmark: Benchmarke die Modellleistung über verschiedene Konfigurationen hinweg.

Jeder Modus wurde entwickelt, um umfassende Funktionen für verschiedene Phasen der Modellentwicklung und -bereitstellung bereitzustellen.

Wie trainiere ich ein benutzerdefiniertes YOLO-Modell unter Verwendung meines Datensatzes?

Um ein benutzerdefiniertes YOLO-Modell zu trainieren, musst du deinen Datensatz und andere Hyperparameter angeben. Hier ist ein kurzes Beispiel:

from ultralytics import YOLO

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

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

Weitere Details zum Training und Hyperlinks zu Beispielanwendungen findest du auf unserer Seite zum Train-Modus.

Wie exportiere ich YOLO-Modelle für die Bereitstellung?

Das Exportieren von YOLO-Modellen in einem für die Bereitstellung geeigneten Format ist mit der Funktion export unkompliziert. Du kannst beispielsweise ein Modell in das ONNX-Format exportieren:

from ultralytics import YOLO

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

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

Für verschiedene Exportoptionen lies bitte die Dokumentation zum Export-Modus.

Kann ich mein YOLO-Modell auf verschiedenen Datensätzen validieren?

Ja, die Validierung von YOLO-Modellen auf verschiedenen Datensätzen ist möglich. Nach dem Training kannst du den Validierungsmodus verwenden, um die Leistung zu bewerten:

from ultralytics import YOLO

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

Besuche die Seite zum Val-Modus für detaillierte Beispiele und Anwendungsfälle.