Modellvorhersage mit Ultralytics YOLO

Einführung

In der Welt des maschinellen Lernens und der Computer-Vision wird der Prozess, aus visuellen Daten einen Sinn zu machen, als "Inferenz" oder "Vorhersage" bezeichnet. Ultralytics YOLO11 bietet eine leistungsstarke Funktion, die als Vorhersagemodus bekannt ist und für hochleistungsfähige Echtzeit-Inferenzen für eine Vielzahl von Datenquellen zugeschnitten ist.

Beobachten: Extrahieren der Ausgaben aus Ultralytics YOLO Modell für benutzerdefinierte Projekte.

Anwendungen in der realen Welt

Herstellung	Sport	Sicherheit
Erkennung von Fahrzeugersatzteilen	Fußballspieler-Erkennung	Erkennung von Personenstürzen

Warum Ultralytics YOLO für Schlussfolgerungen verwenden?

Im Folgenden erfahren Sie, warum Sie den Vorhersagemodus von YOLO11 für Ihre verschiedenen Inferenzanforderungen in Betracht ziehen sollten:

• Vielseitigkeit: Sie können Rückschlüsse auf Bilder, Videos und sogar Live-Streams ziehen.
• Leistung: Entwickelt für Echtzeit-Hochgeschwindigkeitsverarbeitung ohne Abstriche bei der Genauigkeit.
• Benutzerfreundlichkeit: Intuitive Schnittstellen Python und CLI für eine schnelle Bereitstellung und Prüfung.
• Hochgradig anpassbar: Verschiedene Einstellungen und Parameter, um das Inferenzverhalten des Modells auf Ihre spezifischen Anforderungen abzustimmen.

Hauptmerkmale des Vorhersagemodus

YOLO11Der Vorhersagemodus ist robust und vielseitig und bietet folgende Funktionen:

• Kompatibilität mit mehreren Datenquellen: Unabhängig davon, ob es sich bei Ihren Daten um einzelne Bilder, eine Sammlung von Bildern, Videodateien oder Echtzeit-Videoströme handelt, ist der Vorhersagemodus für Sie geeignet.
• Streaming-Modus: Verwenden Sie die Streaming-Funktion, um einen speichereffizienten Generator von Results Objekte. Aktivieren Sie dies durch die Einstellung stream=True in der Aufrufmethode des Prädiktors.
• Stapelverarbeitung: Die Möglichkeit, mehrere Bilder oder Videoframes in einem einzigen Stapel zu verarbeiten, was die Inferenzzeit weiter beschleunigt.
• Integrationsfreundlich: Einfache Integration in bestehende Datenpipelines und andere Softwarekomponenten dank der flexiblen API.

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

from ultralytics import YOLO

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

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # pretrained YOLO11n model

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

# Process results generator
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

Quellen für Schlussfolgerungen

YOLO11 kann verschiedene Arten von Eingabequellen für Schlussfolgerungen verarbeiten, wie in der folgenden Tabelle dargestellt. Zu den Quellen gehören statische Bilder, Videoströme und verschiedene Datenformate. Die Tabelle zeigt auch, ob jede Quelle im Streaming-Modus mit dem Argument stream=True ✅. Der Streaming-Modus ist vorteilhaft für die Verarbeitung von Videos oder Live-Streams, da er einen Generator von Ergebnissen erzeugt, anstatt alle Bilder in den Speicher zu laden.

Im Folgenden finden Sie Codebeispiele für die Verwendung der einzelnen Quellentypen:

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

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

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define current screenshot as source
source = "screen"

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define remote image or video URL
source = "https://ultralytics.com/images/bus.jpg"

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

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Open an image using PIL
source = Image.open("path/to/image.jpg")

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

import cv2

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Read an image using OpenCV
source = cv2.imread("path/to/image.jpg")

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

import numpy as np

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Create a random numpy array of HWC shape (640, 640, 3) with values in range [0, 255] and type uint8
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype="uint8")

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

import torch

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Create a random torch tensor of BCHW shape (1, 3, 640, 640) with values in range [0, 1] and type float32
source = torch.rand(1, 3, 640, 640, dtype=torch.float32)

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define a path to a CSV file with images, URLs, videos and directories
source = "path/to/file.csv"

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define path to video file
source = "path/to/video.mp4"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define path to directory containing images and videos for inference
source = "path/to/dir"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define a glob search for all JPG files in a directory
source = "path/to/dir/*.jpg"

