Seguimiento de Múltiples Objetos con Ultralytics YOLO

El seguimiento de objetos en el ámbito del análisis de video es una tarea crítica que no solo identifica la ubicación y la clase de los objetos dentro del fotograma, sino que también mantiene un ID único para cada objeto detectado a medida que avanza el video. Las aplicaciones son ilimitadas, desde la vigilancia y la seguridad hasta el análisis deportivo en tiempo real.

¿Por qué elegir Ultralytics YOLO para el seguimiento de objetos?

La salida de los trackers de Ultralytics es consistente con la detección de objetos estándar, pero tiene el valor añadido de los ID de objeto. Esto facilita el seguimiento de objetos en transmisiones de video y la realización de análisis posteriores. Aquí te explicamos por qué deberías considerar el uso de Ultralytics YOLO para tus necesidades de seguimiento de objetos:

• Eficiencia: Procesa transmisiones de video en tiempo real sin comprometer la precisión.
• Flexibilidad: Soporta múltiples algoritmos de seguimiento y configuraciones.
• Facilidad de uso: API de python y opciones de CLI sencillas para una rápida integración e implementación.
• Personalización: Fácil de usar con modelos YOLO entrenados a medida, lo que permite la integración en aplicaciones específicas del dominio.

Ver: Detección y seguimiento de objetos con Ultralytics YOLO.

Aplicaciones en el mundo real

Transporte	Venta minorista	Acuicultura
Seguimiento de vehículos	Seguimiento de personas	Seguimiento de peces

Características de un vistazo

Ultralytics YOLO extiende sus funciones de detección de objetos para proporcionar un seguimiento de objetos robusto y versátil:

• Seguimiento en tiempo real: Realiza un seguimiento perfecto de los objetos en vídeos de alta velocidad de fotogramas.
• Soporte para múltiples trackers: Elija entre una variedad de algoritmos de seguimiento establecidos.
• Configuraciones de tracker personalizables: Adapte el algoritmo de seguimiento para que cumpla requisitos específicos ajustando varios parámetros.

Trackers disponibles

Ultralytics YOLO admite los siguientes algoritmos de seguimiento. Se pueden activar pasando el archivo de configuración YAML correspondiente, como tracker=tracker_type.yaml:

• BoT-SORT - Usar botsort.yaml para habilitar este tracker.
• ByteTrack - Usar bytetrack.yaml para habilitar este tracker.

El tracker predeterminado es BoT-SORT.

Seguimiento

Para ejecutar el tracker en transmisiones de vídeo, utilice un modelo Detect, Segment o Pose entrenado, como YOLO11n, YOLO11n-seg y 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"

Como se puede ver en el uso anterior, el seguimiento está disponible para todos los modelos Detect, Segment y Pose que se ejecutan en vídeos o fuentes de transmisión.

Configuración

Argumentos de seguimiento

La configuración del tracking comparte propiedades con el modo Predict, como conf, iou, y show. Para obtener más configuraciones, consulte la Predecir página del modelo.

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

Selección de Tracker

Ultralytics también le permite utilizar un archivo de configuración de tracker modificado. Para ello, simplemente haga una copia de un archivo de configuración de tracker (por ejemplo, custom_tracker.yaml') de ultralytics/cfg/trackers y modifique cualquier configuración (excepto el tracker_type') según sus necesidades.

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'

Consulte la sección Argumentos del Tracker para obtener una descripción detallada de cada parámetro.

Argumentos del Tracker

Algunos comportamientos de seguimiento se pueden ajustar editando los archivos de configuración YAML específicos de cada algoritmo de seguimiento. Estos archivos definen parámetros como umbrales, búferes y lógica de coincidencia:

• botsort.yaml
• bytetrack.yaml

La siguiente tabla proporciona una descripción de cada parámetro:

Habilitación de la reidentificación (ReID)

De forma predeterminada, ReID está desactivado para minimizar la sobrecarga de rendimiento. Habilitarlo es sencillo: solo tienes que configurar with_reid: True en el configuración del tracker. También puede personalizar el model utilizado para ReID, lo que le permite intercambiar precisión y velocidad según su caso de uso:

• Características nativas (model: auto): Esto aprovecha las características directamente del detector YOLO para ReID, añadiendo una sobrecarga mínima. Es ideal cuando se necesita cierto nivel de ReID sin afectar significativamente el rendimiento. Si el detector no admite características nativas, automáticamente recurre al uso de yolo11n-cls.pt.
• Modelos de clasificación YOLO: Puede establecer explícitamente un modelo de clasificación (p. ej. yolo11n-cls.pt) para la extracción de características de ReID. Esto proporciona incrustaciones más discriminativas, pero introduce latencia adicional debido al paso de inferencia extra.

Para un mejor rendimiento, especialmente cuando se utiliza un modelo de clasificación separado para ReID, puede exportarlo a un backend más rápido como 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 vez exportado, puede apuntar a la ruta del modelo TensorRT en su configuración de tracker, y se utilizará para ReID durante el tracking.

Ejemplos de python

Persistencia del bucle de seguimiento

Aquí tienes un script de python que utiliza OpenCV (cv2) y YOLO11 para ejecutar el seguimiento de objetos en fotogramas de vídeo. Este script sigue asumiendo que ya has instalado los paquetes necesarios (opencv-python y ultralytics). El persist=True argumento le indica al rastreador que la imagen o el fotograma actual es el siguiente en una secuencia y que espere pistas de la imagen anterior en la imagen actual.

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

Ten en cuenta el cambio de model(frame) a datos model.track(frame), que permite el seguimiento de objetos en lugar de la simple detección. Este script modificado ejecutará el rastreador en cada fotograma del vídeo, visualizará los resultados y los mostrará en una ventana. Se puede salir del bucle pulsando 'q'.

Trazado de pistas a lo largo del tiempo

La visualización de las trayectorias de los objetos a lo largo de fotogramas consecutivos puede proporcionar información valiosa sobre los patrones de movimiento y el comportamiento de los objetos detectados dentro de un vídeo. Con Ultralytics YOLO11, trazar estas trayectorias es un proceso sencillo y eficiente.

En el siguiente ejemplo, demostramos cómo utilizar las capacidades de seguimiento de YOLO11 para trazar el movimiento de los objetos detectados a través de múltiples fotogramas de vídeo. Este script implica abrir un archivo de vídeo, leerlo fotograma a fotograma y utilizar el modelo YOLO para identificar y rastrear varios objetos. Al retener los puntos centrales de los cuadros delimitadores detectados y conectarlos, podemos dibujar líneas que representan las rutas seguidas por los objetos rastreados.

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

Seguimiento multiproceso

El seguimiento multihilo proporciona la capacidad de ejecutar el seguimiento de objetos en múltiples flujos de vídeo simultáneamente. Esto es particularmente útil cuando se manejan múltiples entradas de vídeo, como las de múltiples cámaras de vigilancia, donde el procesamiento concurrente puede mejorar enormemente la eficiencia y el rendimiento.

En el script de python proporcionado, utilizamos el módulo threading de python para ejecutar múltiples instancias del rastreador concurrentemente. Cada hilo es responsable de ejecutar el rastreador en un archivo de vídeo, y todos los hilos se ejecutan simultáneamente en segundo plano.

Para asegurar que cada hilo recibe los parámetros correctos (el archivo de vídeo, el modelo a utilizar y el índice del archivo), definimos una función run_tracker_in_thread que acepta estos parámetros y contiene el bucle de seguimiento principal. Esta función lee el vídeo fotograma a fotograma, ejecuta el rastreador y muestra los resultados.

En este ejemplo se utilizan dos modelos diferentes: yolo11n.pt y yolo11n-seg.pt, cada uno rastreando objetos en un archivo de vídeo diferente. Los archivos de vídeo se especifican en SOURCES.

El daemon=True parámetro en threading.Thread significa que estos hilos se cerrarán tan pronto como termine el programa principal. A continuación, iniciamos los hilos con start() y utilizamos join() para hacer que el hilo principal espere hasta que ambos hilos de seguimiento hayan terminado.

