Modellvorhersage mit Ultralytics YOLO#

Einführung#

In der Welt des machine learning und der computer vision wird der Prozess der Auswertung visueller Daten oft als Inferenz oder Vorhersage bezeichnet. Ultralytics YOLO26 bietet eine leistungsstarke Funktion namens predict mode, die auf eine performante Echtzeit-Inferenz für eine Vielzahl von Datenquellen zugeschnitten ist.

Anwendungen in der Praxis#

Warum Ultralytics YOLO für die Inferenz verwenden?#

Hier ist, warum du den Predict-Modus von YOLO26 für deine verschiedenen Inferenzanforderungen in Betracht ziehen solltest:

• Vielseitigkeit: Fähigkeit zur Durchführung von Inferenz auf Bildern, Videos und sogar Live-Streams.
• Performance: Entwickelt für High-Speed-Echtzeitverarbeitung ohne Abstriche bei der accuracy.
• Benutzerfreundlichkeit: Intuitive Python- und CLI-Schnittstellen für schnelle Bereitstellung und Tests.
• Hochgradig anpassbar: Verschiedene Einstellungen und Parameter, um das Inferenzverhalten des Modells an deine spezifischen Anforderungen anzupassen.
• Production Ready: Deploye Modelle als Ultralytics Platform inference endpoints mit automatischer Skalierung und Monitoring oder führe die Inferenz lokal aus.

Hauptmerkmale des Predict-Modus#

Der Predict-Modus von YOLO26 ist robust und vielseitig gestaltet und bietet:

• Kompatibilität mit mehreren Datenquellen: Egal ob deine Daten in Form von einzelnen Bildern, einer Bildersammlung, Videodateien oder Echtzeit-Videostreams vorliegen, der Predict-Modus unterstützt sie alle.
• Streaming Mode: Verwende die Streaming-Funktion, um einen speichereffizienten Generator von Results-Objekten zu erstellen. Aktiviere dies, indem du stream=True in der Aufrufmethode des Prädiktors festlegst. Im Gegensatz zum Standardverhalten (stream=False), das eine Liste mit allen Ergebnissen zurückgibt, liefert stream=True die Ergebnisse nacheinander einzeln zurück, was besonders bei langen Videos und Live-Streams nützlich ist.
• Batch-Verarbeitung: Verarbeite mehrere Bilder oder Videobilder in einem einzigen Batch, was die gesamte Inferenzzeit weiter reduziert.
• Integrationsfreundlich: Dank seiner flexiblen API lässt sich das Modell leicht 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

Inferenz-Quellen#

YOLO26 kann verschiedene Arten von Eingabequellen für die Inferenz verarbeiten, wie in der folgenden Tabelle gezeigt. Zu den Quellen gehören statische Bilder, Videostreams und verschiedene Datenformate. Die Tabelle gibt zudem an, ob die jeweilige Quelle im Streaming-Modus mit dem Argument stream=True ✅ verwendet werden kann. Der Streaming-Modus ist vorteilhaft für die Verarbeitung von Videos oder Live-Streams, da er einen Ergebnisgenerator erstellt, anstatt alle Frames in den Speicher 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

Inferenz-Argumente#

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

Feste Form vs. minimales Rechteck (rect)#

Standardmäßig verwendet predict rect=True, was ein Minimalrechteck-Padding (minimum-rectangle) ermöglicht, wann immer dies möglich ist. Das Bild wird so skaliert, dass es in imgsz passt, und nur bis zum nächsten Vielfachen des Strides aufgefüllt, sodass der finale Tensor kleiner sein kann als imgsz. Das Minimalrechteck-Padding wird nur verwendet, wenn alle Bilder im Batch dieselbe Form haben und das Backend dies unterstützt (PyTorch .pt oder dynamisches ONNX / Triton). Andernfalls werden Bilder auf das vollständige imgsz-Ziel aufgefüllt.

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

Integer vs. Tupel imgsz

• Ein ganzzahliges imgsz=640 (Integer) wird nach der Stride-Rundung zu einem quadratischen Ziel (640, 640).
• Ein Tupel imgsz=(384, 672) legt ein rechteckiges Ziel fest. Bei rect=True und auto=True kann der tatsächliche Tensor kleiner sein als dieses Ziel.

Training vs. Predict/Export

Das Training akzeptiert nur ein einzelnes ganzzahliges imgsz (eine [h, w]-Liste wird auf den größten Wert gezwungen). Predict und Export akzeptieren entweder einen Integer 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)

Inferenz-Argumente:

Visualisierungs-Argumente:

Bild- und Videoformate#

YOLO26 unterstützt verschiedene Bild- und Videoformate, wie in ultralytics/data/utils.py angegeben. Siehe die Tabellen unten für gültige Suffixe und Beispiel-Predict-Befehle.

Bilder#

