Seguimiento de múltiples objetos con Ultralytics YOLO

El seguimiento de objetos en el ámbito de la analítica de vídeo 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 vídeo. Las aplicaciones son ilimitadas, desde la vigilancia y la seguridad hasta la analítica deportiva en tiempo real.

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

El resultado de los rastreadores de Ultralytics es consistente con la detección de objetos estándar, pero tiene el valor añadido de los IDs de objeto. Esto facilita el seguimiento de objetos en flujos de vídeo y la realización de análisis posteriores. Aquí tienes por qué deberías considerar el uso de Ultralytics YOLO para tus necesidades de seguimiento de objetos:

• Eficiencia: Procesa flujos de vídeo en tiempo real sin comprometer la precisión.
• Flexibilidad: Admite múltiples algoritmos y configuraciones de seguimiento.
• Facilidad de uso: Opciones sencillas de API y CLI de Python para una integración y despliegue rápidos.
• Personalización: Fácil de usar con modelos YOLO entrenados a medida, lo que permite la integración en aplicaciones específicas de cada dominio.

Aplicaciones en el mundo real

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

Características de un vistazo

Ultralytics YOLO amplía sus características de detección de objetos para proporcionar un seguimiento de objetos robusto y versátil:

• Seguimiento en tiempo real: Rastrea objetos sin problemas en vídeos de alta tasa de fotogramas.
• Soporte para múltiples rastreadores: Elige entre una variedad de algoritmos de seguimiento establecidos.
• Configuraciones de rastreador personalizables: Adapta el algoritmo de seguimiento para satisfacer requisitos específicos ajustando varios parámetros.

Rastreadores disponibles

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

• BoT-SORT - Usa botsort.yaml para habilitar este rastreador.
• ByteTrack - Usa bytetrack.yaml para habilitar este rastreador.

El rastreador predeterminado es BoT-SORT.

Seguimiento

Para ejecutar el rastreador en flujos de vídeo, utiliza un modelo entrenado de Detección, Segmentación o Pose, como YOLO26n, YOLO26n-seg o YOLO26n-pose. Puedes entrenar modelos personalizados localmente o en GPUs en la nube a través de la Plataforma 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

Como se puede ver en el uso anterior, el seguimiento está disponible para todos los modelos de Detección, Segmentación y Pose ejecutados en vídeos o fuentes de streaming.

Configuración

Argumentos de seguimiento

La configuración de seguimiento comparte propiedades con el modo de predicción, como conf, iou y show. Para más configuraciones, consulta la página del modelo 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)

Selección del rastreador

Ultralytics también te permite utilizar un archivo de configuración de rastreador modificado. Para ello, simplemente haz una copia de un archivo de configuración de rastreador (por ejemplo, custom_tracker.yaml) desde ultralytics/cfg/trackers y modifica cualquier configuración (excepto el tracker_type) según tus necesidades.

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 sección Argumentos del rastreador para obtener una descripción detallada de cada parámetro.

Argumentos del rastreador

Algunos comportamientos de seguimiento se pueden ajustar editando los archivos de configuración YAML específicos para cada algoritmo de seguimiento. Estos archivos definen parámetros como umbrales, buffers 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)

Por defecto, ReID está desactivado para minimizar el impacto en el rendimiento. Habilitarlo es sencillo: solo tienes que establecer with_reid: True en la configuración del rastreador. También puedes personalizar el model utilizado para ReID, lo que te permite equilibrar la precisión y la velocidad según tu caso de uso:

• Funciones nativas (model: auto): Esto aprovecha las características directamente del detector YOLO para ReID, añadiendo una carga mínima. Es ideal cuando necesitas cierto nivel de ReID sin afectar significativamente el rendimiento. Si el detector no admite funciones nativas, recurre automáticamente al uso de yolo26n-cls.pt.
• Modelos de clasificación YOLO: Puedes establecer explícitamente un modelo de clasificación (p. ej., yolo26n-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 utilizas un modelo de clasificación separado para ReID, puedes exportarlo a un backend más rápido como 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 vez exportado, puedes señalar la ruta del modelo TensorRT en la configuración de tu rastreador y se utilizará para ReID durante el seguimiento.

Ejemplos en Python

Bucle de persistencia de seguimientos

Aquí tienes un script en Python usando OpenCV (cv2) y YOLO26 para ejecutar el seguimiento de objetos en fotogramas de vídeo. Este script asume que los paquetes necesarios (opencv-python y ultralytics) ya están instalados. El argumento persist=True le indica al rastreador que la imagen o el fotograma actual es el siguiente en una secuencia y que espere seguimientos de la imagen anterior en la imagen actual.

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

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

Trazado de seguimientos a lo largo del tiempo

Visualizar los seguimientos de objetos en 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 YOLO26, trazar estos seguimientos es un proceso fluido y eficiente.

En el siguiente ejemplo, demostramos cómo utilizar las capacidades de seguimiento de YOLO26 para trazar el movimiento de los objetos detectados a lo largo de varios 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 conservar los puntos centrales de los cuadros delimitadores detectados y conectarlos, podemos dibujar líneas que representen las rutas seguidas por los objetos rastreados.

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

Seguimiento multihilo

El seguimiento multihilo ofrece la capacidad de ejecutar el seguimiento de objetos en múltiples flujos de vídeo simultáneamente. Esto es particularmente útil cuando se manejan varias entradas de vídeo, como 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 simultáneamente. Cada hilo es responsable de ejecutar el rastreador en un archivo de vídeo, y todos los hilos se ejecutan al mismo tiempo en segundo plano.

Para asegurar que cada hilo reciba 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: yolo26n.pt y yolo26n-seg.pt, cada uno rastreando objetos en un archivo de vídeo diferente. Los archivos de vídeo se especifican en SOURCES.

El parámetro daemon=True en threading.Thread significa que estos hilos se cerrarán tan pronto como finalice el programa principal. Luego, iniciamos los hilos con start() y usamos join() para hacer que el hilo principal espere hasta que ambos hilos de rastreo 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 = ["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()

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 rastreadores

¿Tienes experiencia en 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 invaluables 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 de Ultralytics YOLO, añadiendo otra capa de funcionalidad y utilidad para la comunidad.

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

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

Preguntas frecuentes

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

El seguimiento de múltiples objetos en el análisis de vídeo implica tanto identificar objetos como mantener un ID único para cada objeto detectado a través de los fotogramas del vídeo. Ultralytics YOLO admite esto proporcionando un seguimiento en tiempo real junto con los IDs de los objetos, lo que facilita tareas como la vigilancia de seguridad y el análisis deportivo. El sistema utiliza trackers como BoT-SORT y ByteTrack, los cuales se pueden configurar mediante 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) desde el directorio de configuración de trackers de Ultralytics y modificando los parámetros según sea necesario, excepto por el tracker_type. Usa este archivo en tu modelo de seguimiento de esta manera:

from ultralytics import YOLO

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

¿Cómo puedo ejecutar el seguimiento de objetos en múltiples flujos de vídeo simultáneamente?

Para ejecutar el seguimiento de objetos en múltiples flujos de vídeo simultáneamente, puedes usar el módulo threading de Python. Cada hilo se encargará de un flujo de vídeo independiente. 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 = ["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()

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

El seguimiento de múltiples objetos con Ultralytics YOLO tiene numerosas aplicaciones, incluyendo:

• Transporte: Seguimiento de vehículos para la gestión del tráfico y conducción autónoma.
• Comercio minorista: Seguimiento de personas para análisis dentro de la tienda y seguridad.
• Acuicultura: Seguimiento de peces para el monitoreo de entornos acuáticos.
• Análisis Deportivo: Seguimiento de jugadores y equipamiento para el análisis de rendimiento.
• Sistemas de Seguridad: Monitorización 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 tasa de fotogramas en tiempo real con una precisión excepcional.

¿Cómo puedo visualizar los seguimientos de objetos a través de múltiples fotogramas de vídeo con Ultralytics YOLO?

Para visualizar los seguimientos de objetos a través de múltiples fotogramas de vídeo, puedes usar las funciones de seguimiento del modelo YOLO junto con OpenCV para dibujar las rutas 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("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()

Este script trazará las líneas de seguimiento mostrando 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.