Python Verwendung

Willkommen bei der Dokumentation zur Verwendung von Ultralytics YOLO Python ! Diese Anleitung soll Ihnen helfen, Ultralytics YOLO nahtlos in Ihre Python zur Objekterkennung, Segmentierung und Klassifizierung zu integrieren. Hier erfahren Sie, wie Sie bereits trainierte Modelle laden und verwenden, neue Modelle trainieren und Vorhersagen für Bilder treffen können. Die einfach zu bedienende Python ist eine wertvolle Ressource für jeden, der YOLO in seine Python einbinden möchte, um schnell fortgeschrittene Objekterkennungsfunktionen zu implementieren. Lassen Sie uns beginnen!

Beobachten: Beherrschung von Ultralytics YOLO: Python

So können Benutzer beispielsweise ein Modell laden, es trainieren, seine Leistung auf einem Validierungssatz bewerten und es sogar mit nur wenigen Codezeilen in das ONNX 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")

Zug

Der Modus Train wird für das Training eines YOLO auf einem benutzerdefinierten Datensatz verwendet. In diesem Modus wird das Modell mit dem angegebenen Datensatz und den Hyperparametern trainiert. Der Trainingsprozess umfasst die Optimierung der Parameter des Modells, damit es die Klassen und Positionen der Objekte 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)

Beispiele für Züge

Val

Der Val-Modus dient der Validierung eines YOLO , nachdem es trainiert worden ist. In diesem Modus wird das Modell anhand eines Validierungssatzes bewertet, um seine Genauigkeit und Generalisierungsleistung zu messen. Dieser Modus kann verwendet werden, um die Hyperparameter des Modells abzustimmen, 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

Vorhersage

Der Vorhersagemodus wird verwendet, um mit einem trainierten YOLO auf neuen Bildern oder Videos Vorhersagen zu machen. In diesem Modus wird das Modell aus einer Prüfpunktdatei geladen, und der Benutzer kann Bilder oder Videos zur Durchführung von Schlussfolgerungen bereitstellen. Das Modell sagt die Klassen und Orte 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()

Beispiele vorhersagen

Exportieren

Der Exportmodus wird verwendet, um ein YOLO in ein Format zu exportieren, das für den Einsatz verwendet werden kann. In diesem Modus wird das Modell in ein Format konvertiert, das von anderen Software-Anwendungen oder Hardware-Geräten verwendet werden kann. Dieser Modus ist nützlich, wenn das Modell in Produktionsumgebungen eingesetzt werden soll.

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)

Beispiele exportieren

Spur

Der Verfolgungsmodus wird für die Verfolgung von Objekten in Echtzeit unter Verwendung eines YOLO verwendet. In diesem Modus wird das Modell aus einer Prüfpunktdatei geladen, und der Benutzer kann einen Live-Videostream bereitstellen, um eine 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 ein Profil der Geschwindigkeit und Genauigkeit verschiedener Exportformate für YOLO zu erstellen. 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 in verschiedenen Exportformaten wie ONNX, OpenVINO, TensorRT und andere. Diese Informationen können den Nutzern helfen, das optimale Exportformat für ihren spezifischen Anwendungsfall zu wählen, basierend auf ihren Anforderungen an Geschwindigkeit und Genauigkeit.

from ultralytics.utils.benchmarks import benchmark

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

Benchmark-Beispiele

Einsatz von Trainern

Die YOLO Model-Klasse dient als High-Level-Wrapper für die Trainer-Klassen. Jede YOLO hat ihren eigenen Trainer, der von der folgenden Klasse erbt BaseTrainer. Diese Architektur ermöglicht eine größere Flexibilität und Anpassbarkeit in Ihrem 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 die Trainer leicht anpassen, um benutzerdefinierte Aufgaben zu unterstützen oder Forschungs- und Entwicklungsideen zu erforschen. Der modulare Aufbau von Ultralytics YOLO ermöglicht es Ihnen, das Framework an Ihre spezifischen Bedürfnisse anzupassen, ganz gleich, ob Sie an einer neuartigen Computer-Vision-Aufgabe arbeiten oder bestehende Modelle für eine bessere Leistung feinabstimmen wollen.

Anpassungs-Tutorials

FAQ

Wie kann ich YOLO in mein Python zur Objekterkennung integrieren?

Die Integration von Ultralytics YOLO in Ihre Python ist einfach. Sie können ein vortrainiertes Modell laden oder ein neues Modell von Grund auf trainieren. Hier erfahren Sie, wie Sie beginnen können:

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

Ausführlichere Beispiele finden Sie in unserem Abschnitt über den Vorhersagemodus.

Welche verschiedenen Modi gibt es in YOLO?

Ultralytics YOLO bietet verschiedene Modi für unterschiedliche Arbeitsabläufe beim maschinellen Lernen. Diese umfassen:

• Zug: Trainieren Sie ein Modell mit benutzerdefinierten Datensätzen.
• Val: Validierung der Modellleistung anhand eines Validierungssatzes.
• Vorhersage: Machen Sie Vorhersagen zu neuen Bildern oder Videostreams.
• Exportieren: Exportieren Sie Modelle in verschiedene Formate wie ONNX und TensorRT.
• Spur: Objektverfolgung in Echtzeit in Videoströmen.
• Benchmark: Benchmarking der Modellleistung in verschiedenen Konfigurationen.

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 mit meinem Datensatz?

Um ein benutzerdefiniertes YOLO 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 Einzelheiten zur Schulung und Hyperlinks zu Anwendungsbeispielen finden Sie auf unserer Seite zum Schulungsmodus.

Wie exportiere ich YOLO für den Einsatz?

Der Export von YOLO in ein für die Bereitstellung geeignetes Format ist mit der Funktion export Funktion. Sie können zum Beispiel ein Modell in das Format ONNX exportieren:

from ultralytics import YOLO

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

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

Die verschiedenen Exportoptionen finden Sie in der Dokumentation zum Exportmodus.

Kann ich mein YOLO an verschiedenen Datensätzen validieren?

Ja, die Validierung von YOLO 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")

Detaillierte Beispiele und Verwendungsmöglichkeiten finden Sie auf der Seite Val Mode.

📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 8 Tagen

Kommentare