Tracciamento di più oggetti con Ultralytics YOLO

Il tracciamento degli oggetti nel campo dell'analisi video è un'attività fondamentale che non solo identifica la posizione e la classe degli oggetti all'interno dell'inquadratura, ma mantiene anche un ID univoco per ogni oggetto rilevato durante l'avanzamento del video. Le applicazioni sono illimitate e spaziano dalla sorveglianza e dalla sicurezza all'analisi degli sport in tempo reale.

Perché scegliere Ultralytics YOLO per il tracciamento degli oggetti?

Il risultato dei tracker Ultralytics è coerente con il rilevamento standard degli oggetti, ma ha il valore aggiunto degli ID degli oggetti. Questo facilita il tracciamento degli oggetti nei flussi video e l'esecuzione di analisi successive. Ecco perché dovreste considerare l'uso di Ultralytics YOLO per le vostre esigenze di tracciamento degli oggetti:

• Efficienza: Elaborazione di flussi video in tempo reale senza compromettere la precisione.
• Flessibilità: Supporta diversi algoritmi e configurazioni di tracciamento.
• 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, che consentono l'integrazione in applicazioni specifiche per il dominio.

Guarda: Rilevamento e tracciamento di oggetti con Ultralytics YOLO .

Applicazioni nel mondo reale

Trasporto	Vendita al dettaglio	Acquacoltura
Tracciamento del veicolo	Tracciamento delle persone	Tracciamento dei pesci

Panoramica delle caratteristiche

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

• Tracciamento in tempo reale: Traccia senza problemi gli oggetti nei video ad alta velocità.
• Supporto di più tracker: Scegliete tra una serie di algoritmi di tracciamento consolidati.
• Configurazioni personalizzabili del tracker: L'algoritmo di tracciamento può essere adattato alle esigenze specifiche regolando vari parametri.

Tracciatori disponibili

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

• SORTEGGIAMENTO - Utilizzo botsort.yaml per abilitare questo tracker.
• ByteTrack - Utilizzo bytetrack.yaml per abilitare questo tracker.

Il tracker predefinito è BoT-SORT.

Tracciamento

Per eseguire il tracker sui flussi video, utilizzare un modello addestrato di Detect, Segment o Pose 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'uso sopra descritto, il tracciamento è disponibile per tutti i modelli Detect, Segment e Pose eseguiti su video o fonti di streaming.

Configurazione

Tracciamento degli argomenti

