Modellvorhersage mit Ultralytics YOLO#

Einleitung#

In der Welt des maschinellen Lernens und der Computer Vision wird der Prozess, visuelle Daten zu verstehen, oft als Inferenz oder Vorhersage bezeichnet. Ultralytics YOLO26 bietet eine leistungsstarke Funktion namens predict mode, die für eine leistungsstarke Inferenz in Echtzeit über eine große Bandbreite von Datenquellen hinweg entwickelt wurde.

Sieh dir die unreleased YOLO27 preview für geplante Inferenzbeispiele an.

Anwendungen in der Praxis#

Warum Ultralytics YOLO für die Inferenz verwenden?#

Hier sind einige Gründe, warum du den Vorhersagemodus von YOLO26 für deine verschiedenen Inferenzanforderungen in Betracht ziehen solltest:

• Vielseitigkeit: Inferenz auf Bildern, Videos und sogar Live-Streams möglich.
• Leistung: Für schnelle Verarbeitung in Echtzeit entwickelt, ohne die Genauigkeit zu beeinträchtigen.
• Benutzerfreundlichkeit: Intuitive Python- und CLI-Schnittstellen für schnelle Bereitstellung und Tests.
• Hochgradig anpassbar: Verschiedene Einstellungen und Parameter ermöglichen es, das Inferenzverhalten des Modells an deine spezifischen Anforderungen anzupassen.
• Produktionsbereit: Stelle Modelle als Ultralytics Platform-Inferenzendpunkte mit automatischer Skalierung und Überwachung bereit oder führe die Inferenz lokal aus.

Wichtige Funktionen des Vorhersagemodus#

Der Vorhersagemodus von YOLO26 ist robust und vielseitig ausgelegt und bietet folgende Funktionen:

• Unterstützung mehrerer Datenquellen: Unabhängig davon, ob deine Daten aus einzelnen Bildern, einer Bildersammlung, Videodateien oder Videostreams in Echtzeit bestehen – der Vorhersagemodus ist dafür geeignet.
• Streaming-Modus: Verwende die Streaming-Funktion, um einen speichereffizienten Generator von Results-Objekten zu erzeugen. Aktiviere ihn, indem du stream=True in der Aufrufmethode des Predictors setzt. Anders als das Standardverhalten (stream=False), das eine Liste mit allen Ergebnissen zurückgibt, liefert stream=True die Ergebnisse einzeln und eignet sich dadurch besonders für lange Videos und Live-Streams.
• Stapelverarbeitung: Verarbeite mehrere Bilder oder Videoframes in einem einzigen Stapel und verkürze dadurch die gesamte Inferenzzeit weiter.
• Einfache Integration: Dank der flexiblen API lässt sich der Modus problemlos in bestehende Datenpipelines und andere Softwarekomponenten integrieren.

Ultralytics YOLO-Modelle geben entweder eine Python-Liste von Results-Objekten oder einen speichereffizienten Generator von Results-Objekten zurück, wenn stream=True während der Inferenz an das Modell übergeben wird:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # pretrained YOLO26n model

# Run batched inference on a list of images
results = model(["image1.jpg", "image2.jpg"])  # return a list of Results objects

# Process results list
for result in results:
    boxes = result.boxes  # Boxes object for bounding box outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    obb = result.obb  # Oriented boxes object for OBB outputs
    result.show()  # display to screen
    result.save(filename="result.jpg")  # save to disk

Inferenzquellen#

YOLO26 kann, wie in der folgenden Tabelle dargestellt, verschiedene Arten von Eingabequellen für die Inferenz verarbeiten. Dazu gehören statische Bilder, Videostreams und verschiedene Datenformate. Die Tabelle zeigt außerdem, ob jede Quelle mit dem Argument stream=True ✅ im Streaming-Modus verwendet werden kann. Der Streaming-Modus eignet sich für die Verarbeitung von Videos oder Live-Streams, da er einen Generator mit Ergebnissen erstellt, anstatt alle Frames in den Arbeitsspeicher zu laden.

Nachfolgend findest du Codebeispiele für die Verwendung der einzelnen Quellentypen:

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Define path to the image file
source = "path/to/image.jpg"

# Run inference on the source
results = model(source)  # list of Results objects

Inferenzargumente#

model.predict() akzeptiert mehrere Argumente, die zur Laufzeit der Inferenz übergeben werden können, um Standardwerte zu überschreiben:

Feste Form im Vergleich zu minimalem Rechteck (rect)#

Standardmäßig verwendet predict rect=True, wodurch nach Möglichkeit eine Auffüllung auf ein minimales Rechteck aktiviert wird. Das Bild wird so skaliert, dass es in imgsz passt, und nur bis zum nächsten Vielfachen des Strides aufgefüllt. Dadurch kann der finale Tensor kleiner als imgsz sein. Die Auffüllung auf ein minimales Rechteck wird nur verwendet, wenn alle Bilder im Stapel dieselbe Form haben und das Backend dies unterstützt (PyTorch .pt oder dynamisches ONNX / Triton). Andernfalls werden die Bilder auf das vollständige Ziel imgsz aufgefüllt.

