Suivi multi-objets avec Ultralytics YOLO#

Dans le domaine de l'analyse vidéo, le suivi d'objets est une tâche essentielle : il permet non seulement d'identifier l'emplacement et la classe des objets dans l'image, mais aussi de conserver un ID unique pour chaque objet détecté au fil de la vidéo. Les possibilités sont illimitées, de la surveillance et de la sécurité à l'analyse sportive en temps réel.

Consulte l'aperçu non publié de YOLO27 pour découvrir les fonctionnalités de suivi prévues.

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

Les sorties des trackers Ultralytics sont cohérentes avec la détection d'objets standard, mais elles ajoutent des ID d'objet. Le suivi des objets dans les flux vidéo et la réalisation d'analyses ultérieures en sont ainsi simplifiés. Voici pourquoi tu devrais envisager Ultralytics YOLO pour tes besoins en 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 et options CLI simples pour une intégration et un déploiement rapides.
• Personnalisation : facile à utiliser avec des modèles YOLO entraînés sur mesure, ce qui permet leur intégration dans des applications spécifiques à un domaine.

Applications concrètes#

Démarrage rapide#

Lance le suivi sur une vidéo avec le tracker TrackTrack par défaut. Pour utiliser un autre tracker, modifie l'argument tracker.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Tracker par défaut (TrackTrack)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)

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

Pour lancer le tracker sur des flux vidéo, utilise un modèle Detect, Segment, Pose ou OBB entraîné, comme YOLO26n, YOLO26n-seg, YOLO26n-pose ou YOLO26n-obb. Tu peux entraîner des modèles personnalisés en local ou avec l'entraînement dans le cloud de la plateforme Ultralytics.

from ultralytics import YOLO

# Charger un modèle officiel ou personnalisé
model = YOLO("yolo26n.pt")  # Charger un modèle Detect officiel
model = YOLO("yolo26n-seg.pt")  # Charger un modèle Segment officiel
model = YOLO("yolo26n-pose.pt")  # Charger un modèle Pose officiel
model = YOLO("path/to/best.pt")  # Charger un modèle entraîné sur mesure

# Effectuer le suivi avec le modèle
results = model.track("https://youtu.be/LNwODJXcvt4", show=True)  # Suivi avec le tracker par défaut
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # avec ByteTrack

Trackers pris en charge#

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

Quel tracker choisir ?#

Suis ce parcours pour choisir un point de départ ; tracktrack.yaml est utilisé si tu ne passes pas tracker :

1. Tu as besoin d'une solution de base rapide et simple ? → ByteTrack (pas de ReID, pas de compensation du mouvement de la caméra, surcharge minimale).
2. Images filmées à la main, par drone ou avec une caméra en mouvement ? → BoT-SORT (ajoute la compensation du mouvement de la caméra et la ReID facultative).
3. Mouvement non linéaire (sports, danse, virages brusques) et pas de ReID ? → OC-SORT (corrections centrées sur les observations, sans coût lié à l'apparence).
4. Scènes encombrées filmées avec une caméra en mouvement, où les changements d'ID sont le principal problème ? → Deep OC-SORT ou TrackTrack (les deux prennent en charge la mise en correspondance facultative des apparences ; TrackTrack ajoute aussi l'association multicritère et la suppression des ID en double).
5. Chevauchements partiels fréquents en temps réel, sans budget pour la ReID ? → FastTracker (variante de ByteTrack sensible aux occultations, avec retour arrière de Kalman).

Changer de tracker#

Passe le nom du fichier de configuration du tracker à 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 Predict, comme conf, iou et show. Pour configurer davantage le modèle, consulte la page Predict.

from ultralytics import YOLO

# Configure les paramètres de suivi et lance le tracker
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.7, show=True)

Configuration personnalisée du tracker#

Ultralytics te permet également d'utiliser un fichier de configuration de tracker modifié. Pour ce faire, copie simplement un fichier de configuration de tracker (par exemple, custom_tracker.yaml) depuis ultralytics/cfg/trackers, puis modifie les configurations de ton choix (à l'exception de tracker_type) selon tes besoins.

from ultralytics import YOLO

# Charge le modèle et lance le tracker avec un fichier de configuration personnalisé
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Arguments communs aux trackers#

Les paramètres suivants sont communs à la plupart des fichiers YAML de tracker ; ils ne figurent pas tous dans chaque configuration :

Arguments propres aux trackers#

Chaque algorithme expose des paramètres supplémentaires en plus des paramètres communs. Consulte les sections consacrées à chaque tracker ci-dessous pour connaître les descriptions et les conseils de réglage, ou consulte directement les fichiers de configuration :

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

Activation de la ré-identification (ReID)#

