Seguimiento de varios 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 del fotograma, sino que también mantiene un ID único para cada objeto detectado a medida que avanza el vídeo. Sus aplicaciones son ilimitadas: desde la vigilancia y la seguridad hasta el análisis deportivo en tiempo real.

Consulta la vista previa no publicada de YOLO27 para conocer el soporte de seguimiento previsto.

¿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 añade los ID de los objetos. Esto facilita el seguimiento de objetos en secuencias de vídeo y la realización de análisis posteriores. Estas son algunas razones para plantearte utilizar Ultralytics YOLO en tus necesidades de seguimiento de objetos:

• Eficiencia: procesa secuencias de vídeo en tiempo real sin comprometer la precisión.
• Flexibilidad: admite varios algoritmos y configuraciones de seguimiento.
• Facilidad de uso: opciones sencillas de API de Python y CLI para una integración e implementación rápidas.
• Personalización: fácil de usar con modelos YOLO entrenados a medida, lo que permite integrarlos en aplicaciones específicas de cada ámbito.

Aplicaciones en el mundo real#

Inicio rápido#

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

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

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

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

Para ejecutar el rastreador en secuencias de vídeo, utiliza un modelo entrenado Detect, Segment, Pose u OBB, como YOLO26n, YOLO26n-seg, YOLO26n-pose o YOLO26n-obb. Puedes entrenar modelos personalizados localmente o mediante el entrenamiento en la nube de Ultralytics Platform.

from ultralytics import YOLO

# Cargar un modelo oficial o personalizado
model = YOLO("yolo26n.pt")  # Cargar un modelo Detect oficial
model = YOLO("yolo26n-seg.pt")  # Cargar un modelo Segment oficial
model = YOLO("yolo26n-pose.pt")  # Cargar un modelo Pose oficial
model = YOLO("path/to/best.pt")  # Cargar un modelo entrenado a medida

# Realizar el seguimiento con el modelo
results = model.track("https://youtu.be/LNwODJXcvt4", show=True)  # Seguimiento con el rastreador predeterminado
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # con ByteTrack

Rastreadores compatibles#

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

¿Qué rastreador debería utilizar?#

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

1. ¿Necesitas una opción básica rápida y sencilla? → ByteTrack (sin ReID, sin compensación del movimiento de la cámara y con una sobrecarga mínima).
2. ¿Vídeos grabados a mano, con dron o con una cámara en movimiento? → BoT-SORT (añade compensación del movimiento de la cámara y ReID opcional).
3. ¿Movimiento no lineal (deportes, baile, giros bruscos) y sin ReID? → OC-SORT (correcciones centradas en las observaciones sin el coste de apariencia).
4. ¿Escenas concurridas con una cámara en movimiento en las que el principal problema son los cambios de ID? → Deep OC-SORT o TrackTrack (ambos admiten la comparación de apariencia opcional; TrackTrack también añade asociación multicriterio y supresión de ID duplicados).
5. ¿Solapamientos parciales frecuentes en tiempo real y sin presupuesto para ReID? → FastTracker (variante de ByteTrack que tiene en cuenta las oclusiones y utiliza reversión de Kalman).

Cambiar de rastreador#

Pasa el nombre del archivo de configuración del rastreador a tracker=. El resto del código no cambia.

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

from ultralytics import YOLO

# Configurar los parámetros de seguimiento y ejecutar el rastreador
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.1, iou=0.7, show=True)

Configuración personalizada del rastreador#

Ultralytics también te permite utilizar un archivo de configuración del rastreador modificado. Para ello, solo tienes que hacer una copia de un archivo de configuración del rastreador (por ejemplo, custom_tracker.yaml) de ultralytics/cfg/trackers y modificar las opciones que necesites (excepto tracker_type).

from ultralytics import YOLO

# Cargar el modelo y ejecutar el rastreador con un archivo de configuración personalizado
model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Argumentos comunes de los rastreadores#

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

Argumentos específicos del rastreador#

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

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

Activar la reidentificación (ReID)#

ReID está desactivado de forma predeterminada para minimizar la sobrecarga. Actívalo estableciendo with_reid: True en un archivo de configuración del rastreador.

Opciones del modelo ReID:

• model: auto — Utiliza las características nativas del detector YOLO con una sobrecarga mínima. Es ideal si necesitas algo de ReID sin una gran pérdida de rendimiento. Si el detector no ofrece características compatibles, recurre a yolo26n-cls.pt.
• Modelo ReID personalizado — Asigna a model: la ruta a un punto de control .pt o a un modelo de incrustaciones exportado compatible, como .torchscript, .onnx, .engine o un directorio de modelo de OpenVINO. Los modelos exportados se cargan mediante AutoBackend y deben generar directamente un tensor de incrustaciones.

