Multi-Objekt-Tracking mit Ultralytics YOLO

Die Objektverfolgung im Bereich der Videoanalyse ist eine kritische Aufgabe, die nicht nur die Position und Klasse von Objekten innerhalb des Bildes identifiziert, sondern auch eine eindeutige ID für jedes erkannte Objekt im Verlauf des Videos beibehält. Die Anwendungen sind grenzenlos – von Überwachung und Sicherheit bis hin zu Echtzeit-Sportanalysen.

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

Die Ausgabe von Ultralytics Trackern ist konsistent mit der Standard-Objekterkennung, hat aber den zusätzlichen Wert von Objekt-IDs. Dies erleichtert die Verfolgung von Objekten in Videostreams und die Durchführung nachfolgender Analysen. Hier sind die Gründe, warum Sie Ultralytics YOLO für Ihre Anforderungen an die Objektverfolgung in Betracht ziehen sollten:

• Effizienz: Verarbeiten Sie Videostreams 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 schnelle Integration und Bereitstellung.
• Anpassbarkeit: Einfache Verwendung mit benutzerdefinierten trainierten YOLO-Modellen, die die Integration in domänenspezifische Anwendungen ermöglichen.

Ansehen: Objekterkennung und -verfolgung mit Ultralytics YOLO.

Anwendungen in der Praxis

Transport	Einzelhandel	Aquakultur
Fahrzeugverfolgung	Personenverfolgung	Fischverfolgung

Funktionen auf einen Blick

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

• Echtzeit-Tracking: Verfolgen Sie Objekte nahtlos in Videos mit hoher Bildrate.
• Unterstützung mehrerer Tracker: Wählen Sie aus einer Vielzahl etablierter Tracking-Algorithmen.
• Anpassbare Tracker-Konfigurationen: Passen Sie den Tracking-Algorithmus an spezifische Anforderungen an, indem Sie verschiedene Parameter anpassen.

Verfügbare Tracker

Ultralytics YOLO unterstützt die folgenden Tracking-Algorithmen. Sie können durch Übergabe der entsprechenden YAML-Konfigurationsdatei aktiviert werden, wie z.B. tracker=tracker_type.yaml:

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

Der Standard-Tracker ist BoT-SORT.

Tracking