ReID est désactivé par défaut afin de limiter la surcharge. Active-le en définissant with_reid: True dans un fichier de configuration du tracker.

Options de modèle ReID :

• model: auto — Utilise les caractéristiques natives du détecteur YOLO, avec une surcharge minimale. Idéal si tu as besoin d’un peu de ReID sans trop dégrader les performances. Se rabat sur yolo26n-cls.pt si le détecteur n’expose pas de caractéristiques compatibles.
• Modèle ReID personnalisé — Indique un checkpoint .pt ou un modèle d’embedding exporté compatible, tel que .torchscript, .onnx, .engine, ou un répertoire de modèle OpenVINO, pour model:. Les modèles exportés sont chargés via AutoBackend et doivent produire directement un tenseur d’embedding.

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 : le fichier est téléchargé automatiquement à la première exécution du tracker, comme les poids YOLO — aucune exportation ni aucun téléchargement manuel n’est nécessaire :

# 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 distinct, exporte-le vers un backend plus rapide comme TensorRT :

from torch import nn

from ultralytics import YOLO

# Charger le modèle de classification
model = YOLO("yolo26n-cls.pt")

# Ajouter une couche de pooling moyen
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

# Exporter vers TensorRT
model.export(format="engine", quantize=16, dynamic=True, batch=32)

Une fois l’exportation terminée, indique le chemin du modèle TensorRT dans la configuration de ton tracker.

Détails des trackers#

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

BoT-SORT#

BoT-SORT (Aharon et al., 2022) étend ByteTrack avec la compensation du mouvement de la caméra et la prise en charge facultative de ReID :

• Compensation du mouvement de la caméra (CMC) : une transformation affine estimée à chaque image (flux optique épars par défaut ; ORB / ECC également disponibles) est appliquée aux états de Kalman avant l’association IoU.
• ReID facultatif : les embeddings d’apparence peuvent être combinés à la matrice de coûts. La fonctionnalité est désactivée par défaut ; active-la avec with_reid: True.

Idéal pour : le suivi généraliste, en particulier avec des caméras mobiles. N’ajoute ReID que si des foules de personnes qui se ressemblent provoquent des changements d’ID.

Arguments propres à BoT-SORT :

Conseils de réglage :

• Caméra fixe : définis gmc_method: none pour économiser quelques ms/image.
• Mouvements importants de la caméra : conserve sparseOptFlow ; ecc est plus précis, mais plus lent.
• Foules de personnes qui se ressemblent : active with_reid: True et augmente appearance_thresh (par ex. 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) est le modèle de référence léger. Il combine un filtre de Kalman linéaire et l’IoU dans une association en deux étapes :

• Étape 1 : associer les détections à score élevé aux pistes actives.
• Étape 2 : réessayer d’associer les pistes non appariées aux détections à score faible pour les récupérer après une brève occultation partielle.

Il n’y a ni modèle d’apparence ni compensation du mouvement de la caméra.

Idéal pour : les caméras fixes ou presque fixes lorsque le coût du détecteur prédomine et que tu veux réduire au minimum la surcharge du tracker.

Arguments propres à ByteTrack : aucun en dehors des arguments communs aux trackers.

Conseils de réglage :

• Détecteur bruité : diminue track_low_thresh pour que la deuxième étape dispose de davantage de candidats.
• Détecteur à fort rappel : augmente track_high_thresh pour réduire la fragmentation des ID.
• Scintillement fréquent des ID : augmente track_buffer pour que les pistes manquées brièvement restent actives.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) est une extension de SORT centrée sur les observations. Elle conserve la conception légère de SORT (sans caractéristiques d’apparence) et ajoute trois corrections :

• Réactualisation centrée sur l’observation (ORU) : rejoue une trajectoire virtuelle entre la dernière observation et la détection actuelle, en recalculant la mise à jour de Kalman pour corriger la dérive de la vitesse.
• Inertie centrée sur l’observation (OCM) : pénalise les détections qui se déplacent dans la mauvaise direction à l’aide d’un terme de cohérence de la vitesse.
• Récupération centrée sur l’observation (OCR) : vérifie à nouveau les détections non appariées par rapport aux pistes récemment perdues, en s’appuyant sur leur dernière observation plutôt que sur l’état prédit.

Idéal pour : les mouvements non linéaires sans le coût d’un modèle ReID.

Arguments propres à OC-SORT :

Conseils de réglage :

• Mouvement non linéaire : augmente inertia (par ex. 0.3-0.4).
• Détections éparses : active use_byte: True.
• Longues occultations : augmente track_buffer pour que l’OCR dispose de davantage 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 la compensation du mouvement de la caméra :

