Multi-Object-Tracking mit Ultralytics YOLO

Objekt-Tracking im Bereich der Videoanalyse ist eine kritische Aufgabe, die nicht nur den Ort und die Klasse von Objekten innerhalb eines Frames identifiziert, sondern auch eine eindeutige ID für jedes erkannte Objekt beibehält, während das Video weiterläuft. Die Anwendungsmöglichkeiten sind grenzenlos – von Überwachung und Sicherheit bis hin zu Echtzeit-Sportanalysen.

Warum Ultralytics YOLO für das Objekt-Tracking wählen?

Die Ausgabe der Ultralytics-Tracker ist konsistent mit der Standard-Objekterkennung, hat jedoch den Mehrwert von Objekt-IDs. Dies erleichtert das Verfolgen von Objekten in Videostreams und die Durchführung nachfolgender Analysen. Hier ist, warum du Ultralytics YOLO für deine Objekt-Tracking-Anforderungen in Betracht ziehen solltest:

• Effizienz: Verarbeite Videostreams in Echtzeit, ohne bei der Genauigkeit Kompromisse einzugehen.
• Flexibilität: Unterstützt mehrere Tracking-Algorithmen und Konfigurationen.
• Benutzerfreundlichkeit: Einfache Python API und CLI-Optionen für schnelle Integration und Bereitstellung.
• Anpassbarkeit: Einfache Verwendung mit benutzerdefiniert trainierten YOLO-Modellen, was die Integration in domänenspezifische Anwendungen ermöglicht.

Anwendungsbereiche in der Praxis

Transportwesen	Einzelhandel	Aquakultur
Fahrzeug-Tracking	Personen-Tracking	Fisch-Tracking

Funktionen auf einen Blick

Ultralytics YOLO erweitert seine Objekterkennungsfunktionen, um robustes und vielseitiges Objekt-Tracking bereitzustellen:

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

Verfügbare Tracker

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

• BoT-SORT – Verwende botsort.yaml, um diesen Tracker zu aktivieren.
• ByteTrack – Verwende bytetrack.yaml, um diesen Tracker zu aktivieren.

Der Standard-Tracker ist BoT-SORT.

Tracking

Um den Tracker auf Videostreams auszuführen, verwende ein trainiertes Detect-, Segment- oder Pose-Modell wie YOLO26n, YOLO26n-seg oder YOLO26n-pose. Du kannst benutzerdefinierte Modelle lokal oder auf Cloud-GPUs über die Ultralytics Platform trainieren.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO("yolo26n.pt")  # Load an official Detect model
model = YOLO("yolo26n-seg.pt")  # Load an official Segment model
model = YOLO("yolo26n-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("https://youtu.be/LNwODJXcvt4", show=True)  # Tracking with default tracker
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # with ByteTrack

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

Konfiguration

Tracking-Argumente

Die Tracking-Konfiguration teilt Eigenschaften mit dem Predict-Modus, wie conf, iou und show. Weitere Konfigurationen findest du auf der Modellseite Predict.

from ultralytics import YOLO

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

Tracker-Auswahl

Ultralytics ermöglicht dir auch die Verwendung einer modifizierten Tracker-Konfigurationsdatei. Erstelle dazu einfach eine Kopie einer Tracker-Konfigurationsdatei (zum Beispiel custom_tracker.yaml) von ultralytics/cfg/trackers und ändere alle Konfigurationen (außer tracker_type) nach deinen Bedürfnissen.

from ultralytics import YOLO

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

Siehe den Abschnitt Tracker-Argumente für eine detaillierte Beschreibung jedes Parameters.

Tracker-Argumente

Einige Tracking-Verhaltensweisen können durch Bearbeitung der für jeden Tracking-Algorithmus spezifischen YAML-Konfigurationsdateien feinabgestimmt werden. Diese Dateien definieren Parameter wie Schwellenwerte, Puffer und Matching-Logik:

• botsort.yaml
• bytetrack.yaml

Die folgende Tabelle bietet eine Beschreibung jedes Parameters:

Aktivierung der Re-Identifizierung (ReID)

Standardmäßig ist ReID deaktiviert, um den Performance-Overhead zu minimieren. Die Aktivierung ist einfach – setze einfach with_reid: True in der Tracker-Konfiguration. Du kannst auch das für ReID verwendete model anpassen, was es dir ermöglicht, je nach Anwendungsfall zwischen Genauigkeit und Geschwindigkeit abzuwägen:

• Native Funktionen (model: auto): Dies nutzt Funktionen direkt vom YOLO-Detektor für ReID, was einen minimalen Overhead hinzufügt. Es ist ideal, wenn du ein gewisses Maß an ReID benötigst, ohne die Performance signifikant zu beeinträchtigen. Wenn der Detektor keine nativen Funktionen unterstützt, greift er automatisch auf die Verwendung von yolo26n-cls.pt zurück.
• YOLO-Klassifizierungsmodelle: Du kannst explizit ein Klassifizierungsmodell (z. B. yolo26n-cls.pt) für die ReID-Merkmalsextraktion festlegen. Dies bietet diskriminativere Embeddings, führt jedoch aufgrund des zusätzlichen Inferenzschritts zu zusätzlicher Latenz.

Für eine bessere Leistung, insbesondere bei Verwendung eines separaten Klassifizierungsmodells für ReID, kannst du es in ein schnelleres Backend wie TensorRT exportieren:

from torch import nn

from ultralytics import YOLO

# Load the classification model
model = YOLO("yolo26n-cls.pt")

# Add average pooling layer
head = model.model.model[-1]
pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(start_dim=1))
pool.f, pool.i = head.f, head.i
model.model.model[-1] = pool