Verwende rect=False, um immer auf das vollständige Ziel imgsz aufzufüllen. Dies wird empfohlen, wenn du eine feste Eingabegröße benötigst, die zu exportierten Modellen (ONNX, TensorRT usw.) passt.

Ganzzahl im Vergleich zu Tupel imgsz

• Eine Ganzzahl imgsz=640 wird nach der Anpassung an den Stride zu einem quadratischen Ziel (640, 640).
• Ein Tupel imgsz=(384, 672) legt ein rechteckiges Ziel fest. Mit rect=True und auto=True kann der tatsächliche Tensor kleiner als dieses Ziel sein.

Training im Vergleich zu predict/export

Das Training akzeptiert nur eine einzelne Ganzzahl imgsz (eine [h, w]-Liste wird auf den größten Wert reduziert). Predict und Export akzeptieren entweder eine Ganzzahl oder ein (height, width)-Tupel.

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on 'bus.jpg' with arguments
model.predict("https://ultralytics.com/images/bus.jpg", save=True, imgsz=320, conf=0.25)

Inferenzargumente:

Argumente für die Visualisierung:

Bild- und Videoformate#

YOLO26 unterstützt verschiedene Bild- und Videoformate, wie in ultralytics/data/utils.py angegeben. In den folgenden Tabellen findest du die gültigen Endungen und Beispiele für Vorhersagebefehle.

Bilder#

Die folgende Tabelle enthält gültige Ultralytics-Bildformate.

Videos#

Die folgende Tabelle enthält gültige Ultralytics-Videoformate.

Arbeiten mit Ergebnissen#

Alle Ultralytics-Aufrufe von predict() geben eine Liste von Results-Objekten zurück:

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
    [
        "https://ultralytics.com/images/bus.jpg",
        "https://ultralytics.com/images/zidane.jpg",
    ]
)  # batch inference

Results-Objekte verfügen über die folgenden Attribute:

Ergebnisse nach Aufgabe#

Welche Felder unten ausgefüllt werden, hängt von der Aufgabe deines Modells ab — vergleiche Objekterkennung, Segmentierung, semantische Segmentierung, Tiefenschätzung, Klassifizierung, Pose und OBB, falls du dich noch für keine entschieden hast. Jede Vorhersage gibt ein Results-Objekt pro Bild oder Frame zurück. Die obigen Standardfelder sind immer verfügbar, während die aufgabenspezifischen Vorhersagedaten in den Feldern unten gespeichert werden. YOLO-Koordinaten- und Konfidenztensoren sind torch.float32; Wahrscheinlichkeitstensoren sind torch.float32, es sei denn, es wird Halauflösung verwendet, dann torch.float16. Nach result.numpy() werden Tensor zu NumPy-Arrays mit passenden NumPy-Datentypen. Instanzmasken sind binäre torch.uint8-Tensoren, während semantische Masken den kleinsten praktischen Ganzzahl-Datentypen für Klassen-IDs verwenden: torch.uint8, torch.int16 oder torch.int32, je nach Anzahl der Klassen.

Results-Objekte verfügen über die folgenden Methoden:

Weitere Informationen findest du in der Dokumentation der Klasse Results.

Boxen#

Das Boxes-Objekt kann zum Indizieren, Bearbeiten und Konvertieren von Bounding Boxes in verschiedene Formate verwendet werden.

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.boxes)  # print the Boxes object containing the detection bounding boxes

Hier ist eine Tabelle mit den Methoden und Eigenschaften der Klasse Boxes, einschließlich Name, Typ und Beschreibung:

Weitere Informationen findest du in der Dokumentation der Klasse Boxes.

Masken#

Das Masks-Objekt kann zum Indizieren, Bearbeiten und Konvertieren von Masken in Segmente verwendet werden.

from ultralytics import YOLO