Die unten stehende Tabelle enthält gültige Ultralytics Bildformate.

Videos#

Die unten stehende Tabelle enthält gültige Ultralytics Videoformate.

Arbeiten mit Ergebnissen#

Alle Ultralytics predict()-Aufrufe 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 haben die folgenden Attribute:

Ergebnisse nach Aufgabe#

Welche der folgenden Felder belegt werden, hängt von der Aufgabe deines Modells ab – vergleiche Detektion, Segmentierung, semantische Segmentierung, Tiefenschätzung, Klassifikation, Pose und OBB, falls du dich noch für keine entschieden hast. Jede Vorhersage liefert ein Results-Objekt pro Bild oder Frame. Die oben genannten gemeinsamen Felder sind immer verfügbar, während die aufgabenspezifischen Vorhersagedaten in den Feldern unten gespeichert sind. Koordinaten-, Konfidenz- und Wahrscheinlichkeitstensoren sind torch.float32, es sei denn, es wird Halbprazision verwendet, dann torch.float16. Nach result.numpy() werden Tensoren zu NumPy-Arrays mit passenden NumPy-Dtypes. Instanzmasken sind binäre torch.uint8-Tensoren, während semantische Masken den kleinsten praktischen Integer-Dtype für Klassen-IDs verwenden: torch.uint8, torch.int16 oder torch.int32, je nach Anzahl der Klassen.

Results-Objekte haben die folgenden Methoden:

Weitere Details findest du in der Results-Klassendokumentation.

Bboxen#

Das Boxes-Objekt kann verwendet werden, um Bounding Boxes zu indizieren, zu manipulieren und in verschiedene Formate zu konvertieren.

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 für die Klassenmethoden und -eigenschaften von Boxes, einschließlich ihres Namens, Typs und ihrer Beschreibung:

Weitere Details findest du in der Boxes-Klassendokumentation.

Masken#

Das Masks-Objekt kann verwendet werden, um Masken zu indizieren, zu manipulieren und in Segmente zu konvertieren.

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 für die Klassenmethoden und -eigenschaften von Masks, einschließlich ihres Namens, Typs und ihrer Beschreibung:

Weitere Details findest du in der Masks-Klassendokumentation.

SemanticMask#

SemanticMask speichert eine dichte Klassenkarte für semantische Segmentierungsergebnisse. Im Gegensatz zu Masks enthält sie nicht eine binäre Maske pro Objekt und bietet keine Polygon-Helfer.

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 verwendet werden, um Koordinaten zu indizieren, zu manipulieren und zu normalisieren.

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 für die Klassenmethoden und -eigenschaften von Keypoints, einschließlich ihres Namens, Typs und ihrer Beschreibung:

Weitere Details findest du in der Keypoints-Klassendokumentation.

Probs#

Das Probs-Objekt kann verwendet werden, um top1- und top5-Klassifikationsindizes und -scores zu erhalten.

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, die die Methoden und Eigenschaften für die Probs-Klasse zusammenfasst:

Weitere Details findest du in der Probs-Klassendokumentation.

OBB#

Das OBB-Objekt kann verwendet werden, um orientierte Bounding Boxes zu indizieren, zu manipulieren und in verschiedene Formate zu konvertieren.

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 für die Klassenmethoden und -eigenschaften von OBB, einschließlich ihres Namens, Typs und ihrer Beschreibung:

Weitere Details findest du in der OBB-Klassendokumentation.

Ergebnisse visualisieren#

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, was eine einfache Anzeige oder Speicherung ermöglicht.

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

Methodenparameter für 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 garantiert, dass die Vorhersagen jedes Threads isoliert sind und sich nicht gegenseitig beeinflussen, wodurch Race Conditions vermieden werden und konsistente sowie zuverlässige Ergebnisse sichergestellt sind.

Bei der Verwendung von YOLO Modellen in einer Multithread-Anwendung ist es wichtig, für jeden Thread separate Modellobjekte 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()

Einen detaillierten Einblick in die Thread-sichere Inferenz mit YOLO-Modellen und Schritt-für-Schritt-Anleitungen findest du in unserem YOLO Thread-Safe Inference Guide. Dieser Leitfaden bietet dir alle notwendigen Informationen, um häufige Fallstricke zu vermeiden und sicherzustellen, dass deine multithreaded Inferenz reibungslos läuft.

Streaming-Quellen-for-Schleife#

Hier ist ein Python-Skript, das OpenCV (cv2) und YOLO verwendet, um Inferenz auf Video-Frames 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 Vorhersagen auf jedem Frame des Videos durch, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drücken von 'q' beendet werden.

Wie geht es weiter?#

Bereit für den nächsten Schritt über ein vortrainiertes Modell hinaus? Stelle sicher, dass deine Aufgabe zu deinem Problem passt, formatiere deine eigenen Daten mit dem Datasets guide und trainiere dann damit.

FAQ#