Hay codificadores ONNX listos para usar para todos los tamaños de modelo. Asigna uno de estos nombres a model: y el archivo se descargará automáticamente la primera vez que se ejecute el rastreador (igual que se descargan los pesos de YOLO); no hace falta exportarlo ni descargarlo manualmente:

# 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 mejorar el 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

# Cargar el modelo de clasificación
model = YOLO("yolo26n-cls.pt")

# Añadir una capa de agrupación media
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

# Exportar a TensorRT
model.export(format="engine", quantize=16, dynamic=True, batch=32)

Una vez exportado, indica la ruta al modelo TensorRT en la configuración del rastreador.

Detalles del rastreador#

En las secciones siguientes se describe el diseño de cada rastreador, sus parámetros específicos y consejos para ajustarlo.

BoT-SORT#

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

• Compensación del movimiento de la cámara (CMC): se aplica una transformación afín, estimada en cada fotograma (flujo óptico disperso de forma predeterminada; también están disponibles ORB / ECC), a los estados de Kalman antes de la asociación IoU.
• ReID opcional: las incrustaciones de apariencia pueden fusionarse en la matriz de costes. Está desactivado de forma predeterminada; actívalo con with_reid: True.

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

Argumentos específicos de BoT-SORT:

Consejos de ajuste:

• Cámara fija: establece gmc_method: none para ahorrar unos pocos ms por fotograma.
• Mucho movimiento de cámara: mantén sparseOptFlow; ecc es más preciso, pero más lento.
• Multitudes de aspecto similar: activa with_reid: True y aumenta appearance_thresh (por ejemplo, 0.85+).

ByteTrack#

ByteTrack (Zhang et al., ECCV 2022) es el modelo de referencia ligero. Utiliza un filtro de Kalman lineal + IoU con una asociación en dos fases:

• Fase 1: asocia las detecciones con puntuación alta a las pistas activas.
• Fase 2: vuelve a comparar las pistas sin asociar con las detecciones de puntuación baja para recuperarlas tras una oclusión parcial breve.

No utiliza un modelo de apariencia ni compensación del movimiento de la cámara.

Ideal para: cámaras fijas o casi fijas en las que el coste del detector es el factor dominante y se busca reducir al mínimo la sobrecarga del rastreador.

Argumentos específicos de ByteTrack: ninguno, aparte de los argumentos compartidos del rastreador.

Consejos de ajuste:

• Detector con ruido: reduce track_low_thresh para que la segunda fase disponga de más candidatos.
• Detector con alta exhaustividad: aumenta track_high_thresh para reducir la fragmentación de los ID.
• Cambios frecuentes de ID: aumenta track_buffer para que las pistas que se pierden brevemente sigan activas.

OC-SORT#

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

• Reactualización centrada en la observación (ORU): reproduce una trayectoria virtual entre la última observación y la detección actual, y vuelve a ejecutar la actualización de Kalman para corregir la velocidad desviada.
• Impulso centrado en la observación (OCM): penaliza las detecciones que se mueven en la dirección incorrecta mediante un término de coherencia de velocidad.
• Recuperación centrada en la observación (OCR): vuelve a comprobar las detecciones sin asociar frente a las pistas perdidas recientemente, usando su última observación en lugar del estado previsto.

Ideal para: movimiento no lineal sin el coste de un modelo 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 prolongadas: aumenta track_buffer para que OCR disponga de más pistas perdidas que volver a asociar.

Con modelos OBB, OCR utiliza la caja orientada prevista por Kalman, ya que no se conserva el 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 del movimiento de la cámara:

• Asociación por apariencia: la distancia de incrustación del coseno se filtra según el 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 del movimiento de la cámara: los estados de Kalman se transforman de un fotograma al siguiente mediante flujo óptico disperso, ORB o ECC.

Ideal para: escenas concurridas o grabadas con cámaras en movimiento, donde son frecuentes los cambios de ID entre objetos visualmente distintos pero próximos en el espacio.

Argumentos específicos de Deep OC-SORT:

Consejos de ajuste:

• Cambios 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 despacio.
• Cámara en movimiento: establece gmc_method: sparseOptFlow (Deep OC-SORT utiliza none de forma predeterminada).
• Menor latencia: mantén with_reid: False (valor predeterminado) para usar solo el movimiento + CMC; activa ReID solo cuando los cambios de ID sean la principal fuente de errores.

FastTracker#

FastTracker es una variante de ByteTrack que tiene en cuenta las oclusiones y no utiliza un modelo de apariencia:

• Detección de oclusiones: marca las pistas como ocluidas cuando la cobertura por parte de otras pistas activas supera occ_cover_thresh.
• Reversión de Kalman durante una oclusión: revierte el estado de Kalman a un fotograma anterior a la oclusión utilizando el historial almacenado en un búfer circular.
• Amortiguación del movimiento y ampliación de la búsqueda: se amortigua la velocidad y se amplía el bbox previsto mientras dura la oclusión.
• Supresión Init-IoU: evita que se inicien nuevas pistas encima de pistas activas.

Ideal para: procesos de detección en tiempo real con solapamientos frecuentes entre objetivos (multitudes, colas, deportes).

Argumentos específicos de FastTracker:

Consejos de ajuste:

• Oclusiones parciales frecuentes: reduce occ_cover_thresh (p. ej., 0.5-0.6).
• ID duplicados en zonas de solapamiento: reduce init_iou_suppress (p. ej., 0.5).
• Oclusiones prolongadas: aumenta occ_reappear_window y track_buffer a la vez.
• Objetos que se mueven rápido: aumenta dampen_motion_occ (acercándolo a 1.0); aumenta enlarge_bbox_occ solo si una región de búsqueda más amplia mejora la recuperación.

TrackTrack#

TrackTrack (Shim et al., CVPR 2025) es el tracker predeterminado. Analiza cada trayectoria desde su propia perspectiva mediante una asociación iterativa basada en varias señales:

• Asociación basada en la perspectiva de la trayectoria (TPA): combina HMIoU, la distancia coseno opcional de ReID, la distancia de proyección de confianza y la distancia del ángulo de las esquinas. La asignación se resuelve de forma iterativa con un umbral que se relaja.
• Inicialización adaptada a la trayectoria (TAI): suprime la creación de trayectorias duplicadas antes de asignar un ID nuevo.

Ideal para: escenas concurridas con oclusiones frecuentes que provocan problemas de ID duplicados.

Argumentos específicos de TrackTrack:

Consejos de ajuste:

• Multitudes de peatones: reduce tai_thr (p. ej., 0.45) para suprimir más trayectorias duplicadas; aumenta track_buffer para las oclusiones prolongadas.
• Movimiento rápido de cámara: mantén activado gmc_method: sparseOptFlow.
• Objetos pequeños o rápidos: aumenta ligeramente angle_weight y reduce min_track_len.
• Activa ReID solo cuando sea necesario: añade coste de inferencia; para oclusiones breves, el coste predeterminado basado en varias señales suele ser suficiente.

Con los modelos Segment y Pose, TrackTrack omite la recuperación de detecciones con NMS flexible para que las máscaras y los puntos clave sigan alineados con sus detecciones.

Ejemplos de Python#

Bucle para mantener las trayectorias#

Aquí tienes un script de Python que utiliza OpenCV (cv2) y YOLO26 para realizar el seguimiento de objetos en fotogramas de vídeo. Este script da por hecho que los paquetes necesarios (opencv-python y ultralytics) ya están instalados. El argumento persist=True indica al tracker que la imagen o el fotograma actual es el siguiente de una secuencia y que debe esperar trayectorias de la imagen anterior en la imagen actual.

import cv2

from ultralytics import YOLO

# Carga el modelo YOLO26
model = YOLO("yolo26n.pt")

# Abre el archivo de vídeo
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Recorre los fotogramas del vídeo
while cap.isOpened():
    # Lee un fotograma del vídeo
    success, frame = cap.read()

    if success:
        # Ejecuta el seguimiento con YOLO26 en el fotograma y mantiene las trayectorias entre fotogramas
        # y utiliza el backend del tracker BoT-SORT
        results = model.track(frame, persist=True, tracker="botsort.yaml")

        # Visualiza los resultados en el fotograma
        annotated_frame = results[0].plot()

        # Muestra el fotograma anotado
        cv2.imshow("YOLO26 Tracking", annotated_frame)

        # Interrumpe el bucle si se pulsa 'q'
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Interrumpe el bucle si se llega al final del vídeo
        break

# Libera el objeto de captura de vídeo y cierra la ventana de visualización
cap.release()
cv2.destroyAllWindows()

Fíjate en el cambio de model(frame) a model.track(frame), que activa el seguimiento de objetos en lugar de la simple detección. Este script modificado ejecuta el tracker en cada fotograma del vídeo, visualiza los resultados y los muestra en una ventana. Puedes salir del bucle pulsando «q».

Representar las trayectorias a lo largo del tiempo#

Visualizar las trayectorias de los objetos en fotogramas consecutivos puede aportar información valiosa sobre los patrones de movimiento y el comportamiento de los objetos detectados en un vídeo. Con Ultralytics YOLO26, representar estas trayectorias es un proceso sencillo y eficiente.