La configurazione di tracciamento condivide le proprietà con la modalità Previsione, come ad esempio conf, iou, e show. Per ulteriori configurazioni, consultare la sezione Prevedere 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 consente anche di utilizzare un file di configurazione del tracker modificato. Per farlo, basta fare una copia del file di configurazione del tracker (per esempio, custom_tracker.yaml) da ultralytics/cfg/tracker e modificare tutte le configurazioni (ad eccezione di quella 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'

Per una descrizione dettagliata di ciascun parametro, consultare la sezione Argomenti del tracker.

Argomenti 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 tabella seguente fornisce una descrizione di ciascun parametro:

Consentire la reidentificazione (ReID)

Per impostazione predefinita, ReID è disattivato per ridurre al minimo l'overhead delle prestazioni. Abilitarlo è semplice: basta impostare with_reid: True nel configurazione del tracker. È inoltre possibile personalizzare il model utilizzato per il ReID, consentendo di scegliere tra precisione e velocità a seconda del caso d'uso:

• Caratteristiche native (model: auto): Sfrutta le funzioni direttamente dal rilevatore YOLO per il ReID, aggiungendo un overhead minimo. È ideale quando si ha bisogno di un certo livello di ReID senza un impatto significativo sulle prestazioni. Se il rilevatore non supporta le funzioni native, torna automaticamente a usare il metodo yolo11n-cls.pt.
• Modelli di classificazione YOLO: È possibile impostare esplicitamente un modello di classificazione (ad es. yolo11n-cls.pt) per l'estrazione delle caratteristiche ReID. In questo modo si ottengono incorporazioni più discriminanti, ma si introduce una latenza aggiuntiva dovuta alla fase di inferenza supplementare.

Per ottenere 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, è possibile indicare il percorso del modello TensorRT nella configurazione del tracker e verrà utilizzato per il ReID durante il tracciamento.

Python Esempi

Tracce persistenti Loop

Ecco uno script di Python che utilizza OpenCV (cv2) e YOLO11 per eseguire il tracciamento degli oggetti sui fotogrammi video. Questo script presuppone che siano già stati installati i pacchetti necessari (opencv-python e ultralytics). Il persist=True indica al tracker che l'immagine o il fotogramma corrente è il successivo di una sequenza e che deve aspettarsi 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 noti il cambiamento da model(frame) a model.track(frame)che consente il tracciamento degli oggetti invece del semplice rilevamento. Questo script modificato esegue il tracker su ogni fotogramma del video, visualizza i risultati e li mostra in una finestra. Il ciclo può essere interrotto premendo 'q'.

Tracciare tracce 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 in un video. Con Ultralytics YOLO11 , tracciare queste tracce è un processo semplice ed efficiente.

Nell'esempio che segue, dimostriamo come utilizzare le capacità di tracciamento di YOLO11 per tracciare il movimento degli oggetti rilevati su più fotogrammi video. Lo 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 tra loro, è possibile 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 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()

Tracciamento multithread

Il tracciamento multithreading consente di eseguire il tracciamento degli oggetti su più flussi video contemporaneamente. Ciò è particolarmente utile quando si gestiscono più ingressi video, ad esempio da più telecamere di sorveglianza, dove l'elaborazione simultanea può migliorare notevolmente l'efficienza e le prestazioni.

Nello script Python fornito, si fa uso di Python's threading per eseguire più istanze del tracker in contemporanea. Ogni thread è responsabile dell'esecuzione del tracker su un file video e tutti i thread vengono eseguiti contemporaneamente in background.

Per garantire che ogni thread riceva i parametri corretti (il file video, il modello da utilizzare e l'indice del file), definiamo la 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 terminerà. Avviamo quindi i thread con start() e utilizzare join() per far sì che il thread principale attenda che entrambi i thread del tracker abbiano terminato.

Infine, dopo che tutti i thread hanno completato il loro compito, le finestre che visualizzano 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.

Contribuire a nuovi tracciatori

Siete esperti nell'inseguimento di più oggetti e avete implementato o adattato con successo un algoritmo di inseguimento con Ultralytics YOLO ? Vi invitiamo a contribuire alla nostra sezione Trackers in ultralytics/cfg/trackers! Le vostre applicazioni e soluzioni reali potrebbero essere preziose per gli utenti che lavorano al tracciamento.

Contribuendo a questa sezione, si contribuisce 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 comunità.

Per dare inizio al vostro contributo, consultate la nostra Guida alla contribuzione per le istruzioni complete sull'invio di una richiesta di pull (PR) 🛠️. Non vediamo l'ora di vedere cosa porterete in tavola!

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

FAQ

Che cos'è il Multi-Object Tracking e come lo supporta Ultralytics YOLO ?

Il tracciamento di più oggetti nell'analisi video implica sia l'identificazione degli oggetti che il mantenimento di un ID univoco per ogni oggetto rilevato in tutti i fotogrammi video. Ultralytics YOLO supporta questo aspetto fornendo il tracking in tempo reale insieme agli ID degli oggetti, facilitando attività come la sorveglianza di sicurezza e l'analisi degli sport. Il sistema utilizza tracker come BoT-SORT e ByteTrack, che possono essere configurati tramite file YAML.

Come si configura un tracker personalizzato per Ultralytics YOLO ?

È possibile configurare un tracker personalizzato copiando un file di configurazione del tracker esistente (ad esempio, custom_tracker.yaml) dal Ultralytics directory di configurazione del tracker e modificando i parametri secondo le necessità, ad eccezione dell'opzione tracker_type. Utilizzate questo file nel vostro modello di tracciamento 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 tracciamento degli oggetti su più flussi video contemporaneamente?

Per eseguire il tracciamento degli oggetti su più flussi video simultaneamente, è possibile utilizzare la funzione Python's threading modulo. Ogni thread gestirà un flusso video separato. Ecco un esempio di come si può configurare:

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 dell'inseguimento di più oggetti con Ultralytics YOLO ?

Il tracciamento di più oggetti con Ultralytics YOLO ha numerose applicazioni, tra cui:

• Trasporti: Tracciamento dei veicoli per la gestione del traffico e la guida autonoma.
• Commercio al dettaglio: Tracciamento delle persone per l'analisi e la sicurezza del punto vendita.
• Acquacoltura: Tracciamento dei pesci per il monitoraggio degli ambienti acquatici.
• Analisi dello sport: 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 traggono vantaggio dalla capacità di Ultralytics YOLO di elaborare video ad alta frequenza di fotogrammi in tempo reale con una precisione eccezionale.

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

Per visualizzare le tracce degli oggetti su più fotogrammi video, è possibile utilizzare le funzioni di tracciamento del modello YOLO insieme a OpenCV per disegnare i percorsi degli oggetti rilevati. Ecco un esempio di script 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 traccia 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.

📅C reato 1 anno fa ✏️ Aggiornato 2 giorni fa

Commenti