Seguimiento de múltiples objetos con Ultralytics YOLO#

El seguimiento de objetos en el ámbito del análisis 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 infinitas, desde la vigilancia y la seguridad hasta el análisis deportivo en tiempo real.

Consulta la vista previa de YOLO27 no publicada para ver el soporte de seguimiento planificado.

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

La salida de los rastreadores de Ultralytics es coherente con la detección de objetos estándar, pero cuenta con el valor añadido de los ID de objetos. Esto facilita el seguimiento de objetos en transmisiones de vídeo y la realización de análisis posteriores. He aquí por qué deberías considerar el uso de Ultralytics YOLO para tus necesidades de seguimiento de objetos:

• Eficiencia: Procesa transmisiones de vídeo en tiempo real sin comprometer la precisión.
• Flexibilidad: Admite múltiples algoritmos y configuraciones de seguimiento.
• Facilidad de uso: API de Python simple y opciones de 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 un dominio.

Aplicaciones del mundo real#

Inicio rápido#

Ejecuta el seguimiento en un vídeo con el rastreador predeterminado TrackTrack. Cambia a otro rastreador modificando el argumento tracker.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Default tracker (TrackTrack)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)

# Switch to ByteTrack
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")

Para ejecutar el rastreador en transmisiones de vídeo, utiliza un modelo entrenado de detección, segmentación, pose u OBB, como YOLO26n, YOLO26n-seg, YOLO26n-pose o YOLO26n-obb. Puedes entrenar modelos personalizados localmente o con el entrenamiento en la nube 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

Rastreadores compatibles#

Ultralytics YOLO incluye seis rastreadores integrados. Activa uno pasando su archivo de configuración YAML al argumento tracker.

¿Qué rastreador deberías usar?#

Usa este flujo para elegir un punto de partida; tracktrack.yaml se utiliza cuando no pasas ningún tracker:

1. ¿Necesitas la línea base más rápida y sencilla? → ByteTrack (sin ReID, sin compensación de movimiento de cámara, sobrecarga mínima).
2. ¿Metraje de cámara en mano, dron o cámara en movimiento? → BoT-SORT (añade compensación de movimiento de cámara y ReID opcional).
3. ¿Movimiento no lineal (deportes, baile, giros bruscos) y sin ReID? → OC-SORT (correcciones céntricas en la observación sin coste de apariencia).
4. ¿Escenas con cámara en movimiento y aglomeraciones donde los cambios de ID son el problema principal? → Deep OC-SORT o TrackTrack (ambos admiten coincidencia de apariencia opcional; TrackTrack también añade asociación de múltiples indicios y supresión de ID duplicados).
5. ¿Solapamiento parcial frecuente en tiempo real, sin presupuesto para ReID? → FastTracker (variante de ByteTrack consciente de oclusiones con reversión de Kalman).

Cambiando de rastreador#

Pasa el nombre del archivo de configuración del rastreador a tracker=. Todo lo demás permanece igual.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

results = model.track(source="path/to/video.mp4", tracker="bytetrack.yaml")
results = model.track(source="path/to/video.mp4", tracker="ocsort.yaml")
results = model.track(source="path/to/video.mp4", tracker="tracktrack.yaml")

Configuración#

Argumentos de seguimiento#

La configuración de seguimiento comparte propiedades con el modo Predict, como conf, iou y show. Para más configuraciones, consulta la página del modelo de predicción.

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)

Configuración de rastreador personalizado#

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 las configuraciones que necesites (excepto el tracker_type).

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

Argumentos de rastreador compartidos#

Los siguientes parámetros son comunes a la mayoría de los archivos YAML de los rastreadores; no todos los parámetros aparecen en cada configuración:

Argumentos específicos del rastreador#

Cada algoritmo expone controles adicionales además de los parámetros compartidos. Consulta las secciones de cada rastreador a continuación para ver descripciones y consejos de ajuste, o consulta directamente los archivos de configuración:

• botsort.yaml
• bytetrack.yaml
• ocsort.yaml
• deepocsort.yaml
• fasttrack.yaml
• tracktrack.yaml

Habilitación de la reidentificación (ReID)#

ReID está deshabilitado de forma predeterminada para minimizar la sobrecarga. Habilítalo configurando with_reid: True en un archivo de configuración del rastreador.

Opciones del modelo ReID:

• model: auto — Utiliza características nativas del detector YOLO, añadiendo una sobrecarga mínima. Es ideal cuando necesitas algo de ReID sin una gran pérdida de rendimiento. Vuelve a yolo26n-cls.pt si el detector no expone características compatibles.
• Modelo ReID personalizado — Apunta model: a un punto de control de .pt o a un modelo de incrustación exportado compatible, como .torchscript, .onnx, .engine o un directorio de modelos OpenVINO. Los modelos exportados se cargan a través de AutoBackend y deben emitir un tensor de incrustación directamente.

Se publican codificadores ONNX listos para usar para cada tamaño de modelo. Configura model: con uno de estos nombres y el archivo se descargará automáticamente la primera vez que se ejecute el rastreador (de la misma manera que se obtienen los pesos de YOLO); no se requiere ningún paso de descarga o exportación manual:

# In your tracker config (e.g. tracktrack.yaml)
with_reid: True
model: yolo26n-reid.onnx # downloaded on first use; swap n→s/m/l/x for a larger encoder

Para un mejor rendimiento con un modelo de clasificación independiente, expórtalo 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", quantize=16, dynamic=True, batch=32)

Una vez exportado, apunta a la ruta del modelo TensorRT en la configuración de tu rastreador.

Detalles del rastreador#

Las secciones siguientes describen el diseño de cada rastreador, sus parámetros específicos y consejos de ajuste.

BoT-SORT#

BoT-SORT (Aharon et al., 2022) amplía ByteTrack con compensación de movimiento de cámara y ReID opcional:

• Compensación de movimiento de cámara (CMC): se aplica una deformación afín estimada en cada fotograma (flujo óptico disperso por defecto; ORB / ECC también disponibles) a los estados de Kalman antes de la coincidencia de IoU.
• ReID opcional: las incrustaciones de apariencia se pueden fusionar en la matriz de costes. Deshabilitado de forma predeterminada; habilítalo con with_reid: True.

Ideal para: seguimiento de propósito general, especialmente con cámaras en movimiento. Añade ReID solo cuando las multitudes con aspecto similar causen cambios de ID.

Argumentos específicos de BoT-SORT:

Consejos de ajuste:

• Cámara estática: configura gmc_method: none para ahorrar unos pocos ms/fotograma.
• Movimiento intenso de la cámara: mantén sparseOptFlow; ecc es más preciso pero más lento.
• Multitudes con aspecto similar: activa with_reid: True y aumenta appearance_thresh (por ejemplo, 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) es la base ligera. Utiliza Kalman lineal + IoU con una asociación en dos fases:

• Fase 1: empareja detecciones de alta puntuación con pistas activas.
• Fase 2: reintenta pistas no emparejadas con detecciones de baja puntuación para recuperar a través de una breve oclusión parcial.

No hay un modelo de apariencia ni compensación de movimiento de cámara.

Ideal para: cámaras estáticas o casi estáticas donde el coste del detector domina y quieres un uso mínimo del rastreador.

Argumentos específicos de ByteTrack: Ninguno más allá de los argumentos compartidos del rastreador.

Consejos de ajuste:

• Detector ruidoso: reduce track_low_thresh para que la segunda fase tenga más candidatos.
• Detector de alta recuperación: aumenta track_high_thresh para reducir IDs fragmentados.
• Parpadeo frecuente de ID: aumenta track_buffer para que las pistas perdidas brevemente sobrevivan.

OC-SORT#

OC-SORT (Cao et al., CVPR 2023) es una extensión de SORT centrada en observaciones. Mantiene el diseño ligero de SORT (sin características de apariencia) y añade tres correcciones:

• Actualización basada en observaciones (ORU): reproduce una trayectoria virtual entre la última observación y la detección actual, ejecutando de nuevo la actualización de Kalman para reparar la velocidad desviada.
• Momento basado en observaciones (OCM): penaliza las detecciones que se mueven en la dirección incorrecta mediante un término de consistencia de velocidad.
• Recuperación basada en observaciones (OCR): vuelve a comprobar las detecciones no emparejadas frente a las pistas perdidas recientemente utilizando su última observación en lugar del estado predicho.

Ideal para: movimiento no lineal sin el coste de un modelo de ReID.

Argumentos específicos de OC-SORT:

Consejos de ajuste:

• Movimiento no lineal: aumenta inertia (por ejemplo, 0.3-0.4).
• Detecciones dispersas: activa use_byte: True.
• Oclusiones largas: aumenta track_buffer para que OCR tenga más pistas perdidas que volver a vincular.

Con los modelos de OBB, OCR utiliza la caja orientada predicha por Kalman porque no se conserva un historial de la última observación orientada.

Deep OC-SORT#

Deep OC-SORT amplía OC-SORT con información de apariencia y compensación de movimiento de cámara:

• Coincidencia de apariencia: la distancia de incrustación de coseno está limitada por solapamiento y se fusiona con el coste de movimiento.
• EMA de apariencia dinámica: las incrustaciones de las pistas se actualizan con una EMA cuyo factor de suavizado se adapta a la confianza de la detección.
• Compensación de movimiento de cámara: los estados de Kalman se deforman de fotograma a fotograma mediante flujo óptico disperso, ORB o ECC.

Ideal para: escenas concurridas o con cámaras en movimiento donde los cambios de ID entre objetos visualmente diferentes pero espacialmente cercanos son comunes.

Argumentos específicos de Deep OC-SORT:

Consejos de ajuste:

• Intercambios de identidad en multitudes: aumenta appearance_thresh (por ejemplo, 0.92-0.95) y aumenta alpha_fixed_emb para que las incrustaciones se adapten más lentamente.
• Cámara en movimiento: configura gmc_method: sparseOptFlow (Deep OC-SORT usa por defecto none).
• Menor latencia: mantén with_reid: False (predeterminado) solo para movimiento + compensación de movimiento de cámara; activa ReID solo cuando los cambios de ID dominen los errores.

