Modellvorhersage mit Ultralytics YOLO#

Einführung#

In der Welt des maschinellen Lernens und des maschinellen Sehens wird der Prozess, visuelle Daten zu interpretieren, oft Inferenz oder Vorhersage genannt. Ultralytics YOLO26 bietet eine leistungsstarke Funktion namens Vorhersagemodus, die für leistungsstarke Inferenz in Echtzeit mit einer Vielzahl von Datenquellen ausgelegt ist.

Geplante Inferenzbeispiele findest du in der Vorschau auf das noch nicht veröffentlichte YOLO27.

Anwendungen in der Praxis#

Warum Ultralytics YOLO für Inferenz verwenden?#

Darum solltest du den Vorhersagemodus von YOLO26 für deine verschiedenen Inferenzanforderungen in Betracht ziehen:

• Vielseitigkeit: Inferenz auf Bildern, Videos und sogar Live-Streams ausführen.
• Leistung: Für echtzeitfähige Verarbeitung mit hoher Geschwindigkeit entwickelt, ohne Abstriche bei der Genauigkeit.
• Einfache Bedienung: Intuitive Schnittstellen für Python und CLI ermöglichen eine schnelle Bereitstellung und Prüfung.
• Umfangreiche Anpassungsmöglichkeiten: Verschiedene Einstellungen und Parameter, mit denen du das Inferenzverhalten des Modells an deine konkreten Anforderungen anpassen kannst.
• Bereit für den Produktionseinsatz: Stelle Modelle als Inferenzendpunkte der Ultralytics Platform mit automatischer Skalierung und Überwachung bereit oder führe die Inferenz lokal aus.

Wichtige Funktionen des Vorhersagemodus#

Der Vorhersagemodus von YOLO26 ist auf Robustheit und Vielseitigkeit ausgelegt und bietet:

• Kompatibilität mit verschiedenen Datenquellen: Ganz gleich, ob deine Daten aus einzelnen Bildern, einer Bildersammlung, Videodateien oder Echtzeit-Videostreams bestehen – der Vorhersagemodus ist dafür geeignet.
• Streaming-Modus: Verwende die Streaming-Funktion, um einen speichereffizienten Generator von Results-Objekten zu erstellen. Aktiviere diese Funktion, indem du stream=True in der Aufrufmethode des Prädiktors setzt. Anders als beim Standardverhalten (stream=False), das eine Liste mit allen Ergebnissen zurückgibt, liefert stream=True die Ergebnisse einzeln. Das ist besonders bei langen Videos und Live-Streams nützlich.
• Stapelverarbeitung: Verarbeite mehrere Bilder oder Videoframes in einem einzigen Stapel und verkürze so die gesamte Inferenzzeit.
• Einfache Integration: Dank der flexiblen API lässt sich das System problemlos in bestehende Datenpipelines und andere Softwarekomponenten integrieren.

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

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n.pt")  # vortrainiertes YOLO26n-Modell

# Stapelweise Inferenz auf einer Liste von Bildern ausführen
results = model(["image1.jpg", "image2.jpg"])  # eine Liste mit Results-Objekten zurückgeben

# Ergebnisliste verarbeiten
for result in results:
    boxes = result.boxes  # Boxes-Objekt für Begrenzungsrahmen-Ausgaben
    masks = result.masks  # Masks-Objekt für Segmentierungsmasken-Ausgaben
    keypoints = result.keypoints  # Keypoints-Objekt für Posenausgaben
    probs = result.probs  # Probs-Objekt für Klassifizierungsausgaben
    obb = result.obb  # Oriented-Boxes-Objekt für OBB-Ausgaben
    result.show()  # auf dem Bildschirm anzeigen
    result.save(filename="result.jpg")  # auf dem Datenträger speichern

Inferenzquellen#

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

Nachfolgend findest du Codebeispiele zur Verwendung der einzelnen Quelltypen:

from ultralytics import YOLO

# Ein vortrainiertes YOLO26n-Modell laden
model = YOLO("yolo26n.pt")

# Pfad zur Bilddatei festlegen
source = "path/to/image.jpg"

# Inferenz auf der Quelle ausführen
results = model(source)  # Liste mit Results-Objekten

Inferenzargumente#

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

Feste Form im Vergleich zu kleinstmöglichem Rechteck (rect)#

Standardmäßig verwendet predict rect=True, wodurch nach Möglichkeit eine Auffüllung auf das kleinstmögliche Rechteck aktiviert wird. Das Bild wird so skaliert, dass es in imgsz passt, und nur bis zum nächsten Vielfachen des Strides aufgefüllt. Daher kann der endgültige Tensor kleiner als imgsz sein. Die Auffüllung auf das kleinstmögliche Rechteck wird nur verwendet, wenn alle Bilder im Batch dieselbe Form haben und das Backend dies unterstützt (PyTorch .pt oder ein Export mit dynamischer Form, etwa dynamisches ONNX). Andernfalls werden die Bilder auf die volle Zielgröße imgsz aufgefüllt.

