Link to this sectionMulti-Objekt-Tracking mit Ultralytics YOLO#

Objekt-Tracking im Bereich der Videoanalyse ist eine entscheidende Aufgabe, die nicht nur den Ort und die Klasse von Objekten im Bild bestimmt, sondern auch eine eindeutige ID für jedes erkannte Objekt im Verlauf des Videos beibehält. Die Anwendungsgebiete sind grenzenlos – von Überwachung und Sicherheit bis hin zu Sportanalysen in Echtzeit.

Link to this sectionWarum Ultralytics YOLO für das Objekt-Tracking wählen?#

Die Ausgabe der Ultralytics Tracker ist konsistent mit der standardmäßigen Objekterkennung, bietet jedoch den Mehrwert von Objekt-IDs. Dies erleichtert das Verfolgen von Objekten in Videostreams und die Durchführung weiterführender Analysen. Hier erfährst du, warum du Ultralytics YOLO für deine Objekt-Tracking-Anforderungen in Betracht ziehen solltest:

• Effizienz: Verarbeite Videostreams in Echtzeit, ohne Kompromisse bei der Genauigkeit 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 benutzerdefinierten, trainierten YOLO Modellen, was die Integration in domänenspezifische Anwendungen ermöglicht.

Link to this sectionAnwendungen in der Praxis#

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

Link to this sectionKurzanleitung#

Führe das Tracking auf einem Video mit dem standardmäßigen BoT-SORT Tracker aus. Wechsle zu einem anderen Tracker, indem du das tracker Argument änderst.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Default tracker (BoT-SORT)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)

# Switch to ByteTrack
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")

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 in der obigen Anwendung zu sehen ist, steht das Tracking für alle Detect-, Segment- und Pose-Modelle zur Verfügung, die auf Videos oder Streaming-Quellen ausgeführt werden.

Link to this sectionUnterstützte Tracker#

Ultralytics YOLO wird mit sechs integrierten Trackern geliefert. Aktiviere einen davon, indem du dessen YAML-Konfigurationsdatei an das tracker Argument übergibst.

Link to this sectionWelchen Tracker soll ich verwenden?#

Nutze diesen Ablauf, um einen Startpunkt zu wählen:

1. Brauchst du die schnellste, einfachste Baseline? → ByteTrack (kein ReID, keine Kamerabewegungskompensation, minimaler Overhead).
2. Handgehalten, Drohne oder Filmmaterial mit bewegter Kamera? → BoT-SORT (Standard; fügt Kamerabewegungskompensation und optionales ReID hinzu).
3. Nicht-lineare Bewegung (Sport, Tanzen, abrupte Kurven) und kein ReID? → OC-SORT (beobachtungszentrierte Korrekturen ohne Erscheinungsbildkosten).
4. Überfüllte Szenen mit bewegter Kamera, bei denen ID-Swaps das Hauptproblem sind? → Deep OC-SORT oder TrackTrack (beide fügen adaptive Erscheinungsbildfusion hinzu; TrackTrack fügt zudem Multi-Cue-Assoziation und Unterdrückung doppelter IDs hinzu).
5. Häufige Teilüberlappung in Echtzeit, kein ReID-Budget? → FastTracker (verdeckungsbewusste ByteTrack-Variante mit Kalman-Rollback).

Link to this sectionTracker wechseln#

Übergebe den Dateinamen der Tracker-Konfiguration an tracker=. Der gesamte andere Code bleibt gleich.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

results = model.track(source="path/to/video.mp4", tracker="bytetrack.yaml")
results = model.track(source="path/to/video.mp4", tracker="ocsort.yaml")
results = model.track(source="path/to/video.mp4", tracker="tracktrack.yaml")

Link to this sectionKonfiguration#

Link to this sectionTracking-Argumente#

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

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)

Link to this sectionBenutzerdefinierte Tracker-Konfiguration#