FastTracker#

FastTracker es una variante de ByteTrack consciente de la oclusión sin modelo de apariencia:

• Detección de oclusión: marca las pistas como ocluidas cuando la cobertura de otras pistas activas supera occ_cover_thresh.
• Reversión de Kalman en oclusión: retrocede el estado de Kalman a un fotograma anterior a la oclusión utilizando un historial en búfer circular.
• Amortiguación del movimiento y expansión de la búsqueda: la velocidad se amortigua y la caja delimitadora predicha se agranda mientras está ocluida.
• Supresión de Init-IoU: evita que se generen nuevas pistas encima de las activas.

Ideal para: canalizaciones de solo detección en tiempo real con solapamiento frecuente entre objetivos (multitudes, colas, deportes).

Argumentos específicos de FastTracker:

Consejos de ajuste:

• Oclusiones parciales frecuentes: reduce occ_cover_thresh (por ejemplo, 0.5-0.6).
• IDs duplicados alrededor del solapamiento: reduce init_iou_suppress (por ejemplo, 0.5).
• Oclusiones largas: aumenta occ_reappear_window y track_buffer juntos.
• Objetivos de movimiento rápido: aumenta dampen_motion_occ (más cerca de 1.0); aumenta enlarge_bbox_occ solo cuando una región de búsqueda más amplia mejore la recuperación.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) es el rastreador por defecto. Razona desde la perspectiva de cada pista con asociación iterativa multiseñal:

• Asociación basada en la perspectiva de la pista (TPA): combina HMIoU, distancia de ReID de coseno opcional, distancia de proyección de confianza y distancia de ángulo de esquina. La asignación se resuelve iterativamente con un umbral relajante.
• Inicialización consciente de la pista (TAI): suprime las creaciones duplicadas antes de que se cree un nuevo ID.

Ideal para: escenas concurridas con oclusión frecuente donde los ID duplicados son un problema.

Argumentos específicos de TrackTrack:

Consejos de ajuste:

• Peatones concurridos: reduce tai_thr (por ejemplo, 0.45) para suprimir más creaciones duplicadas; aumenta track_buffer para oclusiones más largas.
• Movimiento rápido de la cámara: mantén gmc_method: sparseOptFlow habilitado.
• Objetivos pequeños o rápidos: aumenta ligeramente angle_weight y reduce min_track_len.
• Habilita ReID solo cuando sea necesario: añade coste de inferencia; para oclusiones cortas, el coste multiseñal predeterminado suele ser suficiente.

Con los modelos de segmentación y pose, TrackTrack omite la recuperación de detecciones por supresión de máximos no nativa flexible para que las máscaras y los puntos clave permanezcan alineados con sus detecciones.

Ejemplos en Python#

Bucle de persistencia de pistas#

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 indica al rastreador que la imagen o fotograma actual es el siguiente en una secuencia y que debe esperar pistas 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
        # and using the BoT-SORT tracker backend
        results = model.track(frame, persist=True, tracker="botsort.yaml")

        # 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 rastreador en cada fotograma del video, visualizará los resultados y los mostrará en una ventana. El bucle se puede salir presionando 'q'.

Representación de trayectorias a lo largo del tiempo#

Visualizar las trayectorias de los objetos en fotogramas consecutivos puede proporcionar información valiosa sobre los patrones de movimiento y el comportamiento de los objetos detectados dentro de un video. Con Ultralytics YOLO26, representar estas trayectorias es un proceso fluido y eficiente.

En el siguiente ejemplo, demostramos cómo utilizar las capacidades de seguimiento de YOLO26 para representar el movimiento de los objetos detectados a lo largo de múltiples fotogramas de video. Este script implica abrir un archivo de video, 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 representan 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(list)

# 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 video simultáneamente. Esto es especialmente útil al gestionar múltiples entradas de video, como las procedentes de varias cámaras de vigilancia, donde el procesamiento concurrente puede mejorar en gran medida 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 de forma concurrente. Cada hilo se encarga de ejecutar el rastreador en un archivo de video, y todos los hilos se ejecutan simultáneamente en segundo plano.

Para garantizar que cada hilo reciba los parámetros correctos (el archivo de video, el modelo que se va 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 video 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 de los cuales rastrea objetos en un archivo de video diferente. Los archivos de video 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. A continuación, iniciamos los hilos con start() y utilizamos join() para hacer que el hilo principal espere hasta que ambos hilos del rastreador hayan terminado.

Por último, una vez que todos los hilos han completado su tarea, las ventanas que muestran los resultados se cierran utilizando 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): Model checkpoint name or path loaded inside the thread.
        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 gestionar más archivos de video y modelos mediante la creación de más hilos y la aplicación de la misma metodología.

Contribuye con nuevos rastreadores#

¿Tienes experiencia 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 rastreadores en ultralytics/cfg/trackers! Tus aplicaciones y soluciones del mundo real pueden ser de un valor incalculable 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 detalladas sobre cómo enviar una Pull Request (PR) 🛠️. ¡Estamos deseando ver lo que aportas!

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

Preguntas frecuentes#