Suivi multi-objets avec Ultralytics YOLO
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.
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#
| Transport | Commerce de détail | Aquaculture |
|---|---|---|
| Suivi des véhicules | Suivi des personnes | Suivi 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.
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.
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 ByteTrackTrackers 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.
| Tracker | Fichier de configuration | Modèle de mouvement | Apparence / ReID | Compensation du mouvement de la caméra | Gestion des occultations |
|---|---|---|---|---|---|
| BoT-SORT | botsort.yaml | Kalman linéaire | Facultatif (with_reid) | Configurable (gmc_method) | Tampon de suivi + réassociation ReID |
| ByteTrack | bytetrack.yaml | Kalman linéaire | Aucun | Non | Récupération en deux étapes des détections à faible confiance |
| OC-SORT | ocsort.yaml | Kalman centré sur les observations | Aucun | Non | Mise à jour ORU, OCM, OCR à partir de la dernière observation |
| Deep OC-SORT | deepocsort.yaml | Kalman centré sur les observations | Facultatif (with_reid) | Configurable (gmc_method) | OC-SORT + EMA d'apparence adaptative facultative |
| FastTracker | fasttrack.yaml | Kalman linéaire + retour arrière | Aucun | Non | Retour arrière de Kalman + agrandissement de bbox en cas d'occultation |
| TrackTrack | tracktrack.yaml | Kalman 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 :
- 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).
- 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).
- 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).
- 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).
- 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 avec le mode Predict les arguments d’inférence, tels que conf, iou et show.
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.
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 :
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ètre | Valeurs ou plages autorisées | Description |
|---|---|---|
tracker_type | botsort, bytetrack, ocsort, deepocsort, fasttrack, tracktrack | Indique le type de tracker. |
track_high_thresh | 0.0-1.0 | Seuil de la première association. Il détermine le niveau de confiance requis pour associer une détection à une piste existante. |
track_low_thresh | 0.0-1.0 | Borne 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_thresh | 0.0-1.0 | Seuil pour initialiser une nouvelle piste si la détection ne correspond à aucune piste existante. |
track_buffer | >=0 | Nombre 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_thresh | 0.0-1.0 | Seuil d’association des pistes. Des valeurs plus élevées rendent l’association moins stricte. |
fuse_score | True, False | Indique s’il faut combiner les scores de confiance avec les distances IoU avant l’association. |
gmc_method | sparseOptFlow, orb, sift, ecc, none | Méthode de compensation du mouvement global. Elle permet de prendre en compte les mouvements de la caméra. |
proximity_thresh | 0.0-1.0 | IoU 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_thresh | 0.0-1.0 | Similarité d’apparence normalisée minimale requise pour ReID. |
with_reid | True, False | Active 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. |
model | auto ou chemin vers un modèle ReID compatible | Modè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 suryolo26n-cls.ptsi le détecteur n’expose pas de caractéristiques compatibles.- Modèle ReID personnalisé — Indique un checkpoint
.ptou un modèle d’embedding exporté compatible, tel que.torchscript,.onnx,.engine, ou un répertoire de modèle OpenVINO, pourmodel:. Les modèles exportés sont chargés viaAutoBackendet 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èle | taille (pixels) | paramètres (M) | FLOPs (B) |
|---|---|---|---|
| YOLO26n-reid.onnx | 448 | 2.8 | 2.0 |
| YOLO26s-reid.onnx | 448 | 7.5 | 6.6 |
| YOLO26m-reid.onnx | 448 | 12.4 | 20.1 |
| YOLO26l-reid.onnx | 448 | 15.3 | 25.2 |
| YOLO26x-reid.onnx | 448 | 32.7 | 55.9 |
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 :
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ètre | Valeurs ou plages autorisées | Description |
|---|---|---|
gmc_method | sparseOptFlow, orb, sift, ecc, none | Backend de compensation du mouvement de la caméra. sparseOptFlow est la valeur par défaut. none désactive la CMC. |
with_reid | True, False | Active l’association basée sur l’apparence. Désactivée par défaut. |
model | auto ou chemin vers un modèle ReID compatible | auto 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_thresh | 0.0-1.0 | IoU minimale requise avant la prise en compte des caractéristiques d’apparence. |
appearance_thresh | 0.0-1.0 | Similarité 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: nonepour économiser quelques ms/image. - Mouvements importants de la caméra : conserve
sparseOptFlow;eccest plus précis, mais plus lent. - Foules de personnes qui se ressemblent : active
with_reid: Trueet augmenteappearance_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_threshpour que la deuxième étape dispose de davantage de candidats. - Détecteur à fort rappel : augmente
track_high_threshpour réduire la fragmentation des ID. - Scintillement fréquent des ID : augmente
track_bufferpour 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ètre | Valeurs ou plages autorisées | Description |
|---|---|---|
delta_t | >=1 | Fenê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. |
inertia | 0.0-1.0 | Poids du coût de cohérence de la vitesse. Des valeurs plus élevées pénalisent les changements brusques de direction. |
use_byte | True, False | Active 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_bufferpour 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ètre | Valeurs ou plages autorisées | Description |
|---|---|---|
with_reid | True, False | Active l’association basée sur l’apparence. Désactivée par défaut. |
model | auto ou chemin vers un modèle ReID compatible | auto 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_thresh | 0.0-1.0 | IoU minimale requise avant la prise en compte des caractéristiques d’apparence. |
appearance_thresh | 0.0-1.0 | Similarité d’apparence normalisée minimale requise pour une association ReID. |
alpha_fixed_emb | 0.0-1.0 | Facteur EMA de base pour la mise à jour des embeddings des pistes. Des valeurs plus élevées préservent plus longtemps l’ancien embedding. |
gmc_method | sparseOptFlow, orb, sift, ecc, none | Méthode de compensation du mouvement global. |
delta_t | >=1 | Fenêtre temporelle (en images) utilisée pour calculer la direction de la vitesse dans OCM (héritée d’OC-SORT). |
inertia | 0.0-1.0 | Poids du coût de cohérence de la vitesse (hérité d’OC-SORT). |
use_byte | True, False | Active 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 augmentealpha_fixed_embpour que les embeddings s’adaptent plus lentement. - Caméra mobile : définis
gmc_method: sparseOptFlow(Deep OC-SORT utilisenonepar 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ètre | Valeurs ou plages autorisées | Description |
|---|---|---|
reset_velocity_offset_occ | >=0 | Nombre d’images d’historique à remonter pour restaurer la vitesse de Kalman au début de l’occlusion. |
reset_pos_offset_occ | >=0 | Nombre d’images d’historique à remonter pour restaurer la position de Kalman au début de l’occlusion. |
enlarge_bbox_occ | >=1.0 | Facteur 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_occ | 0.0-1.0 | Multiplicateur de vitesse pendant l’occlusion. Des valeurs plus faibles ralentissent la piste pendant l’occlusion. |
active_occ_to_lost_thresh | >=1 | Nombre maximal d’images consécutives d’occlusion avant qu’une piste active passe à l’état perdu. |
occ_cover_thresh | 0.0-1.0 | Fraction de la surface d’une piste couverte par une autre piste active pour déclarer une occlusion. |
occ_reappear_window | >=0 | Nombre d’images pendant lequel une piste perdue récemment occultée reste plus facilement réidentifiable. |
init_iou_suppress | 0.0-1.0 | Empê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_windowettrack_bufferensemble. - Cibles rapides : augmente
dampen_motion_occ(pour le rapprocher de1.0) ; augmenteenlarge_bbox_occuniquement 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ètre | Valeurs ou plages autorisées | Description |
|---|---|---|
iou_weight | 0.0-1.0 | Poids de la distance HMIoU lorsque ReID est activé ; sinon, HMIoU est utilisé directement. |
reid_weight | 0.0-1.0 | Poids de la distance cosinus ReID lorsque ReID est activé ; sinon, cette distance est ignorée. |
conf_weight | 0.0-1.0 | Poids de la distance de projection de confiance. |
angle_weight | 0.0-1.0 | Poids de la distance angulaire des coins. |
penalty_p | 0.0-1.0 | Pénalité de coût pour les détections à faible confiance. |
penalty_q | 0.0-1.0 | Pénalité de coût pour les détections récupérées par le NMS secondaire. |
reduce_step | 0.0-1.0 | Assouplissement du seuil de correspondance à chaque itération. |
tai_thr | 0.0-1.0 | Seuil IoU du NMS d’initialisation tenant compte des pistes. |
min_track_len | >=0 | Longueur minimale de l’historique avant qu’une nouvelle piste soit confirmée. |
lost_match_thr | 0.0-1.0 | Seuil de coût plus permissif pour la passe de réassociation des pistes perdues ; 0 désactive cette option. |
with_reid | True, False | Active la correspondance d’apparence par cosinus ReID (utilise les caractéristiques YOLO natives). Désactivée par défaut. |
model | auto ou chemin vers un modèle ReID compatible | auto 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_method | sparseOptFlow, orb, sift, ecc, none | Mé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 ; augmentetrack_bufferpour les occultations plus longues. - Mouvements rapides de la caméra : garde
gmc_method: sparseOptFlowactivé. - Objets petits ou rapides : augmente légèrement
angle_weightet diminuemin_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.
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".
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.
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().
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
.ptd’Ultralytics stockent les poids du modèle YOLO, tandis que le tracker est créé au moment de l’inférence parmodel.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, avecpersist=Truelorsque 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 detracker_type. Utilise ce fichier dans ton modèle de suivi comme suit :Exemplefrom 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
threadingde Python. Chaque thread gère un flux vidéo distinct. Voici un exemple de configuration :Suivi multithreadimport 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éofrom 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.
bhaskar2443053
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 ?
1maxexplorer
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.
-
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?
-
Is the match_thresh parameter based on IoU, and is it possible to print or visualize the IoU used during matching for debugging?
-
Is there a way to output Kalman-predicted boxes of lost tracks so we can analyze them?
-
Could increasing the video FPS improve tracking and IoU consistency, or is this mainly related to detection stability and parameter tuning?
-
Does ByteTrack or BoT-SORT use a min_hits parameter before confirming tracks, or are tracks confirmed immediately after creation?
-
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?
-
Is the track_buffer parameter the number of frames a track is kept using Kalman prediction after it is lost before being deleted?
-
Do you have any tips to improve tracking stability and avoid unnecessary ID switches?
Thank you for your support!
-
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:
-
ID changes typically occur due to low IoU between predicted and detected boxes, occlusions, or threshold mismatches. Check
track_high_threshandmatch_threshin your tracker config. -
match_threshis indeed IoU-based. For debugging, you can add logging to the tracker code, but there's no built-in visualization. -
Kalman predictions aren't directly exposed, but you can access them by modifying the tracker implementation.
-
Higher FPS generally improves tracking by reducing inter-frame motion, making associations more reliable.
-
Both trackers use confirmation logic - tracks need to meet certain criteria before being confirmed as valid tracks.
-
New tracks can be assigned immediately if detection confidence exceeds
new_track_thresh. -
Correct -
track_buffermaintains lost tracks for that many frames using prediction. -
For stability: increase
track_buffer, adjustmatch_threshbased on your scenario, and ensure consistent detection quality with appropriateconfthresholds.
For detailed parameter tuning, refer to the tracker configuration files and our tracking documentation.
-
rohith-aiunika(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
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 hereThis 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!
rohith-aiunika
i have used stream = True, then the code is just executing without showing error and without tracking also
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'): breakThis 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.
mwasela
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
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.
Orziqulov-Javohir
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
1Orziqulov-Javohir
It is kind a security program detecting who entered zone
1Orziqulov-Javohir
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'): breakRelease all video captures
for cap in caps: cap.release() cv2.destroyAllWindows()
Glenn JocherUltralyticsYour 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!
mariem158
File "", line 91 results = model.track(frame, persist=True, tracker="botsort.yaml") ^ IndentationError: unexpected indent COMMENT CORRIGER CETTE ERREUR
Glenn JocherUltralyticsThe 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.
GKYoffice
How can I get the tracking metrics of a tracker such as MOTA, IDF1, etc.
1GKYoffice
Can I set the parameter ''save_txt'' to True in the track function, and then write code to evaluate the tracking data?
Paula DerrengerUltralyticsCurrently, 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
.txtformat 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 toolsAfterwards, 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!🛠️
AdadAlShabab
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
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
Journey2-20
Hello I'm newer to Opencv and I'm trying to run a tracking camera for airsoft. How would i select specific bounding boxes?
Paula DerrengerUltralyticsUse
model.track(frame, persist=True)and inspectresults[0].boxes.xyxywithresults[0].boxes.id; select the box containing your OpenCV mouse-click coordinates, store its track ID, then process or draw only boxes whoseboxes.idmatches that ID. Feel free to continue posting questions here so the Ultralytics team can help.
yashpatel2010
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.
Glenn JocherUltralyticsUltralytics
trackis single-camera MOT, so cross-camera person IDs are not built in; on DeepStream 7.1 the practical Orin Nano path isNvDeepSORT/ReID per stream plus downstream association from the exported embeddings described in the DeepStreamgst-nvtrackerdocs, 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)
anvi97(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?
anvi97
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 / uniondef 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 Falsewhile 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: breakcap.release() out.release() cv2.destroyAllWindows()
Glenn JocherUltralyticsFor (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 snippetcompute_iou()/should_merge()aren’t actually applied toresults.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=220can’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 checksoutput and one representative frame (plus what you consider the “correct” merged result), I can suggest concrete thresholds/post-processing for your exact outputs.anvi97
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.
Glenn JocherUltralyticsThat 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)
mslabdelhak29
Reid doesn't work how can i fix it i tried to change it True in botsort.yaml but it doesn't work
mslabdelhak29
@glenn_jocher
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 locallyfrom 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 checksand the exactcustom_botsort.yamlyou 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.
