Suivi multi-objet avec Ultralytics YOLO#

Le suivi d'objets dans le domaine de l'analyse vidéo est une tâche essentielle qui identifie non seulement l'emplacement et la classe des objets dans l'image, mais conserve également un identifiant unique pour chaque objet détecté au fil de la progression de la vidéo. Les applications sont infinies, allant de la surveillance et de la sécurité à l'analyse sportive en temps réel.

Consulte l'aperçu non publié de YOLO27 pour le support de suivi planifié.

Pourquoi choisir Ultralytics YOLO pour le suivi d'objets ?#

La sortie des traqueurs Ultralytics est cohérente avec la détection d'objets standard, mais apporte la valeur ajoutée des identifiants d'objets. Cela facilite le suivi d'objets dans les flux vidéo et l'exécution d'analyses ultérieures. Voici pourquoi tu devrais envisager d'utiliser Ultralytics YOLO pour tes besoins de suivi d'objets :

• Efficacité : Traite les flux vidéo en temps réel sans compromettre la précision.
• Flexibilité : Prend en charge plusieurs algorithmes et configurations de suivi.
• Facilité d'utilisation : API Python simple et options CLI pour une intégration et un déploiement rapides.
• Personnalisabilité : Simple à utiliser avec des modèles YOLO entraînés sur mesure, permettant l'intégration dans des applications spécifiques à un domaine.

Applications concrètes#

Démarrage rapide#

Lance le suivi sur une vidéo avec le traqueur par défaut TrackTrack. Change de traqueur en modifiant l'argument tracker.

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

Pour exécuter le traqueur sur des flux vidéo, utilise un modèle entraîné de détection (Detect), de segmentation (Segment), de pose (Pose) ou orienté (OBB) tel que YOLO26n, YOLO26n-seg, YOLO26n-pose ou YOLO26n-obb. Tu peux entraîner des modèles personnalisés localement ou avec l'entraînement cloud de la plateforme Ultralytics.

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

Traqueurs pris en charge#

Ultralytics YOLO est fourni avec six traqueurs intégrés. Active l'un d'eux en passant son fichier de configuration YAML à l'argument tracker.

Quel traqueur devrais-tu utiliser ?#

Utilise ce flux pour choisir un point de départ ; tracktrack.yaml est utilisé lorsque tu ne passes aucun tracker :

1. Besoin de la base la plus rapide et la plus simple ? → ByteTrack (pas de ReID, pas de compensation de mouvement de la caméra, surcharge minimale).
2. Pied, drone ou séquences de caméra en mouvement ? → BoT-SORT (ajoute la compensation du mouvement de la caméra et le ReID optionnel).
3. Mouvement non linéaire (sports, danse, virages brusques) et pas de ReID ? → OC-SORT (corrections centrées sur l'observation sans coût d'apparence).
4. Scènes de caméras en mouvement encombrées où les échanges d'identifiants constituent le problème principal ? → Deep OC-SORT ou TrackTrack (tous deux prennent en charge la correspondance d'apparence optionnelle ; TrackTrack ajoute également l'association multi-indices et la suppression d'identifiants en double).
5. Chevauchement partiel fréquent en temps réel, pas de budget ReID ? → FastTracker (variante de ByteTrack consciente des occlusions avec retour en arrière Kalman).

Changement de traqueur#

Passe le nom du fichier de configuration du traqueur à tracker=. Tout le reste du code reste identique.

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

Configuration#

Arguments de suivi#

La configuration du suivi partage des propriétés avec le mode de prédiction (Predict), telles que conf, iou et show. Pour de plus amples configurations, reporte-toi à la page du modèle 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)

Configuration de traqueur personnalisé#

Ultralytics te permet également d'utiliser un fichier de configuration de traqueur modifié. Pour ce faire, fais simplement une copie d'un fichier de configuration de traqueur (par exemple, custom_tracker.yaml) depuis ultralytics/cfg/trackers et modifie toutes les configurations (sauf le tracker_type) selon tes besoins.

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

Arguments de traqueur partagés#

Les paramètres suivants sont communs à la plupart des fichiers YAML de traqueurs ; tous les paramètres n'apparaissent pas dans chaque configuration :

Arguments spécifiques au traqueur#

Chaque algorithme expose des options supplémentaires en plus des paramètres partagés. Consulte les sections par traqueur ci-dessous pour les descriptions et les conseils de réglage, ou reporte-toi directement aux fichiers de configuration :

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

