Link to this sectionPython-Nutzung#

Willkommen in der Dokumentation zur Ultralytics YOLO Python-Nutzung! Dieser Leitfaden hilft dir dabei, Ultralytics YOLO nahtlos in deine Python-Projekte für Objekterkennung, Instanzsegmentierung, semantische Segmentierung und Klassifizierung zu integrieren. Hier erfährst du, wie du vortrainierte Modelle lädst und verwendest, neue Modelle trainierst und Vorhersagen auf Bildern durchführst. Die benutzerfreundliche Python-Schnittstelle ist eine wertvolle Ressource für alle, die YOLO in ihre Python-Projekte einbinden möchten, und ermöglicht es dir, schnell fortschrittliche Objekterkennungsfunktionen zu implementieren. Lass uns anfangen!

Zum Beispiel können Benutzer ein Modell laden, es trainieren, seine Leistung auf einem Validierungsdatensatz bewerten und es sogar mit nur wenigen Zeilen Code 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")

Link to this sectionTrainieren#

Der Train-Modus wird verwendet, um ein YOLO-Modell mit einem benutzerdefinierten Datensatz zu trainieren. In diesem Modus wird das Modell unter Verwendung des angegebenen Datensatzes und der Hyperparameter trainiert. Der Trainingsprozess beinhaltet die Optimierung der Modellparameter, damit es die 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

Link to this sectionValidieren#

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

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

Validierungsbeispiele

Link to this sectionVorhersagen#

Der Predict-Modus wird verwendet, um mit einem trainierten YOLO-Modell Vorhersagen auf neuen Bildern oder Videos zu treffen. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und der Benutzer kann Bilder oder Videos für die 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])

Vorhersagebeispiele

Link to this sectionExportieren#

Der Export-Modus wird zum Exportieren eines YOLO-Modells in ein für die Bereitstellung geeignetes Format verwendet. 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.

from ultralytics import YOLO

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

Exportbeispiele

Link to this sectionTrack#

Der Track-Modus wird zur Echtzeit-Objektverfolgung 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 Objekterkennung 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")

Tracking-Beispiele

Link to this sectionBenchmark#

Der Benchmark-Modus wird verwendet, um die Geschwindigkeit und Genauigkeit verschiedener Exportformate für YOLO zu profilieren. Die Benchmarks liefern Informationen zur Größe des exportierten Formats, seinen mAP50-95-Metriken (für Objekterkennung und Segmentierung) oder accuracy_top1-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 auszuwählen.

from ultralytics.utils.benchmarks import benchmark

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

Benchmark-Beispiele

Link to this sectionVerwendung 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 mehr Flexibilität und Anpassung 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 optimierst.

Anpassungs-Tutorials

Link to this sectionFAQ#

Link to this sectionWie kann ich YOLO in mein Python-Projekt für die 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 fängst du an:

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

Weitere detaillierte Beispiele findest du in unserem Abschnitt Predict-Modus.

Link to this sectionWelche verschiedenen Modi gibt es in YOLO?#

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

• Train: Trainiere ein Modell mit benutzerdefinierten Datensätzen.
• Val: Validiere die Modellleistung auf 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.

Link to this sectionWie trainiere ich ein benutzerdefiniertes YOLO-Modell mit meinem Datensatz?#

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 Links zu Anwendungsbeispielen findest du auf unserer Seite zum Train-Modus.

Link to this sectionWie exportiere ich YOLO-Modelle für die Bereitstellung?#

Das Exportieren von YOLO-Modellen in ein für die Bereitstellung geeignetes Format ist mit der Funktion export unkompliziert. Du kannst ein Modell zum Beispiel 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 beachte bitte die Dokumentation zum Export-Modus.

Link to this sectionKann ich mein YOLO-Modell auf verschiedenen Datensätzen validieren?#

Ja, das Validieren 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")

Schau dir die Seite zum Val-Modus für detaillierte Beispiele und die Verwendung an.