Python-Verwendung#
Willkommen bei der Dokumentation zur Verwendung von Ultralytics YOLO mit Python! Dieser Leitfaden hilft dir dabei, Ultralytics YOLO nahtlos in deine Python-Projekte für Objekterkennung, Instanzsegmentierung, semantische Segmentierung, Tiefenschätzung und Klassifizierung zu integrieren. Hier erfährst du, wie du vortrainierte Modelle lädst und verwendest, neue Modelle trainierst und Vorhersagen für Bilder ausführst. Die benutzerfreundliche Python-Schnittstelle ist eine wertvolle Ressource für alle, die YOLO in ihre Python-Projekte integrieren möchten. Sie ermöglicht es dir, fortschrittliche Funktionen zur Objekterkennung schnell umzusetzen. Los geht's!
Ansehen: Ultralytics YOLO meistern: Python
Nutzer können beispielsweise ein Modell laden, es trainieren, seine Leistung auf einem Validierungsdatensatz bewerten und es mit nur wenigen Codezeilen sogar in das ONNX-Format exportieren.
from ultralytics import YOLO
# Erstelle ein neues YOLO-Modell von Grund auf
model = YOLO("yolo26n.yaml")
# Lade ein vortrainiertes YOLO-Modell (für das Training empfohlen)
model = YOLO("yolo26n.pt")
# Trainiere das Modell 3 Epochen lang mit dem Datensatz 'coco8.yaml'
results = model.train(data="coco8.yaml", epochs=3)
# Werte die Leistung des Modells auf dem Validierungsdatensatz aus
results = model.val()
# Führe mit dem Modell eine Objekterkennung auf einem Bild aus
results = model("https://ultralytics.com/images/bus.jpg")
# Exportiere das Modell in das ONNX-Format
success = model.export(format="onnx")Trainieren#
Der Train-Modus dient dazu, ein YOLO-Modell mit einem benutzerdefinierten Datensatz zu trainieren. In diesem Modus wird das Modell anhand des angegebenen Datensatzes und der festgelegten Hyperparameter trainiert. Beim Training werden die Parameter des Modells so optimiert, dass es Klassen und Positionen von Objekten in einem Bild präzise vorhersagen kann.
from ultralytics import YOLO
model = YOLO("yolo26n.pt") # Beliebigen Modelltyp übergeben
results = model.train(epochs=5)Validieren#
Der Val-Modus dient zur Validierung eines YOLO-Modells nach dem Training. In diesem Modus wird das Modell anhand eines Validierungssatzes ausgewertet, um seine Genauigkeit und Generalisierungsleistung zu messen. Dieser Modus kann verwendet werden, um die Hyperparameter des Modells anzupassen und seine Leistung zu verbessern.
from ultralytics import YOLO
# Ein YOLO-Modell laden
model = YOLO("yolo26n.yaml")
# Das Modell trainieren
model.train(data="coco8.yaml", epochs=5)
# Validierung anhand der Validierungsaufteilung des Trainingsdatensatzes
model.val()Vorhersagen#
Der Predict-Modus dient dazu, mit einem trainierten YOLO-Modell Vorhersagen für neue Bilder oder Videos zu erstellen. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen. Anschließend kann der Nutzer 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")
# akzeptiert alle Formate – Bild/Verzeichnis/Path/URL/Video/PIL/ndarray. 0 für Webcam
results = model.predict(source="0")
results = model.predict(source="folder", show=True) # Vorhersagen anzeigen. Akzeptiert alle YOLO-Predict-Argumente
# from PIL
im1 = Image.open("bus.jpg")
results = model.predict(source=im1, save=True) # Visualisierte Bilder speichern
# aus ndarray
im2 = cv2.imread("bus.jpg")
results = model.predict(source=im2, save=True, save_txt=True) # Vorhersagen als Labels speichern
# aus einer Liste von PIL/ndarray
results = model.predict(source=[im1, im2])Exportieren#
Der Export-Modus dient dazu, ein YOLO-Modell in ein Format zu exportieren, das für die Bereitstellung verwendet werden kann. In diesem Modus wird das Modell in ein Format konvertiert, das von anderen Softwareanwendungen oder Hardwaregeräten verwendet werden kann. Dieser Modus ist nützlich, wenn das Modell in Produktionsumgebungen bereitgestellt wird.
Ein offizielles YOLO-Modell mit dynamischer Batch- und Bildgröße nach ONNX exportieren.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)Verfolgen#
Der Track-Modus dient dazu, Objekte mithilfe eines YOLO-Modells in Echtzeit zu verfolgen. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen. Anschließend kann der Nutzer einen Live-Videostream für die Objektverfolgung in Echtzeit bereitstellen. Dieser Modus eignet sich für Anwendungen wie Überwachungssysteme oder selbstfahrende Autos.
from ultralytics import YOLO
# Ein Modell laden
model = YOLO("yolo26n.pt") # Ein offizielles Erkennungsmodell laden
model = YOLO("yolo26n-seg.pt") # Ein offizielles Segmentierungsmodell laden
model = YOLO("path/to/best.pt") # Ein benutzerdefiniertes Modell laden
# Mit dem Modell verfolgen
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")Benchmark#
Der Benchmark-Modus dient dazu, die Geschwindigkeit und Genauigkeit verschiedener Exportformate für YOLO zu messen. Die Benchmarks liefern Informationen zur Größe des exportierten Formats, zu den mAP50-95-Metriken (für Objekterkennung und Segmentierung) oder den accuracy_top1-Metriken (für Klassifizierung) sowie zur Inferenzzeit in Millisekunden pro Bild für verschiedene Exportformate wie ONNX, OpenVINO, TensorRT und weitere. Anhand dieser Informationen können Nutzer das optimale Exportformat für ihren jeweiligen Anwendungsfall und ihre Anforderungen an Geschwindigkeit und Genauigkeit auswählen.
Ein offizielles YOLO-Modell mit allen Exportformaten benchmarken.
from ultralytics.utils.benchmarks import benchmark
# Benchmark
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)Trainer verwenden#
Die Modellklasse YOLO dient als übergeordnete Schnittstelle für Trainer-Klassen. Für jede YOLO-Aufgabe gibt es einen eigenen Trainer, der von BaseTrainer abgeleitet ist. Diese Architektur bietet mehr Flexibilität und Anpassungsmöglichkeiten für deine Workflows im maschinellen Lernen.
from ultralytics.models.yolo.detect import DetectionPredictor, DetectionTrainer, DetectionValidator
overrides = {"model": "yolo26n.pt", "data": "coco8.yaml", "epochs": 3}
# Trainer
trainer = DetectionTrainer(overrides=overrides)
trainer.train()
trained_model = trainer.best # Pfad zu best.pt
# Validator
validator = DetectionValidator(args={"data": "coco8.yaml"})
validator(model=trained_model)
# Predictor
predictor = DetectionPredictor(overrides={"model": trained_model})
predictor(source="https://ultralytics.com/images/bus.jpg")
# Einen unterbrochenen Trainingslauf am letzten Checkpoint fortsetzen
trainer = DetectionTrainer(overrides={"resume": "path/to/last.pt"})
trainer.train()Du kannst Trainer ganz einfach anpassen, um benutzerdefinierte Aufgaben zu unterstützen oder Ideen aus Forschung und Entwicklung zu erkunden. Dank des modularen Aufbaus von Ultralytics YOLO kannst du das Framework an deine spezifischen Anforderungen anpassen – ganz gleich, ob du an einer neuen Aufgabe im Bereich Computer Vision arbeitest oder bestehende Modelle optimierst, um bessere Ergebnisse zu erzielen.
Häufig gestellte Fragen#
Ultralytics YOLO lässt sich ganz einfach in deine Python-Projekte integrieren. Du kannst ein vortrainiertes Modell laden oder ein neues Modell von Grund auf trainieren. So legst du los:
from ultralytics import YOLO # Ein vortrainiertes YOLO-Modell laden model = YOLO("yolo26n.pt") # Objekterkennung in einem Bild durchführen results = model("https://ultralytics.com/images/bus.jpg") # Die Ergebnisse visualisieren for result in results: result.show()Weitere ausführliche Beispiele findest du im Abschnitt Predict-Modus.
Ultralytics YOLO bietet verschiedene Modi für unterschiedliche Workflows im maschinellen Lernen. Dazu gehören:
- Trainieren: Ein Modell mit benutzerdefinierten Datensätzen trainieren.
- Validieren: Die Modellleistung anhand eines Validierungssatzes überprüfen.
- Vorhersagen: Vorhersagen für neue Bilder oder Videostreams erstellen.
- Exportieren: Modelle in verschiedene Formate wie ONNX und TensorRT exportieren.
- Verfolgen: Objekte in Videostreams in Echtzeit verfolgen.
- Benchmark: Die Modellleistung mit verschiedenen Konfigurationen benchmarken.
Jeder Modus bietet umfassende Funktionen für die verschiedenen Phasen der Modellentwicklung und -bereitstellung.
Um ein benutzerdefiniertes YOLO-Modell zu trainieren, musst du deinen Datensatz und weitere Hyperparameter angeben. Hier ein kurzes Beispiel:
from ultralytics import YOLO # Das YOLO-Modell laden model = YOLO("yolo26n.yaml") # Das Modell mit einem benutzerdefinierten Datensatz trainieren model.train(data="path/to/your/dataset.yaml", epochs=10)Weitere Informationen zum Training und Links zu Anwendungsbeispielen findest du auf unserer Seite zum Train-Modus.
Mit der Funktion
exportlassen sich YOLO-Modelle ganz einfach in ein für die Bereitstellung geeignetes Format exportieren. Du kannst ein Modell zum Beispiel ins ONNX-Format exportieren:from ultralytics import YOLO # Das YOLO-Modell laden model = YOLO("yolo26n.pt") # Exportiere das Modell in das ONNX-Format model.export(format="onnx")Weitere Exportoptionen findest du in der Dokumentation zum Export-Modus.
Ja, du kannst YOLO-Modelle anhand verschiedener Datensätze validieren. Nach dem Training kannst du den Validierungsmodus verwenden, um die Leistung auszuwerten:
from ultralytics import YOLO # Ein YOLO-Modell laden model = YOLO("yolo26n.yaml") # Das Modell trainieren model.train(data="coco8.yaml", epochs=5) # Das Modell anhand eines anderen Datensatzes validieren model.val(data="path/to/separate/data.yaml")Auf der Seite zum Val-Modus findest du ausführliche Beispiele und Anwendungshinweise.