# OR define a recursive glob search for all JPG files including subdirectories
source = "path/to/dir/**/*.jpg"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Define source as YouTube video URL
source = "https://youtu.be/LNwODJXcvt4"

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Single stream with batch-size 1 inference
source = "rtsp://example.com/media.mp4"  # RTSP, RTMP, TCP, or IP streaming address

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Multiple streams with batched inference (e.g., batch-size 8 for 8 streams)
source = "path/to/list.streams"  # *.streams text file with one streaming address per line

# Run inference on the source
results = model(source, stream=True)  # generator of Results objects

rtsp://example.com/media1.mp4
rtsp://example.com/media2.mp4
rtmp://example2.com/live
tcp://192.168.1.100:554
...

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Run inference on the source
results = model(source=0, stream=True)  # generator of Results objects

Inferenz-Argumente

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Run inference on 'bus.jpg' with arguments
model.predict("bus.jpg", save=True, imgsz=320, conf=0.5)

Argumente für Schlussfolgerungen:

Argumente für die Visualisierung:

Bild- und Videoformate

YOLO11 unterstützt verschiedene Bild- und Videoformate, wie in ultralytics/data/utils .py angegeben. In den nachstehenden Tabellen finden Sie die gültigen Suffixe 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 predict() Aufrufe geben eine Liste von Results Objekte:

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Run inference on an image
results = model("bus.jpg")  # list of 1 Results object
results = model(["bus.jpg", "zidane.jpg"])  # list of 2 Results objects

Results Objekte haben die folgenden Attribute:

Results Objekte haben die folgenden Methoden:

Weitere Einzelheiten finden Sie in der Results Klassendokumentation.

