Commencer

Suivi multi-objets avec Ultralytics YOLO

YOLO multi-object tracking with trajectory paths

Le suivi multi-objets en analyse vidéo identifie la position et la classe des objets dans chaque image, tout en conservant un identifiant unique pour chaque objet détecté au fil de la vidéo. Les applications vont 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.

Trackers : OC-SORT, Deep OC-SORT, FastTracker, TrackTrack

Depuis ultralytics 8.4.63, OC-SORT, Deep OC-SORT, FastTracker et TrackTrack sont disponibles aux côtés de BoT-SORT et ByteTrack.

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

Les résultats des trackers Ultralytics sont cohérents avec la détection d’objets standard, mais ils fournissent en plus les identifiants des objets. Il est ainsi facile de suivre des objets dans des flux vidéo et d’effectuer des analyses ultérieures. Principales raisons d’utiliser Ultralytics YOLO pour le suivi d’objets :

  • Efficacité : traite les flux vidéo en temps réel sans compromettre la précision.
  • Souplesse : prend en charge plusieurs algorithmes de suivi et configurations.
  • 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.


Regarder : Comment effectuer le suivi multi-objets avec Ultralytics YOLO26 | BoT-SORT et ByteTrack | VisionAI 🚀

Applications concrètes#

TransportCommerce de détailAquaculture
Suivi des véhiculesSuivi des personnesSuivi des poissons

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.

Exemple
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 exécuter 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, tous disponibles dans la collection YOLO26 sur Ultralytics Platform. Tu peux entraîner des modèles personnalisés localement ou avec l’entraînement cloud d’Ultralytics Platform.

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

TrackerFichier de configurationModèle de mouvementApparence / ReIDCompensation du mouvement de la caméraGestion des occultations
BoT-SORTbotsort.yamlKalman linéaireFacultatif (with_reid)Configurable (gmc_method)Tampon de suivi + réassociation ReID
ByteTrackbytetrack.yamlKalman linéaireAucunNonRécupération en deux étapes des détections à faible confiance
OC-SORTocsort.yamlKalman centré sur les observationsAucunNonMise à jour ORU, OCM, OCR à partir de la dernière observation
Deep OC-SORTdeepocsort.yamlKalman centré sur les observationsFacultatif (with_reid)Configurable (gmc_method)OC-SORT + EMA d'apparence adaptative facultative
FastTrackerfasttrack.yamlKalman linéaire + retour arrièreAucunNonRetour arrière de Kalman + agrandissement de bbox en cas d'occultation
TrackTracktracktrack.yamlKalman linéaire (NSA)Facultatif (with_reid)Configurable (gmc_method)Association itérative multicritère + TAI

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.

Exemple
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 avec le mode Predict les arguments d’inférence, tels que conf, iou et show.

Exemple
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.5, show=True)

Configuration personnalisée du tracker#

Pour utiliser une configuration de tracker modifiée, copie un fichier de configuration du tracker (par exemple, sous le nom custom_tracker.yaml) depuis ultralytics/cfg/trackers, puis modifie tous les paramètres sauf tracker_type.

Exemple
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 :

Informations sur les seuils du tracker

Les détections dont la valeur est supérieure ou égale à track_high_thresh passent à la première étape d'association. Les détections dont la valeur se situe entre track_low_thresh et track_high_thresh peuvent récupérer des pistes existantes si le tracker sélectionné active l'association à faible confiance, mais elles ne démarrent pas de nouvelles pistes. Les détections dont la valeur est inférieure ou égale à track_low_thresh sont ignorées.

ParamètreValeurs ou plages autoriséesDescription
tracker_typebotsort, bytetrack, ocsort, deepocsort, fasttrack, tracktrackIndique le type de tracker.
track_high_thresh0.0-1.0Seuil de la première association. Il détermine le niveau de confiance requis pour associer une détection à une piste existante.
track_low_thresh0.0-1.0Borne inférieure pour les détections de récupération à faible confiance. OC-SORT et Deep OC-SORT les utilisent uniquement lorsque use_byte: True ; TrackTrack les inclut dans son ensemble d’associations avec pénalité.
new_track_thresh0.0-1.0Seuil pour initialiser une nouvelle piste si la détection ne correspond à aucune piste existante.
track_buffer>=0Nombre d’images pendant lequel les pistes perdues restent actives avant d’être supprimées. Une valeur plus élevée tolère davantage les occultations.
match_thresh0.0-1.0Seuil d’association des pistes. Des valeurs plus élevées rendent l’association moins stricte.
fuse_scoreTrue, FalseIndique s’il faut combiner les scores de confiance avec les distances IoU avant l’association.
gmc_methodsparseOptFlow, orb, sift, ecc, noneMéthode de compensation du mouvement global. Elle permet de prendre en compte les mouvements de la caméra.
proximity_thresh0.0-1.0IoU minimale requise pour qu’une association ReID soit valide. Elle garantit une proximité spatiale avant la prise en compte des caractéristiques d’apparence.
appearance_thresh0.0-1.0Similarité d’apparence normalisée minimale requise pour ReID.
with_reidTrue, FalseActive l’association basée sur l’apparence pour améliorer le suivi en cas d’occultation. Cette fonctionnalité est prise en charge par BoT-SORT, Deep OC-SORT et TrackTrack.
modelauto ou chemin vers un modèle ReID compatibleModèle ReID. auto utilise les caractéristiques natives du backbone YOLO lorsqu’elles sont disponibles ; sinon, il se rabat sur yolo26n-cls.pt. Un encodeur personnalisé peut être un checkpoint .pt ou un modèle exporté, tel que .torchscript, .onnx, .engine, ou un répertoire de modèle OpenVINO.

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 :