Ultralytics ermöglicht es dir auch, eine modifizierte Tracker-Konfigurationsdatei zu verwenden. Erstelle dazu einfach eine Kopie einer Tracker-Konfigurationsdatei (zum Beispiel custom_tracker.yaml) aus ultralytics/cfg/trackers und ändere alle Konfigurationen (außer dem tracker_type) nach Bedarf.

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")

Link to this sectionGeteilte Tracker-Argumente#

Die folgenden Parameter sind für die meisten Tracker-YAML-Dateien üblich; nicht jeder Parameter erscheint in jeder Konfiguration:

Link to this sectionTracker-spezifische Argumente#

Jeder Algorithmus bietet neben den geteilten Parametern zusätzliche Stellschrauben. Siehe die Abschnitte zu den einzelnen Trackern weiter unten für Beschreibungen und Tuning-Tipps oder schau direkt in die Konfigurationsdateien:

• botsort.yaml
• bytetrack.yaml
• ocsort.yaml
• deepocsort.yaml
• fasttrack.yaml
• tracktrack.yaml

Link to this sectionRe-Identifizierung (ReID) aktivieren#

ReID ist standardmäßig deaktiviert, um den Overhead zu minimieren. Aktiviere es, indem du with_reid: True in einer Tracker-Konfigurationsdatei setzt.

Optionen für das ReID-Modell:

• model: auto — Nutzt native YOLO-Detektor-Funktionen bei minimalem Overhead. Ideal, wenn du etwas ReID ohne große Leistungseinbußen benötigst. Fällt auf yolo26n-cls.pt zurück, falls der Detektor keine kompatiblen Merkmale bereitstellt.
• Exportiertes ReID-Modell — Zeige mit model: auf eine exportierte Datei (.torchscript, .onnx, .engine, .openvino usw.) für aussagekräftigere Embeddings auf Kosten eines zusätzlichen Forward-Passes pro Crop. Der Encoder wird über AutoBackend geladen, sodass jedes von Ultralytics unterstützte Exportformat ohne Codeänderungen funktioniert.

Für eine bessere Leistung mit einem separaten Klassifizierungsmodell exportiere es in ein schnelleres Backend wie TensorRT:

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 gib den Pfad zum TensorRT-Modell in deiner Tracker-Konfiguration an.

Link to this sectionTracker-Details#

Erweitere die Abschnitte unten für Design, spezifische Parameter und Tuning-Tipps zu jedem Tracker.

Link to this sectionBoT-SORT#

BoT-SORT (Aharon et al., 2022) ist der Standard-Tracker. Er erweitert ByteTrack um Kamerabewegungskompensation und optionale ReID:

• Kamerabewegungskompensation (CMC): Ein affiner Warp, der pro Frame geschätzt wird (standardmäßig dünnbesetzter optischer Fluss; ORB / ECC ebenfalls verfügbar), wird vor dem IoU-Matching auf die Kalman-Zustände angewendet.
• Optionale ReID: Appearance-Embeddings können in die Kostenmatrix einfließen. Standardmäßig deaktiviert; aktiviere es mit with_reid: True.

Am besten geeignet für: allgemeines Tracking, besonders bei bewegten Kameras. Füge ReID nur hinzu, wenn sich ähnelnde Menschenmengen zu ID-Wechseln führen.

BoT-SORT-spezifische Argumente:

Tuning-Tipps:

• Statische Kamera: Setze gmc_method: none, um einige ms/Frame zu sparen.
• Starke Kamerabewegung: Behalte sparseOptFlow bei; ecc ist genauer, aber langsamer.
• Ähnlich aussehende Menschenmengen: Aktiviere with_reid: True und erhöhe appearance_thresh (z. B. 0.85+).

Link to this sectionByteTrack#

ByteTrack (Zhang et al., ECCV 2022) ist die leichtgewichtige Baseline. Er verwendet linearen Kalman + IoU mit einer zweistufigen Zuordnung:

• Stufe 1: Abgleich von Detections mit hoher Punktzahl gegen aktive Tracks.
• Stufe 2: Erneuter Versuch für nicht zugeordnete Tracks gegen Detections mit niedriger Punktzahl, um kurze partielle Verdeckungen zu überbrücken.

Es gibt kein Appearance-Modell und keine Kamerabewegungskompensation.

Am besten geeignet für: statische oder nahezu statische Kameras, bei denen der Detektoraufwand dominiert und du minimalen Tracker-Overhead wünschst.

ByteTrack-spezifische Argumente: Keine über die geteilten Tracker-Argumente hinaus.

Tuning-Tipps:

• Rauschiger Detektor: Senke track_low_thresh, damit die zweite Stufe mehr Kandidaten hat.
• High-Recall-Detektor: Erhöhe track_high_thresh, um fragmentierte IDs zu reduzieren.
• Häufiges ID-Flackern: Erhöhe track_buffer, damit kurzzeitig verlorene Tracks erhalten bleiben.

Link to this sectionOC-SORT#

OC-SORT (Cao et al., CVPR 2023) ist eine beobachtungszentrierte Erweiterung von SORT. Es behält das leichtgewichtige Design von SORT bei (keine Appearance-Merkmale) und fügt drei Korrekturen hinzu:

• Observation-Centric Re-update (ORU): Wiederholt eine virtuelle Trajektorie zwischen der letzten Beobachtung und der aktuellen Detection und führt das Kalman-Update erneut aus, um eine abgedriftete Geschwindigkeit zu korrigieren.
• Observation-Centric Momentum (OCM): Bestraft Detections, die sich in die falsche Richtung bewegen, mittels eines Konsistenzterms für die Geschwindigkeit.
• Observation-Centric Recovery (OCR): Überprüft nicht zugeordnete Detections erneut gegen kürzlich verlorene Tracks unter Verwendung ihrer letzten Beobachtung anstelle des vorhergesagten Zustands.

Am besten geeignet für: nichtlineare Bewegungen ohne den Overhead eines ReID-Modells.

OC-SORT-spezifische Argumente:

Tuning-Tipps:

• Nichtlineare Bewegung: Erhöhe inertia (z. B. 0.3-0.4).
• Spärliche Detections: Aktiviere use_byte: True.
• Lange Verdeckungen: Erhöhe track_buffer, damit OCR mehr verlorene Tracks zur Neuzuordnung hat.

Link to this sectionDeep OC-SORT#

Deep OC-SORT ergänzt OC-SORT um Appearance-Informationen und Kamerabewegungskompensation:

• Adaptive Appearance-Fusion: Detection-Embeddings werden in die Kostenmatrix integriert, wobei die Gewichtung durch die Detektionskonfidenz und Überlappung moduliert wird.
• Dynamisches Appearance-EMA: Track-Embeddings werden mit einem EMA aktualisiert, dessen Glättungsfaktor sich an die Detektionskonfidenz anpasst.
• Kamerabewegungskompensation: Kalman-Zustände werden Frame für Frame via Sparse Optical Flow, ORB oder ECC transformiert.

Am besten geeignet für: überfüllte Szenen oder Szenen mit bewegter Kamera, in denen ID-Wechsel zwischen visuell verschiedenen, aber räumlich nahen Objekten häufig vorkommen.

Deep OC-SORT-spezifische Argumente:

Tuning-Tipps:

• Identitätswechsel in Menschenmengen: Erhöhe appearance_thresh (z. B. 0.92-0.95) und senke alpha_fixed_emb, damit sich die Embeddings langsamer anpassen.
• Bewegte Kamera: Setze gmc_method: sparseOptFlow (Deep OC-SORT verwendet standardmäßig none).
• Geringere Latenz: Behalte with_reid: False (Standard) nur für Bewegung + CMC bei; aktiviere ReID nur, wenn ID-Wechsel Fehler dominieren.