Verwende rect=False, um immer auf die volle Zielgröße 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 ergibt nach der Rundung auf ein Stride-Vielfaches eine quadratische Zielgröße (640, 640).
• Ein Tupel imgsz=(384, 672) legt eine rechteckige Zielgröße fest. Bei rect=True kann der tatsächliche Tensor kleiner als diese Zielgröße sein.

Training im Vergleich zu predict/export

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

from ultralytics import YOLO

# Ein vortrainiertes YOLO26n-Modell laden
model = YOLO("yolo26n.pt")

# Inferenz auf „bus.jpg“ mit Argumenten ausführen
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 Dateiendungen und Beispiele für predict-Befehle.

Bilder#

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

Videos#

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

Mit Results arbeiten#

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

from ultralytics import YOLO

# Ein vortrainiertes YOLO26n-Modell laden
model = YOLO("yolo26n.pt")

# Eine Inferenz auf einem Bild ausführen
results = model("https://ultralytics.com/images/bus.jpg")
results = model(
    [
        "https://ultralytics.com/images/bus.jpg",
        "https://ultralytics.com/images/zidane.jpg",
    ]
)  # gebündelte Inferenz

Results-Objekte haben die folgenden Attribute:

Ergebnisse nach Aufgabe#

Welche der folgenden Felder befüllt werden, hängt von der Aufgabe deines Modells ab — vergleiche Objekterkennung, Segmentierung, semantische Segmentierung, Tiefenschätzung, Klassifizierung, Posenschätzung und OBB, falls du noch keine Aufgabe ausgewählt hast. Für jedes Bild oder jeden Frame gibt jede Vorhersage ein Results-Objekt zurück. Die oben genannten gemeinsamen Felder sind immer verfügbar, während die aufgabenspezifischen Vorhersagedaten in den unten aufgeführten Feldern gespeichert werden. YOLO-Koordinaten- und Konfidenztensoren sind torch.float32; Wahrscheinlichkeitstensoren sind torch.float32, sofern keine FP16-Inferenz (quantize=16) verwendet wird. In diesem Fall sind sie torch.float16. Nach result.numpy() werden Tensoren zu NumPy-Arrays mit den entsprechenden NumPy-Datentypen. Instanzmasken sind binäre torch.uint8-Tensoren, während semantische Masken den kleinstmöglichen geeigneten Ganzzahl-Datentyp für Klassen-IDs verwenden: torch.uint8, torch.int16 oder torch.int32, je nach Anzahl der Klassen.

Objekte vom Typ Results verfügen über folgende Methoden:

Weitere Informationen findest du in der Dokumentation zur Klasse Results.

Boxen#

Das Objekt Boxes kann verwendet werden, um Begrenzungsboxen zu indizieren, zu bearbeiten und in verschiedene Formate umzuwandeln.

from ultralytics import YOLO

# Ein vortrainiertes YOLO26n-Modell laden
model = YOLO("yolo26n.pt")

# Eine Inferenz auf einem Bild ausführen
results = model("https://ultralytics.com/images/bus.jpg")  # Ergebnisliste

# Ergebnisse anzeigen
for r in results:
    print(r.boxes)  # Gib das Boxes-Objekt mit den erkannten Begrenzungsboxen aus

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

Weitere Informationen findest du in der Dokumentation zur Klasse Boxes.

Masken#

Das Objekt Masks kann verwendet werden, um Masken zu indizieren, zu bearbeiten und in Segmente umzuwandeln.

from ultralytics import YOLO

# Lade ein vortrainiertes YOLO26n-seg-Segmentierungsmodell
model = YOLO("yolo26n-seg.pt")

# Eine Inferenz auf einem Bild ausführen
results = model("https://ultralytics.com/images/bus.jpg")  # Ergebnisliste

# Ergebnisse anzeigen
for r in results:
    print(r.masks)  # Gib das Masks-Objekt mit den erkannten Instanzmasken aus

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

Weitere Informationen findest du in der Dokumentation zur Klasse Masks.

SemanticMask#

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

from ultralytics import YOLO

# Lade ein vortrainiertes YOLO26n-sem-Semantikmodell
model = YOLO("yolo26n-sem.pt")

# Eine Inferenz auf einem Bild ausführen
results = model("https://ultralytics.com/images/bus.jpg")  # Ergebnisliste

# Ergebnisse anzeigen
for r in results:
    print(r.semantic_mask.data)  # Gib die Klassen-ID-Karte mit den Dimensionen H × W aus

Schlüsselpunkte#

Das Objekt Keypoints kann verwendet werden, um Koordinaten zu indizieren, zu bearbeiten und zu normalisieren.

from ultralytics import YOLO