En el siguiente ejemplo, mostramos cómo utilizar las capacidades de seguimiento de YOLO26 para representar el movimiento de los objetos detectados en varios fotogramas de vídeo. El script abre un archivo de vídeo, lo lee fotograma a fotograma y utiliza el modelo YOLO para identificar y seguir varios objetos. Al conservar los puntos centrales de los cuadros delimitadores detectados y conectarlos, podemos dibujar líneas que representan las trayectorias seguidas por los objetos.

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Carga el modelo YOLO26
model = YOLO("yolo26n.pt")

# Abre el archivo de vídeo
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Guarda el historial de trayectorias
track_history = defaultdict(list)

# Recorre los fotogramas del vídeo
while cap.isOpened():
    # Lee un fotograma del vídeo
    success, frame = cap.read()

    if success:
        # Ejecuta el seguimiento con YOLO26 en el fotograma y mantiene las trayectorias entre fotogramas
        result = model.track(frame, persist=True)[0]

        # Obtén los cuadros y los ID de las trayectorias
        if result.boxes and result.boxes.is_track:
            boxes = result.boxes.xywh.cpu()
            track_ids = result.boxes.id.int().cpu().tolist()

            # Visualiza el resultado en el fotograma
            frame = result.plot()

            # Representa las trayectorias
            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)))  # Punto central x, y
                if len(track) > 30:  # Conserva 30 trayectorias durante 30 fotogramas
                    track.pop(0)

                # Dibuja las líneas de seguimiento
                points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                cv2.polylines(frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

        # Muestra el fotograma anotado
        cv2.imshow("YOLO26 Tracking", frame)

        # Interrumpe el bucle si se pulsa 'q'
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Interrumpe el bucle si se llega al final del vídeo
        break

# Libera el objeto de captura de vídeo y cierra la ventana de visualización
cap.release()
cv2.destroyAllWindows()

Seguimiento multiproceso#

El seguimiento multiproceso permite realizar el seguimiento de objetos simultáneamente en varias secuencias de vídeo. Es especialmente útil al gestionar varias entradas de vídeo, por ejemplo, de distintas cámaras de vigilancia, ya que el procesamiento simultáneo puede mejorar considerablemente la eficiencia y el rendimiento.

En el script de Python de ejemplo, utilizamos el módulo threading de Python para ejecutar varias instancias del tracker simultáneamente. Cada hilo se encarga de ejecutar el tracker en un archivo de vídeo y todos los hilos se ejecutan a la vez en segundo plano.

Para asegurarnos de que cada hilo recibe los parámetros correctos (el archivo de vídeo, 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 principal de seguimiento. Esta función lee el vídeo fotograma a fotograma, ejecuta el tracker y guarda los resultados anotados.

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

El parámetro daemon=True de threading.Thread significa que estos hilos se cerrarán en cuanto termine el programa principal. A continuación, iniciamos los hilos con start() y utilizamos join() para que el hilo principal espere hasta que terminen ambos hilos del tracker.

Por último, cuando todos los hilos hayan terminado su tarea, las ventanas que muestran los resultados se cierran con cv2.destroyAllWindows().

import threading

import cv2

from ultralytics import YOLO

# Define los nombres de los modelos y las fuentes de vídeo
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # vídeo local, 0 para la cámara web

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

# Crea e inicia los hilos del tracker con un bucle for
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()

# Espera a que terminen todos los hilos del tracker
for thread in tracker_threads:
    thread.join()

# Limpia y cierra las ventanas
cv2.destroyAllWindows()

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

Contribuye con nuevos trackers#

¿Tienes experiencia en el seguimiento de varios objetos y has implementado o adaptado con éxito un algoritmo de seguimiento para Ultralytics YOLO? ¡Te invitamos a contribuir a nuestra sección Trackers en ultralytics/cfg/trackers! Tus aplicaciones y soluciones del mundo real pueden ser muy valiosas para quienes trabajan en tareas de seguimiento.

Al contribuir a esta sección, ayudas a ampliar el abanico de soluciones de seguimiento disponibles en el framework Ultralytics YOLO y añades otra capa de funcionalidad y utilidad para la comunidad.

Para empezar a contribuir, consulta nuestra Guía de contribución, donde encontrarás instrucciones detalladas para enviar una solicitud de incorporación de cambios (PR) 🛠️. ¡Estamos deseando ver tus propuestas!

¡Mejoremos juntos las capacidades de seguimiento del ecosistema Ultralytics YOLO 🙏!

Preguntas frecuentes#