Multi-Object Tracking con Ultralytics YOLO

Il monitoraggio degli oggetti nell'ambito dell'analisi video è un compito fondamentale 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.

Perché scegliere Ultralytics YOLO per il monitoraggio degli oggetti?

L'output dei tracker Ultralytics è coerente con il normale rilevamento di oggetti, ma ha il valore aggiunto degli ID oggetto. Ciò rende facile tracciare gli oggetti nei flussi video ed eseguire analisi successive. Ecco perché dovresti considerare l'utilizzo di Ultralytics YOLO per le tue esigenze di monitoraggio degli oggetti:

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

Applicazioni nel mondo reale

Trasporti	Vendita al dettaglio	Acquacoltura
Monitoraggio veicoli	Monitoraggio persone	Monitoraggio pesci

Caratteristiche in sintesi

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

• Monitoraggio 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 monitoraggio affermati.
• Configurazioni del tracker personalizzabili: adatta l'algoritmo di monitoraggio per soddisfare requisiti specifici regolando vari parametri.

Tracker disponibili

Ultralytics YOLO supporta i seguenti algoritmi di monitoraggio. 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.

Monitoraggio

Per eseguire il tracker su flussi video, utilizza un modello addestrato Detect, Segment o Pose come YOLO26n, YOLO26n-seg o YOLO26n-pose. Puoi addestrare modelli personalizzati localmente o su GPU cloud tramite la piattaforma Ultralytics.

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 di cui sopra, il monitoraggio è disponibile per tutti i modelli Detect, Segment e Pose eseguiti su video o fonti di streaming.

Configurazione

Argomenti di monitoraggio

La configurazione del monitoraggio 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)

Selezione 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 qualsiasi configurazione (eccetto tracker_type) secondo le 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")

Fai riferimento alla sezione Argomenti del tracker per una descrizione dettagliata di ciascun parametro.

Argomenti del tracker

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

• botsort.yaml
• bytetrack.yaml

La seguente tabella fornisce una descrizione di ciascun parametro:

Abilitazione della re-identificazione (ReID)

Per impostazione predefinita, 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 ReID, permettendoti di bilanciare precisione e velocità a seconda del tuo caso d'uso:

• Funzionalità native (model: auto): questo sfrutta le funzionalità direttamente dal rilevatore YOLO per ReID, aggiungendo un sovraccarico minimo. È ideale quando hai bisogno di un certo livello di ReID senza influire in modo significativo sulle prestazioni. Se il rilevatore non supporta le funzionalità native, torna automaticamente all'utilizzo di yolo26n-cls.pt.
• Modelli di classificazione YOLO: puoi impostare esplicitamente un modello di classificazione (ad es. yolo26n-cls.pt) per l'estrazione di caratteristiche ReID. Ciò fornisce embedding più discriminanti, ma introduce latenza aggiuntiva a causa del passaggio di inferenza extra.

Per prestazioni migliori, specialmente quando si utilizza un modello di classificazione separato per ReID, puoi esportarlo in 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 ReID durante il monitoraggio.

Esempi Python

Ciclo di persistenza delle tracce

Ecco uno script Python che utilizza OpenCV (cv2) e YOLO26 per eseguire il monitoraggio 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 in quella 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 prega di notare il passaggio da model(frame) a model.track(frame), che abilita il monitoraggio 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'.

Tracciamento delle tracce nel tempo

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

Nell'esempio seguente, dimostriamo come utilizzare le capacità di monitoraggio di YOLO26 per tracciare il movimento degli oggetti rilevati su più fotogrammi video. Questo script prevede l'apertura di un file video, la lettura fotogramma per fotogramma e l'utilizzo del modello YOLO per identificare e monitorare 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()

Monitoraggio multithread

Il monitoraggio multithread offre la capacità di eseguire il monitoraggio degli oggetti su più flussi video contemporaneamente. Ciò è particolarmente utile quando si gestiscono più ingressi video, come da 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 contemporaneamente. 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 monitoraggio 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 terminerà. Avviamo quindi i thread con start() e utilizziamo join() per far attendere il thread principale 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): 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.

Contribuisci con nuovi tracker

Sei esperto di multi-object tracking e hai implementato o adattato con successo un algoritmo di tracking 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 tracking.

Contribuendo a questa sezione, aiuti ad espandere la portata delle soluzioni di tracking 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 apporterai!

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

FAQ

Cos'è il multi-object tracking e come lo supporta Ultralytics YOLO?

Il multi-object tracking nell'analisi video comporta sia l'identificazione degli oggetti che il mantenimento di un ID univoco per ogni oggetto rilevato attraverso i frame video. Ultralytics YOLO supporta tutto ciò fornendo un tracking 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.

Come posso configurare un tracker personalizzato per Ultralytics YOLO?

Puoi configurare un tracker personalizzato copiando un file di configurazione tracker esistente (ad esempio, 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 tracking in questo modo:

from ultralytics import YOLO

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

Come posso eseguire il tracking degli oggetti su più stream video contemporaneamente?

Per eseguire il tracking degli oggetti su più stream video contemporaneamente, puoi utilizzare il modulo threading di Python. Ogni thread gestirà uno stream 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()

Quali sono le applicazioni reali del multi-object tracking con Ultralytics YOLO?

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

• Trasporti: Tracking dei veicoli per la gestione del traffico e guida autonoma.
• Vendita al dettaglio: Tracking delle persone per analisi in negozio e 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 beneficiano della capacità di Ultralytics YOLO di elaborare video ad alto frame rate in tempo reale con una precisione eccezionale.

Come posso visualizzare le tracce degli oggetti su più frame video con Ultralytics YOLO?

Per visualizzare le tracce degli oggetti su più frame video, puoi utilizzare le funzionalità di tracking del modello YOLO insieme a OpenCV per disegnare i percorsi 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 tracking mostrando i percorsi di movimento degli oggetti tracciati nel tempo, fornendo preziose informazioni sul comportamento e sui pattern degli oggetti.