# Lade ein vortrainiertes YOLO26n-pose-Posemodell
model = YOLO("yolo26n-pose.pt")

# Eine Inferenz auf einem Bild ausführen
results = model("https://ultralytics.com/images/bus.jpg")  # Ergebnisliste

# Ergebnisse anzeigen
for r in results:
    print(r.keypoints)  # Gib das Keypoints-Objekt mit den erkannten Schlüsselpunkten aus

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

Weitere Informationen findest du in der Dokumentation zur Klasse Keypoints.

Wahrscheinlichkeiten#

Das Objekt Probs kann verwendet werden, um Klassifikationsindizes und -werte top1 und top5 abzurufen.

from ultralytics import YOLO

# Lade ein vortrainiertes YOLO26n-cls-Klassifikationsmodell
model = YOLO("yolo26n-cls.pt")

# Eine Inferenz auf einem Bild ausführen
results = model("https://ultralytics.com/images/bus.jpg")  # Ergebnisliste

# Ergebnisse anzeigen
for r in results:
    print(r.probs)  # Gib das Probs-Objekt mit den erkannten Klassenwahrscheinlichkeiten aus

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

Weitere Informationen findest du in der Dokumentation zur Klasse Probs.

OBB#

Das Objekt OBB kann verwendet werden, um orientierte Begrenzungsrahmen zu indizieren, zu bearbeiten und in verschiedene Formate umzuwandeln.

from ultralytics import YOLO

# Ein vortrainiertes YOLO26n-Modell laden
model = YOLO("yolo26n-obb.pt")

# Eine Inferenz auf einem Bild ausführen
results = model("https://ultralytics.com/images/boats.jpg")  # Ergebnisliste

# Ergebnisse anzeigen
for r in results:
    print(r.obb)  # Gibt das OBB-Objekt mit den orientierten Erkennungsbegrenzungsrahmen aus

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

Weitere Informationen findest du in der Dokumentation zur Klasse OBB.

Ergebnisse visualisieren#

Die Methode plot() in Objekten vom Typ Results erleichtert die Visualisierung von Vorhersagen, indem erkannte Objekte (z. B. Begrenzungsrahmen, Masken, Schlüsselpunkte und Wahrscheinlichkeiten) über das Originalbild gelegt werden. Diese Methode gibt das annotierte Bild als NumPy-Array zurück, das sich einfach anzeigen oder speichern lässt.

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, mit denen du die Ausgabe anpassen kannst:

Threadsichere Inferenz#

Threadsicherheit während der Inferenz ist entscheidend, wenn du mehrere YOLO-Modelle parallel in verschiedenen Threads ausführst. Threadsichere Inferenz stellt sicher, dass die Vorhersagen jedes Threads isoliert bleiben und sich nicht gegenseitig beeinflussen. So werden Race Conditions vermieden und konsistente, zuverlässige Ausgaben gewährleistet.

Wenn du YOLO-Modelle in einer Multithread-Anwendung verwendest, solltest du für jeden Thread ein eigenes Modellobjekt instanziieren oder threadlokalen Speicher nutzen, 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)
    # Ergebnisse verarbeiten

# Threads starten, die jeweils eine eigene Modellinstanz haben
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 Erläuterung zur threadsicheren Inferenz mit YOLO-Modellen und schrittweise Anleitungen findest du in unserem Leitfaden zur threadsicheren YOLO-Inferenz. Dieser Leitfaden enthält alle nötigen Informationen, um häufige Fehler zu vermeiden und einen reibungslosen Ablauf deiner Multithread-Inferenz sicherzustellen.

Streaming-for-Schleife#

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

import cv2

from ultralytics import YOLO

# Das YOLO-Modell laden
model = YOLO("yolo26n.pt")

# Videodatei öffnen
video_path = "path/to/your/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# Videobilder durchlaufen
while cap.isOpened():
    # Ein Videobild einlesen
    success, frame = cap.read()

    if success:
        # YOLO-Inferenz auf dem Bild ausführen
        results = model(frame)

        # Ergebnisse auf dem Bild visualisieren
        annotated_frame = results[0].plot()

        # Annotiertes Bild anzeigen
        cv2.imshow("YOLO Inference", annotated_frame)

        # Schleife beenden, wenn „q“ gedrückt wird
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Schleife beenden, wenn das Video zu Ende ist
        break

# Videoaufnahmeobjekt freigeben und Anzeigefenster schließen
cap.release()
cv2.destroyAllWindows()

Dieses Skript führt für jedes Videobild Vorhersagen aus, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Durch Drücken von „q“ kannst du die Schleife beenden.

Wie geht es weiter?#

Möchtest du über ein vortrainiertes Modell hinausgehen? Prüfe, ob deine Aufgabe zu deinem Problem passt, formatiere deine Daten mithilfe des Leitfadens zu Datensätzen und trainiere anschließend damit.

Häufig gestellte Fragen#