Modell Vorhersage 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 YOLOv8 bietet eine leistungsstarke Funktion, den so genannten Vorhersagemodus, der für hochleistungsfähige Echtzeit-Inferenzen aus einer Vielzahl von Datenquellen zugeschnitten ist.

Pass auf: Wie man die Ergebnisse aus dem Ultralytics YOLOv8 Modell für eigene Projekte extrahiert.

Anwendungen in der realen Welt

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

Warum Ultralytics YOLO für Schlussfolgerungen nutzen?

Hier erfährst du, warum du den Vorhersagemodus von YOLOv8 für deine verschiedenen Schlussfolgerungen in Betracht ziehen solltest:

• Vielseitigkeit: Du kannst 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 schnellen Einsatz und Tests.
• Hochgradig anpassbar: Verschiedene Einstellungen und Parameter, um das Inferenzverhalten des Modells auf deine spezifischen Anforderungen abzustimmen.

Hauptmerkmale des Vorhersagemodus

YOLOv8Der Prädiktionsmodus ist robust und vielseitig und bietet folgende Funktionen:

• Kompatibilität mit mehreren Datenquellen: Egal, ob deine Daten in Form von einzelnen Bildern, einer Sammlung von Bildern, Videodateien oder Echtzeit-Videostreams vorliegen, mit dem Predict-Modus bist du bestens gerüstet.
• Streaming-Modus: Verwende die Streaming-Funktion, um einen speichereffizienten Generator von Results Objekte. Aktiviere 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, um die Inferenzzeit weiter zu verkürzen.
• Integrationsfreundlich: Dank der flexiblen API ist die Integration in bestehende Datenpipelines und andere Softwarekomponenten ganz einfach.

Ultralytics YOLO Modelle geben entweder eine Python Liste von Results Objekte oder ein speichereffizienter 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('yolov8n.pt')  # pretrained YOLOv8n model

# Run batched inference on a list of images
results = model(['im1.jpg', 'im2.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('yolov8n.pt')  # pretrained YOLOv8n model

# Run batched inference on a list of images
results = model(['im1.jpg', 'im2.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

Inferenz-Quellen

YOLOv8 kann verschiedene Arten von Eingangsquellen für Inferenzen verarbeiten, wie in der folgenden Tabelle dargestellt. Zu den Quellen gehören statische Bilder, Videostreams und verschiedene Datenformate. In der Tabelle ist auch angegeben, 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 findest du Codebeispiele für die Verwendung der einzelnen Quellentypen:

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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

import torch
from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.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 YOLOv8n model
model = YOLO('yolov8n.pt')

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

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

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

Argumente für Schlussfolgerungen

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

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.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

YOLOv8 unterstützt verschiedene Bild- und Videoformate, wie in ultralytics/data/utils .py angegeben. In den folgenden Tabellen findest du die gültigen Suffixe und Beispielvorhersagebefehle.

Bilder

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

Videos

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

Mit Ergebnissen arbeiten

Alle Ultralytics predict() Aufrufe geben eine Liste von Results Gegenstände:

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.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 findest du in der Results Klassendokumentation.

Boxen

Boxes Objekt kann verwendet werden, um Boundingboxen zu indizieren, zu bearbeiten und in verschiedene Formate zu konvertieren.

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n.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 findest du in der Boxes Klassendokumentation.

Masken

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

from ultralytics import YOLO

# Load a pretrained YOLOv8n-seg Segment model
model = YOLO('yolov8n-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 findest du in der Masks Klassendokumentation.

Keypoints

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

from ultralytics import YOLO

# Load a pretrained YOLOv8n-pose Pose model
model = YOLO('yolov8n-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 findest du in der Keypoints Klassendokumentation.

Probs

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

from ultralytics import YOLO

# Load a pretrained YOLOv8n-cls Classify model
model = YOLO('yolov8n-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

Hier ist eine Tabelle mit einer Zusammenfassung der Methoden und Eigenschaften für die Probs Klasse:

Weitere Einzelheiten findest du in der Probs Klassendokumentation.

OBB

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

from ultralytics import YOLO

# Load a pretrained YOLOv8n model
model = YOLO('yolov8n-obb.pt')

# Run inference on an image
results = model('bus.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 findest du in der OBB Klassendokumentation.

Ergebnisse ausdrucken

Die plot() Methode in Results Objekte erleichtert die Visualisierung von Vorhersagen, indem die erkannten Objekte (z. B. Bounding Boxes, Masken, Keypoints und Wahrscheinlichkeiten) über das Originalbild gelegt werden. Diese Methode gibt das kommentierte 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 YOLOv8n model
model = YOLO('yolov8n.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, um die Ausgabe anzupassen:

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. Threadsichere Inferenz garantiert, dass die Vorhersagen der einzelnen Threads isoliert sind und sich nicht gegenseitig beeinflussen. So werden Wettlaufsituationen vermieden und konsistente und zuverlässige Ergebnisse sichergestellt.

Wenn du YOLO Modelle in einer Multi-Thread-Anwendung verwendest, ist es wichtig, dass du für jeden Thread ein eigenes Modellobjekt instanziierst oder einen Thread-lokalen Speicher verwendest, um Konflikte zu vermeiden:

from ultralytics import YOLO
from threading import Thread

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


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

Einen detaillierten Einblick in die thread-sichere Inferenz mit YOLO Modellen und eine Schritt-für-Schritt-Anleitung findest du in unserem YOLO Leitfaden zur thread-sicheren Inferenz. In diesem Leitfaden findest du alle notwendigen Informationen, um häufige Fallstricke zu vermeiden und sicherzustellen, dass deine Multi-Thread-Inferenz reibungslos funktioniert.

Streaming Quelle for-Schleife

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

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('yolov8n.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 YOLOv8 inference on the frame
        results = model(frame)

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

        # Display the annotated frame
        cv2.imshow("YOLOv8 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.

Kommentare