Tracciamento multi-oggetto con Ultralytics YOLO#

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

Consulta l' anteprima non rilasciata di YOLO27 per il supporto al tracciamento pianificato.

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

L'output dei tracker Ultralytics è coerente con il rilevamento degli oggetti standard object detection, ma offre il valore aggiunto degli ID di oggetto. Ciò facilita il tracciamento degli oggetti nei flussi video e l'esecuzione di analisi successive. Ecco perché dovresti considerare l'uso di Ultralytics YOLO per le tue esigenze di tracciamento degli oggetti:

• Efficienza: elabora i flussi video in tempo reale senza compromettere la precisione.
• Flessibilità: supporta molteplici algoritmi e configurazioni di tracciamento.
• Facilità d'uso: semplice API Python e opzioni CLI per una rapida integrazione e distribuzione.
• Personalizzabilità: facile da usare con modelli YOLO addestrati su misura, consentendo l'integrazione in applicazioni specifiche di dominio.

Applicazioni nel mondo reale#

Avvio rapido#

Esegui il tracciamento su un video con il tracker predefinito TrackTrack. Passa a un altro tracker modificando l'argomento tracker.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Default tracker (TrackTrack)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)

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

Per eseguire il tracker sui flussi video, usa un modello addestrato Detect, Segment, Pose o OBB come YOLO26n, YOLO26n-seg, YOLO26n-pose o YOLO26n-obb. Puoi addestrare modelli personalizzati localmente o con l'addestramento cloud di Ultralytics Platform.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO("yolo26n.pt")  # Load an official Detect model
model = YOLO("yolo26n-seg.pt")  # Load an official Segment model
model = YOLO("yolo26n-pose.pt")  # Load an official Pose model
model = YOLO("path/to/best.pt")  # Load a custom-trained model

# Perform tracking with the model
results = model.track("https://youtu.be/LNwODJXcvt4", show=True)  # Tracking with default tracker
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # with ByteTrack

Tracker supportati#

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

Quale tracker dovrei usare?#

Usa questo flusso per scegliere un punto di partenza; tracktrack.yaml viene utilizzato quando non passi alcun tracker:

1. Ti serve la base più veloce e semplice? → ByteTrack (nessun ReID, nessuna compensazione del movimento della telecamera, overhead minimo).
2. Riprese a mano, da drone o con telecamera in movimento? → BoT-SORT (aggiunge la compensazione del movimento della telecamera e il ReID opzionale).
3. Movimento non lineare (sport, danza, curve brusche) e nessun ReID? → OC-SORT (correzioni incentrate sulle osservazioni senza costi di aspetto).
4. Scene affollate con telecamera in movimento in cui gli scambi di ID sono il problema principale? → Deep OC-SORT o TrackTrack (entrambi supportano la corrispondenza dell'aspetto opzionale; TrackTrack aggiunge anche l'associazione a più indizi e la soppressione dei duplicati di ID).
5. Frequente sovrapposizione parziale in tempo reale, nessun budget per il ReID? → FastTracker (variante di ByteTrack consapevole delle occlusioni con rollback di Kalman).

Cambio dei tracker#

Passa il nome del file di configurazione del tracker a tracker=. Tutto 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 di tracciamento#

La configurazione del tracciamento condivide le proprietà con la modalità Predict, come conf, iou e show. Per ulteriori configurazioni, fai riferimento alla pagina del modello Predict.

from ultralytics import YOLO

# Configure the tracking parameters and run the 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 consente inoltre di utilizzare un file di configurazione del tracker modificato. Per fare ciò, è sufficiente creare una copia di un file di configurazione del tracker (ad esempio, custom_tracker.yaml) da ultralytics/cfg/trackers e modificare qualsiasi configurazione (eccetto tracker_type) in base alle proprie esigenze.

from ultralytics import YOLO

# Load the model and run the tracker with a custom configuration file
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Argomenti condivisi del tracker#

I seguenti parametri sono comuni alla maggior parte dei file YAML dei tracker; non tutti i parametri compaiono in ogni configurazione:

Argomenti specifici del tracker#

Ogni algoritmo espone ulteriori opzioni oltre ai parametri condivisi. Consulta le sezioni specifiche per ogni tracker di seguito per le descrizioni e i consigli di ottimizzazione, oppure fai riferimento direttamente ai file di configurazione:

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

Abilitazione della re-identificazione (ReID)#

Il ReID è disabilitato per impostazione predefinita per ridurre al minimo l'overhead. Abilitalo impostando with_reid: True in un file di configurazione del tracker.

Opzioni del modello ReID:

• model: auto — Utilizza le caratteristiche native del rilevatore YOLO, aggiungendo un overhead minimo. Ideale quando ti serve un po' di ReID senza un calo drastico delle prestazioni. Torna a yolo26n-cls.pt se il rilevatore non espone caratteristiche compatibili.
• Modello ReID personalizzato — Punta model: a un checkpoint .pt o a un modello di embedding esportato compatibile, come .torchscript, .onnx, .engine o una directory di modelli OpenVINO. I modelli esportati vengono caricati tramite AutoBackend e devono restituire direttamente un tensore di embedding.

I codificatori ONNX pronti all'uso vengono pubblicati per ogni dimensione di modello. Imposta model: su uno di questi nomi e il file verrà scaricato automaticamente la prima volta che il tracker viene eseguito (allo stesso modo in cui vengono recuperati i pesi di YOLO), senza che sia necessaria alcuna esportazione manuale o fase di download:

# 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

# Load the classification model
model = YOLO("yolo26n-cls.pt")

# Add average pooling layer
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

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

Una volta esportato, punta al percorso del modello TensorRT nella configurazione del tuo tracker.

Dettagli del tracker#

Le sezioni seguenti descrivono il design, i parametri specifici e i consigli di sintonizzazione di ciascun tracker.

BoT-SORT#

BoT-SORT (Aharon et al., 2022) estende ByteTrack con la compensazione del movimento della telecamera e il ReID opzionale:

• Compensazione del movimento della telecamera (CMC): una deformazione affine stimata a ogni fotogramma (flusso ottico sparso per impostazione predefinita; sono disponibili anche ORB ed ECC) viene applicata agli stati di Kalman prima dell'abbinamento IoU.
• ReID opzionale: gli embedding di aspetto possono essere fusi nella matrice dei costi. Disabilitato per impostazione predefinita; abilitalo con with_reid: True.

Ideale per: tracciamento generico, in particolare con telecamere in movimento. Aggiungi ReID solo quando folle di persone dall'aspetto simile causano scambi di ID.

Argomenti specifici di BoT-SORT:

Consigli per la messa a punto:

• Telecamera statica: imposta gmc_method: none per risparmiare pochi ms/fotogramma.
• Forte movimento della telecamera: mantieni sparseOptFlow; ecc è più accurato ma più lento.
• Folle dall'aspetto simile: attiva with_reid: True e aumenta appearance_thresh (ad es. 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) è la baseline leggera. Utilizza Kalman lineare + IoU con un'associazione in due fasi:

• Fase 1: associa le rilevazioni con punteggio alto alle tracce attive.
• Fase 2: riprova le tracce non associate con le rilevazioni a punteggio basso per recuperarle durante brevi occlusioni parziali.

Non è presente alcun modello di aspetto e nessuna compensazione del movimento della telecamera.

Ideale per: telecamere statiche o quasi statiche in cui il costo del rilevatore predomina e desideri un overhead minimo del tracker.

Argomenti specifici di ByteTrack: Nessuno oltre agli argomenti condivisi del tracker.

Consigli per la messa a punto:

• Rilevatore rumoroso: abbassa track_low_thresh in modo che la seconda fase abbia più candidati.
• Rilevatore ad alto richiamo: aumenta track_high_thresh per ridurre gli ID frammentati.
• Frequente sfarfallio degli ID: aumenta track_buffer in modo che le tracce brevemente mancate sopravvivano.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) è un'estensione di SORT incentrata sulle osservazioni. Mantiene il design leggero di SORT (senza caratteristiche di aspetto) e aggiunge tre correzioni:

• Observation-Centric Re-update (ORU): riproduce una traiettoria virtuale tra l'ultima osservazione e la rilevazione corrente, rieseguendo l'aggiornamento di Kalman per riparare la velocità derivata.
• Observation-Centric Momentum (OCM): penalizza le rilevazioni che si muovono nella direzione sbagliata tramite un termine di coerenza della velocità.
• Observation-Centric Recovery (OCR): ricontrolla le rilevazioni non associate rispetto alle tracce perse di recente utilizzando la loro ultima osservazione anziché lo stato previsto.

Ideale per: movimento non lineare senza il costo di un modello ReID.

Argomenti specifici di OC-SORT:

Consigli per la messa a punto:

• Movimento non lineare: aumenta inertia (ad es. 0.3-0.4).
• Rilevazioni sparse: abilita use_byte: True.
• Occlusioni lunghe: aumenta track_buffer in modo che OCR abbia più tracce perse da ricollegare.

Con i modelli OBB, OCR utilizza il box orientato previsto da Kalman poiché non viene mantenuta una cronologia dell'ultima osservazione orientata.

Deep OC-SORT#

Deep OC-SORT arricchisce OC-SORT con informazioni sull'aspetto e compensazione del movimento della telecamera:

• Matching dell'aspetto: la distanza di embedding del coseno è limitata dalla sovrapposizione e fusa con il costo del movimento.
• EMA dell'aspetto dinamico: gli embedding delle tracce si aggiornano con un'EMA il cui fattore di attenuazione si adatta alla confidenza di rilevamento.
• Compensazione del movimento della telecamera: gli stati di Kalman vengono deformati fotogramma per fotogramma tramite flusso ottico scarso, ORB o ECC.

Ideale per: scene affollate o con telecamera in movimento in cui gli scambi di ID tra oggetti visivamente differenti ma spazialmente vicini sono comuni.

Argomenti specifici di Deep OC-SORT:

Consigli per la messa a punto:

• Scambi di identità nelle folle: aumenta appearance_thresh (ad es. 0.92-0.95) e aumenta alpha_fixed_emb in modo che gli embedding si adattino più lentamente.
• Telecamera in movimento: imposta gmc_method: sparseOptFlow (Deep OC-SORT utilizza none come valore predefinito).
• Latenza inferiore: mantieni with_reid: False (predefinito) solo per movimento + CMC; abilita ReID solo quando gli scambi di ID dominano gli errori.

FastTracker#

FastTracker è una variante di ByteTrack consapevole dell'occlusione senza alcun modello di aspetto:

• Rilevamento dell'occlusione: contrassegna le tracce come occluse quando la copertura da parte di altre tracce attive supera occ_cover_thresh.
• Ripristino di Kalman in caso di occlusione: riporta lo stato di Kalman a un fotogramma precedente all'occlusione utilizzando la cronologia con buffer circolare.
• Smorzamento del movimento ed espansione della ricerca: la velocità viene smorzata e il bbox previsto viene ingrandito durante l'occlusione.
• Soppressione Init-IoU: impedisce la creazione di nuove tracce sopra quelle attive.

Ideale per: pipeline in tempo reale basate solo sul rilevamento con frequenti sovrapposizioni tra bersagli (folle, code, sport).

Argomenti specifici di FastTracker:

Consigli per la messa a punto:

• Occlusioni parziali frequenti: abbassa occ_cover_thresh (ad es. 0.5-0.6).
• ID duplicati attorno alla sovrapposizione: abbassa init_iou_suppress (ad es. 0.5).
• Occlusioni lunghe: aumenta occ_reappear_window e track_buffer insieme.
• Bersagli in rapido movimento: aumenta dampen_motion_occ (più vicino a 1.0); aumenta enlarge_bbox_occ solo quando una regione di ricerca più ampia migliora il recupero.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) è il tracker predefinito. Ragiona dalla prospettiva di ciascuna traccia con un'associazione iterativa a più segnali:

• Track-Perspective-Based Association (TPA): combina HMIoU, distanza ReID del coseno opzionale, distanza di proiezione della confidenza e distanza dell'angolo dell'angolo. L'assegnazione viene risolta in modo iterativo con una soglia di rilassamento.
• Track-Aware Initialization (TAI): sopprime le generazioni duplicate prima che venga creato un nuovo ID.

Ideale per: scene affollate con frequenti occlusioni in cui gli ID duplicati rappresentano un problema.

Argomenti specifici di TrackTrack:

Consigli per la messa a punto:

• Pedoni affollati: abbassa tai_thr (ad es. 0.45) per sopprimere più generazioni duplicate; aumenta track_buffer per occlusioni più lunghe.
• Movimento rapido della telecamera: mantieni gmc_method: sparseOptFlow abilitato.
• Oggetti piccoli/veloci: aumenta leggermente angle_weight e abbassa min_track_len.
• Abilita ReID solo quando necessario: aggiunge costi di inferenza; per brevi occlusioni, il costo multi-segnale predefinito è solitamente sufficiente.

Con i modelli Segment e Pose, TrackTrack salta il recupero delle rilevazioni con NMS allentato in modo che le maschere e i punti chiave rimangano allineati con le rispettive rilevazioni.

Esempi Python#

Ciclo di persistenza delle tracce#

Ecco uno script Python che utilizza OpenCV (cv2) e YOLO26 per eseguire il tracciamento degli oggetti sui fotogrammi video. Questo 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 fotogramma corrente è il successivo in una sequenza e di attendersi tracce dall'immagine precedente nell'immagine corrente.

import cv2

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Open the video file
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO26 tracking on the frame, persisting tracks between frames
        # and using the BoT-SORT tracker backend
        results = model.track(frame, persist=True, tracker="botsort.yaml")

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLO26 Tracking", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Nota il cambiamento da model(frame) a model.track(frame), che abilita il tracciamento degli oggetti invece della semplice rilevazione. Questo script modificato eseguirà il tracker su ciascun fotogramma del video, ne visualiserà i risultati e li mostrerà in una finestra. È possibile uscire dal ciclo premendo 'q'.