Boxen

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

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Run inference on an image
results = model("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 Boxes Methoden und Eigenschaften der Klasse, einschließlich ihres Namens, Typs und ihrer Beschreibung:

Weitere Einzelheiten finden Sie in der Boxes Klassendokumentation.

Masken

Masks Objekt kann zum Indizieren, Manipulieren und Konvertieren von Masken in Segmente verwendet werden.

from ultralytics import YOLO

# Load a pretrained YOLO11n-seg Segment model
model = YOLO("yolo11n-seg.pt")

# Run inference on an image
results = model("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 Masks Methoden und Eigenschaften der Klasse, einschließlich ihres Namens, Typs und ihrer Beschreibung:

Weitere Einzelheiten finden Sie in der Masks Klassendokumentation.

Stichpunkte

Keypoints Objekt kann zum Indizieren, Manipulieren und Normalisieren von Koordinaten verwendet werden.

from ultralytics import YOLO

# Load a pretrained YOLO11n-pose Pose model
model = YOLO("yolo11n-pose.pt")

# Run inference on an image
results = model("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 Keypoints Methoden und Eigenschaften der Klasse, einschließlich ihres Namens, Typs und ihrer Beschreibung:

Weitere Einzelheiten finden Sie in der Keypoints Klassendokumentation.

Probs

Probs Objekt kann verwendet werden index, get top1 und top5 Indizes und Punktzahlen der Klassifizierung.

from ultralytics import YOLO

# Load a pretrained YOLO11n-cls Classify model
model = YOLO("yolo11n-cls.pt")

# Run inference on an image
results = model("bus.jpg")  # results list

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

Die folgende Tabelle fasst die Methoden und Eigenschaften für die Probs Klasse:

Weitere Einzelheiten finden Sie in der Probs Klassendokumentation.

OBB

OBB Objekt kann zum Indizieren, Manipulieren und Konvertieren von orientierten Boundingboxen in verschiedene Formate verwendet werden.

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n-obb.pt")

# Run inference on an image
results = model("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 OBB Methoden und Eigenschaften der Klasse, einschließlich ihres Namens, Typs und ihrer Beschreibung:

Weitere Einzelheiten finden Sie in der OBB Klassendokumentation.

Ergebnisse grafisch darstellen

Die plot() Methode in Results Objekte erleichtert die Visualisierung von Vorhersagen durch Überlagerung der erkannten Objekte (wie Bounding Boxes, Masken, Keypoints und Wahrscheinlichkeiten) mit dem Originalbild. Diese Methode gibt das kommentierte Bild als NumPy-Array zurück, das sich leicht anzeigen oder speichern lässt.

from PIL import Image

from ultralytics import YOLO

# Load a pretrained YOLO11n model
model = YOLO("yolo11n.pt")

# Run inference on 'bus.jpg'
results = model(["bus.jpg", "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")

plot() Parameter der Methode

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

Thread-sichere Inferenz

Die Gewährleistung der Thread-Sicherheit während der Inferenz ist von entscheidender Bedeutung, wenn Sie mehrere YOLO Modelle parallel in verschiedenen Threads ausführen. Threadsichere Inferenz garantiert, dass die Vorhersagen der einzelnen Threads isoliert sind und sich nicht gegenseitig beeinflussen, wodurch Race Conditions vermieden und konsistente und zuverlässige Ergebnisse gewährleistet werden.

Bei der Verwendung von YOLO Modellen in einer Multi-Thread-Anwendung ist es wichtig, separate Modellobjekte für jeden Thread zu instanziieren oder thread-lokale Speicherung 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=("yolo11n.pt", "image1.jpg")).start()
Thread(target=thread_safe_predict, args=("yolo11n.pt", "image2.jpg")).start()

Einen detaillierten Einblick in die thread-sichere Inferenz mit YOLO Modellen und eine schrittweise Anleitung finden Sie in unserem YOLO Leitfaden für thread-sichere Inferenz. In diesem Leitfaden finden Sie alle notwendigen Informationen, um häufige Fallstricke zu vermeiden und sicherzustellen, dass Ihre Multithreading-Inferenz reibungslos funktioniert.

Streaming-Quelle for-Schleife

Hier ist ein Python Skript, das OpenCV (cv2) und YOLO , um die Inferenz auf Videobilder anzuwenden. Dieses Skript setzt voraus, dass Sie die notwendigen Pakete bereits installiert haben (opencv-python und ultralytics).

import cv2

from ultralytics import YOLO

# Load the YOLO model
model = YOLO("yolo11n.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 Einzelbild des Videos Vorhersagen durch, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drücken von "q" beendet werden.

FAQ

Was ist Ultralytics YOLO und sein Vorhersagemodus für Echtzeit-Inferenz?

Ultralytics YOLO ist ein hochmodernes Modell für die Erkennung, Segmentierung und Klassifizierung von Objekten in Echtzeit. Sein Vorhersagemodus ermöglicht es den Nutzern, Hochgeschwindigkeitsinferenzen auf verschiedenen Datenquellen wie Bildern, Videos und Live-Streams durchzuführen. Das auf Leistung und Vielseitigkeit ausgelegte Programm bietet auch Stapelverarbeitungs- und Streaming-Modi. Weitere Einzelheiten zu den Funktionen finden Sie unter Ultralytics YOLO predict mode.

Wie kann ich mit Ultralytics YOLO aus verschiedenen Datenquellen Schlüsse ziehen?

Ultralytics YOLO kann eine breite Palette von Datenquellen verarbeiten, darunter einzelne Bilder, Videos, Verzeichnisse, URLs und Streams. Sie können die Datenquelle in der model.predict() aufrufen. Verwenden Sie zum Beispiel 'image.jpg' für ein lokales Bild oder 'https://ultralytics.com/images/bus.jpg' für eine URL. Sehen Sie sich die ausführlichen Beispiele für verschiedene Inferenzquellen in der Dokumentation.

Wie kann ich die Geschwindigkeit und den Speicherverbrauch von YOLO optimieren?

Um die Inferenzgeschwindigkeit zu optimieren und den Speicher effizient zu verwalten, können Sie den Streaming-Modus verwenden, indem Sie stream=True in der Aufrufmethode des Prädiktors. Der Streaming-Modus erzeugt einen speichereffizienten Generator von Results Objekte, anstatt alle Bilder in den Speicher zu laden. Für die Verarbeitung langer Videos oder großer Datensätze ist der Streaming-Modus besonders nützlich. Erfahren Sie mehr über Streaming-Modus.

Welche Schlussfolgerungsargumente werden von Ultralytics YOLO unterstützt?

Die model.predict() Methode in YOLO unterstützt verschiedene Argumente wie conf, iou, imgsz, deviceund mehr. Mit diesen Argumenten können Sie den Schlussfolgerungsprozess anpassen und Parameter wie Vertrauensschwellen, Bildgröße und das für die Berechnung verwendete Gerät festlegen. Ausführliche Beschreibungen dieser Argumente finden Sie in der Schlussfolgerungsargumente Abschnitt.

Wie kann ich die Ergebnisse der YOLO Vorhersagen visualisieren und speichern?

Nachdem die Inferenz mit YOLO durchgeführt wurde, wird die Results Objekte enthalten Methoden zum Anzeigen und Speichern von Bildern mit Anmerkungen. Sie können Methoden verwenden wie result.show() und result.save(filename="result.jpg") um die Ergebnisse zu visualisieren und zu speichern. Eine umfassende Liste dieser Methoden finden Sie in der Arbeit mit Ergebnissen Abschnitt.

📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 27 Tagen

Kommentare