Multi-Object Tracking mit Ultralytics YOLO

Die Objektverfolgung in der Videoanalyse ist eine wichtige Aufgabe, bei der nicht nur der Ort und die Klasse von Objekten innerhalb des Bildes identifiziert werden, sondern auch eine eindeutige ID für jedes erkannte Objekt im weiteren Verlauf des Videos beibehalten wird. Die Anwendungsmöglichkeiten sind grenzenlos und reichen von der Überwachung und Sicherheit bis hin zur Echtzeitanalyse von Sportveranstaltungen.

Warum Ultralytics YOLO für die Objektverfolgung wählen?

Die Ergebnisse der Ultralytics Tracker entsprechen der normalen Objekterkennung, haben aber den zusätzlichen Vorteil von Objekt-IDs. Das macht es einfach, Objekte in Videostreams zu verfolgen und anschließend zu analysieren. Hier erfährst du, warum du Ultralytics YOLO für deine Objektverfolgung nutzen solltest:

• Effizienz: Verarbeite Videoströme in Echtzeit, ohne die Genauigkeit zu beeinträchtigen.
• Flexibilität: Unterstützt mehrere Tracking-Algorithmen und Konfigurationen.
• Benutzerfreundlichkeit: Einfache Python API und CLI Optionen für eine schnelle Integration und Bereitstellung.
• Anpassungsfähigkeit: Einfache Nutzung mit individuell trainierten YOLO Modellen, die in domänenspezifische Anwendungen integriert werden können.

Pass auf: Objekterkennung und -verfolgung mit Ultralytics YOLOv8 .

Anwendungen in der realen Welt

Transport	Einzelhandel	Aquakultur
Fahrzeugverfolgung	Menschen aufspüren	Fisch Tracking

Funktionen im Überblick

Ultralytics YOLO erweitert seine Objekterkennungsfunktionen, um eine robuste und vielseitige Objektverfolgung zu ermöglichen:

• Verfolgung in Echtzeit: Verfolge nahtlos Objekte in Videos mit hoher Bildrate.
• Unterstützung mehrerer Tracker: Wähle aus einer Vielzahl von etablierten Tracking-Algorithmen.
• Anpassbare Tracker-Konfigurationen: Passe den Tracking-Algorithmus durch die Einstellung verschiedener Parameter an die jeweiligen Anforderungen an.

Verfügbare Tracker

Ultralytics YOLO unterstützt die folgenden Tracking-Algorithmen. Sie können aktiviert werden, indem die entsprechende YAML-Konfigurationsdatei übergeben wird, z. B. tracker=tracker_type.yaml:

• BoT-SORT - Verwendung botsort.yaml um diesen Tracker zu aktivieren.
• ByteTrack - Verwendung bytetrack.yaml um diesen Tracker zu aktivieren.

Der Standard-Tracker ist BoT-SORT.

Nachverfolgung

Um den Tracker auf Videostreams anzuwenden, verwende ein trainiertes Detektions-, Segment- oder Posenmodell wie YOLOv8n, YOLOv8n-seg und YOLOv8n-pose.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO('yolov8n.pt')  # Load an official Detect model
model = YOLO('yolov8n-seg.pt')  # Load an official Segment model
model = YOLO('yolov8n-pose.pt')  # Load an official Pose model
model = YOLO('path/to/best.pt')  # Load a custom trained model

# Perform tracking with the model
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)  # Tracking with default tracker
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # Tracking with ByteTrack tracker

# Perform tracking with various models using the command line interface
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4"  # Official Detect model
yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4"  # Official Segment model
yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4"  # Official Pose model
yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4"  # Custom trained model

# Track using ByteTrack tracker
yolo track model=path/to/best.pt tracker="bytetrack.yaml"

Wie in der obigen Anwendung zu sehen ist, ist das Tracking für alle Detect-, Segment- und Pose-Modelle verfügbar, die auf Videos oder Streaming-Quellen ausgeführt werden.

Konfiguration

Argumente nachverfolgen

Die Tracking-Konfiguration hat die gleichen Eigenschaften wie der Predict-Modus, z. B. conf, iou, und show. Weitere Konfigurationen findest du in der Vorhersage Modellseite.

from ultralytics import YOLO