Tracciamento dei percorsi nel corso del tempo#

La visualizzazione dei percorsi degli oggetti su fotogrammi consecutivi può offrire preziose informazioni sui pattern di movimento e sul comportamento degli oggetti rilevati all'interno di un video. Con Ultralytics YOLO26, tracciare questi percorsi è un processo semplice ed efficiente.

Nel seguente esempio, mostriamo come utilizzare le funzionalità di tracciamento di YOLO26 per tracciare il movimento degli oggetti rilevati su più fotogrammi video. Questo script prevede l'apertura di un file video, la sua lettura fotogramma per fotogramma e l'utilizzo del modello YOLO per identificare e tracciare vari oggetti. Mantenendo i punti centrali dei riquadri di delimitazione rilevati e collegandoli tra loro, possiamo tracciare linee che rappresentano i percorsi seguiti dagli oggetti tracciati.

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Open the video file
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Store the track history
track_history = defaultdict(list)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLO26 tracking on the frame, persisting tracks between frames
        result = model.track(frame, persist=True)[0]

        # Get the boxes and track IDs
        if result.boxes and result.boxes.is_track:
            boxes = result.boxes.xywh.cpu()
            track_ids = result.boxes.id.int().cpu().tolist()

            # Visualize the result on the frame
            frame = result.plot()

            # Plot the tracks
            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)))  # x, y center point
                if len(track) > 30:  # retain 30 tracks for 30 frames
                    track.pop(0)

                # Draw the tracking lines
                points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                cv2.polylines(frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

        # Display the annotated frame
        cv2.imshow("YOLO26 Tracking", frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Tracciamento multithread#

Il tracciamento multithread offre la possibilità di eseguire il tracciamento degli oggetti su più flussi video contemporaneamente. Questo è particolarmente utile quando si gestiscono più input video, ad esempio da più telecamere di sorveglianza, dove l'elaborazione simultanea può migliorare notevolmente l'efficienza e le prestazioni.

Nel codice Python fornito, utilizziamo il modulo threading di Python per eseguire più istanze del tracker contemporaneamente. Ciascun thread è responsabile dell'esecuzione del tracker su un file video e tutti i thread vengono eseguiti simultaneamente in background.

Per garantire che ciascun thread riceva i parametri corretti (il file video, il modello da utilizzare e l'indice del file), definiamo una funzione run_tracker_in_thread che accetta questi parametri e contiene il ciclo di tracciamento principale. Questa funzione legge il video fotogramma per fotogramma, esegue il tracker e visualizza i risultati.

In questo esempio vengono utilizzati due modelli differenti: yolo26n.pt e yolo26n-seg.pt, ognuno dei quali traccia oggetti in un file video diverso. I file video sono specificati in SOURCES.

Il parametro daemon=True in threading.Thread significa che questi thread verranno chiusi non appena il programma principale avrà terminato. Avviamo quindi i thread con start() e utilizziamo join() per fare in modo che il thread principale attenda fino al completamento di entrambi i thread del tracker.

Infine, dopo che tutti i thread hanno completato il loro compito, le finestre che mostrano i risultati vengono chiuse utilizzando cv2.destroyAllWindows().

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # local video, 0 for 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

# Create and start tracker threads using a for loop
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()

# Wait for all tracker threads to finish
for thread in tracker_threads:
    thread.join()

# Clean up and close windows
cv2.destroyAllWindows()

Questo esempio può essere facilmente esteso per gestire un numero maggiore di file video e modelli creando ulteriori thread e applicando la stessa metodologia.

Contribuisci a nuovi tracker#

Hai esperienza nel tracciamento di oggetti multipli e hai implementato o adattato con successo un algoritmo di tracciamento con Ultralytics YOLO? Ti invitiamo a contribuire alla nostra sezione Trackers in ultralytics/cfg/trackers! Le tue applicazioni e soluzioni del mondo reale potrebbero rivelarsi preziosissime per gli utenti che lavorano su attività di tracciamento.

Contribuendo a questa sezione, aiuti ad ampliare la portata delle soluzioni di tracciamento disponibili all'interno del framework Ultralytics YOLO, aggiungendo un ulteriore livello di funzionalità e utilità per la community.

Per iniziare il tuo contributo, fai riferimento alla nostra Guida ai contributi per istruzioni dettagliate su come inviare una Pull Request (PR) 🛠️. Non vediamo l'ora di scoprire cosa porterai in tavola!

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

FAQ#