# Load a pretrained YOLO26n-seg Segment model
model = YOLO("yolo26n-seg.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.masks)  # print the Masks object containing the detected instance masks

Hier ist eine Tabelle mit den Methoden und Eigenschaften der Klasse Masks, einschließlich Name, Typ und Beschreibung:

Weitere Informationen findest du in der Dokumentation der Klasse Masks.

SemanticMask#

Das SemanticMask-Objekt speichert für die Ergebnisse der semantischen Segmentierung eine dichte Klassenkarte. Anders als Masks enthält es keine binäre Maske pro Objekt und stellt keine Hilfsfunktionen für Polygone bereit.

from ultralytics import YOLO

# Load a pretrained YOLO26n-sem Semantic model
model = YOLO("yolo26n-sem.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.semantic_mask.data)  # print the H x W class-ID map

Keypoints#

Das Keypoints-Objekt kann zum Indizieren, Bearbeiten und Normalisieren von Koordinaten verwendet werden.

from ultralytics import YOLO

# Load a pretrained YOLO26n-pose Pose model
model = YOLO("yolo26n-pose.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.keypoints)  # print the Keypoints object containing the detected keypoints

Hier ist eine Tabelle mit den Methoden und Eigenschaften der Klasse Keypoints, einschließlich Name, Typ und Beschreibung:

Weitere Informationen findest du in der Dokumentation der Klasse Keypoints.

Probs#

Das Probs-Objekt kann verwendet werden, um die Klassifizierungsindizes und -scores top1 und top5 abzurufen.

from ultralytics import YOLO

# Load a pretrained YOLO26n-cls Classify model
model = YOLO("yolo26n-cls.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/bus.jpg")  # results list

# View results
for r in results:
    print(r.probs)  # print the Probs object containing the detected class probabilities

Hier ist eine Tabelle mit einer Zusammenfassung der Methoden und Eigenschaften der Klasse Probs:

Weitere Informationen findest du in der Dokumentation der Klasse Probs.

OBB#

Das OBB-Objekt kann zum Indizieren, Bearbeiten und Konvertieren von orientierten Bounding Boxes in verschiedene Formate verwendet werden.

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n-obb.pt")

# Run inference on an image
results = model("https://ultralytics.com/images/boats.jpg")  # results list

# View results
for r in results:
    print(r.obb)  # print the OBB object containing the oriented detection bounding boxes

Hier ist eine Tabelle mit den Methoden und Eigenschaften der Klasse OBB, einschließlich Name, Typ und Beschreibung:

Weitere Informationen findest du in der Dokumentation der Klasse OBB.

Ergebnisse darstellen#

Die Methode plot() in Results-Objekten erleichtert die Visualisierung von Vorhersagen, indem erkannte Objekte wie Bounding Boxes, Masken, Keypoints und Wahrscheinlichkeiten über das Originalbild gelegt werden. Diese Methode gibt das annotierte Bild als NumPy-Array zurück, sodass es einfach angezeigt oder gespeichert werden kann.

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Run inference on 'bus.jpg'
results = model(["https://ultralytics.com/images/bus.jpg", "https://ultralytics.com/images/zidane.jpg"])  # results list

# Visualize the results
for i, r in enumerate(results):
    # Plot results image
    im_bgr = r.plot()  # BGR-order numpy array
    im_rgb = Image.fromarray(im_bgr[..., ::-1])  # RGB-order PIL image

    # Show results to screen (in supported environments)
    r.show()

    # Save results to disk
    r.save(filename=f"results{i}.jpg")

Parameter der Methode plot()#

Die Methode plot() unterstützt verschiedene Argumente zur Anpassung der Ausgabe:

Thread-sichere Inferenz#

Die Gewährleistung der Thread-Sicherheit während der Inferenz ist entscheidend, wenn du mehrere YOLO-Modelle parallel in verschiedenen Threads ausführst. Thread-sichere Inferenz stellt sicher, dass die Vorhersagen jedes Threads isoliert sind und sich nicht gegenseitig beeinflussen. Dadurch werden Race Conditions vermieden und konsistente, zuverlässige Ausgaben gewährleistet.

Wenn du YOLO-Modelle in einer Multithreading-Anwendung verwendest, ist es wichtig, für jeden Thread ein eigenes Modellobjekt zu instanziieren oder thread-lokalen Speicher zu verwenden, um Konflikte zu vermeiden:

from threading import Thread

from ultralytics import YOLO

def thread_safe_predict(model, image_path):
    """Performs thread-safe prediction on an image using a locally instantiated YOLO model."""
    model = YOLO(model)
    results = model.predict(image_path)
    # Process results

# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo26n.pt", "image2.jpg")).start()

Eine ausführliche Betrachtung der thread-sicheren Inferenz mit YOLO-Modellen und schrittweise Anleitungen findest du in unserem Leitfaden zur thread-sicheren YOLO-Inferenz. Dieser Leitfaden enthält alle erforderlichen Informationen, um häufige Fehler zu vermeiden und sicherzustellen, dass deine Inferenz mit mehreren Threads reibungslos ausgeführt wird.

Streaming-Quelle for-Schleife#

Hier ist ein Python-Skript, das OpenCV (cv2) und YOLO verwendet, um Inferenz auf Videoframes auszuführen. Dieses Skript setzt voraus, dass du die erforderlichen Pakete (opencv-python und ultralytics) bereits installiert hast.

import cv2

from ultralytics import YOLO

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

# Open the video file
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO inference on the frame
        results = model(frame)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLO Inference", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Dieses Skript führt für jedes Videobild Vorhersagen aus, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drücken von „q“ beendet werden.

Wie geht es weiter?#

Möchtest du über ein vortrainiertes Modell hinausgehen? Bestätige, dass deine Aufgabe zu deinem Problem passt, formatiere deine eigenen Daten mit dem Datenset-Leitfaden und trainiere anschließend damit.

FAQ#