Activation de la ré-identification (ReID)#

La réidentification (ReID) est désactivée par défaut pour limiter la surcharge. Active-la 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
Modèletaille
(pixels)
paramètres
(M)
FLOPs
(B)
YOLO26n-reid.onnx4482.82.0
YOLO26s-reid.onnx4487.56.6
YOLO26m-reid.onnx44812.420.1
YOLO26l-reid.onnx44815.325.2
YOLO26x-reid.onnx44832.755.9
ReID est réservé au suivi

Seuls les encodeurs ReID ONNX destinés à la branche d’apparence du tracker sont actuellement disponibles. Les modes ReID train, val et predict, ainsi que les recettes dédiées à l’exportation ReID, sont encore en cours de développement.

Pour de meilleures performances avec un modèle de classification distinct, exporte-le vers un backend plus rapide comme TensorRT :

Exporter un modèle ReID vers 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.



Regarder : Quel traqueur d’objets est le plus performant ? | Vitesse, FPS et stabilité des identifiants | Ultralytics YOLO26 📊

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 :

ParamètreValeurs ou plages autoriséesDescription
gmc_methodsparseOptFlow, orb, sift, ecc, noneBackend de compensation du mouvement de la caméra. sparseOptFlow est la valeur par défaut. none désactive la CMC.
with_reidTrue, FalseActive l’association basée sur l’apparence. Désactivée par défaut.
modelauto ou chemin vers un modèle ReID compatibleauto utilise les caractéristiques natives de YOLO lorsqu’elles sont disponibles ; les modèles personnalisés peuvent être des checkpoints .pt ou des exportations compatibles.
proximity_thresh0.0-1.0IoU minimale requise avant la prise en compte des caractéristiques d’apparence.
appearance_thresh0.0-1.0Similarité d’apparence normalisée minimale requise pour une association ReID. Augmente cette valeur pour rendre l’association plus stricte.

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 :

ParamètreValeurs ou plages autoriséesDescription
delta_t>=1Fenêtre temporelle (en images) utilisée pour calculer la direction de la vitesse dans OCM. Des valeurs plus élevées lissent davantage le résultat.
inertia0.0-1.0Poids du coût de cohérence de la vitesse. Des valeurs plus élevées pénalisent les changements brusques de direction.
use_byteTrue, FalseActive une deuxième passe d’association de type ByteTrack sur les détections à faible confiance.

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 :