• Association basée sur l’apparence : la distance des embeddings cosinus est filtrée selon le chevauchement, puis combinée au coût du mouvement.
• EMA d’apparence dynamique : les embeddings des pistes sont mis à jour avec une EMA dont le facteur de lissage s’adapte à la confiance de la détection.
• Compensation du mouvement de la caméra : les états de Kalman sont recalés d’une image à l’autre à l’aide du flux optique épars, d’ORB ou d’ECC.

Idéal pour : les scènes encombrées ou filmées par une caméra mobile, où les changements d’ID entre des objets visuellement différents mais spatialement proches sont fréquents.

Arguments propres à Deep OC-SORT :

Conseils de réglage :

• Changements d’identité dans les foules : augmente appearance_thresh (par ex. 0.92-0.95) et augmente alpha_fixed_emb pour que les embeddings s’adaptent plus lentement.
• Caméra mobile : définis gmc_method: sparseOptFlow (Deep OC-SORT utilise none par défaut).
• Latence réduite : conserve with_reid: False (valeur par défaut) pour le mouvement et la CMC uniquement ; n’active ReID que si les changements d’ID sont la principale source d’erreurs.

FastTracker#

FastTracker est une variante de ByteTrack qui tient compte des occultations et n’utilise pas de modèle d’apparence :

• Détection des occultations : marque les pistes comme occultées lorsque la couverture par d’autres pistes actives dépasse occ_cover_thresh.
• Retour arrière de Kalman en cas d’occultation : restaure l’état de Kalman à une image antérieure à l’occultation en s’appuyant sur l’historique conservé dans un tampon circulaire.
• Atténuation du mouvement et élargissement de la zone de recherche : la vitesse est atténuée et la bbox prédite est agrandie pendant l’occultation.
• Suppression par IoU à l’initialisation : empêche la création de nouvelles pistes par-dessus des pistes actives.

Idéal pour : les pipelines de détection en temps réel sans étape de suivi dédiée, où les cibles se chevauchent fréquemment (foules, files d’attente, sport).

Arguments propres à FastTracker :

Conseils de réglage :

• Occultations partielles fréquentes : diminue occ_cover_thresh (par ex. 0.5-0.6).
• ID en double autour des chevauchements : diminue init_iou_suppress (par ex. 0.5).
• Occultations longues : augmente occ_reappear_window et track_buffer ensemble.
• Cibles rapides : augmente dampen_motion_occ (pour le rapprocher de 1.0) ; augmente enlarge_bbox_occ uniquement si une zone de recherche plus large améliore la récupération.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) est le tracker par défaut. Il raisonne du point de vue de chaque piste et utilise une association itérative à plusieurs indices :

• Association fondée sur la perspective de la piste (TPA) : combine HMIoU, la distance cosinus ReID facultative, la distance de projection de confiance et la distance angulaire des coins. L’affectation est résolue de manière itérative avec un seuil assoupli.
• Initialisation tenant compte des pistes (TAI) : supprime les créations de pistes en double avant la création d’un nouvel ID.

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

Arguments propres à TrackTrack :

Conseils de réglage :

• Piétons dans des scènes encombrées : diminue tai_thr (par ex. 0.45) pour supprimer davantage de créations en double ; augmente track_buffer pour les occultations plus longues.
• Mouvements rapides de la caméra : garde gmc_method: sparseOptFlow activé.
• Objets petits ou rapides : augmente légèrement angle_weight et diminue min_track_len.
• Active ReID uniquement si nécessaire : cette option augmente le coût d’inférence ; pour les occultations courtes, le coût multi-indices par défaut est généralement suffisant.

Avec les modèles Segment et Pose, TrackTrack ignore la récupération de détections avec un NMS permissif afin que les masques et les points clés restent alignés sur leurs détections.

Exemples Python#

Boucle avec persistance des pistes#

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

import cv2

from ultralytics import YOLO

# Charger le modèle YOLO26
model = YOLO("yolo26n.pt")

# Ouvrir le fichier vidéo
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Parcourir les images vidéo
while cap.isOpened():
    # Lire une image de la vidéo
    success, frame = cap.read()

    if success:
        # Effectuer le suivi avec YOLO26 sur l’image et conserver les pistes entre les images
        # et utiliser le moteur de suivi BoT-SORT
        results = model.track(frame, persist=True, tracker="botsort.yaml")

        # Visualiser les résultats sur l’image
        annotated_frame = results[0].plot()

        # Afficher l’image annotée
        cv2.imshow("YOLO26 Tracking", annotated_frame)

        # Interrompre la boucle si « q » est pressé
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Interrompre la boucle si la fin de la vidéo est atteinte
        break

# Libérer l’objet de capture vidéo et fermer la fenêtre d’affichage
cap.release()
cv2.destroyAllWindows()

