Link to this sectionTracciamento multi-oggetto con Ultralytics YOLO#

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

Link to this sectionPerché scegliere Ultralytics YOLO per il tracciamento degli oggetti?#

L'output dai tracker Ultralytics è coerente con il classico rilevamento oggetti, ma ha il valore aggiunto degli ID oggetto. Questo rende facile tracciare gli oggetti nei flussi video ed eseguire analisi successive. Ecco perché dovresti considerare di utilizzare Ultralytics YOLO per le tue esigenze di tracciamento oggetti:

• Efficienza: Elabora flussi video in tempo reale senza compromettere la precisione.
• Flessibilità: Supporta molteplici algoritmi di tracciamento e configurazioni.
• Facilità d'uso: Semplici 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.

Link to this sectionApplicazioni nel mondo reale#

Trasporti	Vendita al dettaglio	Acquacoltura
Tracciamento veicoli	Tracciamento persone	Tracciamento pesci

Link to this sectionFunzionalità in sintesi#

Ultralytics YOLO estende le sue funzionalità di rilevamento oggetti per fornire un tracciamento degli oggetti robusto e versatile:

• Tracciamento in tempo reale: Traccia senza interruzioni gli oggetti in video ad alto frame rate.
• Supporto per tracker multipli: Scegli tra una varietà di algoritmi di tracciamento consolidati.
• Configurazioni tracker personalizzabili: Adatta l'algoritmo di tracciamento per soddisfare requisiti specifici regolando vari parametri.

Link to this sectionTracker disponibili#

Ultralytics YOLO supporta i seguenti algoritmi di tracciamento. Possono essere abilitati passando il relativo file di configurazione YAML come tracker=tracker_type.yaml:

• BoT-SORT - Usa botsort.yaml per abilitare questo tracker.
• ByteTrack - Usa bytetrack.yaml per abilitare questo tracker.

Il tracker predefinito è BoT-SORT.

Link to this sectionTracciamento#

Per eseguire il tracker su flussi video, usa un modello addestrato di tipo Detect, Segment o Pose come YOLO26n, YOLO26n-seg o YOLO26n-pose. Puoi addestrare modelli personalizzati localmente o su GPU cloud tramite 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

Come si può vedere nell'utilizzo sopra riportato, il tracciamento è disponibile per tutti i modelli Detect, Segment e Pose eseguiti su video o sorgenti in streaming.

Link to this sectionConfigurazione#

Link to this sectionArgomenti di tracciamento#

La configurazione del tracciamento condivide proprietà con la modalità Predict, come conf, iou e show. Per ulteriori configurazioni, consulta la 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)

Link to this sectionSelezione del tracker#

Ultralytics ti consente anche di utilizzare 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 (tranne tracker_type) in base alle tue 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")

Consulta la sezione Argomenti del tracker per una descrizione dettagliata di ciascun parametro.

Link to this sectionArgomenti del tracker#

Alcuni comportamenti di tracciamento possono essere perfezionati modificando i file di configurazione YAML specifici per ogni algoritmo di tracciamento. Questi file definiscono parametri come soglie, buffer e logica di corrispondenza:

• botsort.yaml
• bytetrack.yaml

La seguente tabella fornisce una descrizione di ciascun parametro:

Link to this sectionAbilitazione della Re-identificazione (ReID)#

Per impostazione predefinita, il ReID è disattivato per ridurre al minimo il sovraccarico delle prestazioni. Abilitarlo è semplice: basta impostare with_reid: True nella configurazione del tracker. Puoi anche personalizzare il model utilizzato per il ReID, permettendoti di trovare un compromesso tra precisione e velocità a seconda del tuo caso d'uso:

• Funzionalità native (model: auto): Sfrutta le funzionalità direttamente dal rilevatore YOLO per il ReID, aggiungendo un sovraccarico minimo. È ideale quando hai bisogno di un certo livello di ReID senza influire significativamente sulle prestazioni. Se il rilevatore non supporta le funzionalità native, ricorre automaticamente all'uso di yolo26n-cls.pt.
• Modelli di classificazione YOLO: Puoi impostare esplicitamente un modello di classificazione (es. yolo26n-cls.pt) per l'estrazione delle caratteristiche ReID. Questo fornisce embedding più discriminanti, ma introduce una latenza aggiuntiva dovuta al passaggio di inferenza extra.

Per prestazioni migliori, specialmente quando si utilizza un modello di classificazione separato per il ReID, puoi esportarlo 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", half=True, dynamic=True, batch=32)

Una volta esportato, puoi puntare al percorso del modello TensorRT nella configurazione del tuo tracker e verrà utilizzato per il ReID durante il tracciamento.

Link to this sectionEsempi Python#

Link to this sectionCiclo 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 aspettarsi 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
        results = model.track(frame, persist=True)

        # 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()