Activation de la réidentification (ReID)#

Le ReID est désactivé par défaut pour minimiser la surcharge. Active-le en configurant with_reid: True dans un fichier de configuration de traqueur.

Options du modèle ReID :

• model: auto — Utilise les caractéristiques natives du détecteur YOLO, ajoutant une surcharge minime. Idéal lorsque tu as besoin d'un certain ReID sans baisse de performance importante. Revient à yolo26n-cls.pt si le détecteur n'expose pas de caractéristiques compatibles.
• Modèle ReID personnalisé — Pointe model: vers un point de contrôle (checkpoint) .pt ou un modèle de plongement (embedding) exporté compatible, tel que .torchscript, .onnx, .engine, ou un répertoire de modèles OpenVINO. Les modèles exportés sont chargés via AutoBackend et doivent produire directement un tenseur de plongement (embedding tensor).

Des encodeurs ONNX prêts à l'emploi sont publiés pour chaque taille de modèle. Définis model: sur l'un de ces noms et le fichier est téléchargé automatiquement lors de la première exécution du traqueur (de la même manière que les poids YOLO sont récupérés) — aucune étape d'exportation ou de téléchargement manuelle requise :

# 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

Pour de meilleures performances avec un modèle de classification séparé, exporte-le vers un moteur plus rapide tel que 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)

Une fois exporté, pointe vers le chemin du modèle TensorRT dans ta configuration de traqueur.

Détails des traqueurs#

Les sections ci-dessous décrivent la conception, les paramètres spécifiques et les conseils de réglage de chaque traqueur.

BoT-SORT#

BoT-SORT (Aharon et al., 2022) étend ByteTrack avec une compensation du mouvement de la caméra et un ReID optionnel :

• Compensation du mouvement de la caméra (CMC) : une distorsion affine estimée à chaque image (flux optique clairsemé par défaut ; ORB / ECC également disponibles) est appliquée aux états de Kalman avant la correspondance par intersection sur union (IoU).
• ReID optionnel : les plongements (embeddings) d'apparence peuvent être fusionnés dans la matrice de coûts. Désactivé par défaut ; active-le avec with_reid: True.

Idéal pour : le suivi polyvalent, en particulier avec des caméras en mouvement. Ajoute la ré-identification (ReID) uniquement lorsque des foules aux apparences similaires provoquent des inversions d'ID.

Arguments spécifiques à BoT-SORT :

Conseils de réglage :

• Caméra fixe : définis gmc_method: none pour économiser quelques ms/image.
• Mouvement de caméra important : conserve sparseOptFlow ; ecc est plus précis mais plus lent.
• Foules aux apparences similaires : active with_reid: True et augmente appearance_thresh (par exemple, 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) est la référence légère. Il utilise un filtre de Kalman linéaire + une intersection sur union (IoU) avec une association en deux étapes :

• Étape 1 : associe les détections à score élevé aux pistes actives.
• Étape 2 : réessaie les pistes non associées avec les détections à score faible pour récupérer les occlusions partielles et brèves.

Il n'y a pas de modèle d'apparence ni de compensation des mouvements de caméra.

Idéal pour : les caméras fixes ou quasi fixes où le coût du détecteur domine et où tu souhaites un surcoût minimal pour le suivi.

Arguments spécifiques à ByteTrack : Aucun en dehors des arguments de suivi partagés.

Conseils de réglage :

• Détecteur bruyant : réduit track_low_thresh pour que la deuxième étape dispose de plus de candidats.
• Détecteur à haut rappel : augmente track_high_thresh pour réduire les ID fragmentés.
• Scintillement fréquent des ID : augmente track_buffer pour que les pistes brièvement manquées survivent.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) est une extension de SORT axée sur l'observation. Il conserve la conception légère de SORT (pas de caractéristiques d'apparence) et ajoute trois corrections :

• Mise à jour de ré-observation axée sur l'observation (ORU) : rejoue une trajectoire virtuelle entre la dernière observation et la détection actuelle, en réexécutant la mise à jour de Kalman pour réparer la vitesse dérivée.
• Momentum axé sur l'observation (OCM) : pénalise les détections se déplaçant dans la mauvaise direction via un terme de cohérence de vitesse.
• Récupération axée sur l'observation (OCR) : revérifie les détections non associées par rapport aux pistes récemment perdues en utilisant leur dernière observation plutôt que l'état prédit.

