Tracking Multi-Oggetto con Ultralytics YOLO

Il tracking degli oggetti nel campo della video analisi è 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 ogni oggetto rilevato man mano che il video avanza. Le applicazioni sono illimitate, che vanno dalla sorveglianza e sicurezza all'analisi sportiva in tempo reale.

Perché scegliere Ultralytics YOLO per il tracking degli oggetti?

L'output dei tracker Ultralytics è coerente con il rilevamento oggetti standard, ma ha il valore aggiunto degli ID oggetto. Questo semplifica il tracking degli oggetti nei flussi video e l'esecuzione di analisi successive. Ecco perché dovresti considerare l'utilizzo di Ultralytics YOLO per le tue esigenze di tracking degli oggetti:

• Efficienza: Elabora flussi video in tempo reale senza compromettere l'accuratezza.
• Flessibilità: Supporta molteplici algoritmi di tracking e configurazioni.
• Facilità d'uso: Semplice API Python e opzioni CLI per una rapida integrazione e implementazione.
• Personalizzabilità: Facile da usare con modelli YOLO addestrati personalizzati, consentendo l'integrazione in applicazioni specifiche del settore.

Guarda: Rilevamento e tracciamento di oggetti con Ultralytics YOLO.

Applicazioni nel mondo reale

Trasporti	Vendita al dettaglio	Acquacoltura
Tracciamento di veicoli	Tracciamento di persone	Tracciamento di pesci

Caratteristiche in sintesi

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

• Tracciamento in tempo reale: Traccia gli oggetti in video ad alta frequenza di fotogrammi senza interruzioni.
• Supporto di più tracker: Scegli tra una varietà di algoritmi di tracciamento consolidati.
• Configurazioni del tracker personalizzabili: Personalizza l'algoritmo di tracciamento per soddisfare requisiti specifici regolando vari parametri.

Tracker disponibili

Ultralytics YOLO supporta i seguenti algoritmi di tracciamento. Possono essere abilitati passando il file di configurazione YAML pertinente, come ad esempio 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.

Tracking

