Tracciamento di oggetti multipli con Ultralytics YOLO#

Il tracciamento degli oggetti nell'ambito dell'analisi video è un'attività fondamentale: non solo identifica la posizione e la classe degli oggetti nel fotogramma, ma mantiene anche un ID univoco per ogni oggetto rilevato man mano che il video procede. Le applicazioni sono infinite: dalla sorveglianza e sicurezza all'analisi sportiva in tempo reale.

Consulta l'anteprima non ancora rilasciata di YOLO27 per conoscere il supporto al tracciamento previsto.

Perché scegliere Ultralytics YOLO per il tracciamento degli oggetti?#

L'output dei tracker Ultralytics è coerente con il rilevamento degli oggetti standard, ma aggiunge gli ID degli oggetti. Questo semplifica il tracciamento degli oggetti nei flussi video e l'esecuzione di analisi successive. Ecco perché dovresti valutare Ultralytics YOLO per le tue esigenze di tracciamento degli oggetti:

• Efficienza: elabora flussi video in tempo reale senza compromettere la precisione.
• Flessibilità: supporta più algoritmi e configurazioni di tracciamento.
• 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.

Applicazioni nel mondo reale#

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 su flussi video, usa un modello Detect, Segment, Pose o OBB addestrato, come YOLO26n, YOLO26n-seg, YOLO26n-pose o YOLO26n-obb. Puoi addestrare modelli personalizzati in locale o tramite l'addestramento 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 ByteTrack

Tracker supportati#

Ultralytics YOLO include sei tracker integrati. Attivane uno passando il relativo file di configurazione YAML all'argomento tracker.

Quale tracker dovrei usare?#

Usa questo flusso per scegliere da dove iniziare; viene usato tracktrack.yaml se non passi tracker:

1. Ti serve una soluzione di base rapida e semplice? → ByteTrack (nessun ReID, nessuna compensazione del movimento della telecamera, overhead minimo).
2. Riprese da dispositivo portatile, drone o telecamera in movimento? → BoT-SORT (aggiunge la compensazione del movimento della telecamera e il ReID opzionale).
3. Movimento non lineare (sport, danza, svolte brusche) e nessun ReID? → OC-SORT (correzioni basate sulle osservazioni senza costi legati all'aspetto).
4. 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).
5. 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 alcune proprietà con la modalità Predict, come conf, iou e show. Per altre configurazioni, consulta la pagina del modello Predict.

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

Configurazione personalizzata del tracker#

Ultralytics ti permette anche di usare un file di configurazione del tracker modificato. Per farlo, crea semplicemente una copia di un file di configurazione del tracker (ad esempio, custom_tracker.yaml) da ultralytics/cfg/trackers e modifica le configurazioni secondo le tue esigenze (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:

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:

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

Abilitare la Re-Identification (ReID)#

ReID è disabilitato per impostazione predefinita per ridurre al minimo il sovraccarico. Abilitalo 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 a yolo26n-cls.pt.
• Modello ReID personalizzato — Imposta model: su un checkpoint .pt o su un modello di embedding esportato compatibile, come .torchscript, .onnx, .engine oppure una directory di modello OpenVINO. I modelli esportati vengono caricati tramite AutoBackend e 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

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.

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:

Consigli per la configurazione:

• Videocamera fissa: imposta gmc_method: none per risparmiare qualche ms/frame.
• Movimento intenso della videocamera: mantieni sparseOptFlow; ecc è più preciso, ma più lento.
• Folla con soggetti simili: abilita with_reid: True e aumenta appearance_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_thresh per fornire più candidati alla seconda fase.
• Rilevatore con alta copertura: aumenta track_high_thresh per ridurre la frammentazione degli ID.
• Sfarfallio frequente degli ID: aumenta track_buffer affinché 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:

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_buffer per 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:

Consigli per la configurazione:

• Scambi di identità nella folla: aumenta appearance_thresh (ad es. 0.92-0.95) e aumenta alpha_fixed_emb per adattare più lentamente gli embedding.
• Videocamera in movimento: imposta gmc_method: sparseOptFlow (Deep OC-SORT usa none per 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:

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_window e track_buffer.
• Target in rapido movimento: aumenta dampen_motion_occ (avvicinandolo a 1.0); aumenta enlarge_bbox_occ solo 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:

Consigli per la configurazione:

• Pedoni in scene affollate: abbassa tai_thr (ad es. 0.45) per sopprimere più creazioni duplicate; aumenta track_buffer per le occlusioni più lunghe.
• Movimenti rapidi della videocamera: mantieni abilitato gmc_method: sparseOptFlow.
• Oggetti piccoli/veloci: aumenta leggermente angle_weight e abbassa min_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#

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.

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 tracking degli oggetti anziché il semplice rilevamento. Questo script modificato esegue il tracker su ogni frame 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 frame consecutivi può offrire informazioni preziose sui modelli di movimento e sul comportamento degli oggetti rilevati in un video. Con Ultralytics YOLO26, tracciare queste traiettorie è semplice ed efficiente.

Nell'esempio seguente mostriamo come usare le funzionalità di tracking di YOLO26 per tracciare il movimento degli oggetti rilevati in più frame video. Lo script apre un file video, lo legge frame per frame e usa il modello YOLO per identificare e tracciare vari oggetti. Conservando i punti centrali dei riquadri di delimitazione rilevati e collegandoli, possiamo disegnare 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 tracking multithread consente di eseguire contemporaneamente il tracking degli oggetti su più flussi video. È particolarmente utile quando gestisci più input video, ad esempio da diverse telecamere di sorveglianza, perché l'elaborazione simultanea può migliorare notevolmente l'efficienza e le prestazioni.

Nello script Python fornito usiamo il modulo threading di Python per eseguire contemporaneamente più istanze del tracker. Ogni thread è responsabile del tracking su un file video e tutti i thread vengono eseguiti simultaneamente in background.

Per garantire che ogni thread riceva i parametri corretti (il file video, il modello da usare e l'indice del file), definiamo una funzione run_tracker_in_thread che accetta questi parametri e contiene il ciclo principale di tracking. La funzione legge il video frame per frame, 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 un file video diverso. I file video sono specificati 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#

Hai esperienza nel tracking di più oggetti e hai implementato o adattato con successo un algoritmo di tracking con Ultralytics YOLO? Ti invitiamo a contribuire alla nostra sezione Tracker in ultralytics/cfg/trackers! Le tue applicazioni e soluzioni reali potrebbero rivelarsi preziose per chi lavora su attività di tracking.

Contribuendo a questa sezione, aiuti ad ampliare la gamma di soluzioni di tracking disponibili nel framework Ultralytics YOLO, aggiungendo un ulteriore livello di funzionalità e utilità per la community.

Per iniziare a contribuire, consulta la nostra Guida per i contributi, che contiene istruzioni dettagliate per inviare una Pull Request (PR) 🛠️. Non vediamo l'ora di scoprire il tuo contributo!

Insieme, miglioriamo le capacità di tracking dell'ecosistema Ultralytics YOLO 🙏!

Domande frequenti#