Idéal pour : le mouvement non linéaire sans le coût d'un modèle ReID.

Arguments spécifiques à OC-SORT :

Conseils de réglage :

• Mouvement non linéaire : augmente inertia (par exemple, 0.3-0.4).
• Détections éparses : active use_byte: True.
• Occlusions longues : augmente track_buffer afin que l'OCR dispose de plus de pistes perdues à réassocier.

Avec les modèles OBB, l'OCR utilise la boîte orientée prédite par Kalman car l'historique de la dernière observation orientée n'est pas conservé.

Deep OC-SORT#

Deep OC-SORT enrichit OC-SORT avec des informations d'apparence et une compensation des mouvements de caméra :

• Correspondance d'apparence : la distance de plongement cosinus est filtrée par le chevauchement et fusionnée avec le coût de mouvement.
• Moyenne mobile exponentielle (EMA) d'apparence dynamique : les plongements de piste se mettent à jour avec une EMA dont le facteur de lissage s'adapte à la confiance de la détection.
• Compensation des mouvements de caméra : les états de Kalman sont déformés d'une image à l'autre via un flux optique clairsemé, ORB ou ECC.

Idéal pour : les scènes encombrées ou avec des caméras en mouvement où les inversions d'ID entre des objets visuellement différents mais spatialement proches sont fréquentes.

Arguments spécifiques à Deep OC-SORT :

Conseils de réglage :

• Inversions d'identité dans les foules : augmente appearance_thresh (par exemple, 0.92-0.95) et augmente alpha_fixed_emb pour que les plongements s'adaptent plus lentement.
• Caméra en mouvement : définis gmc_method: sparseOptFlow (Deep OC-SORT utilise par défaut none).
• Latence plus faible : conserve with_reid: False (par défaut) pour le mouvement et la compensation des mouvements de caméra uniquement ; active la ReID uniquement lorsque les inversions d'ID dominent les erreurs.

FastTracker#

FastTracker est une variante de ByteTrack sensible aux occlusions, sans modèle d'apparence :

• Détection d'occlusion : signale les pistes comme occultées lorsque la couverture par d'autres pistes actives dépasse occ_cover_thresh.
• Restauration de Kalman en cas d'occlusion : ramène l'état de Kalman à une image antérieure à l'occlusion en utilisant un historique mis en mémoire tampon circulaire.
• Amortissement du mouvement et expansion de la recherche : la vitesse est amortie et la boîte englobante prédite (bbox) est élargie pendant l'occlusion.
• Suppression Init-IoU : empêche la création de nouvelles pistes par-dessus les pistes actives.