Link to this sectionFastTracker#

FastTracker ist eine verdeckungsbewusste ByteTrack-Variante ohne Appearance-Modell:

• Verdeckungsdetektion: Markiert Tracks als verdeckt, wenn die Abdeckung durch andere aktive Tracks occ_cover_thresh überschreitet.
• Kalman-Rollback bei Verdeckung: Setzt den Kalman-Zustand auf einen Frame vor der Verdeckung zurück, unter Verwendung der Ringpuffer-Historie.
• Bewegungsdämpfung und Sucherweiterung: Die Geschwindigkeit wird gedämpft und die vorhergesagte BBox während der Verdeckung vergrößert.
• Init-IoU-Unterdrückung: Verhindert, dass neue Tracks über aktiven Tracks entstehen.

Am besten geeignet für: Echtzeit-Detection-only-Pipelines mit häufigen Überlappungen von Zielen (Menschenmengen, Warteschlangen, Sport).

FastTracker-spezifische Argumente:

Tuning-Tipps:

• Häufige Teilverdeckungen: verringere occ_cover_thresh (z. B. 0.5-0.6).
• Doppelte IDs bei Überlappung: verringere init_iou_suppress (z. B. 0.5).
• Lange Verdeckungen: erhöhe occ_reappear_window und track_buffer gemeinsam.
• Sich schnell bewegende Ziele: erhöhe dampen_motion_occ (näher an 1.0) und verringere enlarge_bbox_occ.

Link to this sectionTrackTrack#

TrackTrack (Shim et al., CVPR 2025) analysiert aus der Perspektive jedes Tracks mit iterativer Multi-Cue-Assoziation:

• Track-Perspective-Based Association (TPA): kombiniert HMIoU, Kosinus-ReID-Distanz, Konfidenzprojektions-Distanz und Winkelabstand der Ecken. Die Zuweisung wird iterativ mit einem entspannenden Schwellenwert gelöst.
• Track-Aware Initialization (TAI): unterdrückt doppelte Spawns, bevor eine neue ID erstellt wird.

Am besten geeignet für: überfüllte Szenen mit häufigen Verdeckungen, bei denen doppelte IDs ein Problem darstellen.

TrackTrack-spezifische Argumente:

Tuning-Tipps:

• Überfüllte Fußgängerbereiche: verringere tai_thr (z. B. 0.45), um mehr doppelte Spawns zu unterdrücken; erhöhe track_buffer für längere Verdeckungen.
• Schnelle Kamerabewegung: behalte gmc_method: sparseOptFlow bei.
• Kleine/schnelle Objekte: erhöhe angle_weight leicht und verringere min_track_len.
• Aktiviere ReID nur bei Bedarf: es erhöht die Inferenzkosten; bei kurzen Verdeckungen sind die standardmäßigen Multi-Cue-Kosten normalerweise ausreichend.

Link to this sectionPython-Beispiele#

Link to this sectionSchleife für persistente Tracks#

Hier ist ein Python-Skript, das OpenCV (cv2) und YOLO26 verwendet, um Objekt-Tracking auf Video-Frames durchzuführen. Dieses Skript setzt voraus, dass die erforderlichen Pakete (opencv-python und ultralytics) bereits installiert sind. Das Argument persist=True signalisiert dem Tracker, dass das aktuelle Bild oder der aktuelle Frame der nächste in einer Sequenz ist und er Tracks aus dem vorherigen Bild im aktuellen Bild erwarten soll.

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 die Änderung von model(frame) zu model.track(frame), was Objekt-Tracking anstelle von einfacher Detektion 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.

Link to this sectionTracks im Zeitverlauf plotten#

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