# Export to TensorRT
model.export(format="engine", half=True, dynamic=True, batch=32)

Nach dem Export kannst du auf den Pfad des TensorRT-Modells in deiner Tracker-Konfiguration verweisen, und es wird während des Trackings für ReID verwendet.

Python-Beispiele

Persistente Tracking-Schleife

Hier ist ein Python-Skript, das OpenCV (cv2) und YOLO26 verwendet, um Objekt-Tracking auf Videoframes auszuführen. Dieses Skript setzt voraus, dass die notwendigen Pakete (opencv-python und ultralytics) bereits installiert sind. Das Argument persist=True teilt dem Tracker mit, dass das aktuelle Bild oder Frame das nächste in einer Sequenz ist und Tracks aus dem vorherigen Bild im aktuellen Bild erwartet werden.

import cv2

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.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 YOLO26 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("YOLO26 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 beachte den Wechsel von model(frame) zu model.track(frame), was Objekt-Tracking anstelle einer einfachen Erkennung ermöglicht. Dieses modifizierte Skript führt den Tracker auf jedem Frame des Videos aus, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drücken von 'q' beendet werden.

Plotten von Tracks über die Zeit

Die Visualisierung von Objekt-Tracks über aufeinanderfolgende Frames hinweg kann wertvolle Einblicke in die Bewegungsmuster und das Verhalten erkannter Objekte innerhalb eines Videos liefern. Mit Ultralytics YOLO26 ist das Plotten dieser Tracks ein nahtloser und effizienter Prozess.

Im folgenden Beispiel zeigen wir, wie die Tracking-Fähigkeiten von YOLO26 genutzt werden können, um die Bewegung erkannter Objekte über mehrere Videoframes hinweg zu plotten. Dieses Skript beinhaltet das Öffnen einer Videodatei, das frame-weise Lesen und die Verwendung des YOLO-Modells zur Identifizierung und Verfolgung verschiedener Objekte. Durch Beibehalten der Mittelpunkte der erkannten Bounding Boxes und deren Verbindung können wir Linien zeichnen, die die von den verfolgten Objekten eingeschlagenen Pfade darstellen.

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.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 YOLO26 tracking on the frame, persisting tracks between frames
        result = model.track(frame, persist=True)[0]

        # Get the boxes and track IDs
        if result.boxes and result.boxes.is_track:
            boxes = result.boxes.xywh.cpu()
            track_ids = result.boxes.id.int().cpu().tolist()

            # Visualize the result on the frame
            frame = result.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 30 tracks for 30 frames
                    track.pop(0)

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

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

Multithreaded-Tracking bietet die Fähigkeit, Objekt-Tracking gleichzeitig auf mehreren Videostreams auszuführen. Dies ist besonders nützlich, wenn mehrere Videoeingänge verarbeitet werden, wie z. B. von mehreren Überwachungskameras, wo gleichzeitige Verarbeitung die Effizienz und Leistung erheblich steigern kann.

Im bereitgestellten Python-Skript nutzen wir das threading-Modul von Python, um mehrere Instanzen des Trackers gleichzeitig auszuführen. Jeder Thread ist für das Ausführen des Trackers auf einer Videodatei verantwortlich, und alle Threads laufen gleichzeitig im Hintergrund.

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

In diesem Beispiel werden zwei verschiedene Modelle verwendet: yolo26n.pt und yolo26n-seg.pt, wobei jedes Objekte in einer anderen Videodatei verfolgt. Die Videodateien sind in SOURCES spezifiziert.

Der Parameter daemon=True in threading.Thread bedeutet, dass diese Threads geschlossen werden, sobald das Hauptprogramm endet. Wir starten dann die Threads mit start() und verwenden join(), damit der Haupt-Thread wartet, bis beide Tracker-Threads beendet sind.

Schließlich werden, nachdem alle Threads ihre Aufgabe abgeschlossen haben, die Fenster, die die Ergebnisse anzeigen, mit cv2.destroyAllWindows() geschlossen.

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # local video, 0 for webcam

def run_tracker_in_thread(model_name, filename):
    """Run YOLO tracker in its own thread for concurrent processing.

    Args:
        model_name (str): The YOLO26 model object.
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
    """
    model = YOLO(model_name)
    results = model.track(filename, save=True, stream=True)
    for r in results:
        pass

# Create and start tracker threads using a for loop
tracker_threads = []
for video_file, model_name in zip(SOURCES, MODEL_NAMES):
    thread = threading.Thread(target=run_tracker_in_thread, args=(model_name, video_file), daemon=True)
    tracker_threads.append(thread)
    thread.start()

# Wait for all tracker threads to finish
for thread in tracker_threads:
    thread.join()

# Clean up and close windows
cv2.destroyAllWindows()

Dieses Beispiel kann leicht erweitert werden, um mehr Videodateien und Modelle zu verarbeiten, indem mehr Threads erstellt und die gleiche Methodik angewendet wird.

Neue Tracker beisteuern

Bist du erfahren in der Multi-Objekt-Verfolgung und hast bereits einen Tracking-Algorithmus mit Ultralytics YOLO implementiert oder angepasst? Wir laden dich ein, einen Beitrag zu unserem Trackers-Bereich unter ultralytics/cfg/trackers zu leisten! Deine realen Anwendungen und Lösungen könnten für Anwender, die an Tracking-Aufgaben arbeiten, von unschätzbarem Wert sein.

Indem du einen Beitrag zu diesem Bereich leistest, hilfst du dabei, den Umfang der innerhalb des Ultralytics YOLO Frameworks verfügbaren Tracking-Lösungen zu erweitern und eine weitere Ebene an Funktionalität und Nutzen für die Community hinzuzufügen.

Um mit deinem Beitrag zu beginnen, schau dir bitte unseren Contributing Guide für umfassende Anweisungen zum Einreichen eines Pull Request (PR) 🛠️ an. Wir sind gespannt darauf, was du einbringst!

Lass uns gemeinsam die Tracking-Fähigkeiten des Ultralytics YOLO Ökosystems verbessern 🙏!

FAQ

Was ist Multi-Objekt-Verfolgung und wie unterstützt Ultralytics YOLO diese?

Die Multi-Objekt-Verfolgung in der Videoanalyse beinhaltet sowohl das Identifizieren von Objekten als auch das Beibehalten einer eindeutigen ID für jedes erkannte Objekt über Videoframes hinweg. Ultralytics YOLO unterstützt dies durch Echtzeit-Tracking zusammen mit Objekt-IDs, was Aufgaben wie Sicherheitsüberwachung und Sportanalyse erleichtert. Das System verwendet Tracker wie BoT-SORT und ByteTrack, die über YAML-Dateien konfiguriert werden können.

Wie konfiguriere ich einen benutzerdefinierten Tracker für Ultralytics YOLO?

Du kannst einen benutzerdefinierten Tracker konfigurieren, indem du eine existierende Tracker-Konfigurationsdatei (z. B. custom_tracker.yaml) aus dem Ultralytics Tracker-Konfigurationsverzeichnis kopierst und die Parameter nach Bedarf anpasst, mit Ausnahme von tracker_type. Verwende diese Datei in deinem Tracking-Modell wie folgt:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Wie kann ich die Objektverfolgung auf mehreren Videostreams gleichzeitig ausführen?

Um die Objektverfolgung auf mehreren Videostreams gleichzeitig auszuführen, kannst du das threading-Modul von Python verwenden. Jeder Thread kümmert sich um einen separaten Videostream. Hier ist ein Beispiel, wie du dies einrichten kannst:

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # local video, 0 for webcam

def run_tracker_in_thread(model_name, filename):
    """Run YOLO tracker in its own thread for concurrent processing.

    Args:
        model_name (str): The YOLO26 model object.
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
    """
    model = YOLO(model_name)
    results = model.track(filename, save=True, stream=True)
    for r in results:
        pass

# Create and start tracker threads using a for loop
tracker_threads = []
for video_file, model_name in zip(SOURCES, MODEL_NAMES):
    thread = threading.Thread(target=run_tracker_in_thread, args=(model_name, video_file), daemon=True)
    tracker_threads.append(thread)
    thread.start()

# Wait for all tracker threads to finish
for thread in tracker_threads:
    thread.join()

# Clean up and close windows
cv2.destroyAllWindows()

Was sind die realen Anwendungen der Multi-Objekt-Verfolgung mit Ultralytics YOLO?

Die Multi-Objekt-Verfolgung mit Ultralytics YOLO hat zahlreiche Anwendungen, darunter:

• Transport: Fahrzeugverfolgung für Verkehrsmanagement und autonomes Fahren.
• Einzelhandel: Personenverfolgung für In-Store-Analysen und Sicherheit.
• Aquakultur: Fischverfolgung zur Überwachung aquatischer Umgebungen.
• Sportanalyse: Verfolgung von Spielern und Ausrüstung zur Leistungsanalyse.
• Sicherheitssysteme: Überwachung verdächtiger Aktivitäten und Erstellen von Sicherheitsalarmen.

Diese Anwendungen profitieren von der Fähigkeit von Ultralytics YOLO, Videos mit hoher Framerate in Echtzeit und mit außergewöhnlicher Genauigkeit zu verarbeiten.

Wie kann ich Objektspuren über mehrere Videoframes hinweg mit Ultralytics YOLO visualisieren?

Um Objektspuren über mehrere Videoframes hinweg zu visualisieren, kannst du die Tracking-Funktionen des YOLO-Modells zusammen mit OpenCV verwenden, um die Pfade der erkannten Objekte zu zeichnen. Hier ist ein Beispielskript, das dies demonstriert:

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)
track_history = defaultdict(lambda: [])

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        boxes = results[0].boxes.xywh.cpu()
        track_ids = results[0].boxes.id.int().cpu().tolist()
        annotated_frame = results[0].plot()
        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)))
            if len(track) > 30:
                track.pop(0)
            points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
            cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
        cv2.imshow("YOLO26 Tracking", annotated_frame)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break
cap.release()
cv2.destroyAllWindows()

Dieses Skript zeichnet die Tracking-Linien, die die Bewegungspfade der verfolgten Objekte über die Zeit darstellen, und liefert wertvolle Einblicke in das Verhalten und die Muster von Objekten.