Multi-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.

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

Die Ausgabe von Ultralytics-Trackern ist konsistent mit der Standard-Objekterkennung, bietet jedoch den zusätzlichen Mehrwert von Objekt-IDs. Dies erleichtert das Verfolgen von Objekten in Videostreams und die Durchführung nachfolgender Analysen. Hier sind die Gründe, warum du Ultralytics YOLO für deine Objekterkennungsanforderungen 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.

Anwendungen in der Praxis#

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

Kurzanleitung#

Führe das Tracking für ein Video mit dem Standard-BoT-SORT-Tracker aus. Wechsle zu einem anderen Tracker, indem du das Argument tracker ä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-, Pose- oder OBB-Modell wie YOLO26n, YOLO26n-seg, YOLO26n-pose oder YOLO26n-obb. Du kannst benutzerdefinierte Modelle lokal oder mit dem Ultralytics Platform cloud training 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

Unterstützte Tracker#

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

Welchen 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).

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

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)

Benutzerdefinierte Tracker-Konfiguration#

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

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

Geteilte Tracker-Argumente#

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

Tracker-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

Re-Identifizierung (ReID) aktivieren#

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

Optionen für das ReID-Modell:

• model: auto — Verwendet native YOLO-Detektorfunktionen mit minimalem Mehraufwand. Ideal, wenn du etwas ReID ohne großen Leistungseinbruch benötigst. Greift auf yolo26n-cls.pt zurück, wenn der Detektor keine kompatiblen Funktionen bereitstellt.
• Exportiertes ReID-Modell — Verweise mit model: auf eine exportierte Datei (.torchscript, .onnx, .engine, .openvino usw.) für aussagekräftigere Einbettungen auf Kosten eines zusätzlichen Vorwärtsdurchlaufs pro Crop. Der Encoder wird über AutoBackend geladen, sodass jedes von Ultralytics unterstützte Exportformat ohne Codeänderungen funktioniert.

Gebrauchsfertige ONNX-Encoder werden für jede Modellgröße veröffentlicht. Setze model: auf einen dieser Namen, und die Datei wird beim ersten Ausführen des Tracker automatisch heruntergeladen (genauso wie YOLO-Gewichte abgerufen werden) – kein manueller Export- oder Downloadschritt erforderlich:

# In your tracker config (e.g. tracktrack.yaml)
with_reid: True
model: yolo26n-reid.onnx # downloaded on first use; swap n→s/m/l/x for a larger encoder

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", quantize=16, dynamic=True, batch=32)

Nach dem Export gib den Pfad zum TensorRT-Modell in deiner Tracker-Konfiguration an.

Tracker-Details#

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

BoT-SORT#

BoT-SORT (Aharon et al., 2022) ist der Standard-Tracker. Er erweitert ByteTrack um Kamerabewegungskompensation und optionales 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.
• Optionales ReID: Einbettungen des Erscheinungsbilds können in die Kostenmatrix einfließen. Standardmäßig deaktiviert; aktiviere sie 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 ein paar ms/Frame einzusparen.
• Starke Kamerabewegung: Behalte sparseOptFlow bei; ecc ist genauer, aber langsamer.
• Ähnlich aussehende Menschenmengen: Schalte with_reid: True ein und erhöhe appearance_thresh (z. B. 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) ist die leichtgewichtige Baseline. Sie verwendet lineares 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 gemeinsamen Tracker-Argumente hinaus.

Tuning-Tipps:

• Rauschbehafteter Detektor: Verringere track_low_thresh, damit die zweite Stufe mehr Kandidaten hat.
• Detektor mit hoher Wiedererkennungsrate: Erhöhe track_high_thresh, um fragmentierte IDs zu reduzieren.
• Häufiges ID-Flimmern: Erhöhe track_buffer, damit kurzzeitig verfehlte Tracks überleben.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) ist eine beobachtungszentrierte Erweiterung von SORT. Sie behält das leichtgewichtige Design von SORT bei (keine Erscheinungsmerkmale) 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 Detektionen: Aktiviere use_byte: True.
• Lange Okklusionen: Erhöhe track_buffer, damit OCR mehr verlorene Tracks zur Neuzuordnung hat.

Deep OC-SORT#

Deep OC-SORT erweitert OC-SORT um Erscheinungsdaten 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ätstausch in Menschenmengen: Erhöhe appearance_thresh (z. B. 0.92-0.95) und verringere alpha_fixed_emb, damit sich Einbettungen langsamer anpassen.
• Sich bewegende 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-Tausche die Fehler dominieren.

FastTracker#

FastTracker ist eine okklusionsbewusste ByteTrack-Variante ohne Erscheinungsmodell:

• Okklusionserkennung: Markiert Tracks als okkludiert, wenn die Überdeckung 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 partielle Okklusionen: Verringere occ_cover_thresh (z. B. 0.5-0.6).
• Doppelte IDs bei Überlappungen: Verringere init_iou_suppress (z. B. 0.5).
• Lange Okklusionen: Erhöhe occ_reappear_window und track_buffer gemeinsam.
• Schnell bewegte Ziele: Erhöhe dampen_motion_occ (näher an 1.0) und verringere enlarge_bbox_occ.

TrackTrack#

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

• 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ängerzonen: Verringere tai_thr (z. B. 0.45), um mehr doppelte Spawns zu unterdrücken; erhöhe track_buffer für längere Okklusionen.
• Schnelle Kamerabewegung: Lasse gmc_method: sparseOptFlow aktiviert.
• 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.

Python-Beispiele#

Schleife für persistente Tracks#

Hier ist ein Python-Skript unter Verwendung von OpenCV (cv2) und YOLO26 zur Durchführung der Objekterkennung auf Videoframes. Dieses Skript setzt voraus, dass die erforderlichen Pakete (opencv-python und ultralytics) bereits installiert sind. Das Argument persist=True teilt dem Tracker mit, dass das aktuelle Bild bzw. der 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
        # and using the BoT-SORT tracker backend
        results = model.track(frame, persist=True, tracker="botsort.yaml")

        # 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), womit das Objekt-Tracking anstelle einer einfachen Detektion aktiviert wird. 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' verlassen werden.

Tracks 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(list)

# 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 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 verwenden wir das Python-Modul threading, 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 korrekten Parameter erhält (die Videodatei, das zu verwendende Modell und den Dateidex), 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 werden in SOURCES angegeben.

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 sorgen mit join() dafür, dass der Haupt-Thread wartet, bis beide Tracker-Threads beendet sind.

Schließlich, nachdem alle Threads ihre Aufgabe abgeschlossen haben, werden die Fenster mit den Ergebnissen über 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.

Neue Tracker beitragen#

Kennst du dich gut mit Multi-Object-Tracking aus 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önnen 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 starten, 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 🙏!

FAQ#