Python-Nutzung#
Willkommen bei der Python-Nutzungsdokumentation für Ultralytics YOLO! Diese Anleitung soll dir dabei helfen, 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 an 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 dir die schnelle Implementierung fortschrittlicher Objekterkennungsfunktionen. Fangen wir an!
Watch: Mastering Ultralytics YOLO: Python
Benutzer können beispielsweise mit nur wenigen Zeilen Code ein Modell laden, es trainieren, seine Leistung an einem Validierungssatz bewerten und es 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 verwendet, um ein YOLO-Modell anhand eines benutzerdefinierten Datensatzes zu trainieren. In diesem Modus wird das Modell unter Verwendung des angegebenen Datensatzes und der angegebenen Hyperparameter trainiert. Der Trainingsprozess umfasst die Optimierung der Modellparameter, damit das Modell 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)Validierung#
Der Val-Modus wird verwendet, um ein YOLO-Modell nach dem Training zu validieren. In diesem Modus wird das Modell an einem Validierungssatz bewertet, um seine Genauigkeit und Verallgemeinerungsleistung zu messen. Dieser Modus kann verwendet werden, um die Hyperparameter des Modells abzustimmen 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()Vorhersage#
Der Predict-Modus wird verwendet, um mit einem trainierten YOLO-Modell Vorhersagen an neuen Bildern oder Videos durchzuführen. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und du kannst Bilder oder Videos bereitstellen, um die Inferenz durchzuführen. Das Modell sagt die Klassen und Positionen von Objekten 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])Export#
Der Export-Modus wird verwendet, um 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 konvertiert, das von anderen Softwareanwendungen oder Hardwaregeräten verwendet werden kann. Dieser Modus ist nützlich, wenn das Modell in Produktionsumgebungen bereitgestellt wird.
Exportiere ein offizielles YOLO-Modell nach ONNX mit dynamischer Batch-Größe und Bildgröße.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)Track#
Der Track-Modus wird verwendet, um Objekte in Echtzeit mit einem YOLO-Modell zu verfolgen. In diesem Modus wird das Modell aus einer Checkpoint-Datei geladen, und du kannst einen Live-Videostream bereitstellen, um eine Echtzeit-Objektverfolgung 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")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_top1-Metriken (für die Klassifizierung) sowie die Inferenzzeit in Millisekunden pro Bild über verschiedene Exportformate wie ONNX, OpenVINO, TensorRT und andere hinweg. Diese Informationen können dir helfen, basierend auf deinen Anforderungen an Geschwindigkeit und Genauigkeit das optimale Exportformat für deinen spezifischen Anwendungsfall auszuwählen.
Erstelle einen Benchmark für ein offizielles YOLO-Modell über alle Exportformate hinweg.
from ultralytics.utils.benchmarks import benchmark
# Benchmark
benchmark(model="yolo26n.pt", data="coco8.yaml", imgsz=640, device=0)Verwendung von Trainern#
Die Modellklasse YOLO dient als High-Level-Wrapper für Trainer-Klassen. Jede YOLO-Aufgabe hat ihren eigenen Trainer, der von BaseTrainer erbt. Diese Architektur ermöglicht eine größere Flexibilität und Anpassbarkeit in deinen Workflows für maschinelles 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 # path to 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")
# Resume from the last checkpoint
trainer = DetectionTrainer(overrides={**overrides, "resume": trainer.last})Du kannst Trainer ganz 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.
FAQ#
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 gelingt dir der Einstieg:
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 zum Predict-Modus.
Ultralytics YOLO bietet verschiedene Modi für unterschiedliche Workflows im Bereich des maschinellen Lernens. Dazu gehören:
- Train: Trainiere ein Modell anhand benutzerdefinierter Datensätze.
- Val: Validiere die Modellleistung an einem Validierungssatz.
- Predict: Führe Vorhersagen an neuen Bildern oder Videostreams durch.
- Export: Exportiere Modelle in verschiedene Formate wie ONNX und TensorRT.
- Track: Objektverfolgung in Echtzeit in Videostreams.
- Benchmark: Erstelle Benchmarks für die Modellleistung über verschiedene Konfigurationen hinweg.
Jeder Modus wurde entwickelt, um umfassende Funktionen für verschiedene Phasen der Modellentwicklung und -bereitstellung bereitzustellen.
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 Anwendungsbeispielen findest du auf unserer Seite zum Train-Modus.
Das Exportieren von YOLO-Modellen in ein für die Bereitstellung geeignetes Format ist mit der Funktion
exportganz unkompliziert. Du kannst ein Modell beispielsweise 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")Verschiedene Exportoptionen findest du in der Dokumentation zum Export-Modus.
Ja, das Validieren von YOLO-Modellen an 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 Anwendungsbeispiele.