Um den Tracker auf Videostreams auszuführen, verwenden Sie ein trainiertes Detect-, Segment- oder Pose-Modell wie YOLO11n, YOLO11n-seg und YOLO11n-pose.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO("yolo11n.pt")  # Load an official Detect model
model = YOLO("yolo11n-seg.pt")  # Load an official Segment model
model = YOLO("yolo11n-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

# Perform tracking with various models using the command line interface
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4"      # Official Detect model
yolo track model=yolo11n-seg.pt source="https://youtu.be/LNwODJXcvt4"  # Official Segment model
yolo track model=yolo11n-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 Verwendung zu sehen ist, ist 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 z. B. conf, iouund showWeitere Konfigurationen finden Sie auf der Vorhersagen Modellseite.

from ultralytics import YOLO

# Configure the tracking parameters and run the tracker
model = YOLO("yolo11n.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=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show

Tracker-Auswahl

Ultralytics ermöglicht es Ihnen auch, eine modifizierte Tracker-Konfigurationsdatei zu verwenden. Erstellen Sie dazu einfach eine Kopie einer Tracker-Konfigurationsdatei (z. B. custom_tracker.yaml) aus ultralytics/cfg/trackers und ändern Sie alle Konfigurationen (außer der tracker_type) nach Ihren Bedürfnissen.

from ultralytics import YOLO

# Load the model and run the tracker with a custom configuration file
model = YOLO("yolo11n.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=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'

Weitere Informationen zu den einzelnen Parametern finden Sie im Abschnitt Tracker-Argumente.

Tracker-Argumente

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

• botsort.yaml
• bytetrack.yaml

Die folgende Tabelle bietet eine Beschreibung der einzelnen Parameter:

Re-Identifizierung (ReID) aktivieren

Standardmäßig ist ReID deaktiviert, um den Leistungsaufwand zu minimieren. Das Aktivieren ist einfach—setzen Sie einfach with_reid: True in der Tracker-KonfigurationSie können auch die model wird für ReID verwendet, wodurch Sie je nach Anwendungsfall Genauigkeit und Geschwindigkeit gegeneinander abwägen können:

• Native Funktionen (model: auto): Dies nutzt Funktionen direkt vom YOLO-Detektor für ReID und fügt minimalen Overhead hinzu. Es ist ideal, wenn Sie ein gewisses Maß an ReID benötigen, ohne die Leistung wesentlich zu beeinträchtigen. Wenn der Detektor keine nativen Funktionen unterstützt, greift er automatisch auf die Verwendung von zurück yolo11n-cls.pt.
• YOLO-Klassifizierungsmodelle: Sie können explizit ein Klassifizierungsmodell festlegen (z. B. yolo11n-cls.pt) zur ReID-Merkmalsextraktion. Dies führt zu differenzierteren Einbettungen, bringt aber aufgrund des zusätzlichen Inferenzschritts zusätzliche Latenz mit sich.

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

from torch import nn

from ultralytics import YOLO

# Load the classification model
model = YOLO("yolo11n-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)

Sobald Sie es exportiert haben, können Sie im Tracker-Konfigurationsdatei auf den TensorRT-Modellpfad verweisen, und er wird für ReID während der Verfolgung verwendet.

python Beispiele

Tracks Loop beibehalten

Hier ist ein python-Skript, das OpenCV (cv2) und YOLO11 verwendet, um Objektverfolgung auf Videobildern auszuführen. Dieses Skript setzt weiterhin voraus, dass Sie die erforderlichen Pakete bereits installiert haben (opencv-python und ultralytics). 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 YOLO11 model
model = YOLO("yolo11n.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 YOLO11 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("YOLO11 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), wodurch die Objektverfolgung anstelle der einfachen Erkennung aktiviert wird. Dieses modifizierte Skript führt den Tracker für jedes Frame des Videos aus, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drücken von 'q' verlassen werden.

Plotten von Tracks im Zeitverlauf

Das Visualisieren von Objektspuren über aufeinanderfolgende Frames hinweg kann wertvolle Einblicke in die Bewegungsmuster und das Verhalten erkannter Objekte innerhalb eines Videos liefern. Mit Ultralytics YOLO11 ist das Plotten dieser Spuren ein nahtloser und effizienter Prozess.

Im folgenden Beispiel zeigen wir, wie die Tracking-Funktionen von YOLO11 genutzt werden können, um die Bewegung erkannter Objekte über mehrere Videoframes hinweg zu plotten. Dieses Skript beinhaltet das Öffnen einer Videodatei, das frameweise Lesen und die Verwendung des YOLO-Modells, um verschiedene Objekte zu identifizieren und zu verfolgen. Indem wir die Mittelpunkte der erkannten Begrenzungsrahmen beibehalten und sie verbinden, können wir Linien zeichnen, die die von den verfolgten Objekten zurückgelegten Pfade darstellen.

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.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 YOLO11 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("YOLO11 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 Möglichkeit, Objektverfolgung auf mehreren Videostreams gleichzeitig auszuführen. Dies ist besonders nützlich bei der Verarbeitung mehrerer Videoeingänge, z. B. von mehreren Überwachungskameras, wo die gleichzeitige Verarbeitung die Effizienz und Leistung erheblich steigern kann.

In dem bereitgestellten python-Skript verwenden wir das threading Modul von python, um mehrere Instanzen des Trackers gleichzeitig auszuführen. Jeder Thread ist für die Ausführung des Trackers auf einer 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 frameweise, führt den Tracker aus und zeigt die Ergebnisse an.

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

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 Haupt-Thread warten zu lassen, bis beide Tracker-Threads abgeschlossen 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

# Define model names and video sources
MODEL_NAMES = ["yolo11n.pt", "yolo11n-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 YOLO11 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()

geschlossen. 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 beitragen

Sind Sie erfahren im Multi-Objekt-Tracking und haben erfolgreich einen Tracking-Algorithmus mit Ultralytics YOLO implementiert oder angepasst? Wir laden Sie ein, zu unserem Bereich "Trackers" in ultralytics/cfg/trackers beizutragen! Ihre realen Anwendungen und Lösungen könnten für Benutzer, die an Tracking-Aufgaben arbeiten, von unschätzbarem Wert sein.

Durch Ihren Beitrag zu diesem Abschnitt helfen Sie, den Umfang der verfügbaren Tracking-Lösungen innerhalb des Ultralytics YOLO Frameworks zu erweitern und fügen eine weitere Ebene von Funktionalität und Nutzen für die Community hinzu.

Um Ihren Beitrag zu starten, lesen Sie bitte unseren Contributing Guide für umfassende Anweisungen zum Einreichen eines Pull Requests (PR) 🛠️. Wir sind gespannt auf Ihren Beitrag!

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

FAQ

Was ist Multi-Objekt-Tracking und wie unterstützt Ultralytics YOLO es?

Die Multi-Objekt-Verfolgung in der Videoanalyse umfasst sowohl die Identifizierung von Objekten als auch die Beibehaltung einer eindeutigen ID für jedes erkannte Objekt über Videobilder hinweg. Ultralytics YOLO unterstützt dies, indem es Echtzeit-Tracking zusammen mit Objekt-IDs bereitstellt, 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?

Sie können einen benutzerdefinierten Tracker konfigurieren, indem Sie eine bestehende Tracker-Konfigurationsdatei kopieren (z.B. custom_tracker.yaml) aus dem Ultralytics Tracker-Konfigurationsverzeichnis und die Parameter nach Bedarf ändern, außer dem tracker_type. Verwenden Sie diese Datei in Ihrem Tracking-Modell wie folgt:

from ultralytics import YOLO

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

yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'

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

Um Objektverfolgung auf mehreren Videostreams gleichzeitig auszuführen, können Sie das python threading Modul verwenden. Jeder Thread verarbeitet einen separaten Videostream. Hier ist ein Beispiel, wie Sie dies einrichten können:

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo11n.pt", "yolo11n-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 YOLO11 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?

Multi-Objekt-Tracking 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.
• Sportanalytik: Verfolgung von Spielern und Ausrüstung zur Leistungsanalyse.
• Sicherheitssysteme: Überwachung verdächtiger Aktivitäten und Erstellung von Sicherheitsalarmen.

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

Wie kann ich Objektpfade über mehrere Videobilder mit Ultralytics YOLO visualisieren?

Um Objektspuren über mehrere Videobilder zu visualisieren, können Sie 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("yolo11n.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("YOLO11 Tracking", annotated_frame)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break
cap.release()
cv2.destroyAllWindows()

Dieses Skript plottet die Tracking-Linien, die die Bewegungspfade der verfolgten Objekte im Zeitverlauf zeigen, und liefert so wertvolle Einblicke in das Verhalten und die Muster der Objekte.

📅 Erstellt vor 1 Jahr ✏️ Aktualisiert vor 2 Monaten

Kommentare