Per eseguire il tracker su flussi video, utilizzare un modello Detect, Segment o Pose addestrato come YOLO11n, YOLO11n-seg e YOLO11n-pose.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO("yolo11n.pt")  # Load an official Detect model
model = YOLO("yolo11n-seg.pt")  # Load an official Segment model
model = YOLO("yolo11n-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

# Perform tracking with various models using the command line interface
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4"      # Official Detect model
yolo track model=yolo11n-seg.pt source="https://youtu.be/LNwODJXcvt4"  # Official Segment model
yolo track model=yolo11n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Official Pose model
yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Custom trained model

# Track using ByteTrack tracker
yolo track model=path/to/best.pt tracker="bytetrack.yaml"

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

Configurazione

Argomenti di Tracking

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

from ultralytics import YOLO

# Configure the tracking parameters and run the tracker
model = YOLO("yolo11n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)

# Configure tracking parameters and run the tracker using the command line interface
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show

Selezione del Tracker

Ultralytics ti consente anche di utilizzare un file di configurazione del tracker modificato. Per fare ciò, è sufficiente fare una copia di un file di configurazione del tracker (ad esempio, custom_tracker.yaml) da ultralytics/cfg/trackers e modificare qualsiasi configurazione (ad eccezione di 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("yolo11n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

# Load the model and run the tracker with a custom configuration file using the command line interface
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'

Fare riferimento alla sezione Argomenti Tracker per una descrizione dettagliata di ciascun parametro.

Argomenti del tracker

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

• botsort.yaml
• bytetrack.yaml

La tabella seguente 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 nel configurazione del tracker. Puoi anche personalizzare il model utilizzato per ReID, consentendo di bilanciare accuratezza e velocità a seconda del caso d'uso:

• Funzionalità native (model: auto): Questo sfrutta le caratteristiche direttamente dal detector YOLO per il ReID, aggiungendo un overhead minimo. È ideale quando hai bisogno di un certo livello di ReID senza influire significativamente sulle prestazioni. Se il detector non supporta le funzionalità native, ricade automaticamente sull'utilizzo di yolo11n-cls.pt.
• Modelli di classificazione YOLO: Puoi impostare esplicitamente un modello di classificazione (ad es. yolo11n-cls.pt) per l'estrazione delle feature ReID. Questo fornisce embedding più discriminanti, ma introduce ulteriore latenza a causa del passaggio di inferenza aggiuntivo.

Per prestazioni migliori, soprattutto quando si utilizza un modello di classificazione separato per ReID, è possibile esportarlo in un backend più veloce come TensorRT:

from torch import nn

from ultralytics import YOLO

# Load the classification model
model = YOLO("yolo11n-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 tracking.

Esempi Python

Loop di Persistenza dei Tracciati

Ecco uno script python che utilizza OpenCV (cv2) e YOLO11 per eseguire il tracciamento degli oggetti sui fotogrammi video. Questo script presuppone che tu abbia già installato i pacchetti necessari (opencv-python e ultralytics). L'argomento persist=True indica al tracker che l'immagine o il fotogramma corrente è il successivo in una sequenza e di prevedere le tracce dall'immagine precedente nell'immagine corrente.

import cv2

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.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 YOLO11 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("YOLO11 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 la modifica da model(frame) a model.track(frame), che abilita il tracciamento degli oggetti invece della semplice rilevazione. Questo script modificato eseguirà il tracker su ogni fotogramma del video, visualizzerà i risultati e li mostrerà in una finestra. È possibile uscire dal ciclo premendo 'q'.

Tracciamento dei Percorsi nel Tempo

La visualizzazione delle tracce 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 YOLO11, tracciare queste tracce è un processo semplice ed efficiente.

Nel seguente esempio, dimostriamo come utilizzare le funzionalità di tracciamento di YOLO11 per tracciare il movimento degli oggetti rilevati attraverso 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 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 YOLO11 model
model = YOLO("yolo11n.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 YOLO11 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("YOLO11 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()

Tracking Multithreaded

Il tracciamento multithread offre la possibilità di eseguire il tracciamento degli oggetti su più flussi video contemporaneamente. Ciò è particolarmente utile quando si gestiscono più input video, ad esempio da più telecamere di sorveglianza, dove l'elaborazione concorrente 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 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: yolo11n.pt e yolo11n-seg.pt, ciascuno dei quali traccia gli oggetti in un file video diverso. I file video sono specificati in SOURCES.

Il daemon=True parametro in threading.Thread significa che questi thread verranno chiusi non appena il programma principale termina. Avviamo quindi i thread con start() e usiamo join() per fare in modo che il thread principale attenda fino al termine 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 usando cv2.destroyAllWindows().

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo11n.pt", "yolo11n-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 YOLO11 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

Hai esperienza nel 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 nel mondo reale potrebbero essere preziose per gli utenti che lavorano su attività di tracking.

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

Per iniziare il tuo contributo, consulta la nostra Guida per i contributi per istruzioni complete sull'invio di una Pull Request (PR) 🛠️. Siamo entusiasti di vedere cosa porterai!

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

FAQ

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

Il tracciamento multi-oggetto nell'analisi video implica sia l'identificazione degli oggetti sia il mantenimento di un ID univoco per ciascun oggetto rilevato nei fotogrammi video. Ultralytics YOLO supporta questo fornendo il tracciamento in tempo reale insieme agli ID oggetto, 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?

È possibile configurare un tracker personalizzato copiando un file di configurazione del tracker esistente (ad esempio, custom_tracker.yaml) dalla directory di configurazione del tracker Ultralytics e modificando i parametri in base alle esigenze, ad eccezione di. tracker_typeUsa questo file nel tuo modello di tracking in questo modo:

from ultralytics import YOLO

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

yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'

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

Per eseguire l'object tracking su più flussi video contemporaneamente, puoi usare il modulo threading di python. Ogni thread gestirà un flusso video separato. Ecco un esempio di come puoi impostarlo:

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo11n.pt", "yolo11n-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 YOLO11 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 tracking multi-oggetto con Ultralytics YOLO?

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

• Trasporti: Monitoraggio dei veicoli per la gestione del traffico e la guida autonoma.
• Vendita al dettaglio: Tracking delle persone per l'analisi e la sicurezza in negozio.
• Acquacoltura: Tracking dei pesci per il monitoraggio degli ambienti acquatici.
• Analisi Sportiva: Tracciamento 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 alta frequenza di fotogrammi in tempo reale con un'eccezionale accuratezza.

Come posso visualizzare i tracciati degli oggetti su più fotogrammi video con Ultralytics YOLO?

Per visualizzare le tracce degli oggetti su più fotogrammi 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("yolo11n.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("YOLO11 Tracking", annotated_frame)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break
cap.release()
cv2.destroyAllWindows()

Questo script traccerà le linee di tracciamento che mostrano i percorsi di movimento degli oggetti tracciati nel tempo, fornendo preziose informazioni sul comportamento e sui modelli degli oggetti.

📅 Creato 1 anno fa ✏️ Aggiornato 2 mesi fa

Commenti