Idéal pour : les pipelines de détection en temps réel avec des chevauchements fréquents entre cibles (foules, files d'attente, sports).

Arguments spécifiques à FastTracker :

Conseils de réglage :

• Occlusions partielles fréquentes : réduis occ_cover_thresh (par exemple, 0.5-0.6).
• ID en double autour du chevauchement : réduis init_iou_suppress (par exemple, 0.5).
• Occlusions longues : augmente occ_reappear_window et track_buffer ensemble.
• Cibles se déplaçant rapidement : augmente dampen_motion_occ (plus près de 1.0) ; augmente enlarge_bbox_occ uniquement lorsqu'une région de recherche plus large améliore la récupération.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) est le dispositif de suivi par défaut. Il raisonne du point de vue de chaque piste grâce à une association itérative à critères multiples :

• Association basée sur la perspective de la piste (TPA) : combine la distance HMIoU, la distance ReID par cosinus facultative, la distance de projection de confiance et la distance d'angle de coin. L'affectation est résolue de manière itérative avec un seuil assoupli.
• Initialisation consciente de la piste (TAI) : supprime les duplications de création avant qu'un nouvel ID ne soit généré.

Idéal pour : les scènes encombrées avec des occlusions fréquentes où les ID en double posent problème.

Arguments spécifiques à TrackTrack :

Conseils de réglage :

• Piétons en foule : réduis tai_thr (par exemple, 0.45) pour supprimer davantage de créations en double ; augmente track_buffer pour des occlusions plus longues.
• Mouvement rapide de la caméra : garde gmc_method: sparseOptFlow activé.
• Petits objets ou objets rapides : augmente légèrement angle_weight et réduis min_track_len.
• Active la ReID uniquement en cas de besoin : elle ajoute un coût d'inférence ; pour les occlusions brèves, le coût à critères multiples par défaut est généralement suffisant.

Avec les modèles de segmentation et de pose, TrackTrack ignore la récupération de détection NMS souple afin que les masques et les points clés restent alignés avec leurs détections.

Exemples en Python#

Boucle de persistance des pistes#

Voici un script Python utilisant OpenCV (cv2) et YOLO26 pour exécuter le suivi d'objets sur des images vidéo. Ce script suppose que les paquets nécessaires (opencv-python et ultralytics) sont déjà installés. L'argument persist=True indique au dispositif de suivi que l'image ou la trame actuelle est la suivante dans une séquence et qu'il doit s'attendre à recevoir des pistes provenant de l'image précédente dans l'image actuelle.

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

Note bien le changement de model(frame) à model.track(frame), qui permet le suivi d'objets au lieu d'une simple détection. Ce script modifié exécutera le suivi sur chaque image de la vidéo, visualisera les résultats et les affichera dans une fenêtre. Tu peux quitter la boucle en appuyant sur 'q'.

Tracer les trajectoires au fil du temps#

Visualiser les trajectoires d'objets sur des images consécutives peut fournir des informations précieuses sur les schémas de mouvement et le comportement des objets détectés dans une vidéo. Avec Ultralytics YOLO26, tracer ces trajectoires est un processus simple et efficace.

Dans l'exemple suivant, nous montrons comment utiliser les capacités de suivi de YOLO26 pour tracer le mouvement des objets détectés sur plusieurs images vidéo. Ce script implique d'ouvrir un fichier vidéo, de le lire image par image et d'utiliser le modèle YOLO pour identifier et suivre divers objets. En conservant les points centraux des boîtes englobantes détectées et en les connectant, nous pouvons dessiner des lignes qui représentent les chemins suivis par les objets suivis.

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

Suivi multithread#

Le suivi multithread offre la possibilité d'exécuter le suivi d'objets sur plusieurs flux vidéo simultanément. Ceci est particulièrement utile lors de la gestion de plusieurs entrées vidéo, telles que celles provenant de plusieurs caméras de surveillance, où le traitement simultané peut grandement améliorer l'efficacité et les performances.

Dans le script Python fourni, nous utilisons le module threading de Python pour exécuter plusieurs instances du suivi simultanément. Chaque thread est responsable de l'exécution du suivi sur un fichier vidéo, et tous les threads s'exécutent simultanément en arrière-plan.

Pour s'assurer que chaque thread reçoit les bons paramètres (le fichier vidéo, le modèle à utiliser et l'index du fichier), nous définissons une fonction run_tracker_in_thread qui accepte ces paramètres et contient la boucle de suivi principale. Cette fonction lit la vidéo image par image, exécute le suivi et affiche les résultats.

Deux modèles différents sont utilisés dans cet exemple : yolo26n.pt et yolo26n-seg.pt, chacun suivant des objets dans un fichier vidéo différent. Les fichiers vidéo sont spécifiés dans SOURCES.

Le paramètre daemon=True dans threading.Thread signifie que ces threads seront fermés dès que le programme principal se terminera. Nous démarrons ensuite les threads avec start() et utilisons join() pour faire attendre le thread principal jusqu'à ce que les deux threads de suivi soient terminés.

Enfin, une fois que tous les threads ont terminé leur tâche, les fenêtres affichant les résultats sont fermées à l'aide de cv2.destroyAllWindows().

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

Cet exemple peut facilement être étendu pour gérer davantage de fichiers vidéo et de modèles en créant plus de threads et en appliquant la même méthodologie.

Contribuer de nouveaux suivis#

Tu maîtrises le suivi d'objets multiples et tu as implémenté ou adapté avec succès un algorithme de suivi avec Ultralytics YOLO ? Nous t'invitons à contribuer à notre section Trackers dans ultralytics/cfg/trackers ! Tes applications et solutions du monde réel pourraient être inestimables pour les utilisateurs travaillant sur des tâches de suivi.

En contribuant à cette section, tu aides à élargir la portée des solutions de suivi disponibles dans le cadre d'Ultralytics YOLO, en ajoutant une couche supplémentaire de fonctionnalité et d'utilité pour la communauté.

Pour initier ta contribution, consulte notre Guide de contribution pour des instructions complètes sur la soumission d'une Pull Request (PR) 🛠️. Nous avons hâte de voir ce que tu vas apporter !

Ensemble, améliorons les capacités de suivi de l'écosystème Ultralytics YOLO 🙏 !

FAQ#