Multi-Objekt-Tracking mit Ultralytics YOLO#

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

Sieh dir die unreleased YOLO27 preview für geplante Tracking-Unterstützung an.

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

Die Ausgabe von Ultralytics-Trackern ist konsistent mit der standardmäßigen Objekterkennung, bietet jedoch den zusätzlichen Nutzen von Objekt-IDs. Dies erleichtert das Tracking von Objekten in Videostreams und die Durchführung nachfolgender 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 eine schnelle Integration und Bereitstellung.
• Anpassbarkeit: Einfache Verwendung mit benutzerdefinierten YOLO-Modellen, die eine Integration in domänenspezifische Anwendungen ermöglicht.

Anwendungen in der Praxis#

Schnellstart#

Führe das Tracking für ein Video mit dem Standard-TrackTrack-Tracker aus. Wechsle zu einem anderen Tracker, indem du das Argument tracker änderst.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Default tracker (TrackTrack)
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 Cloud-Training der 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

Unterstützte Tracker#

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

Welchen Tracker solltest du verwenden?#

Nutze diesen Ablauf, um einen Startpunkt zu wählen; tracktrack.yaml wird verwendet, wenn du kein tracker übergibst:

1. Benötigst du die schnellste und einfachste Basislinie? → ByteTrack (kein ReID, keine Kamerabewegungskompensation, minimaler Overhead).
2. Handheld-, Drohnen- oder bewegtes Kamera-Footage? → BoT-SORT (fügt Kamerabewegungskompensation und optionales ReID hinzu).
3. Nicht-lineare Bewegung (Sport, Tanzen, abrupte Drehungen) 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 unterstützen optionales Abgleichen des Erscheinungsbilds; TrackTrack fügt zudem Multi-Cue-Assoziation und Unterdrückung doppelt vorhandener IDs hinzu).
5. Häufige partielle Überlappung in Echtzeit, kein ReID-Budget? → FastTracker (verdeckungsbewusste ByteTrack-Variante mit Kalman-Rollback).

Tracker umschalten#

Ü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 etwa conf, iou und show. Weitere Konfigurationen findest du auf der Predict-Modellseite.

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 dem tracker_type) an deine Bedürfnisse 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")

Gemeinsame Tracker-Argumente#

Die folgenden Parameter sind in den meisten Tracker-YAML-Dateien gemeinsam; nicht jeder Parameter kommt in jeder Konfiguration vor:

Tracker-spezifische Argumente#

Jeder Algorithmus stellt zusätzliche Stellschrauben über die gemeinsamen Parameter hinaus bereit. Siehe die Abschnitte pro Tracker unten für Beschreibungen und Optimierungshinweise oder wende dich direkt an die Konfigurationsdateien:

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

Re-Identification (ReID) aktivieren#

ReID ist standardmäßig deaktiviert, um den Overhead 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-Detektor-Funktionen und fügt minimalen Overhead hinzu. Ideal, wenn du etwas ReID ohne große Leistungseinbußen benötigst. Greift auf yolo26n-cls.pt zurück, wenn der Detektor keine kompatiblen Funktionen bereitstellt.
• Benutzerdefiniertes ReID-Modell — Verweise mit model: auf ein .pt-Checkpoint oder ein kompatibles exportiertes Einbettungsmodell, wie etwa .torchscript, .onnx, .engine oder ein OpenVINO-Modellverzeichnis. Exportierte Modelle werden über AutoBackend geladen und müssen direkt einen Einbettungs-Tensor ausgeben.

Einsatzbereite 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 Trackers automatisch heruntergeladen (auf dieselbe Weise wie YOLO-Gewichte abgerufen werden) – kein manueller Export- oder Download-Schritt 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)

Verweise nach dem Export in deiner Tracker-Konfiguration auf den TensorRT-Modellpfad.

Tracker-Details#

Die folgenden Abschnitte beschreiben das Design jedes Trackers, spezifische Parameter und Optimierungstipps.

BoT-SORT#

BoT-SORT (Aharon et al., 2022) erweitert ByteTrack um Kamerabewegungskompensation und optionales ReID:

• Kamerabewegungskompensation (CMC): Ein für jeden Frame geschätzter affiner Warp (standardmäßig sparse optical flow; ORB / ECC ebenfalls verfügbar) wird vor dem IoU-Abgleich auf die Kalman-Zustände angewendet.
• Optionales ReID: Erscheinungsbild-Einbettungen können in die Kostenmatrix verschmolzen werden. Standardmäßig deaktiviert; aktiviere sie mit with_reid: True.

Am besten geeignet für: Allzweck-Tracking, insbesondere bei sich bewegenden Kameras. Füge ReID nur hinzu, wenn sich ähnliche Menschenmengen gegenseitig ID-Tausche verursachen.

BoT-SORT-spezifische Argumente:

Tipps zum Feintuning:

• Statische Kamera: Setze gmc_method: none, um ein paar ms/Frame einzusparen.
• Starke Kamerabewegung: Behalte sparseOptFlow bei; ecc ist genauer, aber langsamer.
• Sich ähnelnde 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: Gleiche Erkennungen mit hoher Konfidenz mit aktiven Tracks ab.
• Stufe 2: Versuche nicht zugeordnete Tracks erneut mit Erkennungen mit niedriger Konfidenz abzugleichen, um sie bei kurzer partieller Okklusion wiederherzustellen.

Es gibt kein Erscheinungsmodell und keine Kamerabewegungskompensation.

Am besten geeignet für: Statische oder nahezu statische Kameras, bei denen die Detektorkosten überwiegen und du minimalen Tracker-Overhead wünschst.

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

Tipps zum Feintuning:

• Rauschhafter Detektor: Verringere track_low_thresh, damit die zweite Stufe mehr Kandidaten hat.
• Detektor mit hohem Recall: Erhöhe track_high_thresh, um fragmentierte IDs zu reduzieren.
• Häufiges ID-Flackern: 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 Erkennung und führt das Kalman-Update erneut aus, um abgedriftete Geschwindigkeiten zu korrigieren.
• Observation-Centric Momentum (OCM): Bestraft Erkennungen, die sich in die falsche Richtung bewegen, über einen Geschwindigkeitskonsistenzterm.
• Observation-Centric Recovery (OCR): Überprüft nicht zugeordnete Erkennungen anhand kürzlich verlorener Tracks unter Verwendung ihrer letzten Beobachtung anstelle des vorhergesagten Zustands erneut.

Am besten geeignet für: Nichtlineare Bewegung ohne die Kosten eines ReID-Modells.

OC-SORT-spezifische Argumente:

Tipps zum Feintuning:

• Nichtlineare Bewegung: Erhöhe inertia (z. B. 0.3-0.4).
• Sparse-Erkennungen: Aktiviere use_byte: True.
• Lange Okklusionen: Erhöhe track_buffer, damit OCR mehr verlorene Tracks zur Neuzuordnung hat.

Bei OBB-Modellen verwendet OCR die vom Kalman-Filter vorhergesagte orientierte Bounding Box, da kein Verlauf orientierter letzter Beobachtungen beibehalten wird.

Deep OC-SORT#

Deep OC-SORT erweitert OC-SORT um Erscheinungs情報を (Erscheinungsinformationen) und Kamerabewegungskompensation:

• Erscheinungsabgleich: Die Kosinus-Einbettungsdistanz wird durch Überlappung begrenzt und mit Bewegungskosten zusammengelegt.
• Dynamischer Erscheinungs-EMA: Track-Einbettungen werden mit einem EMA aktualisiert, dessen Glättungsfaktor sich an die Erkennungskonfidenz anpasst.
• Kamerabewegungskompensation: Kalman-Zustände werden Frame für Frame über spärlichen optischen Fluss, ORB oder ECC gewarpt.

Am besten geeignet für: Szenen mit Menschenmengen oder bewegten Kameras, in denen ID-Tausche zwischen visuell unterschiedlichen, aber räumlich nahen Objekten häufig vorkommen.

Deep OC-SORT-spezifische Argumente:

Tipps zum Feintuning:

• Identitätstausche in Menschenmengen: Erhöhe appearance_thresh (z. B. 0.92-0.95) und erhöhe alpha_fixed_emb, damit sich Einbettungen 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-Tausche die Fehler dominieren.

FastTracker#

FastTracker ist eine okklusionsbewusste ByteTrack-Variante ohne Erscheinungsmodell:

• Okklusionserkennung: Markiert Tracks als okkludiert, wenn die Abdeckung durch andere aktive Tracks occ_cover_thresh überschreitet.
• Kalman-Rollback bei Okklusion: Setzt den Kalman-Zustand mithilfe eines Ringpufferverlaufs auf einen Frame vor der Okklusion zurück.
• Bewegungsdämpfung und Sucherweiterung: Die Geschwindigkeit wird gedämpft und die vorhergesagte Bounding Box wird während der Okklusion vergrößert.
• Init-IoU-Unterdrückung: Verhindert, dass neue Tracks auf aktiven Tracks erstellt werden.

Am besten geeignet für: Echtzeit-Pipelines nur für Erkennungen mit häufigen Ziel-zu-Ziel-Überlappungen (Mengen, Warteschlangen, Sport).

FastTracker-spezifische Argumente:

Tipps zum Feintuning:

• Häufige partielle Okklusionen: Verringere occ_cover_thresh (z. B. 0.5-0.6).
• Doppelte IDs bei Überlappung: 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); erhöhe enlarge_bbox_occ nur, wenn ein größerer Suchbereich die Wiederherstellung verbessert.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) ist der Standard-Tracker. Er argumentiert aus der Perspektive jedes Tracks mit iterativer Multicue-Zuordnung:

• Track-Perspective-Based Association (TPA): Kombiniert HMIoU, optionale Kosinus-ReID-Distanz, Konfidenzprojektionsdistanz und Eckenwinkeldistanz. Die Zuweisung wird iterativ mit einem lockeren Schwellenwert gelöst.
• Track-Aware Initialization (TAI): Unterdrückt doppelte Erstellungen, bevor eine neue ID erzeugt wird.

Am besten geeignet für: Szenen mit Menschenmengen und häufigen Okklusionen, bei denen doppelte IDs ein Problem darstellen.

TrackTrack-spezifische Argumente:

Tipps zum Feintuning:

• Überfüllte Fußgängerzonen: Verringere tai_thr (z. B. 0.45), um mehr doppelte Erstellungen zu unterdrücken; erhöhe track_buffer für längere Okklusionen.
• Schnelle Kamerabewegung: Behalte gmc_method: sparseOptFlow aktiviert.
• Kleine/schnelle Objekte: Erhöhe angle_weight leicht und verringere min_track_len.
• ReID nur bei Bedarf aktivieren: Es erhöht die Inferenzkosten; bei kurzen Okklusionen sind die Standard-Multicue-Kosten in der Regel ausreichend.

Bei Segment- und Pose-Modellen überspringt TrackTrack die Wiederherstellung von Erkennungen durch lockeres NMS, damit Masken und Keypoints mit ihren Erkennungen ausgerichtet bleiben.

Python-Beispiele#

Schleife zum Beibehalten von Tracks#

Hier ist ein Python-Skript, das OpenCV (cv2) und YOLO26 verwendet, um Objekt-Tracking auf Video-Frames auszuführen. 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 oder der aktuelle Frame der 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), welche die Objektverfolgung anstelle einer einfachen Erkennung ermöglicht. Dieses modifizierte Skript führt den Tracker auf jedem Einzelbild des Videos aus, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drücken von 'q' beendet werden.

Verläufe im Zeitverlauf darstellen#

Die Visualisierung von Objektverläufen über aufeinanderfolgende Einzelbilder hinweg kann wertvolle Einblicke in die Bewegungsmuster und das Verhalten erkannter Objekte in einem Video liefern. Mit Ultralytics YOLO26 ist das Darstellen dieser Verläufe ein nahtloser und effizienter Prozess.

Im folgenden Beispiel demonstrieren wir, wie du die Tracking-Funktionen von YOLO26 nutzen kannst, um die Bewegungerkannter Objekte über mehrere Video-Einzelbilder hinweg darzustellen. Dieses Skript umfasst das Öffnen einer Videodatei, das Auslesen Einzelbild für Einzelbild und die Verwendung des YOLO-Modells zum Identifizieren und Verfolgen verschiedener Objekte. Durch das Speichern der Mittelpunkte der erkannten Bounding Boxes und deren Verbindung können wir Linien zeichnen, die die von den verfolgten Objekten zurückgelegten Pfade repräsentieren.

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, die Objektverfolgung auf mehreren Videostreams gleichzeitig auszuführen. Dies ist besonders nützlich, wenn mehrere Videoeingaben verarbeitet werden, wie etwa von mehreren Überwachungskameras, bei denen eine gleichzeitige Verarbeitung die Effizienz und Leistung erheblich steigern kann.

In dem bereitgestellten Python-Skript nutzen wir das Python-Modul threading, 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 korrekten Parameter (die Videodatei, das zu verwendende Modell und den Dateidekey) 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 Einzelbild für Einzelbild, 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 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 verwenden join(), um den Haupt-Thread warten zu lassen, bis beide Tracker-Threads beendet sind.

Schließlich werden, nachdem alle Threads ihre Aufgabe abgeschlossen haben, die Fenster zur Anzeige der Ergebnisse 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): Model checkpoint name or path loaded inside the thread.
        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 lässt sich leicht erweitern, um mehr Videodateien und Modelle zu verarbeiten, indem du weitere Threads erstellst und dieselbe Methodik anwendest.

Neue Tracker beisteuern#

Kennst du dich gut mit Multi-Object Tracking aus und hast einen Tracking-Algorithmus erfolgreich mit Ultralytics YOLO implementiert oder angepasst? Wir laden dich ein, einen Beitrag zu unserem Tracker-Abschnitt in ultralytics/cfg/trackers zu leisten! 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 Abschnitt beiträgst, hilfst du dabei, den Umfang der im Ultralytics YOLO-Framework verfügbaren Tracking-Lösungen zu erweitern und der Community eine weitere Ebene an Funktionalität und Nutzen 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 beisteuerst!

Lass uns gemeinsam die Tracking-Funktionen des Ultralytics YOLO-Ökosystems verbessern 🙏!

FAQ#