Python-Nutzung

Willkommen bei der Ultralytics YOLO Python Usage Dokumentation! Dieser Leitfaden soll Ihnen helfen, Ultralytics YOLO nahtlos in Ihre Python-Projekte zur Objekterkennung, Segmentierung und Klassifizierung zu integrieren. Hier erfahren Sie, wie Sie vortrainierte Modelle laden und verwenden, neue Modelle trainieren und Vorhersagen auf Bildern durchführen. Die benutzerfreundliche Python-Schnittstelle ist eine wertvolle Ressource für alle, die YOLO in ihre Python-Projekte integrieren möchten, sodass Sie schnell erweiterte Objekterkennungsfunktionen implementieren können. Lass uns anfangen!

Ansehen: YOLO mit Ultralytics meistern: Python

Zum Beispiel können Benutzer ein Modell laden, es trainieren, seine Leistung auf einem Validierungsset bewerten und es sogar mit nur wenigen Codezeilen in das ONNX-Format exportieren.

from ultralytics import YOLO

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

# Load a pretrained YOLO model (recommended for training)
model = YOLO("yolo11n.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 Trainingsmodus wird verwendet, um ein YOLO-Modell auf einem benutzerdefinierten Datensatz zu trainieren. In diesem Modus wird das Modell anhand des angegebenen Datensatzes und der Hyperparameter trainiert. Der Trainingsprozess umfasst die Optimierung der Parameter des Modells, sodass es die Klassen und Positionen von Objekten in einem Bild genau vorhersagen kann.

from ultralytics import YOLO

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

from ultralytics import YOLO

model = YOLO("yolo11n.yaml")
results = model.train(data="coco8.yaml", epochs=5)

model = YOLO("last.pt")
results = model.train(resume=True)

Train-Beispiele

Validieren

Der Val-Modus wird verwendet, um ein YOLO-Modell zu validieren, nachdem es trainiert wurde. In diesem Modus wird das Modell anhand eines Validierungsdatensatzes evaluiert, um seine Genauigkeit und Generalisierungsleistung zu messen. Dieser Modus kann verwendet werden, um die Hyperparameter des Modells zu optimieren, um seine Leistung zu verbessern.

from ultralytics import YOLO

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

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

# Validate on training data
model.val()

from ultralytics import YOLO

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

Vorhersagen

Der Vorhersagemodus wird verwendet, um Vorhersagen mit einem trainierten YOLO-Modell 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 zur Durchführung der Inferenz bereitstellen. 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])

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

Predict-Beispiele

Export

Der Exportmodus wird verwendet, um 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.

from ultralytics import YOLO

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

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="engine", device=0)

Export-Beispiele

Verfolgen

Der Track-Modus wird verwendet, um Objekte in Echtzeit mithilfe eines YOLO-Modells zu verfolgen. 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("yolo11n.pt")  # load an official detection model
model = YOLO("yolo11n-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

Benchmark-Modus wird verwendet, um die 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 die Klassifizierung) und die Inferenzzeit in Millisekunden pro Bild über verschiedene Exportformate wie ONNX, OpenVINO, TensorRT und andere. 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="yolo11n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)

Benchmark-Beispiele

Verwendung von Trainern

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

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 = DetectionTrainer(overrides=overrides)

Sie können Trainer einfach anpassen, um benutzerdefinierte Aufgaben zu unterstützen oder Forschungs- und Entwicklungsideen zu erkunden. Das modulare Design von Ultralytics YOLO ermöglicht es Ihnen, das Framework an Ihre spezifischen Bedürfnisse anzupassen, egal ob Sie an einer neuartigen Computer Vision-Aufgabe arbeiten oder bestehende Modelle für eine bessere Leistung feinabstimmen.

Tutorials zur Anpassung

FAQ

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

Die Integration von Ultralytics YOLO in Ihre python-Projekte ist einfach. Sie können ein vortrainiertes Modell laden oder ein neues Modell von Grund auf neu trainieren. So legen Sie los:

from ultralytics import YOLO

# Load a pretrained YOLO model
model = YOLO("yolo11n.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 finden Sie in unserem Abschnitt Vorhersagemodus.

Welche verschiedenen Modi sind in YOLO verfügbar?

Ultralytics YOLO bietet verschiedene Modi, um unterschiedliche Machine-Learning-Workflows zu unterstützen. Dazu gehören:

• Trainieren: Trainieren Sie ein Modell mit benutzerdefinierten Datensätzen.
• Validieren: Validieren Sie die Modellleistung anhand eines Validierungsdatensatzes.
• Vorhersagen: Treffen Sie Vorhersagen auf der Grundlage neuer Bilder oder Videostreams.
• Exportieren: Modelle in verschiedene Formate wie ONNX und TensorRT exportieren.
• Verfolgen: Echtzeit-Objektverfolgung in Videostreams.
• Benchmark: Benchmark-Modellleistung über verschiedene Konfigurationen hinweg.

Jeder Modus ist so konzipiert, dass er umfassende Funktionalitäten für verschiedene Phasen der Modellentwicklung und -bereitstellung bietet.

Wie trainiere ich ein benutzerdefiniertes YOLO-Modell mit meinem Datensatz?

Um ein benutzerdefiniertes YOLO-Modell zu trainieren, müssen Sie Ihren Datensatz und andere Hyperparameter angeben. Hier ist ein kurzes Beispiel:

from ultralytics import YOLO

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

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

Weitere Informationen zum Training und Hyperlinks zu Anwendungsbeispielen finden Sie auf unserer Seite Trainingsmodus.

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

Das Exportieren von YOLO-Modellen in einem für die Bereitstellung geeigneten Format ist mit dem Export unkompliziert export Funktion unkompliziert. Sie können beispielsweise ein Modell in das ONNX-Format exportieren:

from ultralytics import YOLO

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

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

Informationen zu verschiedenen Exportoptionen finden Sie in der Dokumentation zum Exportmodus.

Kann 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 können Sie den Validierungsmodus verwenden, um die Leistung zu bewerten:

from ultralytics import YOLO

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

Auf der Seite Val-Modus finden Sie detaillierte Beispiele und Anwendungsfälle.

📅 Vor 1 Jahr erstellt ✏️ Vor 5 Monaten aktualisiert

Kommentare