Tracciamento di oggetti multipli con Ultralytics YOLO
Il tracciamento di più oggetti nell'analisi video identifica la posizione e la classe degli oggetti in ogni fotogramma e mantiene anche un ID univoco per ogni oggetto rilevato man mano che il video procede. Le applicazioni spaziano dalla sorveglianza e dalla sicurezza all'analisi sportiva in tempo reale.
Consulta l'anteprima non ancora rilasciata di YOLO27 per conoscere il supporto al tracciamento previsto.
A partire da ultralytics 8.4.63, OC-SORT, Deep OC-SORT, FastTracker e TrackTrack sono disponibili insieme a BoT-SORT e ByteTrack.
Perché scegliere Ultralytics YOLO per il tracciamento degli oggetti?#
L'output dei tracker Ultralytics è coerente con il normale rilevamento degli oggetti, ma include anche gli ID degli oggetti. Questo semplifica il tracciamento degli oggetti nei flussi video e le analisi successive. Motivi principali per usare Ultralytics YOLO per il tracciamento degli oggetti:
- Efficienza: elabora flussi video in tempo reale senza compromettere la precisione.
- Flessibilità: supporta più algoritmi di tracciamento e configurazioni.
- Facilità d'uso: API Python e opzioni CLI semplici per un'integrazione e una distribuzione rapide.
- Personalizzazione: facile da usare con modelli YOLO addestrati su misura, consentendo l'integrazione in applicazioni specifiche del dominio.
Guarda: Come eseguire il tracking multi-oggetto con Ultralytics YOLO26 | BoT-SORT e ByteTrack | VisionAI 🚀
Applicazioni nel mondo reale#
| Trasporti | Commercio al dettaglio | Acquacoltura |
|---|---|---|
| Tracciamento dei veicoli | Tracciamento delle persone | Tracciamento dei pesci |
Guida rapida#
Esegui il tracciamento su un video con il tracker TrackTrack predefinito. Passa a un altro tracker modificando l'argomento tracker.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
# Tracker predefinito (TrackTrack)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)
# Passa a ByteTrack
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")Per eseguire il tracker sui flussi video, usa un modello Detect, Segment, Pose o OBB addestrato, ad esempio YOLO26n, YOLO26n-seg, YOLO26n-pose o YOLO26n-obb, tutti disponibili nella raccolta YOLO26 su Ultralytics Platform. Puoi addestrare modelli personalizzati in locale o con l'addestramento nel cloud di Ultralytics Platform.
from ultralytics import YOLO
# Carica un modello ufficiale o personalizzato
model = YOLO("yolo26n.pt") # Carica un modello Detect ufficiale
model = YOLO("yolo26n-seg.pt") # Carica un modello Segment ufficiale
model = YOLO("yolo26n-pose.pt") # Carica un modello Pose ufficiale
model = YOLO("path/to/best.pt") # Carica un modello addestrato su misura
# Esegui il tracciamento con il modello
results = model.track("https://youtu.be/LNwODJXcvt4", show=True) # Tracciamento con il tracker predefinito
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # con ByteTrackTracker supportati#
Ultralytics YOLO include sei tracker integrati. Attivane uno passando il relativo file di configurazione YAML all'argomento tracker.
| Tracker | File di configurazione | Modello del moto | Aspetto / ReID | Compensazione del movimento della telecamera | Gestione delle occlusioni |
|---|---|---|---|---|---|
| BoT-SORT | botsort.yaml | Kalman lineare | Opzionale (with_reid) | Configurabile (gmc_method) | Buffer delle tracce + ricollegamento ReID |
| ByteTrack | bytetrack.yaml | Kalman lineare | Nessuno | No | Recupero in due fasi dei rilevamenti a bassa confidenza |
| OC-SORT | ocsort.yaml | Kalman basato sulle osservazioni | Nessuno | No | ORU, OCM, OCR: nuovo aggiornamento dall'ultima osservazione |
| Deep OC-SORT | deepocsort.yaml | Kalman basato sulle osservazioni | Opzionale (with_reid) | Configurabile (gmc_method) | OC-SORT + EMA adattiva dell'aspetto opzionale |
| FastTracker | fasttrack.yaml | Kalman lineare + rollback | Nessuno | No | Rollback di Kalman + ampliamento di bbox in caso di occlusione |
| TrackTrack | tracktrack.yaml | Kalman lineare (NSA) | Opzionale (with_reid) | Configurabile (gmc_method) | Associazione iterativa basata su più indizi + TAI |
Quale tracker dovrei usare?#
Usa questo flusso per scegliere da dove iniziare; viene usato tracktrack.yaml se non passi tracker:
- Ti serve una soluzione di base rapida e semplice? → ByteTrack (nessun ReID, nessuna compensazione del movimento della telecamera, overhead minimo).
- Riprese da dispositivo portatile, drone o telecamera in movimento? → BoT-SORT (aggiunge la compensazione del movimento della telecamera e il ReID opzionale).
- Movimento non lineare (sport, danza, svolte brusche) e nessun ReID? → OC-SORT (correzioni basate sulle osservazioni senza costi legati all'aspetto).
- Scene affollate con telecamera in movimento, in cui il problema principale sono gli scambi di ID? → Deep OC-SORT o TrackTrack (entrambi supportano l'abbinamento opzionale basato sull'aspetto; TrackTrack aggiunge anche l'associazione basata su più indizi e la soppressione degli ID duplicati).
- Sovrapposizioni parziali frequenti in tempo reale, senza budget per il ReID? → FastTracker (variante di ByteTrack che tiene conto delle occlusioni e usa il rollback di Kalman).
Cambiare tracker#
Passa il nome del file di configurazione del tracker a tracker=. Il resto del codice rimane invariato.
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")Configurazione#
Argomenti del tracciamento#
La configurazione del tracciamento condivide con la modalità Predict gli argomenti di inferenza, come conf, iou e show.
from ultralytics import YOLO
# Configura i parametri di tracciamento ed esegui il tracker
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.5, show=True)Configurazione personalizzata del tracker#
Per usare una configurazione del tracker modificata, copia un file di configurazione del tracker (ad esempio, come custom_tracker.yaml) da ultralytics/cfg/trackers e modifica tutte le impostazioni tranne tracker_type.
from ultralytics import YOLO
# Carica il modello ed esegui il tracker con un file di configurazione personalizzato
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")Argomenti condivisi dai tracker#
I seguenti parametri sono comuni alla maggior parte dei file YAML dei tracker; non tutti i parametri sono presenti in ogni configurazione:
I rilevamenti con valore pari o superiore a track_high_thresh accedono alla prima fase di associazione. I rilevamenti compresi tra track_low_thresh e track_high_thresh possono recuperare tracce esistenti quando il tracker selezionato abilita l'associazione a bassa confidenza, ma non avviano nuove tracce. I rilevamenti pari o inferiori a track_low_thresh vengono ignorati.
| Parametro | Valori o intervalli validi | Descrizione |
|---|---|---|
tracker_type | botsort, bytetrack, ocsort, deepocsort, fasttrack, tracktrack | Specifica il tipo di tracker. |
track_high_thresh | 0.0-1.0 | Soglia per la prima associazione. Influisce sul livello di sicurezza con cui una rilevazione viene abbinata a una traccia esistente. |
track_low_thresh | 0.0-1.0 | Limite inferiore per le rilevazioni di recupero a bassa confidenza. OC-SORT e Deep OC-SORT usano queste rilevazioni solo quando use_byte: True; TrackTrack le include nel proprio insieme di associazioni penalizzate. |
new_track_thresh | 0.0-1.0 | Soglia per inizializzare una nuova traccia se la rilevazione non corrisponde ad alcuna traccia esistente. |
track_buffer | >=0 | Numero di frame per cui le tracce perse restano attive prima della rimozione. Un valore più alto aumenta la tolleranza alle occlusioni. |
match_thresh | 0.0-1.0 | Soglia per l'abbinamento delle tracce. Valori più alti rendono l'abbinamento più permissivo. |
fuse_score | True, False | Indica se fondere i punteggi di confidenza con le distanze IoU prima dell'abbinamento. |
gmc_method | sparseOptFlow, orb, sift, ecc, none | Metodo di compensazione del movimento globale. Aiuta a tenere conto dei movimenti della videocamera. |
proximity_thresh | 0.0-1.0 | IoU minimo richiesto per un abbinamento ReID valido. Garantisce una sufficiente vicinanza spaziale prima di usare gli indizi visivi. |
appearance_thresh | 0.0-1.0 | Somiglianza visiva normalizzata minima richiesta per ReID. |
with_reid | True, False | Abilita l'abbinamento basato sull'aspetto per migliorare il tracciamento attraverso le occlusioni. Supportato da BoT-SORT, Deep OC-SORT e TrackTrack. |
model | auto o percorso di un modello ReID compatibile | Modello ReID. auto usa le caratteristiche native del backbone YOLO quando disponibili; altrimenti ricorre a yolo26n-cls.pt. Un encoder personalizzato può essere un checkpoint .pt o un modello esportato come .torchscript, .onnx, .engine oppure una directory di modello OpenVINO. |
Argomenti specifici del tracker#
Ogni algoritmo offre parametri aggiuntivi oltre a quelli condivisi. Consulta le sezioni dedicate ai singoli tracker qui sotto per le descrizioni e i consigli di configurazione, oppure consulta direttamente i file di configurazione:
Abilitare la Re-Identification (ReID)#
La ReID è disabilitata per impostazione predefinita per ridurre al minimo il sovraccarico. Abilitala impostando with_reid: True in un file di configurazione del tracker.
Opzioni del modello ReID:
model: auto— Usa le caratteristiche native del rilevatore YOLO, con un sovraccarico minimo. Ideale quando ti serve un po' di ReID senza un forte impatto sulle prestazioni. Se il rilevatore non espone caratteristiche compatibili, ricorre ayolo26n-cls.pt.- Modello ReID personalizzato — Imposta
model:su un checkpoint.pto su un modello di embedding esportato compatibile, come.torchscript,.onnx,.engineoppure una directory di modello OpenVINO. I modelli esportati vengono caricati tramiteAutoBackende devono restituire direttamente un tensore di embedding.
Sono disponibili encoder ONNX pronti all'uso per ogni dimensione del modello. Imposta model: su uno di questi nomi e il file verrà scaricato automaticamente al primo avvio del tracker (come avviene per i pesi YOLO): non serve esportarlo o scaricarlo manualmente.
# 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| Modello | dimensione (pixel) | parametri (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 |
Al momento sono disponibili solo encoder ReID ONNX per il ramo di aspetto del tracker. Le modalità ReID train, val e predict, così come le procedure dedicate all'esportazione ReID, sono ancora in fase di sviluppo.
Per ottenere prestazioni migliori con un modello di classificazione separato, esportalo su un backend più veloce come TensorRT:
from torch import nn
from ultralytics import YOLO
# Carica il modello di classificazione
model = YOLO("yolo26n-cls.pt")
# Aggiungi un livello di pooling medio
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
# Esporta in TensorRT
model.export(format="engine", quantize=16, dynamic=True, batch=32)Dopo l'esportazione, indica il percorso del modello TensorRT nella configurazione del tracker.
Dettagli sui tracker#
Le sezioni seguenti descrivono il funzionamento di ciascun tracker, i parametri specifici e i consigli per la configurazione.
Guarda: Quale tracker di oggetti offre prestazioni migliori? | Velocità, FPS e stabilità degli ID | Ultralytics YOLO26 📊
BoT-SORT#
BoT-SORT (Aharon et al., 2022) estende ByteTrack con la compensazione del movimento della videocamera e la ReID opzionale:
- Compensazione del movimento della videocamera (CMC): a ogni frame viene applicata agli stati di Kalman una trasformazione affine stimata (per impostazione predefinita tramite flusso ottico sparso; sono disponibili anche ORB / ECC), prima dell'abbinamento IoU.
- ReID opzionale: gli embedding di aspetto possono essere fusi nella matrice dei costi. È disabilitata per impostazione predefinita; per abilitarla, imposta
with_reid: True.
Ideale per: il tracciamento generico, soprattutto con videocamere in movimento. Aggiungi ReID solo quando le somiglianze visive tra soggetti causano scambi di ID.
Argomenti specifici di BoT-SORT:
| Parametro | Valori o intervalli validi | Descrizione |
|---|---|---|
gmc_method | sparseOptFlow, orb, sift, ecc, none | Backend per la compensazione del movimento della videocamera. sparseOptFlow è l'impostazione predefinita. none disabilita CMC. |
with_reid | True, False | Abilita l'abbinamento basato sull'aspetto. Disabilitato per impostazione predefinita. |
model | auto o percorso di un modello ReID compatibile | auto usa le caratteristiche native di YOLO quando disponibili; i modelli personalizzati possono essere checkpoint .pt o esportazioni compatibili. |
proximity_thresh | 0.0-1.0 | IoU minimo prima di considerare le caratteristiche di aspetto. |
appearance_thresh | 0.0-1.0 | Somiglianza visiva normalizzata minima richiesta per un abbinamento ReID. Aumentala per rendere l'abbinamento più rigoroso. |
Consigli per la configurazione:
- Videocamera fissa: imposta
gmc_method: noneper risparmiare qualche ms/frame. - Movimento intenso della videocamera: mantieni
sparseOptFlow;eccè più preciso, ma più lento. - Folla con soggetti simili: abilita
with_reid: Truee aumentaappearance_thresh(ad es.0.85+).
ByteTrack#
ByteTrack (Zhang et al., ECCV 2022) è il modello di riferimento leggero. Usa un filtro di Kalman lineare + IoU con un'associazione in due fasi:
- Fase 1: abbina le rilevazioni con punteggio alto alle tracce attive.
- Fase 2: prova di nuovo ad abbinare le tracce non abbinate alle rilevazioni con punteggio basso, per recuperarle dopo brevi occlusioni parziali.
Non usa un modello di aspetto né la compensazione del movimento della videocamera.
Ideale per: videocamere fisse o quasi fisse, quando il costo del rilevatore è predominante e vuoi ridurre al minimo il sovraccarico del tracker.
Argomenti specifici di ByteTrack: nessuno oltre agli argomenti condivisi del tracker.
Consigli per la configurazione:
- Rilevatore rumoroso: abbassa
track_low_threshper fornire più candidati alla seconda fase. - Rilevatore con alta copertura: aumenta
track_high_threshper ridurre la frammentazione degli ID. - Sfarfallio frequente degli ID: aumenta
track_bufferaffinché le tracce mancate per breve tempo sopravvivano.
OC-SORT#
OC-SORT (Cao et al., CVPR 2023) è un'estensione di SORT incentrata sulle osservazioni. Mantiene la struttura leggera di SORT (senza caratteristiche di aspetto) e aggiunge tre correzioni:
- Ricalcolo incentrato sull'osservazione (ORU): riproduce una traiettoria virtuale tra l'ultima osservazione e la rilevazione corrente, ripetendo l'aggiornamento di Kalman per correggere la velocità deviata.
- Momento incentrato sull'osservazione (OCM): penalizza le rilevazioni che si muovono nella direzione sbagliata tramite un termine di coerenza della velocità.
- Recupero incentrato sull'osservazione (OCR): ricontrolla le rilevazioni non abbinate confrontandole con le tracce perse di recente, usando la loro ultima osservazione anziché lo stato previsto.
Ideale per: movimenti non lineari senza il costo di un modello ReID.
Argomenti specifici di OC-SORT:
| Parametro | Valori o intervalli validi | Descrizione |
|---|---|---|
delta_t | >=1 | Finestra temporale (in frame) per il calcolo della direzione della velocità in OCM. Valori più alti producono un maggiore livellamento. |
inertia | 0.0-1.0 | Peso del costo di coerenza della velocità. Valori più alti penalizzano i cambiamenti improvvisi di direzione. |
use_byte | True, False | Abilita un secondo passaggio di associazione, in stile ByteTrack, sulle rilevazioni a bassa confidenza. |
Consigli per la configurazione:
- Movimento non lineare: aumenta
inertia(ad es.0.3-0.4). - Rilevazioni sparse: abilita
use_byte: True. - Occlusioni prolungate: aumenta
track_bufferper fornire a OCR più tracce perse da ricollegare.
Con i modelli OBB, OCR usa il riquadro orientato previsto da Kalman perché non viene conservata una cronologia dell'ultima osservazione orientata.
Deep OC-SORT#
Deep OC-SORT arricchisce OC-SORT con informazioni sull'aspetto e compensazione del movimento della videocamera:
- Abbinamento basato sull'aspetto: la distanza tra embedding coseno è soggetta a una soglia basata sulla sovrapposizione e viene fusa con il costo del movimento.
- EMA dinamica dell'aspetto: gli embedding delle tracce vengono aggiornati con un'EMA, il cui fattore di smoothing si adatta alla confidenza della rilevazione.
- Compensazione del movimento della videocamera: gli stati di Kalman vengono trasformati da un frame all'altro tramite flusso ottico sparso, ORB o ECC.
Ideale per: scene affollate o riprese con videocamera in movimento, dove sono frequenti gli scambi di ID tra oggetti visivamente diversi ma vicini nello spazio.
Argomenti specifici di Deep OC-SORT:
| Parametro | Valori o intervalli validi | Descrizione |
|---|---|---|
with_reid | True, False | Abilita l'abbinamento basato sull'aspetto. Disabilitato per impostazione predefinita. |
model | auto o percorso di un modello ReID compatibile | auto usa le caratteristiche native di YOLO quando disponibili; i modelli personalizzati possono essere checkpoint .pt o esportazioni compatibili. |
proximity_thresh | 0.0-1.0 | IoU minimo prima di considerare le caratteristiche di aspetto. |
appearance_thresh | 0.0-1.0 | Somiglianza visiva normalizzata minima richiesta per un abbinamento ReID. |
alpha_fixed_emb | 0.0-1.0 | Fattore EMA di base per gli aggiornamenti degli embedding delle tracce. Valori più alti mantengono più a lungo il vecchio embedding. |
gmc_method | sparseOptFlow, orb, sift, ecc, none | Metodo di compensazione del movimento globale. |
delta_t | >=1 | Finestra temporale (in frame) per il calcolo della direzione della velocità in OCM (ereditata da OC-SORT). |
inertia | 0.0-1.0 | Peso del costo di coerenza della velocità (ereditato da OC-SORT). |
use_byte | True, False | Abilita una seconda associazione in stile ByteTrack sulle rilevazioni a bassa confidenza (ereditata da OC-SORT). |
Consigli per la configurazione:
- Scambi di identità nella folla: aumenta
appearance_thresh(ad es.0.92-0.95) e aumentaalpha_fixed_embper adattare più lentamente gli embedding. - Videocamera in movimento: imposta
gmc_method: sparseOptFlow(Deep OC-SORT usanoneper impostazione predefinita). - Latenza inferiore: mantieni
with_reid: False(predefinito) per usare solo il movimento + CMC; abilita ReID solo quando gli errori sono dovuti soprattutto agli scambi di ID.
FastTracker#
FastTracker è una variante di ByteTrack che gestisce le occlusioni senza un modello di aspetto:
- Rilevamento delle occlusioni: segnala le tracce come occluse quando la copertura da parte di altre tracce attive supera
occ_cover_thresh. - Ripristino di Kalman in caso di occlusione: ripristina lo stato di Kalman a un frame precedente all'occlusione usando la cronologia memorizzata in un buffer circolare.
- Attenuazione del movimento ed espansione dell'area di ricerca: la velocità viene attenuata e il bbox previsto viene ingrandito durante l'occlusione.
- Soppressione Init-IoU: impedisce la creazione di nuove tracce sopra quelle attive.
Ideale per: pipeline di rilevamento in tempo reale senza altri modelli, con frequenti sovrapposizioni tra bersagli (folla, code, sport).
Argomenti specifici di FastTracker:
| Parametro | Valori o intervalli validi | Descrizione |
|---|---|---|
reset_velocity_offset_occ | >=0 | Numero di frame indietro nella cronologia da cui ripristinare la velocità di Kalman all'inizio dell'occlusione. |
reset_pos_offset_occ | >=0 | Numero di frame indietro nella cronologia da cui ripristinare la posizione di Kalman all'inizio dell'occlusione. |
enlarge_bbox_occ | >=1.0 | Fattore di scala dell'altezza applicato al bbox predetto durante l'occlusione (la larghezza viene scalata in base al rapporto d'aspetto XYAH). |
dampen_motion_occ | 0.0-1.0 | Moltiplicatore della velocità durante l'occlusione. Valori più bassi fanno "rallentare" la traccia durante l'occlusione. |
active_occ_to_lost_thresh | >=1 | Numero massimo di frame consecutivi in occlusione prima che una traccia attiva venga spostata tra quelle perse. |
occ_cover_thresh | 0.0-1.0 | Frazione dell'area di una traccia coperta da un'altra traccia attiva per dichiarare un'occlusione. |
occ_reappear_window | >=0 | Numero di frame per cui una traccia persa di recente dopo un'occlusione resta più facilmente ritrovabile. |
init_iou_suppress | 0.0-1.0 | Esclude l'inizializzazione di nuove tracce se il loro IoU con una qualsiasi traccia attiva supera questo valore. Imposta 1.0 per disattivare. |
Consigli per la configurazione:
- Occlusioni parziali frequenti: abbassa
occ_cover_thresh(ad es.0.5-0.6). - ID duplicati in corrispondenza delle sovrapposizioni: abbassa
init_iou_suppress(ad es.0.5). - Occlusioni prolungate: aumenta insieme
occ_reappear_windowetrack_buffer. - Target in rapido movimento: aumenta
dampen_motion_occ(avvicinandolo a1.0); aumentaenlarge_bbox_occsolo se una regione di ricerca più ampia migliora il recupero.
TrackTrack#
TrackTrack (Shim et al., CVPR 2025) è il tracker predefinito. Ragiona dal punto di vista di ogni traccia e usa un'associazione iterativa basata su più indizi:
- Associazione basata sulla prospettiva della traccia (TPA): combina HMIoU, la distanza coseno ReID opzionale, la distanza di proiezione della confidenza e la distanza angolare degli angoli. L'assegnazione viene risolta iterativamente con una soglia progressivamente meno restrittiva.
- Inizializzazione consapevole delle tracce (TAI): sopprime le creazioni duplicate prima che venga creato un nuovo ID.
Ideale per: scene affollate con occlusioni frequenti in cui gli ID duplicati sono un problema.
Argomenti specifici di TrackTrack:
| Parametro | Valori o intervalli validi | Descrizione |
|---|---|---|
iou_weight | 0.0-1.0 | Peso della distanza HMIoU quando ReID è abilitato; altrimenti, HMIoU viene usato direttamente. |
reid_weight | 0.0-1.0 | Peso della distanza coseno ReID quando ReID è abilitato; altrimenti, viene ignorata. |
conf_weight | 0.0-1.0 | Peso della distanza di proiezione della confidenza. |
angle_weight | 0.0-1.0 | Peso della distanza angolare degli angoli. |
penalty_p | 0.0-1.0 | Penalità di costo per le rilevazioni a bassa confidenza. |
penalty_q | 0.0-1.0 | Penalità di costo per le rilevazioni recuperate dall'NMS secondaria. |
reduce_step | 0.0-1.0 | Riduzione della soglia di corrispondenza a ogni iterazione. |
tai_thr | 0.0-1.0 | Soglia IoU per l'NMS di inizializzazione consapevole delle tracce. |
min_track_len | >=0 | Lunghezza minima della cronologia prima che una nuova traccia venga confermata. |
lost_match_thr | 0.0-1.0 | Soglia di costo meno restrittiva per il passaggio di riassociazione delle tracce perse; 0 la disattiva. |
with_reid | True, False | Abilita la corrispondenza dell'aspetto basata sul coseno ReID (usa le feature native di YOLO). Disattivata per impostazione predefinita. |
model | auto o percorso di un modello ReID compatibile | auto usa le caratteristiche native di YOLO quando disponibili; i modelli personalizzati possono essere checkpoint .pt o esportazioni compatibili. |
gmc_method | sparseOptFlow, orb, sift, ecc, none | Metodo di compensazione del movimento globale. |
Consigli per la configurazione:
- Pedoni in scene affollate: abbassa
tai_thr(ad es.0.45) per sopprimere più creazioni duplicate; aumentatrack_bufferper le occlusioni più lunghe. - Movimenti rapidi della videocamera: mantieni abilitato
gmc_method: sparseOptFlow. - Oggetti piccoli/veloci: aumenta leggermente
angle_weighte abbassamin_track_len. - Abilita ReID solo quando serve: aumenta il costo dell'inferenza; per occlusioni brevi, di solito è sufficiente il costo predefinito basato su più indizi.
Con i modelli Segment e Pose, TrackTrack evita il recupero delle rilevazioni con NMS meno restrittiva, così maschere e keypoint restano allineati alle rispettive rilevazioni.
Esempi Python#
Guarda: Come creare un sistema interattivo di tracciamento degli oggetti con Ultralytics YOLO26: realizzalo in pochi minuti | Python!
Ciclo con tracce persistenti#
Ecco uno script Python che usa OpenCV (cv2) e YOLO26 per eseguire il tracking degli oggetti nei frame di un video. Lo script presuppone che i pacchetti necessari (opencv-python e ultralytics) siano già installati. L'argomento persist=True indica al tracker che l'immagine o il frame corrente è il successivo di una sequenza e che nell'immagine corrente sono previste tracce provenienti dall'immagine precedente.
Usa persist=True solo quando passi frame consecutivi dello stesso flusso video a model.track(). In questo modo il tracker può riutilizzare lo stato dei frame precedenti e mantenere ID delle tracce coerenti nel tempo. Non usare persist=True con immagini non correlate o con un flusso diverso, perché lo stato delle tracce precedenti potrebbe essere mantenuto.
Puoi anche scegliere un backend del tracker passando un file di configurazione del tracker, ad esempio tracker="botsort.yaml", tracker="bytetrack.yaml" o tracker="tracktrack.yaml".
import cv2
from ultralytics import YOLO
# Carica il modello YOLO26
model = YOLO("yolo26n.pt")
# Apri il file video
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)
# Scorri i fotogrammi del video
while cap.isOpened():
# Leggi un fotogramma dal video
success, frame = cap.read()
if success:
# Esegui il tracking YOLO26 sul frame, mantenendo le tracce tra un frame e l'altro
# e usando il backend del tracker BoT-SORT
results = model.track(frame, persist=True, tracker="botsort.yaml")
# Visualizza i risultati sul fotogramma
annotated_frame = results[0].plot()
# Mostra il fotogramma annotato
cv2.imshow("YOLO26 Tracking", annotated_frame)
# Interrompi il ciclo se viene premuto 'q'
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Interrompi il ciclo se il video è terminato
break
# Rilascia l'oggetto di acquisizione video e chiudi la finestra di visualizzazione
cap.release()
cv2.destroyAllWindows()Nota il passaggio da model(frame) a model.track(frame), che abilita il tracciamento degli oggetti anziché il semplice rilevamento. Questo script modificato esegue il tracker su ogni fotogramma del video, visualizza i risultati e li mostra in una finestra. Puoi uscire dal ciclo premendo 'q'.
Tracciare le tracce nel tempo#
Visualizzare le tracce degli oggetti nei fotogrammi consecutivi può fornire informazioni preziose sugli schemi di movimento e sul comportamento degli oggetti rilevati in un video. Ultralytics YOLO26 semplifica la visualizzazione di queste tracce.
L'esempio seguente usa il tracciamento di YOLO26 per visualizzare il movimento degli oggetti rilevati in più fotogrammi video. Lo script apre un file video, legge i fotogrammi uno alla volta e usa il modello YOLO per identificare e tracciare gli oggetti. Memorizzando i punti centrali dei riquadri di delimitazione rilevati e collegandoli, disegna linee che rappresentano i percorsi seguiti dagli oggetti tracciati.
from collections import defaultdict
import cv2
import numpy as np
from ultralytics import YOLO
# Carica il modello YOLO26
model = YOLO("yolo26n.pt")
# Apri il file video
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)
# Memorizza la cronologia delle tracce
track_history = defaultdict(list)
# Scorri i fotogrammi del video
while cap.isOpened():
# Leggi un fotogramma dal video
success, frame = cap.read()
if success:
# Esegui il tracking YOLO26 sul frame, mantenendo le tracce tra un frame e l'altro
result = model.track(frame, persist=True)[0]
# Ottieni i riquadri e gli ID delle tracce
if result.boxes and result.boxes.is_track:
boxes = result.boxes.xywh.cpu()
track_ids = result.boxes.id.int().cpu().tolist()
# Visualizza il risultato sul frame
frame = result.plot()
# Traccia le traiettorie
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))) # Punto centrale x, y
if len(track) > 30: # mantieni 30 tracce per 30 frame
track.pop(0)
# Disegna le linee delle tracce
points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
cv2.polylines(frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
# Mostra il fotogramma annotato
cv2.imshow("YOLO26 Tracking", frame)
# Interrompi il ciclo se viene premuto 'q'
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Interrompi il ciclo se il video è terminato
break
# Rilascia l'oggetto di acquisizione video e chiudi la finestra di visualizzazione
cap.release()
cv2.destroyAllWindows()Tracking multithread#
Il tracciamento multithread permette di tracciare gli oggetti contemporaneamente in più flussi video. È particolarmente utile quando si gestiscono più input video, ad esempio quelli provenienti da più telecamere di sorveglianza, perché l'elaborazione simultanea aumenta la produttività.
Lo script Python riportato di seguito usa il modulo threading di Python per eseguire contemporaneamente più istanze del tracker. Ogni thread esegue il tracker su una sorgente video e tutti i thread vengono eseguiti simultaneamente in background.
Per assicurarti che ogni thread riceva i parametri corretti (il modello da usare e la sorgente video), lo script definisce una funzione run_tracker_in_thread che accetta questi parametri e contiene il ciclo principale di tracking. Questa funzione legge il video fotogramma per fotogramma, esegue il tracker e salva i risultati annotati.
In questo esempio vengono usati due modelli diversi, yolo26n.pt e yolo26n-seg.pt, ognuno dei quali traccia gli oggetti in una sorgente diversa: un file video locale e una webcam. Le sorgenti sono specificate in SOURCES.
Il parametro daemon=True in threading.Thread indica che questi thread verranno chiusi non appena termina il programma principale. Avviamo quindi i thread con start() e usiamo join() per fare in modo che il thread principale attenda la conclusione di entrambi i thread del tracker.
Infine, al termine del lavoro di tutti i thread, le finestre che mostrano i risultati vengono chiuse usando cv2.destroyAllWindows().
import threading
import cv2
from ultralytics import YOLO
# Definisci i nomi dei modelli e le sorgenti video
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"] # video locale, 0 per 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
# Crea e avvia i thread del tracker usando un ciclo 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()
# Attendi la conclusione di tutti i thread del tracker
for thread in tracker_threads:
thread.join()
# Pulisci e chiudi le finestre
cv2.destroyAllWindows()Puoi estendere facilmente questo esempio per gestire più file video e modelli creando altri thread e applicando la stessa metodologia.
Contribuisci con nuovi tracker#
Se hai implementato o adattato un algoritmo di tracking multi-oggetto per Ultralytics YOLO, valuta di contribuirlo a ultralytics/trackers con una configurazione corrispondente in ultralytics/cfg/trackers. I contributi ampliano le opzioni di tracking disponibili per tutta la community.
Domande frequenti#
Il tracking di più oggetti nell'analisi video consiste nell'identificare gli oggetti e mantenere un ID univoco per ogni oggetto rilevato nei vari frame del video. Ultralytics YOLO supporta questa funzionalità fornendo tracking in tempo reale insieme agli ID degli oggetti, agevolando attività come la videosorveglianza e l'analisi sportiva. Il sistema usa tracker come BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker e TrackTrack, configurabili tramite file YAML.
No. I file standard
.ptdi Ultralytics contengono i pesi del modello YOLO, mentre il tracker viene creato al momento dell'inferenza damodel.track(). Gli ID delle tracce dipendono dallo stato del tracker nei frame consecutivi; un'unica immagine indipendente può quindi restituire rilevazioni, come riquadri, classi e valori di confidenza, ma non può generare da sola ID di tracking persistenti e significativi.Per la distribuzione, integra il rilevatore e il tracker nella tua applicazione e chiama
model.track()frame per frame conpersist=Truequando i frame provengono dallo stesso flusso video. Usa istanze separate del modello o del tracker per flussi non correlati, in modo che lo stato non venga mantenuto tra i video.Puoi configurare un tracker personalizzato copiando un file di configurazione di un tracker esistente (ad es.
custom_tracker.yaml) dalla directory di configurazione dei tracker di Ultralytics e modificando i parametri secondo necessità, fatta eccezione pertracker_type. Usa questo file nel tuo modello di tracking, come segue:Esempiofrom ultralytics import YOLO model = YOLO("yolo26n.pt") results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")Per eseguire contemporaneamente il tracking degli oggetti su più flussi video, puoi usare il modulo
threadingdi Python. Ogni thread gestirà un flusso video separato. Ecco un esempio di configurazione:Tracking multithreadimport threading import cv2 from ultralytics import YOLO # Definisci i nomi dei modelli e le sorgenti video MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"] SOURCES = ["path/to/video.mp4", "0"] # video locale, 0 per 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 # Crea e avvia i thread del tracker usando un ciclo 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() # Attendi la conclusione di tutti i thread del tracker for thread in tracker_threads: thread.join() # Pulisci e chiudi le finestre cv2.destroyAllWindows()Il tracking di più oggetti con Ultralytics YOLO ha numerose applicazioni, tra cui:
- Trasporti: tracking dei veicoli per la gestione del traffico e la guida autonoma.
- Commercio al dettaglio: tracking delle persone per l'analisi in negozio e la sicurezza.
- Acquacoltura: tracking dei pesci per il monitoraggio degli ambienti acquatici.
- Analisi sportiva: tracking di giocatori e attrezzature per l'analisi delle prestazioni.
- Sistemi di sicurezza: monitoraggio di attività sospette e creazione di allarmi di sicurezza.
Queste applicazioni traggono vantaggio dalla capacità di Ultralytics YOLO di elaborare video ad alto frame rate in tempo reale e con elevata precisione.
Per visualizzare le tracce degli oggetti in più frame video, puoi usare le funzionalità di tracking del modello YOLO insieme a OpenCV per disegnare i percorsi degli oggetti rilevati. Ecco uno script di esempio che lo mostra:
Tracciare le traiettorie in più frame videofrom 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()Questo script traccia le linee che rappresentano i percorsi degli oggetti monitorati nel tempo, offrendo informazioni preziose sul comportamento e sui modelli degli oggetti.
Commenti679
Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.
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(modificato)
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(modificato)
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(modificato)@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.