# Configure the tracking parameters and run the tracker
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)

# Configure tracking parameters and run the tracker using the command line interface
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show

Tracker Auswahl

Ultralytics ermöglicht es dir auch, eine geänderte Tracker-Konfigurationsdatei zu verwenden. Dazu erstellst du einfach eine Kopie einer Tracker-Konfigurationsdatei (z.B., custom_tracker.yaml) von ultralytics/cfg/trackers und ändern Sie alle Konfigurationen (außer die tracker_type) nach deinen Bedürfnissen.

from ultralytics import YOLO

# Load the model and run the tracker with a custom configuration file
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')

# Load the model and run the tracker with a custom configuration file using the command line interface
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'

Eine umfassende Liste der Tracking-Argumente findest du auf der Seite ultralytics/cfg/trackers.

Python Beispiele

Persisting Tracks Schleife

Hier ist ein Python Skript, das OpenCV (cv2) und YOLOv8 , um die Objektverfolgung auf Videobildern durchzuführen. Dieses Skript geht weiterhin davon aus, dass du die notwendigen Pakete bereits installiert hast (opencv-python und ultralytics). Die persist=True sagt dem Tracker, dass das aktuelle Bild das nächste in einer Sequenz ist und er die Spuren des vorherigen Bildes im aktuellen Bild erwarten soll.

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('yolov8n.pt')

# Open the video file
video_path = "path/to/video.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 tracking on the frame, persisting tracks between frames
        results = model.track(frame, persist=True)

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

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

Bitte beachten Sie die Änderung von model(frame) zu model.track(frame)das eine Objektverfolgung anstelle einer einfachen Erkennung ermöglicht. Dieses geänderte Skript lässt den Tracker auf jedem Bild des Videos laufen, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drücken von "q" beendet werden.

Spuren im Zeitverlauf aufzeichnen

Die Visualisierung von Objektspuren über aufeinanderfolgende Frames hinweg kann wertvolle Einblicke in die Bewegungsmuster und das Verhalten von erkannten Objekten in einem Video liefern. Mit Ultralytics YOLOv8 ist das Plotten dieser Spuren ein nahtloser und effizienter Prozess.

Im folgenden Beispiel zeigen wir dir, wie du die Tracking-Funktionen von YOLOv8 nutzen kannst, um die Bewegung von erkannten Objekten über mehrere Videobilder hinweg aufzuzeichnen. In diesem Skript wird eine Videodatei geöffnet, Bild für Bild gelesen und das Modell YOLO verwendet, um verschiedene Objekte zu identifizieren und zu verfolgen. Indem wir die Mittelpunkte der erkannten Bounding Boxes beibehalten und sie miteinander verbinden, können wir Linien zeichnen, die die Pfade darstellen, denen die verfolgten Objekte folgen.

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('yolov8n.pt')

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

# Store the track history
track_history = defaultdict(lambda: [])

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

    if success:
        # Run YOLOv8 tracking on the frame, persisting tracks between frames
        results = model.track(frame, persist=True)

        # Get the boxes and track IDs
        boxes = results[0].boxes.xywh.cpu()
        track_ids = results[0].boxes.id.int().cpu().tolist()

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

        # Plot the tracks
        for box, track_id in zip(boxes, track_ids):
            x, y, w, h = box
            track = track_history[track_id]
            track.append((float(x), float(y)))  # x, y center point
            if len(track) > 30:  # retain 90 tracks for 90 frames
                track.pop(0)

            # Draw the tracking lines
            points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
            cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

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

Multithreaded Tracking

Multithreading ermöglicht es, die Objektverfolgung auf mehreren Videoströmen gleichzeitig durchzuführen. Dies ist besonders nützlich, wenn mehrere Videoeingänge verarbeitet werden, z. B. von mehreren Überwachungskameras, wo die gleichzeitige Verarbeitung die Effizienz und Leistung erheblich steigern kann.

In dem mitgelieferten Python Skript verwenden wir Python's threading Modul, um mehrere Instanzen des Trackers gleichzeitig laufen zu lassen. Jeder Thread ist für die Ausführung des Trackers für eine Videodatei verantwortlich, und alle Threads laufen gleichzeitig im Hintergrund.