Si noti il cambiamento da model(frame) a model.track(frame), che abilita il tracciamento degli oggetti invece del semplice rilevamento. Questo script modificato eseguirà il tracker su ogni fotogramma del video, visualizzerà i risultati e li mostrerà in una finestra. Il ciclo può essere interrotto premendo 'q'.

Link to this sectionTracciamento dei percorsi nel tempo#

Visualizzare i percorsi degli oggetti su fotogrammi consecutivi può fornire preziose informazioni sui modelli di movimento e sul comportamento degli oggetti rilevati all'interno di un video. Con Ultralytics YOLO26, tracciare questi percorsi è un processo fluido ed efficiente.

Nel seguente esempio, mostriamo come utilizzare le capacità di tracciamento di YOLO26 per tracciare il movimento degli oggetti rilevati attraverso più fotogrammi video. Questo script comporta l'apertura di un file video, la 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, 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

# 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(lambda: [])

# 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()

Link to this sectionTracciamento multithread#

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

Nello script Python fornito, utilizziamo il modulo threading di Python per eseguire più istanze del tracker simultaneamente. Ogni thread è responsabile dell'esecuzione del tracker 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 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 diversi: 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 termina. Avviamo quindi i thread con start() e utilizziamo join() per far attendere il thread principale finché entrambi i thread del tracker non hanno terminato.

Infine, dopo che tutti i thread hanno completato il loro compito, le finestre che visualizzano 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): The YOLO26 model object.
        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 più file video e modelli creando più thread e applicando la stessa metodologia.

Link to this sectionContribuisci con nuovi tracker#

Sei esperto di multi-object tracking 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 reali potrebbero essere preziose per gli utenti che lavorano su attività di tracciamento.

Contribuendo a questa sezione, aiuti ad espandere l'ambito 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 al contributo per istruzioni complete sull'invio di una Pull Request (PR) 🛠️. Siamo entusiasti di vedere cosa porterai sul tavolo!

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

Link to this sectionFAQ#

Link to this sectionCos'è il Multi-Object Tracking e come lo supporta Ultralytics YOLO?#

Il multi-object tracking nella video analisi comporta sia l'identificazione degli oggetti che il mantenimento di un ID univoco per ogni oggetto rilevato tra i frame video. Ultralytics YOLO supporta tutto ciò fornendo il tracciamento in tempo reale insieme agli ID degli oggetti, facilitando attività come la sorveglianza di sicurezza e l'analisi sportiva. Il sistema utilizza tracker come BoT-SORT e ByteTrack, che possono essere configurati tramite file YAML.

Link to this sectionCome configuro un tracker personalizzato per Ultralytics YOLO?#

Puoi configurare un tracker personalizzato copiando un file di configurazione tracker esistente (es. custom_tracker.yaml) dalla directory di configurazione dei tracker di Ultralytics e modificando i parametri secondo necessità, ad eccezione di tracker_type. Usa questo file nel tuo modello di tracciamento così:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Link to this sectionCome posso eseguire il tracciamento degli oggetti su più flussi video contemporaneamente?#

Per eseguire il tracciamento degli oggetti su più flussi video simultaneamente, puoi usare il modulo threading di Python. Ogni thread gestirà un flusso video separato. Ecco un esempio di come puoi configurarlo:

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): The YOLO26 model object.
        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()

Link to this sectionQuali sono le applicazioni reali del multi-object tracking con Ultralytics YOLO?#

Il multi-object tracking con Ultralytics YOLO ha numerose applicazioni, tra cui:

• Trasporti: Tracciamento dei veicoli per la gestione del traffico e guida autonoma.
• Retail: Tracciamento delle persone per analisi in negozio e sicurezza.
• Acquacoltura: Tracciamento dei pesci per il monitoraggio di ambienti acquatici.
• Analisi sportiva: Tracciamento di atleti e attrezzature per l'analisi delle performance.
• Sistemi di sicurezza: Monitoraggio di attività sospette e creazione di allarmi di sicurezza.

Queste applicazioni beneficiano della capacità di Ultralytics YOLO di elaborare video ad alto frame-rate in tempo reale con un'accuratezza eccezionale.

Link to this sectionCome posso visualizzare i percorsi degli oggetti su più frame video con Ultralytics YOLO?#

Per visualizzare i percorsi degli oggetti su più frame video, puoi usare le funzionalità di tracciamento del modello YOLO insieme a OpenCV per disegnare le traiettorie degli oggetti rilevati. Ecco uno script di esempio che lo dimostra:

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)
track_history = defaultdict(lambda: [])

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        boxes = results[0].boxes.xywh.cpu()
        track_ids = results[0].boxes.id.int().cpu().tolist()
        annotated_frame = results[0].plot()
        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 traccerà le linee di monitoraggio mostrando i percorsi di movimento degli oggetti tracciati nel tempo, fornendo informazioni preziose sui comportamenti e i modelli degli oggetti.