Link to this sectionSeguimiento de múltiples objetos con Ultralytics YOLO#

El seguimiento de objetos en el ámbito de la analítica de vídeo es una tarea fundamental 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 vigilancia y seguridad hasta analítica deportiva en tiempo real.

Link to this section¿Por qué elegir Ultralytics YOLO para el seguimiento de objetos?#

El resultado de los seguidores 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. He aquí por qué deberías considerar usar 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 en Python y CLI 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 dominio.

Link to this sectionAplicaciones en el mundo real#

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

Link to this sectionResumen de características#

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 fluido de objetos en vídeos con alta tasa de fotogramas.
• Compatibilidad con múltiples seguidores: Elige entre una variedad de algoritmos de seguimiento establecidos.
• Configuraciones de seguimiento personalizables: Adapta el algoritmo de seguimiento para cumplir con requisitos específicos ajustando varios parámetros.

Link to this sectionSeguidores disponibles#

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

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

El seguidor predeterminado es BoT-SORT.

Link to this sectionSeguimiento#

Para ejecutar el seguidor 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 Ultralytics Platform.

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.

Link to this sectionConfiguración#

Link to this sectionArgumentos de seguimiento#

La configuración de seguimiento comparte propiedades con el modo Predict, como conf, iou y show. Para configuraciones adicionales, 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)

Link to this sectionSelección del seguidor#

Ultralytics también te permite usar un archivo de configuración de seguidor modificado. Para hacer esto, simplemente realiza una copia de un archivo de configuración de seguidor (por ejemplo, custom_tracker.yaml) desde ultralytics/cfg/trackers y modifica las configuraciones (excepto 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 seguidor para obtener una descripción detallada de cada parámetro.

Link to this sectionArgumentos del seguidor#

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, búferes y lógica de emparejamiento:

• botsort.yaml
• bytetrack.yaml

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

Link to this sectionHabilitación de la reidentificación (ReID)#

De forma predeterminada, ReID está desactivado para minimizar la sobrecarga de rendimiento. Habilitarlo es sencillo: solo establece with_reid: True en la configuración del seguidor. 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:

• 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 necesitas cierto nivel de ReID sin afectar significativamente el rendimiento. Si el detector no admite características nativas, automáticamente recurre al uso de yolo26n-cls.pt.
• Modelos de clasificación YOLO: Puedes establecer explícitamente un modelo de clasificación (por ejemplo, yolo26n-cls.pt) para la extracción de características ReID. Esto proporciona incrustaciones más discriminativas, pero introduce una latencia adicional debido al paso de inferencia extra.

Para un mejor rendimiento, especialmente al usar 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 apuntar a la ruta del modelo TensorRT en tu configuración de seguidor, y se utilizará para ReID durante el seguimiento.

Link to this sectionEjemplos en Python#

Link to this sectionBucle de persistencia de seguimientos#

Aquí tienes un script de Python que utiliza 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 seguidor 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 la simple detección. Este script modificado ejecutará el seguidor en cada fotograma del vídeo, visualizará los resultados y los mostrará en una ventana. El bucle se puede salir presionando 'q'.

Link to this sectionTrazado 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 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 las cajas delimitadoras detectadas y conectarlos, podemos dibujar líneas que representen los caminos seguidos 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()

Link to this sectionSeguimiento multihilo#

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 al manejar múltiples entradas de vídeo, como las de varias cámaras de vigilancia, donde el procesamiento concurrente puede mejorar enormemente la eficiencia y el rendimiento.

En el script de Python proporcionado, hacemos uso del módulo threading de Python para ejecutar múltiples instancias del seguidor de forma concurrente. Cada hilo es responsable de ejecutar el seguidor en un archivo de vídeo, y todos los hilos se ejecutan simultáneamente en segundo plano.

Para asegurar que cada hilo reciba los parámetros correctos (el archivo de vídeo, el modelo a usar 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 seguidor 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 del seguidor 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 se puede ampliar fácilmente para manejar más archivos de vídeo y modelos creando más hilos y aplicando la misma metodología.

Link to this sectionContribuye con nuevos seguidores#

¿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 seguidores 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 puedes aportar!

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

Link to this sectionPreguntas frecuentes#

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

El seguimiento de múltiples objetos en analítica de vídeo implica tanto identificar objetos como mantener 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 IDs de los objetos, lo que facilita tareas como la vigilancia de seguridad y el análisis deportivo. El sistema utiliza seguidores como BoT-SORT y ByteTrack, los cuales pueden configurarse mediante archivos YAML.

Link to this section¿Cómo configuro un seguidor personalizado para Ultralytics YOLO?#

Puedes configurar un seguidor personalizado copiando un archivo de configuración de seguidor existente (por ejemplo, custom_tracker.yaml) desde el directorio de configuración de seguidores de Ultralytics y modificando los parámetros según sea necesario, a excepción de tracker_type. Usa este archivo en tu modelo de seguimiento de la siguiente manera:

from ultralytics import YOLO

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

Link to this section¿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 utilizar el módulo threading de Python. Cada hilo gestionará un flujo de vídeo separado. 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()

Link to this section¿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.
• Venta minorista: Seguimiento de personas para análisis en tienda y seguridad.
• Acuicultura: Seguimiento de peces para monitorizar entornos acuáticos.
• Análisis deportivo: Seguimiento de jugadores y equipamiento para 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.

Link to this section¿Cómo puedo visualizar los recorridos de objetos a través de múltiples fotogramas de vídeo con Ultralytics YOLO?#

Para visualizar los recorridos 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 trayectorias de los objetos detectados. Aquí tienes un ejemplo de script 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.