Um sicherzustellen, dass jeder Thread die richtigen Parameter erhält (die Videodatei, das zu verwendende Modell und den Dateiindex), definieren wir eine Funktion run_tracker_in_thread die diese Parameter akzeptiert und die Haupt-Tracking-Schleife enthält. Diese Funktion liest das Video Bild für Bild, führt den Tracker aus und zeigt die Ergebnisse an.

In diesem Beispiel werden zwei verschiedene Modelle verwendet: yolov8n.pt und yolov8n-seg.pt, die jeweils Objekte in einer anderen Videodatei verfolgen. Die Videodateien werden in video_file1 und video_file2.

Die daemon=True Parameter in threading.Thread bedeutet, dass diese Threads geschlossen werden, sobald das Hauptprogramm beendet ist. Wir starten die Threads dann mit start() und verwenden join() um den Hauptthread warten zu lassen, bis beide Tracker-Threads fertig sind.

Nachdem alle Threads ihre Aufgabe erfüllt haben, werden die Fenster, die die Ergebnisse anzeigen, mit cv2.destroyAllWindows().

import threading
import cv2
from ultralytics import YOLO


def run_tracker_in_thread(filename, model, file_index):
    """
    Runs a video file or webcam stream concurrently with the YOLOv8 model using threading.

    This function captures video frames from a given file or camera source and utilizes the YOLOv8 model for object
    tracking. The function runs in its own thread for concurrent processing.

    Args:
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
        model (obj): The YOLOv8 model object.
        file_index (int): An index to uniquely identify the file being processed, used for display purposes.

    Note:
        Press 'q' to quit the video display window.
    """
    video = cv2.VideoCapture(filename)  # Read the video file

    while True:
        ret, frame = video.read()  # Read the video frames

        # Exit the loop if no more frames in either video
        if not ret:
            break

        # Track objects in frames if available
        results = model.track(frame, persist=True)
        res_plotted = results[0].plot()
        cv2.imshow(f"Tracking_Stream_{file_index}", res_plotted)

        key = cv2.waitKey(1)
        if key == ord('q'):
            break

    # Release video sources
    video.release()


# Load the models
model1 = YOLO('yolov8n.pt')
model2 = YOLO('yolov8n-seg.pt')

# Define the video files for the trackers
video_file1 = "path/to/video1.mp4"  # Path to video file, 0 for webcam
video_file2 = 0  # Path to video file, 0 for webcam, 1 for external camera

# Create the tracker threads
tracker_thread1 = threading.Thread(target=run_tracker_in_thread, args=(video_file1, model1, 1), daemon=True)
tracker_thread2 = threading.Thread(target=run_tracker_in_thread, args=(video_file2, model2, 2), daemon=True)

# Start the tracker threads
tracker_thread1.start()
tracker_thread2.start()

# Wait for the tracker threads to finish
tracker_thread1.join()
tracker_thread2.join()

# Clean up and close windows
cv2.destroyAllWindows()

Dieses Beispiel kann leicht erweitert werden, um mehr Videodateien und Modelle zu verarbeiten, indem du mehr Threads erstellst und dieselbe Methodik anwendest.

Neue Tracker beisteuern

Du kennst dich mit der Verfolgung von mehreren Objekten aus und hast einen Tracking-Algorithmus mit Ultralytics YOLO erfolgreich implementiert oder angepasst? Wir laden dich ein, zu unserem Trackers-Bereich unter ultralytics/cfg/trackers beizutragen! Deine Anwendungen und Lösungen aus der Praxis können für Nutzer, die an Tracking-Aufgaben arbeiten, von unschätzbarem Wert sein.

Indem du zu diesem Bereich beiträgst, trägst du dazu bei, den Umfang der Tracking-Lösungen zu erweitern, die innerhalb des Ultralytics YOLO Frameworks zur Verfügung stehen, und fügst eine weitere Funktionsebene und Nützlichkeit für die Gemeinschaft hinzu.

Wenn du einen Beitrag leisten willst, findest du in unserem Contributing Guide eine ausführliche Anleitung zum Einreichen eines Pull Request (PR) 🛠️. Wir sind gespannt, was du einbringst!

Lass uns gemeinsam die Verfolgungsmöglichkeiten des Ultralytics YOLO Ökosystems verbessern 🙏!

Kommentare