Im folgenden Beispiel zeigen wir, wie man die Tracking-Fähigkeiten von YOLO26 nutzt, um die Bewegung von detektierten Objekten über mehrere Video-Frames hinweg zu plotten. Dieses Skript umfasst das Öffnen einer Videodatei, das Lesen Frame für Frame und das Verwenden des YOLO-Modells zur Identifizierung und Verfolgung verschiedener Objekte. Durch das Beibehalten der Mittelpunkte der detektierten Bounding Boxes und deren Verbindung 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 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()

Link to this sectionMultithreaded-Tracking#

Multithreaded-Tracking bietet die Möglichkeit, Objekt-Tracking auf mehreren Video-Streams gleichzeitig auszuführen. Dies ist besonders nützlich bei der Handhabung mehrerer Videoeingaben, wie z. B. von mehreren Überwachungskameras, wo gleichzeitige Verarbeitung die Effizienz und Leistung erheblich verbessern kann.

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

Um sicherzustellen, dass jeder Thread die richtigen Parameter (die Videodatei, das zu verwendende Modell und den Datei-Index) 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, die jeweils Objekte in einer anderen Videodatei verfolgen. 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 die Threads dann mit start() und verwenden join(), damit der Haupt-Thread wartet, bis beide Tracker-Threads beendet sind.

Nachdem alle Threads ihre Aufgabe erledigt haben, werden die Fenster mit den Ergebnissen schließlich 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 dieselbe Methodik angewendet wird.

Link to this sectionNeue Tracker beitragen#

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

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

Um deinen Beitrag zu initiieren, lies bitte unseren Contributing Guide für umfassende Anweisungen zum Einreichen eines Pull Requests (PR) 🛠️. Wir sind gespannt darauf, was du einbringst!

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

Link to this sectionFAQ#

Link to this sectionWas ist Multi-Object Tracking und wie unterstützt es Ultralytics YOLO?#

Multi-Object Tracking in der Videoanalyse umfasst sowohl die Identifizierung von Objekten als auch die Beibehaltung einer eindeutigen ID für jedes detektierte Objekt über Video-Frames 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, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker und TrackTrack, die über YAML-Dateien konfiguriert werden können.

Link to this sectionWie konfiguriere ich einen benutzerdefinierten Tracker für Ultralytics YOLO?#

Du kannst einen benutzerdefinierten Tracker konfigurieren, indem du eine bestehende Tracker-Konfigurationsdatei (z. B. custom_tracker.yaml) aus dem Ultralytics Tracker-Konfigurationsverzeichnis kopierst und die Parameter nach Bedarf änderst, 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")

Link to this sectionWie kann ich Objekt-Tracking auf mehreren Video-Streams gleichzeitig ausführen?#

Um Objekt-Tracking auf mehreren Video-Streams gleichzeitig auszuführen, kannst du das threading-Modul von Python verwenden. Jeder Thread behandelt einen separaten Video-Stream. Hier ist ein Beispiel, wie du das 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()

Link to this sectionWas sind die realen Anwendungen von Multi-Object Tracking mit Ultralytics YOLO?#

Multi-Object Tracking mit Ultralytics YOLO hat zahlreiche Anwendungen, darunter:

• Transport: Fahrzeug-Tracking für Verkehrsmanagement und autonomes Fahren.
• Einzelhandel: Personen-Tracking für In-Store-Analytik und Sicherheit.
• Aquakultur: Fisch-Tracking zur Überwachung aquatischer Umgebungen.
• Sportanalyse: Tracking von Spielern und Ausrüstung für Leistungsanalysen.
• Sicherheitssysteme: Überwachung verdächtiger Aktivitäten und Erstellung 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.

Link to this sectionWie kann ich Objekt-Tracks über mehrere Video-Frames mit Ultralytics YOLO visualisieren?#

Um Objekt-Tracks über mehrere Video-Frames zu visualisieren, kannst du die Tracking-Features des YOLO-Modells zusammen mit OpenCV verwenden, um die Pfade der detektierten 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 im Zeitverlauf zeigen, und liefert wertvolle Einblicke in das Verhalten und die Muster der Objekte.