Finalmente, después de que todos los hilos hayan completado su tarea, las ventanas que muestran los resultados se cierran 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()

Este ejemplo puede extenderse fácilmente para manejar más archivos de vídeo y modelos creando más hilos y aplicando la misma metodología.

Contribuir con nuevos Trackers

¿Eres experto en el seguimiento de múltiples objetos y has implementado o adaptado con éxito un algoritmo de seguimiento con Ultralytics YOLO? ¡Te invitamos a contribuir a nuestra sección de Trackers en ultralytics/cfg/trackers! Tus aplicaciones y soluciones del mundo real podrían ser inestimables para los usuarios que trabajan en tareas de seguimiento.

Al contribuir a esta sección, ayudas a ampliar el alcance de las soluciones de seguimiento disponibles dentro del framework Ultralytics YOLO, añadiendo otra capa de funcionalidad y utilidad para la comunidad.

Para iniciar tu contribución, por favor, consulta nuestra Guía de Contribución para obtener instrucciones completas sobre cómo enviar un Pull Request (PR) 🛠️. ¡Estamos emocionados de ver lo que aportas!

¡Juntos, mejoremos las capacidades de seguimiento del ecosistema Ultralytics YOLO 🙏!

Preguntas frecuentes

¿Qué es el seguimiento de múltiples objetos y cómo lo soporta Ultralytics YOLO?

El seguimiento de múltiples objetos en el análisis de vídeo implica tanto la identificación de objetos como el mantenimiento de un ID único para cada objeto detectado a través de los fotogramas de vídeo. Ultralytics YOLO admite esto proporcionando seguimiento en tiempo real junto con los ID de los objetos, facilitando tareas como la vigilancia de seguridad y el análisis deportivo. El sistema utiliza rastreadores como BoT-SORT y ByteTrack, que se pueden configurar a través de archivos YAML.

¿Cómo configuro un tracker personalizado para Ultralytics YOLO?

Puedes configurar un tracker personalizado copiando un archivo de configuración de tracker existente (por ejemplo, custom_tracker.yaml) del directorio de configuración de trackers de Ultralytics y modificando los parámetros según sea necesario, excepto el tracker_type. Utiliza este archivo en tu modelo de seguimiento de la siguiente manera:

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'

¿Cómo puedo ejecutar el seguimiento de objetos en múltiples transmisiones de video simultáneamente?

Para ejecutar el seguimiento de objetos en múltiples transmisiones de video simultáneamente, puedes usar el módulo threading de python. Cada hilo manejará una transmisión de video separada. Aquí tienes un ejemplo de cómo puedes configurarlo:

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

¿Cuáles son las aplicaciones en el mundo real del seguimiento de múltiples objetos con Ultralytics YOLO?

El seguimiento multi-objeto con Ultralytics YOLO tiene numerosas aplicaciones, incluyendo:

• Transporte: Seguimiento de vehículos para la gestión del tráfico y la conducción autónoma.
• Venta al por menor: Seguimiento de personas para análisis en tienda y seguridad.
• Acuicultura: Seguimiento de peces para la monitorización de entornos acuáticos.
• Análisis deportivo: Seguimiento de jugadores y equipos para el análisis del rendimiento.
• Sistemas de seguridad: Monitoreo de actividades sospechosas y creación de alarmas de seguridad.

Estas aplicaciones se benefician de la capacidad de Ultralytics YOLO para procesar vídeos de alta velocidad de fotogramas en tiempo real con una precisión excepcional.

¿Cómo puedo visualizar el seguimiento de objetos en múltiples fotogramas de video con Ultralytics YOLO?

Para visualizar los seguimientos de objetos a través de múltiples fotogramas de video, puedes usar las funciones de seguimiento del modelo YOLO junto con OpenCV para dibujar las trayectorias de los objetos detectados. Aquí tienes un script de ejemplo que demuestra esto:

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

Este script trazará las líneas de seguimiento que muestran las rutas de movimiento de los objetos rastreados a lo largo del tiempo, proporcionando información valiosa sobre el comportamiento y los patrones de los objetos.

📅 Creado hace 1 año ✏️ Actualizado hace 2 meses

Comentarios