ParamètreValeurs ou plages autoriséesDescription
with_reidTrue, FalseActive l’association basée sur l’apparence. Désactivée par défaut.
modelauto ou chemin vers un modèle ReID compatibleauto utilise les caractéristiques natives de YOLO lorsqu’elles sont disponibles ; les modèles personnalisés peuvent être des checkpoints .pt ou des exportations compatibles.
proximity_thresh0.0-1.0IoU minimale requise avant la prise en compte des caractéristiques d’apparence.
appearance_thresh0.0-1.0Similarité d’apparence normalisée minimale requise pour une association ReID.
alpha_fixed_emb0.0-1.0Facteur EMA de base pour la mise à jour des embeddings des pistes. Des valeurs plus élevées préservent plus longtemps l’ancien embedding.
gmc_methodsparseOptFlow, orb, sift, ecc, noneMéthode de compensation du mouvement global.
delta_t>=1Fenêtre temporelle (en images) utilisée pour calculer la direction de la vitesse dans OCM (héritée d’OC-SORT).
inertia0.0-1.0Poids du coût de cohérence de la vitesse (hérité d’OC-SORT).
use_byteTrue, FalseActive une deuxième association de type ByteTrack sur les détections à faible confiance (héritée d’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 :

ParamètreValeurs ou plages autoriséesDescription
reset_velocity_offset_occ>=0Nombre d’images d’historique à remonter pour restaurer la vitesse de Kalman au début de l’occlusion.
reset_pos_offset_occ>=0Nombre d’images d’historique à remonter pour restaurer la position de Kalman au début de l’occlusion.
enlarge_bbox_occ>=1.0Facteur d’échelle appliqué à la hauteur de la bbox prédite pendant l’occlusion (la largeur est mise à l’échelle selon le rapport d’aspect XYAH).
dampen_motion_occ0.0-1.0Multiplicateur de vitesse pendant l’occlusion. Des valeurs plus faibles ralentissent la piste pendant l’occlusion.
active_occ_to_lost_thresh>=1Nombre maximal d’images consécutives d’occlusion avant qu’une piste active passe à l’état perdu.
occ_cover_thresh0.0-1.0Fraction de la surface d’une piste couverte par une autre piste active pour déclarer une occlusion.
occ_reappear_window>=0Nombre d’images pendant lequel une piste perdue récemment occultée reste plus facilement réidentifiable.
init_iou_suppress0.0-1.0Empêche l’initialisation d’une nouvelle piste si son IoU avec une piste active dépasse cette valeur. Définis 1.0 pour désactiver cette option.

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 :

ParamètreValeurs ou plages autoriséesDescription
iou_weight0.0-1.0Poids de la distance HMIoU lorsque ReID est activé ; sinon, HMIoU est utilisé directement.
reid_weight0.0-1.0Poids de la distance cosinus ReID lorsque ReID est activé ; sinon, cette distance est ignorée.
conf_weight0.0-1.0Poids de la distance de projection de confiance.
angle_weight0.0-1.0Poids de la distance angulaire des coins.
penalty_p0.0-1.0Pénalité de coût pour les détections à faible confiance.
penalty_q0.0-1.0Pénalité de coût pour les détections récupérées par le NMS secondaire.
reduce_step0.0-1.0Assouplissement du seuil de correspondance à chaque itération.
tai_thr0.0-1.0Seuil IoU du NMS d’initialisation tenant compte des pistes.
min_track_len>=0Longueur minimale de l’historique avant qu’une nouvelle piste soit confirmée.
lost_match_thr0.0-1.0Seuil de coût plus permissif pour la passe de réassociation des pistes perdues ; 0 désactive cette option.
with_reidTrue, FalseActive la correspondance d’apparence par cosinus ReID (utilise les caractéristiques YOLO natives). Désactivée par défaut.
modelauto ou chemin vers un modèle ReID compatibleauto utilise les caractéristiques natives de YOLO lorsqu’elles sont disponibles ; les modèles personnalisés peuvent être des checkpoints .pt ou des exportations compatibles.
gmc_methodsparseOptFlow, orb, sift, ecc, noneMéthode de compensation du mouvement global.

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#



À voir : Comment créer un suivi interactif d’objets avec Ultralytics YOLO26 : crée-le en quelques minutes | 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.

Persistance des pistes et choix d’un tracker

Utilise persist=True uniquement lorsque tu transmets à model.track() des images consécutives provenant du même flux vidéo. Le tracker peut ainsi réutiliser l’état des images précédentes et conserver des ID de piste cohérents au fil du temps. N’utilise pas persist=True avec des images sans lien entre elles ou un autre flux, car l’état des pistes précédentes pourrait être conservé.

Tu peux aussi choisir un moteur de suivi en transmettant un fichier de configuration de tracker, tel que tracker="botsort.yaml", tracker="bytetrack.yaml" ou tracker="tracktrack.yaml".

Boucle for avec suivi en continu
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 de la 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 trajectoires d’objets sur des images successives peut fournir des informations précieuses sur les déplacements et le comportement des objets détectés dans une vidéo. Ultralytics YOLO26 facilite le tracé de ces trajectoires.

L’exemple suivant utilise le suivi YOLO26 pour tracer le déplacement des objets détectés sur plusieurs images vidéo. Le script ouvre un fichier vidéo, le lit image par image et utilise le modèle YOLO pour identifier et suivre les objets. En conservant les points centraux des boîtes englobantes détectées et en les reliant, il trace les trajectoires suivies par les objets.

Tracé des pistes sur plusieurs images vidéo
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 de suivre simultanément des objets dans plusieurs flux vidéo. C’est particulièrement utile pour traiter plusieurs sources vidéo, par exemple celles de plusieurs caméras de surveillance, car le traitement simultané améliore le débit.

Le script Python ci-dessous utilise le module Python threading pour exécuter plusieurs instances du tracker simultanément. Chaque thread exécute le tracker sur une source vidéo, et tous les threads s’exécutent en arrière-plan en même temps.

Pour que chaque thread reçoive les bons paramètres (le modèle à utiliser et la source vidéo), le script définit 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 une source différente : un fichier vidéo local et une webcam. Les sources sont spécifiées 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().

Implémentation du suivi multithread
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#

Si tu as implémenté ou adapté un algorithme de suivi multi-objets pour Ultralytics YOLO, pense à le contribuer à ultralytics/trackers avec une configuration correspondante dans ultralytics/cfg/trackers. Les contributions élargissent les options de suivi accessibles à toute la communauté.

FAQ#

  • Le suivi multi-objets dans l’analyse vidéo consiste à identifier les objets et à conserver un ID unique pour chaque objet détecté d’une image vidéo à l’autre. Ultralytics YOLO prend en charge cette fonction en proposant le suivi en temps réel avec des ID d’objet, ce qui facilite des tâches comme la surveillance de sécurité et l’analyse sportive. Le système utilise des trackers tels que BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker et TrackTrack, configurables à l’aide de fichiers YAML.

  • Non. Les fichiers standard .pt d’Ultralytics stockent les poids du modèle YOLO, tandis que le tracker est créé au moment de l’inférence par model.track(). Les ID de piste dépendent de l’état du tracker entre des images consécutives ; une image seule peut donc renvoyer des détections telles que des boîtes, des classes et des niveaux de confiance, mais ne peut pas produire à elle seule des ID de suivi persistants pertinents.

    Pour le déploiement, regroupe le détecteur et le tracker dans ton application et appelle model.track() image par image, avec persist=True lorsque les images proviennent du même flux vidéo. Utilise des instances distinctes du modèle ou du tracker pour les flux sans lien entre eux afin que l’état ne soit pas conservé d’une vidéo à l’autre.

  • Tu peux configurer un tracker personnalisé en copiant un fichier de configuration de tracker existant (par ex. custom_tracker.yaml) depuis le répertoire de configuration des trackers d’Ultralytics, puis en modifiant les paramètres selon tes besoins, à l’exception de tracker_type. Utilise ce fichier dans ton modèle de suivi comme suit :

    Exemple
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")
  • Pour effectuer simultanément le suivi d’objets sur plusieurs flux vidéo, tu peux utiliser le module threading de Python. Chaque thread gère un flux vidéo distinct. Voici un exemple de configuration :

    Suivi multithread
    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()
  • Le suivi multi-objets avec Ultralytics YOLO a de nombreuses applications, notamment :

    • Transports : suivi des véhicules pour la gestion du trafic et la conduite autonome.
    • Commerce de détail : suivi des personnes pour l’analyse en magasin et la sécurité.
    • Aquaculture : suivi des poissons pour surveiller les milieux aquatiques.
    • Analyse sportive : suivi des joueurs et du matériel pour l’analyse des performances.
    • Systèmes de sécurité : surveillance des activités suspectes et création d’alarmes de sécurité.

    Ces applications tirent parti de la capacité d'Ultralytics YOLO à traiter en temps réel des vidéos à haute fréquence d'images avec une grande précision.

  • Pour visualiser les pistes d’objets sur plusieurs images vidéo, tu peux utiliser les fonctionnalités de suivi du modèle YOLO avec OpenCV afin de tracer les trajectoires des objets détectés. Voici un exemple de script qui montre comment procéder :

    Tracé des pistes sur plusieurs images vidéo
    from collections import defaultdict
    
    import cv2
    import numpy as np
    
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    video_path = "path/to/video.mp4"
    cap = cv2.VideoCapture(video_path)
    track_history = defaultdict(list)
    
    while cap.isOpened():
        success, frame = cap.read()
        if success:
            result = model.track(frame, persist=True)[0]
            annotated_frame = result.plot()
            if result.boxes and result.boxes.is_track:
                boxes = result.boxes.xywh.cpu()
                track_ids = result.boxes.id.int().cpu().tolist()
                for box, track_id in zip(boxes, track_ids):
                    x, y, w, h = box
                    track = track_history[track_id]
                    track.append((float(x), float(y)))
                    if len(track) > 30:
                        track.pop(0)
                    points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                    cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
            cv2.imshow("YOLO26 Tracking", annotated_frame)
            if cv2.waitKey(1) & 0xFF == ord("q"):
                break
        else:
            break
    cap.release()
    cv2.destroyAllWindows()

    Ce script tracera les lignes de suivi représentant les trajectoires des objets suivis au fil du temps, et fournira ainsi des informations précieuses sur le comportement et les schémas de déplacement des objets.

Commentaires679

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. bhaskar2443053GitHub

    I’m using YOLO-Pose to detect and track people throughout ~1-hour videos and need each person to keep the same ID. I already have high-quality ground-truth tracks from a SAM-based tracker.

    Do you have a script that can fine-tune YOLO-Pose (and its tracker/Re-ID parameters) against this ground truth to squeeze out the best IDF1 or HOTA scores ?

    1
    1. maxexplorerGitHub

      Hi!

      Thank you for your great work on YOLO and tracking integration. We are using YOLO with ByteTrack/BoT-SORT for object counting and tracking and want to improve ID stability.

      1. We notice that sometimes, even when the object visually looks the same and the scene and motion are stable, the track_id changes. What parameters or reasons should we check to understand why the ID changes unexpectedly?

      2. Is the match_thresh parameter based on IoU, and is it possible to print or visualize the IoU used during matching for debugging?

      3. Is there a way to output Kalman-predicted boxes of lost tracks so we can analyze them?

      4. Could increasing the video FPS improve tracking and IoU consistency, or is this mainly related to detection stability and parameter tuning?

      5. Does ByteTrack or BoT-SORT use a min_hits parameter before confirming tracks, or are tracks confirmed immediately after creation?

      6. If a track is lost, can a new ID only be assigned on the second frame after reappearance if conf > new_track_thresh and then conf > track_high_thresh, or can it happen immediately on the first detection?

      7. Is the track_buffer parameter the number of frames a track is kept using Kalman prediction after it is lost before being deleted?

      8. Do you have any tips to improve tracking stability and avoid unnecessary ID switches?

      Thank you for your support!

    2. Glenn JocherUltralytics

      @bhaskar2443053 currently there isn't a built-in script for fine-tuning YOLO-Pose tracking parameters against ground truth. You would need to implement custom evaluation using libraries like TrackEval or MOTChallenge to compute IDF1/HOTA scores and optimize tracker parameters iteratively.

      @maxexplorer great questions about tracking stability! Here are the key points:

      1. ID changes typically occur due to low IoU between predicted and detected boxes, occlusions, or threshold mismatches. Check track_high_thresh and match_thresh in your tracker config.

      2. match_thresh is indeed IoU-based. For debugging, you can add logging to the tracker code, but there's no built-in visualization.

      3. Kalman predictions aren't directly exposed, but you can access them by modifying the tracker implementation.

      4. Higher FPS generally improves tracking by reducing inter-frame motion, making associations more reliable.

      5. Both trackers use confirmation logic - tracks need to meet certain criteria before being confirmed as valid tracks.

      6. New tracks can be assigned immediately if detection confidence exceeds new_track_thresh.

      7. Correct - track_buffer maintains lost tracks for that many frames using prediction.

      8. For stability: increase track_buffer, adjust match_thresh based on your scenario, and ensure consistent detection quality with appropriate conf thresholds.

      For detailed parameter tuning, refer to the tracker configuration files and our tracking documentation.

  2. rohith-aiunikaGitHub(modifié)

    Hi YOLO Team, I've been using the following Python script to track objects with my YOLOv8 model: from ultralytics import YOLO

    model = YOLO(r"/home/best_pt_files/v1.0.2.pt") results = model.track(r"/home/video.MP4", save=False, stream=False)

    However, I noticed that my GPU memory usage gradually increases, leading to an "out of memory" error before the video finishes processing. Interestingly, when I use the following command from the terminal, the entire video tracks successfully without excessive GPU memory consumption: yolo track model=/home/best_pt_files/1.0.2.pt source=/home/video.MP4

    Previously, the Python script worked without any issues. The memory issue has only recently started occurring. Could you please help me understand the possible reasons for this memory increase and how to address it?

    i have experimented with persist= True and False,stream = true and false, show = true and false also but the issue is still there

    1
    1. Glenn JocherUltralytics

      @rohith-aiunika thanks for reporting this. The memory buildup in Python scripts (but not CLI) typically occurs when not using streaming mode. To match the CLI's memory behavior, modify your Python script to process frames iteratively using stream=True:

      from ultralytics import YOLO
      
      model = YOLO("/home/best_pt_files/v1.0.2.pt")
      for result in model.track("/home/video.MP4", stream=True):  # Process frames iteratively
          pass  # Add your frame processing logic here

      This streams frames sequentially like the CLI, preventing memory accumulation. For more details, see the streaming implementation in our Tracking documentation. Let us know if this resolves the issue!

    2. rohith-aiunikaGitHub

      i have used stream = True, then the code is just executing without showing error and without tracking also

    3. Glenn JocherUltralytics

      @rohith-aiunika thanks for the update. Let's ensure you're properly iterating through streaming results. Try adding a processing loop like this:

      for result in model.track(source=video_path, stream=True):
          annotated_frame = result[0].plot()
          cv2.imshow('Tracking', annotated_frame)
          if cv2.waitKey(1) == ord('q'):
              break

      This actively processes each frame and displays tracking annotations. If issues persist, you might need to verify your video source format using our supported inference sources documentation.

  3. mwaselaGitHub

    Hello, Made a custom model that i can successfully run and with a well tweaked confidence filter, am getting good results.

    Now Ive wrapped the classification and tracking functionality into a flask app, that returns the count ID's when accessed by a REST call like get, meaning it can be accessed by a separate app for processing and stuff. I want to be able to reset the counting through some other request. My camera feed is always live, i need a way to reset the track id's to zero when neccessary, they just keep counting until i exit the program.

    1
    1. Glenn JocherUltralytics

      @mwasela hello,

      It's great to hear that your custom model is performing well. To reset the tracking IDs in your Flask app, you can implement a mechanism to reinitialize the tracker state upon receiving a specific request. This can be done by resetting the tracker object or reloading the model within your tracking function.

      For more detailed guidance on configuring and using trackers, please refer to our documentation: Multi-Object Tracking with Ultralytics YOLO.

  4. Orziqulov-JavohirGitHub

    I really need help to do this programm: I wanna select region via mouse "dangerous zone" Track detected person, If person enters this zone crop and save person's photo Can you show me pls how to do it for 10 cameras, my gpu is RTX 3080TI

    1
    1. Orziqulov-JavohirGitHub

      import cv2 from ultralytics import YOLO import time

      Load the YOLOv8 model

      model = YOLO("yolov8n.pt") # pretrained YOLOv8n model

      Initialize video capture for multiple cameras

      camera_ids = [

      'rtsp://admin:admin12345@172.17.67.20:554',

      'rtsp://admin:admin12345@172.17.67.16:554', 'rtsp://admin:admin12345@172.17.67.18:554', 'rtsp://admin:admin12345@172.17.67.19:554', 'rtsp://admin:admin12345@172.17.67.17:554', 'rtsp://admin:admin12345@172.17.67.21:554', 'rtsp://admin:admin12345@172.17.67.17:554', 'rtsp://admin:admin12345@172.17.67.21:554', 'rtsp://admin:admin12345@172.17.67.17:554',
      ]

      caps = [cv2.VideoCapture(camera_id) for camera_id in camera_ids]

      Open the video file

      roi_start = [(0, 0)] * len(caps) roi_end = [(0, 0)] * len(caps) drawing = [False] * len(caps)

      tracked_persons = [[] for _ in range(len(caps))] # List to track persons in dangerous zones

      def draw_rectangle(event, x, y, flags, param): global roi_start, roi_end, drawing idx = param # Use param to identify the camera index if event == cv2.EVENT_LBUTTONDOWN: drawing[idx] = True roi_start[idx] = (x, y) roi_end[idx] = (x, y) print(f"Camera {idx}: Started drawing rectangle at: {roi_start[idx]}") elif event == cv2.EVENT_MOUSEMOVE: if drawing[idx]: roi_end[idx] = (x, y) print(f"Camera {idx}: Updated rectangle end to: {roi_end[idx]}") elif event == cv2.EVENT_LBUTTONUP: drawing[idx] = False roi_end[idx] = (x, y) print(f"Camera {idx}: Finished drawing rectangle at: {roi_end[idx]}")

      Create a window and set mouse callback for each camera

      for idx in range(len(caps)): window_name = f'Video {idx}' cv2.namedWindow(window_name) cv2.setMouseCallback(window_name, draw_rectangle, idx)

      def is_inside_roi(x, y, roi_start, roi_end): x1, y1 = roi_start x2, y2 = roi_end return min(x1, x2) <= x <= max(x1, x2) and min(y1, y2) <= y <= max(y1, y2)

      while True: frames = [] for cap in caps: ret, frame = cap.read() if not ret: continue # frame = cv2.resize(frame, (640, 480)) frames.append(frame)

      for idx, frame in enumerate(frames):
          window_name = f'Video {idx}'
          
          # Draw the ROI rectangle on the frame
          if drawing[idx] or roi_start[idx] != roi_end[idx]:
              cv2.rectangle(frame, roi_start[idx], roi_end[idx], (0, 255, 0), 2)
              cv2.putText(frame, "Dangerous Zone", (roi_start[idx][0], roi_start[idx][1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
      
          # Run YOLOv8 tracking on the frame, persisting tracks between frames
          results = model.track(frame, tracker="bytetrack.yaml", persist=True)
      
          for result in results:
              boxes = result.boxes
      
              for box in boxes:
                  x1, y1, x2, y2 = box.xyxy.tolist()[0][:4]
                  cls = box.cls.tolist()[0]
                  if cls == 0:  # Person class in COCO dataset
                      # Check if the center of the person is inside the ROI
                      cx, cy = int((x1 + x2) / 2), int((y1 + y2) / 2)
                      if is_inside_roi(cx, cy, roi_start[idx], roi_end[idx]):
                          # Check if this person is already tracked
                          person_id = box.id.tolist()[0] if box.id is not None else None
                          
                          if person_id not in tracked_persons[idx]:
                              tracked_persons[idx].append(person_id)
                              # Crop and save the frame
                              crop = frame[int(y1):int(y2), int(x1):int(x2)]
                              cv2.imwrite(f"cropped_camera{idx}_person{person_id}_{int(time.time())}.jpg", crop)
                              # Draw a label on the person
                              cv2.putText(frame, "Person in Dangerous Zone", (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
                              cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)
      
          cv2.imshow(window_name, frame)
      
      if cv2.waitKey(1) & 0xFF == ord('q'):
          break

      Release all video captures

      for cap in caps: cap.release() cv2.destroyAllWindows()

    2. Glenn JocherUltralytics

      Your approach looks solid for setting up a security program to track and save images of individuals entering a designated "dangerous zone" across multiple cameras. To enhance your implementation, ensure you're using the latest versions of the Ultralytics package for optimal performance and bug fixes. For more detailed guidance on tracking configurations and additional features, you can refer to the Ultralytics tracking documentation. If you encounter any specific issues or need further assistance, feel free to ask!

    3. mariem158GitHub

      File "", line 91 results = model.track(frame, persist=True, tracker="botsort.yaml") ^ IndentationError: unexpected indent COMMENT CORRIGER CETTE ERREUR

    4. Glenn JocherUltralytics

      The error you're encountering is due to an unexpected indent in your code. Ensure that the indentation is consistent throughout your script. If the issue persists, please verify it with the latest version of the Ultralytics package. For more details on tracking configurations, you can refer to the Ultralytics tracking documentation.

  5. GKYofficeGitHub

    How can I get the tracking metrics of a tracker such as MOTA, IDF1, etc.

    1
    1. GKYofficeGitHub

      Can I set the parameter ''save_txt'' to True in the track function, and then write code to evaluate the tracking data?

    2. Paula DerrengerUltralytics

      Currently, the Ultralytics YOLO framework doesn't provide built-in functionality for computing tracking metrics like MOTA or IDF1 directly through the API or command line. However, you can utilize external libraries such as MOTChallenge eval for calculating these metrics.

      After running your tracking with YOLOv8, you'd typically export your tracking results in a format compatible with these libraries (usually a .txt format with frame ID, object ID, bounding boxes, etc.). Then, use the external library to compute the desired metrics by providing it with both the ground truth and your results file.

      Here's a generic example on how you might save tracking results (modify based on your actual use case):

      from ultralytics import YOLO
      
      # Initialize and load your model
      model = YOLO("path/to/your/model.pt")
      
      # Tracking
      results = model.track(source='path/to/video.mp4', save_txt=True, project='runs/track', name='exp')
      
      # results are saved in 'runs/track/exp' in a format that can be used with MOTChallenge eval tools

      Afterwards, follow the documentation of the MOTChallenge eval toolkit to compute the metrics using the outputs stored in 'runs/track/exp'.

      If you encounter any specific issues while implementing this, feel free to ask!🛠️

  6. AdadAlShababGitHub

    Can I run two models simultaneously in one video? Ex: model = YOLO('E:/Ultralytics/best.pt') model = YOLO('yolov8m-pose.pt') results = model.track(source="file.mp4", show=True, conf=0.3, save=False) results = model.track(source="file.mp4", show=True, conf=0.3, save=False)

    I want that two models will works simultaneously with cumulative results? Is it possible? Please let me know. Thanks in advance!!

    1
    1. Paula DerrengerUltralytics

      @AdadAlShabab yes, you can run two models simultaneously on one video, but you'll need to manage the inference in a way that allows both models to process the video frames concurrently. Here's a simplified example using threading to achieve this:

      import threading
      from ultralytics import YOLO
      
      # Load the models
      model1 = YOLO('E:/Ultralytics/best.pt')
      model2 = YOLO('yolov8m-pose.pt')
      
      # Function to run tracking
      def track_video(model, source, conf, show, save):
          results = model.track(source=source, show=show, conf=conf, save=save)
          # Process results here or return them
      
      # Create threads for each model
      thread1 = threading.Thread(target=track_video, args=(model1, "file.mp4", 0.3, True, False))
      thread2 = threading.Thread(target=track_video, args=(model2, "file.mp4", 0.3, True, False))
      
      # Start the threads
      thread1.start()
      thread2.start()
      
      # Wait for both threads to finish
      thread1.join()
      thread2.join()

      This script will run both models in separate threads. If you want to combine the results from both models, you'll need to implement a mechanism to synchronize and merge the results from both threads. Keep in mind that displaying the results (show=True) from two threads might not work as expected, and you might need to handle the visualization separately.

      Remember to handle the GPU memory usage carefully, as running two models simultaneously will require more memory. If you encounter any issues, consider running the models sequentially or on separate GPUs if available.

      4
  7. Journey2-20GitHub

    Hello I'm newer to Opencv and I'm trying to run a tracking camera for airsoft. How would i select specific bounding boxes?

    1. Paula DerrengerUltralytics

      Use model.track(frame, persist=True) and inspect results[0].boxes.xyxy with results[0].boxes.id; select the box containing your OpenCV mouse-click coordinates, store its track ID, then process or draw only boxes whose boxes.id matches that ID. Feel free to continue posting questions here so the Ultralytics team can help.

  8. yashpatel2010GitHub

    In my jetson orin nano super developer kit with jetpack6.1 and deepstream7.1 i want to do cross camera person tracking. Is there any default way in deepstream configs to do it? Or any other lightweight thing that can be easily doable in jetson orin nano 8 gb super dev kit.

    1. Glenn JocherUltralytics

      Ultralytics track is single-camera MOT, so cross-camera person IDs are not built in; on DeepStream 7.1 the practical Orin Nano path is NvDeepSORT/ReID per stream plus downstream association from the exported embeddings described in the DeepStream gst-nvtracker docs, or NVIDIA’s separate Multi-Camera Tracking workflow for full MTMC. Please keep the details here in Discussions and share your current tracker config if you want a minimal setup suggestion. (docs.nvidia.com)

  9. anvi97GitHub(modifié)

    Hi @glenn-jocher,

    I am building a road surface detection system using YOLO segmentation.

    My pipeline:

    Apply bird eye view using cv2.getPerspectiveTransform()

    Mask only road area

    Detect potholes, zebra crossings, and speed bumps

    I am facing the following issues:

    1️⃣ Overlapping Potholes Not Merging Properly

    I want overlapping potholes to merge into one bounding box.

    In many cases it works, but sometimes:

    Two boxes are still shown for the same pothole

    Even when they overlap visually

    I am using YOLO with:

    results = model(frame, conf=0.45, iou=0.4)

    Is YOLO’s internal NMS preventing full merging? Should I apply custom merging after inference? Is segmentation-based merging better than bounding box merging for potholes?

    2️⃣ Object Size Changing After Bird Eye View

    I calculate pothole size using:

    pixels_per_foot = 220

    But I selected this value randomly (no real-world measurement).

    Because of this:

    Object size changes depending on frame position

    Same pothole appears different size

    Is it correct that without real-world calibration, size cannot be accurate? What is the correct method to calculate real-world size in a monocular dashcam setup?

    3️⃣ Zebra Crossing vs Black–White Speed Bump Confusion

    Black–white speed bumps are getting confused with zebra crossings because both have parallel white-black stripes.

    Currently I am detecting only yellow speed bumps to avoid confusion.

    What is the better approach to separate them?

    Use segmentation instead of boxes?

    Add geometry-based filtering?

    Train with more hard-negative examples?

    1. anvi97GitHub

      this is my code ..... from ultralytics import YOLO import cv2 import numpy as np

      model = YOLO("runs/segment/pothole_seg_model3/weights/best.pt") pixels_per_foot = 220

      video_path = "sample_video.mp4" cap = cv2.VideoCapture(video_path)

      if not cap.isOpened(): print(" Cannot open video") exit()

      width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = cap.get(cv2.CAP_PROP_FPS) or 25.0

      fourcc = cv2.VideoWriter_fourcc(*'avc1') out = cv2.VideoWriter("pothole5.mp4", fourcc, fps, (width, height))

      STRETCH_AMOUNT = 50

      src = np.float32([ [0, height],
      [width, height],
      [922, 183],
      [265, 183]
      ])

      dst = np.float32([ [0, height], [width, height], [width + STRETCH_AMOUNT, 0], [0 - STRETCH_AMOUNT, 0] ])

      matrix = cv2.getPerspectiveTransform(src, dst) def compute_iou(box1, box2): x1 = max(box1[0], box2[0]) y1 = max(box1[1], box2[1]) x2 = min(box1[2], box2[2]) y2 = min(box1[3], box2[3])

      inter_area = max(0, x2 - x1) * max(0, y2 - y1)
      
      box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
      box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
      
      union = box1_area + box2_area - inter_area
      
      if union == 0:
          return 0
      
      return inter_area / union

      def should_merge(box1, box2, iou_thresh=0.1, dist_thresh=150): # Containment check - if one box is inside the other if (box1[0] >= box2[0] and box1[1] >= box2[1] and box1[2] <= box2[2] and box1[3] <= box2[3]): return True if (box2[0] >= box1[0] and box2[1] >= box1[1] and box2[2] <= box1[2] and box2[3] <= box1[3]): return True

      iou = compute_iou(box1, box2)
      if iou > iou_thresh:
          return True
      
      cx1, cy1 = (box1[0]+box1[2])/2, (box1[1]+box1[3])/2
      cx2, cy2 = (box2[0]+box2[2])/2, (box2[1]+box2[3])/2
      
      if np.sqrt((cx1-cx2)**2 + (cy1-cy2)**2) < dist_thresh:
          return True
      
      return False

      while True: ret, frame = cap.read() if not ret: break

      bird_eye = cv2.warpPerspective(frame, matrix, (width, height))
      
      results = model(bird_eye, conf=0.45, iou=0.4)[0]
      annotated = results.plot()
      
      if results.boxes is not None:
          for box in results.boxes:
              cls_id = int(box.cls.item())
      
              if cls_id == 0:  # pothole only
                  x1, y1, x2, y2 = map(int, box.xyxy.cpu().numpy()[0])
      
                  w_px = x2 - x1
                  h_px = y2 - y1
      
                  w_ft = w_px / pixels_per_foot
                  h_ft = h_px / pixels_per_foot
      
                  label = f"{w_ft:.2f}ft x {h_ft:.2f}ft"
      
                  cv2.putText(
                      annotated,
                      label,
                      (x1, y1 - 15),
                      cv2.FONT_HERSHEY_SIMPLEX,
                      0.6,
                      (0, 255, 255),
                      2
                  )
      
      cv2.imshow("Bird Eye + Pothole Detection", annotated)
      out.write(annotated)
      
      if cv2.waitKey(1) & 0xFF == 27:
          break

      cap.release() out.release() cv2.destroyAllWindows()

    2. Glenn JocherUltralytics

      For (1), YOLO’s NMS will only suppress duplicate detections based on iou=...—it won’t “merge” two overlapping detections into a larger union box, and in your snippet compute_iou() / should_merge() aren’t actually applied to results.boxes, so you’re still visualizing the raw post-NMS output; since you’re using a Segment model, the most robust way to merge “split” potholes is to union the pothole masks and re-extract connected components (then box/measure those) rather than trying to union boxes.

      import cv2
      import numpy as np
      
      r = model(bird_eye, conf=0.45, iou=0.4)[0]
      
      if r.masks is not None and r.boxes is not None:
          cls = r.boxes.cls.int().cpu().numpy()
          pothole_idx = np.where(cls == 0)[0]
          if pothole_idx.size:
              m = r.masks.data[pothole_idx].cpu().numpy()  # (N,H,W), 0/1
              union = (m.sum(0) > 0).astype(np.uint8) * 255
              n, labels = cv2.connectedComponents(union)
              for k in range(1, n):
                  ys, xs = np.where(labels == k)
                  x1, y1, x2, y2 = xs.min(), ys.min(), xs.max(), ys.max()
                  cv2.rectangle(bird_eye, (x1, y1), (x2, y2), (0, 255, 255), 2)

      For (2), yes—without real-world calibration (and a valid “road plane” assumption), pixels_per_foot=220 can’t be physically meaningful, and even with a BEV warp you only get consistent scale if your homography is tied to metric coordinates; the usual monocular approach is: calibrate camera intrinsics, estimate the road plane, build a homography to a top-down plane in real units (or derive scale from at least one known road-plane measurement like lane width/stripe spacing), then measure in the BEV plane.

      For (3), the best fix is usually data: train both classes explicitly with lots of “hard negatives” (zebra crossings that look like bumps and vice versa) and keep labels consistent; segmentation often helps because you can then add simple shape/location constraints on the mask (zebra = large repeated pattern region, bump = single narrow band across lane) and optionally smooth decisions over time (if you’re doing video, using model.track(..., persist=True) from the Track mode docs can help stabilize per-frame flicker, even though it won’t merge instances within a frame).

      If you can paste !yolo checks output and one representative frame (plus what you consider the “correct” merged result), I can suggest concrete thresholds/post-processing for your exact outputs.

    3. anvi97GitHub

      Representative frame In the attached frame:

      The large water-filled pothole on the left should be treated as a single instance.

      The small region in the top-left corner (currently detected as separate) should be merged with the large region.

      Essentially, all visually continuous damaged area should result in one bounding box / one connected component.

      Currently:

      Mask union + connected components splits them due to small segmentation gaps

      Goal:

      Treat visually continuous pothole surface as one instance for measurement stability.

    4. Glenn JocherUltralytics

      That split is expected because connectedComponents() treats any 1–2 px “mask hole” as a hard break, so add a small gap-closing step on the union mask (morphological close / dilate→erode) before components, with the kernel sized to the largest gap you still consider “visually continuous” (see Ultralytics YOLO segmentation docs for more mask/seg usage details):

      # union: uint8 {0,255}
      union = (m.sum(0) > 0).astype(np.uint8) * 255
      
      # bridge small gaps (tune kernel size to your expected mask discontinuities)
      k_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (25, 25))
      union_closed = cv2.morphologyEx(union, cv2.MORPH_CLOSE, k_close, iterations=1)
      
      # optional: remove tiny speckles after closing
      k_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
      union_closed = cv2.morphologyEx(union_closed, cv2.MORPH_OPEN, k_open, iterations=1)
      
      n, labels = cv2.connectedComponents(union_closed)
  10. mslabdelhak29GitHub

    Reid doesn't work how can i fix it i tried to change it True in botsort.yaml but it doesn't work

    1. Glenn JocherUltralytics(modifié)

      @mslabdelhak29 ReID is only supported by some trackers (for example BoT-SORT), not ByteTrack, and it’s enabled via the tracker YAML you pass at runtime. Copy the default config, enable ReID explicitly, and point track() to your copy:

      # custom_botsort.yaml
      tracker_type: botsort
      with_reid: True
      model: yolo26n-cls.pt  # or another YOLO classification weight you have locally
      from ultralytics import YOLO
      model = YOLO("yolo26n.pt")  # any YOLO detector
      results = model.track(source="path/to/video.mp4", tracker="custom_botsort.yaml", persist=True, show=False)

      If it still doesn’t work, you’re likely editing a different YAML than the one being loaded; always pass the path as above. Also share the output of yolo checks and the exact custom_botsort.yaml you used so we can verify your environment and keys. See the ReID section in the tracking guide and the BoT-SORT config for details: Multi‑Object Tracking docs and botsort.yaml config.