Note le passage de model(frame) à model.track(frame), qui active le suivi d’objets au lieu d’une simple détection. Ce script modifié exécute le tracker sur chaque image de la vidéo, visualise les résultats et les affiche dans une fenêtre. Tu peux quitter la boucle en appuyant sur « q ».

Tracer les pistes au fil du temps#

La visualisation des pistes d’objets sur des images consécutives peut fournir des informations précieuses sur les schémas de déplacement et le comportement des objets détectés dans une vidéo. Avec Ultralytics YOLO26, le tracé de ces pistes est simple et efficace.

Dans l’exemple suivant, nous montrons comment utiliser les capacités de suivi de YOLO26 pour tracer le déplacement des objets détectés sur plusieurs images vidéo. Ce script ouvre un fichier vidéo, le lit image par image et utilise le modèle YOLO pour identifier et suivre différents objets. En conservant les points centraux des BBox détectées et en les reliant, nous pouvons tracer les trajectoires suivies par les objets.

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Charger le modèle YOLO26
model = YOLO("yolo26n.pt")

# Ouvrir le fichier vidéo
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Stocker l’historique des pistes
track_history = defaultdict(list)

# Parcourir les images vidéo
while cap.isOpened():
    # Lire une image de la vidéo
    success, frame = cap.read()

    if success:
        # Effectuer le suivi avec YOLO26 sur l’image et conserver les pistes entre les images
        result = model.track(frame, persist=True)[0]

        # Récupérer les boîtes et les ID de piste
        if result.boxes and result.boxes.is_track:
            boxes = result.boxes.xywh.cpu()
            track_ids = result.boxes.id.int().cpu().tolist()

            # Visualiser le résultat sur l’image
            frame = result.plot()

            # Tracer les pistes
            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)))  # Point central x, y
                if len(track) > 30:  # conserver 30 pistes pendant 30 images
                    track.pop(0)

                # Tracer les lignes de suivi
                points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                cv2.polylines(frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

        # Afficher l’image annotée
        cv2.imshow("YOLO26 Tracking", frame)

        # Interrompre la boucle si « q » est pressé
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Interrompre la boucle si la fin de la vidéo est atteinte
        break

# Libérer l’objet de capture vidéo et fermer la fenêtre d’affichage
cap.release()
cv2.destroyAllWindows()

Suivi multithread#

Le suivi multithread permet d’effectuer simultanément le suivi d’objets sur plusieurs flux vidéo. Cette approche est particulièrement utile pour traiter plusieurs entrées vidéo, par exemple celles de plusieurs caméras de surveillance, car le traitement simultané peut considérablement 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 tracker simultanément. Chaque thread est chargé d’exécuter le tracker sur un fichier vidéo, et tous les threads s’exécutent en arrière-plan en même temps.

Pour garantir 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 principale de suivi. Cette fonction lit la vidéo image par image, exécute le tracker et enregistre les résultats annotés.

Cet exemple utilise deux modèles différents : yolo26n.pt et yolo26n-seg.pt, qui suivent chacun des objets dans un fichier vidéo différent. Les fichiers vidéo sont indiqués dans SOURCES.

Le paramètre daemon=True de threading.Thread signifie que ces threads seront fermés dès que le programme principal se termine. Nous démarrons ensuite les threads avec start() et utilisons join() pour que le thread principal attende la fin des deux threads de suivi.

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

import threading

import cv2

from ultralytics import YOLO

# Définir les noms des modèles et les sources vidéo
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # vidéo locale, 0 pour la 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

# Créer et démarrer les threads de suivi à l’aide d’une boucle for
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()

# Attendre la fin de tous les threads de suivi
for thread in tracker_threads:
    thread.join()

# Nettoyer et fermer les fenêtres
cv2.destroyAllWindows()

Tu peux facilement étendre cet exemple pour gérer davantage de fichiers vidéo et de modèles en créant d’autres threads et en appliquant la même méthode.

Contribuer de nouveaux trackers#

Tu maîtrises le suivi multi-objets et tu as réussi à implémenter ou à adapter un algorithme de suivi avec Ultralytics YOLO ? Nous t’invitons à contribuer à notre section Trackers dans ultralytics/cfg/trackers ! Tes applications et solutions concrètes pourraient être très utiles aux utilisateurs qui travaillent sur des tâches de suivi.

En contribuant à cette section, tu aides à élargir la gamme de solutions de suivi disponibles dans le framework Ultralytics YOLO, en ajoutant une fonctionnalité et une utilité supplémentaires pour la communauté.

Pour commencer ta contribution, consulte notre Guide de contribution pour obtenir des instructions détaillées sur l’envoi d’une Pull Request (PR) 🛠️. Nous avons hâte de découvrir ta contribution !

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

FAQ#