Empezar

Seguimiento de varios objetos con Ultralytics YOLO

YOLO multi-object tracking with trajectory paths

El seguimiento de varios objetos en el análisis de vídeo identifica la ubicación y la clase de los objetos en cada fotograma, y también mantiene un ID único para cada objeto detectado a medida que avanza el vídeo. Sus aplicaciones abarcan 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.

Rastreadores: OC-SORT, Deep OC-SORT, FastTracker, TrackTrack

Desde la versión 8.4.63 de ultralytics, OC-SORT, Deep OC-SORT, FastTracker y TrackTrack están disponibles junto con BoT-SORT y ByteTrack.

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

Los resultados de los rastreadores de Ultralytics son coherentes con los de la detección de objetos estándar, pero añaden los ID de los objetos. Esto facilita el seguimiento de objetos en transmisiones de vídeo y la realización de análisis posteriores. Motivos principales para utilizar Ultralytics YOLO en el seguimiento de objetos:

  • Eficiencia: procesa secuencias de vídeo en tiempo real sin comprometer la precisión.
  • Flexibilidad: Admite varios algoritmos de seguimiento y configuraciones.
  • 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.


Ver: Cómo realizar el seguimiento de varios objetos con Ultralytics YOLO26 | BoT-SORT y ByteTrack | VisionAI 🚀

Aplicaciones en el mundo real#

TransporteComercio minoristaAcuicultura
Seguimiento de vehículosSeguimiento de personasSeguimiento de peces

Inicio rápido#

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

Ejemplo
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 transmisiones de vídeo, utiliza un modelo entrenado de Detect, Segment, Pose u OBB, como YOLO26n, YOLO26n-seg, YOLO26n-pose o YOLO26n-obb, todos disponibles en la colección YOLO26 de Ultralytics Platform. Puedes entrenar modelos personalizados localmente o mediante el entrenamiento en la nube de Ultralytics Platform.

Ejemplo
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.

RastreadorArchivo de configuraciónModelo de movimientoApariencia / ReIDCompensación del movimiento de la cámaraGestión de oclusiones
BoT-SORTbotsort.yamlKalman linealOpcional (with_reid)Configurable (gmc_method)Búfer de seguimiento + reasociación ReID
ByteTrackbytetrack.yamlKalman linealNingunoNoRecuperación en dos etapas de detecciones con baja confianza
OC-SORTocsort.yamlKalman centrado en las observacionesNingunoNoORU, OCM, OCR: actualización de nuevo a partir de la última observación
Deep OC-SORTdeepocsort.yamlKalman centrado en las observacionesOpcional (with_reid)Configurable (gmc_method)OC-SORT + EMA de apariencia adaptativa opcional
FastTrackerfasttrack.yamlKalman lineal + reversiónNingunoNoReversión de Kalman + ampliación de bbox en caso de oclusión
TrackTracktracktrack.yamlKalman lineal (NSA)Opcional (with_reid)Configurable (gmc_method)Asociación iterativa multicriterio + TAI

¿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.

Ejemplo
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 argumentos de inferencia con el modo Predict, como conf, iou y show.

Ejemplo
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.5, show=True)

Configuración personalizada del rastreador#

Para utilizar una configuración de rastreador modificada, copia un archivo de configuración del rastreador (por ejemplo, como custom_tracker.yaml) desde ultralytics/cfg/trackers y modifica cualquier ajuste excepto tracker_type.

Ejemplo
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:

Información sobre los umbrales del rastreador

Las detecciones iguales o superiores a track_high_thresh pasan a la primera etapa de asociación. Las detecciones entre track_low_thresh y track_high_thresh pueden recuperar seguimientos existentes cuando el rastreador seleccionado activa la asociación de baja confianza, pero no inician seguimientos nuevos. Las detecciones iguales o inferiores a track_low_thresh se ignoran.

ParámetroValores o rangos válidosDescripción
tracker_typebotsort, bytetrack, ocsort, deepocsort, fasttrack, tracktrackEspecifica el tipo de rastreador.
track_high_thresh0.0-1.0Umbral para la primera asociación. Afecta al grado de confianza con el que una detección se asigna a una pista existente.
track_low_thresh0.0-1.0Límite inferior para las detecciones de recuperación con baja confianza. OC-SORT y Deep OC-SORT solo las usan cuando use_byte: True; TrackTrack las incluye en su grupo de asociación penalizado.
new_track_thresh0.0-1.0Umbral para iniciar una nueva pista si la detección no coincide con ninguna pista existente.
track_buffer>=0Número de fotogramas durante los que se mantienen activas las pistas perdidas antes de eliminarlas. Un valor más alto permite tolerar mejor las oclusiones.
match_thresh0.0-1.0Umbral para asociar pistas. Los valores más altos hacen que la asociación sea más permisiva.
fuse_scoreTrue, FalseIndica si se fusionan las puntuaciones de confianza con las distancias IoU antes de la asociación.
gmc_methodsparseOptFlow, orb, sift, ecc, noneMétodo de compensación del movimiento global. Ayuda a tener en cuenta el movimiento de la cámara.
proximity_thresh0.0-1.0IoU mínimo necesario para una asociación ReID válida. Garantiza una proximidad espacial suficiente antes de usar indicios de apariencia.
appearance_thresh0.0-1.0Similitud de apariencia normalizada mínima necesaria para ReID.
with_reidTrue, FalseActiva la asociación basada en la apariencia para mejorar el seguimiento durante las oclusiones. Compatible con BoT-SORT, Deep OC-SORT y TrackTrack.
modelauto o ruta a un modelo ReID compatibleModelo ReID. auto utiliza las características nativas de la red troncal de YOLO cuando están disponibles; de lo contrario, recurre a yolo26n-cls.pt. Un codificador personalizado puede ser un punto de control .pt o un modelo exportado, como .torchscript, .onnx, .engine o un directorio de modelo de OpenVINO.

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:

Activar la reidentificación (ReID)#

ReID está desactivado de forma predeterminada para reducir 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
Modelotamaño
(píxeles)
parámetros
(M)
FLOPs
(B)
YOLO26n-reid.onnx4482.82.0
YOLO26s-reid.onnx4487.56.6
YOLO26m-reid.onnx44812.420.1
YOLO26l-reid.onnx44815.325.2
YOLO26x-reid.onnx44832.755.9
ReID solo está disponible para el seguimiento

Actualmente solo hay codificadores ReID ONNX disponibles para la rama de apariencia del rastreador. Los modos ReID train, val y predict, así como las recetas específicas para exportar ReID, siguen en desarrollo.

Para mejorar el rendimiento con un modelo de clasificación independiente, expórtalo a un backend más rápido, como TensorRT:

Exportar un modelo ReID a 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.



Ver: ¿Qué rastreador de objetos ofrece mejores resultados? | Velocidad, FPS y estabilidad de ID | Ultralytics YOLO26 📊

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:

ParámetroValores o rangos válidosDescripción
gmc_methodsparseOptFlow, orb, sift, ecc, noneBackend de compensación del movimiento de la cámara. sparseOptFlow es el valor predeterminado. none desactiva CMC.
with_reidTrue, FalseActiva la asociación basada en la apariencia. Está desactivada de forma predeterminada.
modelauto o ruta a un modelo ReID compatibleauto utiliza características nativas de YOLO cuando están disponibles; los modelos personalizados pueden ser puntos de control .pt o exportaciones compatibles.
proximity_thresh0.0-1.0IoU mínimo necesario para tener en cuenta las características de apariencia.
appearance_thresh0.0-1.0Similitud de apariencia normalizada mínima necesaria para una asociación ReID. Auméntala para que la asociación sea más estricta.

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:

ParámetroValores o rangos válidosDescripción
delta_t>=1Ventana temporal (en fotogramas) para calcular la dirección de la velocidad en OCM. Los valores más altos suavizan más el resultado.
inertia0.0-1.0Peso del coste de coherencia de velocidad. Los valores más altos penalizan los cambios bruscos de dirección.
use_byteTrue, FalseActiva una segunda pasada de asociación, al estilo de ByteTrack, sobre las detecciones de baja confianza.

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:

ParámetroValores o rangos válidosDescripción
with_reidTrue, FalseActiva la asociación basada en la apariencia. Está desactivada de forma predeterminada.
modelauto o ruta a un modelo ReID compatibleauto utiliza características nativas de YOLO cuando están disponibles; los modelos personalizados pueden ser puntos de control .pt o exportaciones compatibles.
proximity_thresh0.0-1.0IoU mínimo necesario para tener en cuenta las características de apariencia.
appearance_thresh0.0-1.0Similitud de apariencia normalizada mínima necesaria para una asociación ReID.
alpha_fixed_emb0.0-1.0Factor EMA base para actualizar las incrustaciones de las pistas. Los valores más altos conservan durante más tiempo la incrustación anterior.
gmc_methodsparseOptFlow, orb, sift, ecc, noneMétodo de compensación del movimiento global.
delta_t>=1Ventana temporal (en fotogramas) para calcular la dirección de la velocidad en OCM (heredada de OC-SORT).
inertia0.0-1.0Peso del coste de coherencia de velocidad (heredado de OC-SORT).
use_byteTrue, FalseActiva una segunda asociación al estilo de ByteTrack sobre las detecciones de baja confianza (heredada de 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:

ParámetroValores o rangos válidosDescripción
reset_velocity_offset_occ>=0Número de fotogramas históricos para restaurar la velocidad de Kalman al comenzar una oclusión.
reset_pos_offset_occ>=0Número de fotogramas históricos para restaurar la posición de Kalman al comenzar una oclusión.
enlarge_bbox_occ>=1.0Escalado de la altura aplicado al bbox predicho durante la oclusión (la anchura se escala según la relación de aspecto XYAH).
dampen_motion_occ0.0-1.0Multiplicador de velocidad durante la oclusión. Los valores más bajos hacen que la trayectoria «reduzca la velocidad» durante la oclusión.
active_occ_to_lost_thresh>=1Número máximo de fotogramas consecutivos con oclusión antes de que una trayectoria activa pase a estar perdida.
occ_cover_thresh0.0-1.0Fracción del área de una trayectoria cubierta por otra trayectoria activa para declarar una oclusión.
occ_reappear_window>=0Número de fotogramas durante los que una trayectoria perdida que haya sufrido una oclusión reciente sigue siendo más fácil de volver a encontrar.
init_iou_suppress0.0-1.0Suprime la inicialización de nuevas trayectorias si su IoU con cualquier trayectoria activa supera este valor. Establece 1.0 para desactivarlo.

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:

ParámetroValores o rangos válidosDescripción
iou_weight0.0-1.0Peso de la distancia HMIoU cuando ReID está activado; en caso contrario, se utiliza HMIoU directamente.
reid_weight0.0-1.0Peso de la distancia coseno de ReID cuando ReID está activado; en caso contrario, se ignora.
conf_weight0.0-1.0Peso de la distancia de proyección de confianza.
angle_weight0.0-1.0Peso de la distancia del ángulo de las esquinas.
penalty_p0.0-1.0Penalización de coste para las detecciones con poca confianza.
penalty_q0.0-1.0Penalización de coste para las detecciones recuperadas mediante NMS secundaria.
reduce_step0.0-1.0Relajación del umbral de coincidencia en cada iteración.
tai_thr0.0-1.0Umbral IoU para la NMS de inicialización adaptada a la trayectoria.
min_track_len>=0Longitud mínima del historial antes de confirmar una trayectoria nueva.
lost_match_thr0.0-1.0Límite de coste más flexible para la pasada de reasociación de trayectorias perdidas; 0 lo desactiva.
with_reidTrue, FalseActiva la asociación de apariencia con ReID coseno (utiliza las características nativas de YOLO). Está desactivada de forma predeterminada.
modelauto o ruta a un modelo ReID compatibleauto utiliza características nativas de YOLO cuando están disponibles; los modelos personalizados pueden ser puntos de control .pt o exportaciones compatibles.
gmc_methodsparseOptFlow, orb, sift, ecc, noneMétodo de compensación del movimiento global.

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#



Ver: Cómo crear un seguimiento interactivo de objetos con Ultralytics YOLO26: ¡créalo en minutos | 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.

Mantener las trayectorias y seleccionar un tracker

Usa persist=True solo al pasar fotogramas consecutivos de la misma secuencia de vídeo a model.track(). Así, el tracker puede reutilizar el estado de fotogramas anteriores y mantener ID de trayectoria coherentes a lo largo del tiempo. No uses persist=True con imágenes no relacionadas ni con otra secuencia, ya que el estado de las trayectorias anteriores podría conservarse.

También puedes elegir un backend de tracker pasando un archivo de configuración del tracker, como tracker="botsort.yaml", tracker="bytetrack.yaml" o tracker="tracktrack.yaml".

Bucle for con streaming y seguimiento
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()

Observa el cambio de model(frame) a model.track(frame), que activa el seguimiento de objetos en lugar de la detección simple. Este script modificado ejecuta el rastreador 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. Ultralytics YOLO26 facilita el trazado de estas trayectorias.

El siguiente ejemplo utiliza el seguimiento de YOLO26 para trazar 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 objetos. Al conservar los puntos centrales de los cuadros delimitadores detectados y conectarlos, dibuja líneas que representan las trayectorias de los objetos seguidos.

Representar las trayectorias en varios fotogramas de vídeo
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 con varios hilos permite ejecutar el seguimiento de objetos simultáneamente en varias transmisiones de vídeo. Esto resulta especialmente útil al trabajar con varias entradas de vídeo, como las de distintas cámaras de vigilancia, donde el procesamiento simultáneo mejora el rendimiento.

El script de Python siguiente utiliza el módulo threading de Python para ejecutar varias instancias del rastreador simultáneamente. Cada hilo ejecuta el rastreador en una fuente de vídeo y todos los hilos funcionan a la vez en segundo plano.

Para asegurarte de que cada hilo recibe los parámetros correctos (el modelo que debe usar y la fuente de vídeo), el script define 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 rastreador y guarda los resultados anotados.

En este ejemplo se utilizan dos modelos distintos, yolo26n.pt y yolo26n-seg.pt, cada uno de los cuales sigue objetos en una fuente diferente: un archivo de vídeo local y una webcam. Las fuentes 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().

Implementación del seguimiento multiproceso
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#

Si has implementado o adaptado un algoritmo de seguimiento de múltiples objetos para Ultralytics YOLO, plantéate contribuir con él a ultralytics/trackers, junto con una configuración correspondiente en ultralytics/cfg/trackers. Las contribuciones amplían las opciones de seguimiento disponibles para toda la comunidad.

Preguntas frecuentes#

  • El seguimiento de varios objetos en el análisis de vídeo consiste en identificar objetos y mantener un ID único para cada objeto detectado a lo largo de los fotogramas del vídeo. Ultralytics YOLO lo admite ofreciendo seguimiento en tiempo real junto con ID de objeto, lo que facilita tareas como la vigilancia de seguridad y el análisis deportivo. El sistema utiliza trackers como BoT-SORT, ByteTrack, OC-SORT, Deep OC-SORT, FastTracker y TrackTrack, que se pueden configurar mediante archivos YAML.

  • No. Los archivos .pt estándar de Ultralytics guardan los pesos del modelo YOLO, mientras que el tracker se crea durante la inferencia mediante model.track(). Los ID de trayectoria dependen del estado del tracker en fotogramas consecutivos, por lo que una imagen independiente puede devolver detecciones como cuadros, clases y niveles de confianza, pero no puede generar por sí sola ID de seguimiento persistentes con sentido.

    Para el despliegue, incluye el detector y el tracker juntos en tu aplicación y llama a model.track() fotograma a fotograma con persist=True cuando los fotogramas procedan de la misma secuencia de vídeo. Utiliza instancias de modelo o tracker independientes para secuencias no relacionadas, de modo que el estado no pase de un vídeo a otro.

  • Puedes configurar un tracker personalizado copiando un archivo de configuración de tracker existente (p. ej., custom_tracker.yaml) del directorio de configuración de trackers de Ultralytics y modificando los parámetros según sea necesario, excepto tracker_type. Usa este archivo en tu modelo de seguimiento así:

    Ejemplo
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")
  • Para realizar el seguimiento de objetos simultáneamente en varias secuencias de vídeo, puedes utilizar el módulo threading de Python. Cada hilo se encargará de una secuencia de vídeo distinta. Aquí tienes un ejemplo de configuración:

    Seguimiento multiproceso
    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()
  • El seguimiento de varios objetos con Ultralytics YOLO tiene numerosas aplicaciones, entre ellas:

    • Transporte: seguimiento de vehículos para la gestión del tráfico y la conducción autónoma.
    • Comercio minorista: seguimiento de personas para analizar la actividad en tienda y mejorar la seguridad.
    • Acuicultura: seguimiento de peces para supervisar entornos acuáticos.
    • Análisis deportivo: seguimiento de jugadores y equipamiento para analizar el rendimiento.
    • Sistemas de seguridad: supervisión de actividades sospechosas y creación de alarmas de seguridad.

    Estas aplicaciones aprovechan la capacidad de Ultralytics YOLO para procesar vídeos con una alta frecuencia de fotogramas en tiempo real y con gran precisión.

  • Para visualizar las trayectorias de objetos en varios fotogramas de vídeo, puedes utilizar 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 lo muestra:

    Representar las trayectorias en varios fotogramas de vídeo
    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(list)
    
    while cap.isOpened():
        success, frame = cap.read()
        if success:
            result = model.track(frame, persist=True)[0]
            annotated_frame = result.plot()
            if result.boxes and result.boxes.is_track:
                boxes = result.boxes.xywh.cpu()
                track_ids = result.boxes.id.int().cpu().tolist()
                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 representará las líneas de seguimiento que muestran las rutas de movimiento de los objetos a lo largo del tiempo y aportará información valiosa sobre su comportamiento y sus patrones.

Comentarios679

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  1. bhaskar2443053GitHub

    I’m using YOLO-Pose to detect and track people throughout ~1-hour videos and need each person to keep the same ID. I already have high-quality ground-truth tracks from a SAM-based tracker.

    Do you have a script that can fine-tune YOLO-Pose (and its tracker/Re-ID parameters) against this ground truth to squeeze out the best IDF1 or HOTA scores ?

    1
    1. maxexplorerGitHub

      Hi!

      Thank you for your great work on YOLO and tracking integration. We are using YOLO with ByteTrack/BoT-SORT for object counting and tracking and want to improve ID stability.

      1. We notice that sometimes, even when the object visually looks the same and the scene and motion are stable, the track_id changes. What parameters or reasons should we check to understand why the ID changes unexpectedly?

      2. Is the match_thresh parameter based on IoU, and is it possible to print or visualize the IoU used during matching for debugging?

      3. Is there a way to output Kalman-predicted boxes of lost tracks so we can analyze them?

      4. Could increasing the video FPS improve tracking and IoU consistency, or is this mainly related to detection stability and parameter tuning?

      5. Does ByteTrack or BoT-SORT use a min_hits parameter before confirming tracks, or are tracks confirmed immediately after creation?

      6. If a track is lost, can a new ID only be assigned on the second frame after reappearance if conf > new_track_thresh and then conf > track_high_thresh, or can it happen immediately on the first detection?

      7. Is the track_buffer parameter the number of frames a track is kept using Kalman prediction after it is lost before being deleted?

      8. Do you have any tips to improve tracking stability and avoid unnecessary ID switches?

      Thank you for your support!

    2. Glenn JocherUltralytics

      @bhaskar2443053 currently there isn't a built-in script for fine-tuning YOLO-Pose tracking parameters against ground truth. You would need to implement custom evaluation using libraries like TrackEval or MOTChallenge to compute IDF1/HOTA scores and optimize tracker parameters iteratively.

      @maxexplorer great questions about tracking stability! Here are the key points:

      1. ID changes typically occur due to low IoU between predicted and detected boxes, occlusions, or threshold mismatches. Check track_high_thresh and match_thresh in your tracker config.

      2. match_thresh is indeed IoU-based. For debugging, you can add logging to the tracker code, but there's no built-in visualization.

      3. Kalman predictions aren't directly exposed, but you can access them by modifying the tracker implementation.

      4. Higher FPS generally improves tracking by reducing inter-frame motion, making associations more reliable.

      5. Both trackers use confirmation logic - tracks need to meet certain criteria before being confirmed as valid tracks.

      6. New tracks can be assigned immediately if detection confidence exceeds new_track_thresh.

      7. Correct - track_buffer maintains lost tracks for that many frames using prediction.

      8. For stability: increase track_buffer, adjust match_thresh based on your scenario, and ensure consistent detection quality with appropriate conf thresholds.

      For detailed parameter tuning, refer to the tracker configuration files and our tracking documentation.

  2. rohith-aiunikaGitHub(editado)

    Hi YOLO Team, I've been using the following Python script to track objects with my YOLOv8 model: from ultralytics import YOLO

    model = YOLO(r"/home/best_pt_files/v1.0.2.pt") results = model.track(r"/home/video.MP4", save=False, stream=False)

    However, I noticed that my GPU memory usage gradually increases, leading to an "out of memory" error before the video finishes processing. Interestingly, when I use the following command from the terminal, the entire video tracks successfully without excessive GPU memory consumption: yolo track model=/home/best_pt_files/1.0.2.pt source=/home/video.MP4

    Previously, the Python script worked without any issues. The memory issue has only recently started occurring. Could you please help me understand the possible reasons for this memory increase and how to address it?

    i have experimented with persist= True and False,stream = true and false, show = true and false also but the issue is still there

    1
    1. Glenn JocherUltralytics

      @rohith-aiunika thanks for reporting this. The memory buildup in Python scripts (but not CLI) typically occurs when not using streaming mode. To match the CLI's memory behavior, modify your Python script to process frames iteratively using stream=True:

      from ultralytics import YOLO
      
      model = YOLO("/home/best_pt_files/v1.0.2.pt")
      for result in model.track("/home/video.MP4", stream=True):  # Process frames iteratively
          pass  # Add your frame processing logic here

      This streams frames sequentially like the CLI, preventing memory accumulation. For more details, see the streaming implementation in our Tracking documentation. Let us know if this resolves the issue!

    2. rohith-aiunikaGitHub

      i have used stream = True, then the code is just executing without showing error and without tracking also

    3. Glenn JocherUltralytics

      @rohith-aiunika thanks for the update. Let's ensure you're properly iterating through streaming results. Try adding a processing loop like this:

      for result in model.track(source=video_path, stream=True):
          annotated_frame = result[0].plot()
          cv2.imshow('Tracking', annotated_frame)
          if cv2.waitKey(1) == ord('q'):
              break

      This actively processes each frame and displays tracking annotations. If issues persist, you might need to verify your video source format using our supported inference sources documentation.

  3. mwaselaGitHub

    Hello, Made a custom model that i can successfully run and with a well tweaked confidence filter, am getting good results.

    Now Ive wrapped the classification and tracking functionality into a flask app, that returns the count ID's when accessed by a REST call like get, meaning it can be accessed by a separate app for processing and stuff. I want to be able to reset the counting through some other request. My camera feed is always live, i need a way to reset the track id's to zero when neccessary, they just keep counting until i exit the program.

    1
    1. Glenn JocherUltralytics

      @mwasela hello,

      It's great to hear that your custom model is performing well. To reset the tracking IDs in your Flask app, you can implement a mechanism to reinitialize the tracker state upon receiving a specific request. This can be done by resetting the tracker object or reloading the model within your tracking function.

      For more detailed guidance on configuring and using trackers, please refer to our documentation: Multi-Object Tracking with Ultralytics YOLO.

  4. Orziqulov-JavohirGitHub

    I really need help to do this programm: I wanna select region via mouse "dangerous zone" Track detected person, If person enters this zone crop and save person's photo Can you show me pls how to do it for 10 cameras, my gpu is RTX 3080TI

    1
    1. Orziqulov-JavohirGitHub

      import cv2 from ultralytics import YOLO import time

      Load the YOLOv8 model

      model = YOLO("yolov8n.pt") # pretrained YOLOv8n model

      Initialize video capture for multiple cameras

      camera_ids = [

      'rtsp://admin:admin12345@172.17.67.20:554',

      'rtsp://admin:admin12345@172.17.67.16:554', 'rtsp://admin:admin12345@172.17.67.18:554', 'rtsp://admin:admin12345@172.17.67.19:554', 'rtsp://admin:admin12345@172.17.67.17:554', 'rtsp://admin:admin12345@172.17.67.21:554', 'rtsp://admin:admin12345@172.17.67.17:554', 'rtsp://admin:admin12345@172.17.67.21:554', 'rtsp://admin:admin12345@172.17.67.17:554',
      ]

      caps = [cv2.VideoCapture(camera_id) for camera_id in camera_ids]

      Open the video file

      roi_start = [(0, 0)] * len(caps) roi_end = [(0, 0)] * len(caps) drawing = [False] * len(caps)

      tracked_persons = [[] for _ in range(len(caps))] # List to track persons in dangerous zones

      def draw_rectangle(event, x, y, flags, param): global roi_start, roi_end, drawing idx = param # Use param to identify the camera index if event == cv2.EVENT_LBUTTONDOWN: drawing[idx] = True roi_start[idx] = (x, y) roi_end[idx] = (x, y) print(f"Camera {idx}: Started drawing rectangle at: {roi_start[idx]}") elif event == cv2.EVENT_MOUSEMOVE: if drawing[idx]: roi_end[idx] = (x, y) print(f"Camera {idx}: Updated rectangle end to: {roi_end[idx]}") elif event == cv2.EVENT_LBUTTONUP: drawing[idx] = False roi_end[idx] = (x, y) print(f"Camera {idx}: Finished drawing rectangle at: {roi_end[idx]}")

      Create a window and set mouse callback for each camera

      for idx in range(len(caps)): window_name = f'Video {idx}' cv2.namedWindow(window_name) cv2.setMouseCallback(window_name, draw_rectangle, idx)

      def is_inside_roi(x, y, roi_start, roi_end): x1, y1 = roi_start x2, y2 = roi_end return min(x1, x2) <= x <= max(x1, x2) and min(y1, y2) <= y <= max(y1, y2)

      while True: frames = [] for cap in caps: ret, frame = cap.read() if not ret: continue # frame = cv2.resize(frame, (640, 480)) frames.append(frame)

      for idx, frame in enumerate(frames):
          window_name = f'Video {idx}'
          
          # Draw the ROI rectangle on the frame
          if drawing[idx] or roi_start[idx] != roi_end[idx]:
              cv2.rectangle(frame, roi_start[idx], roi_end[idx], (0, 255, 0), 2)
              cv2.putText(frame, "Dangerous Zone", (roi_start[idx][0], roi_start[idx][1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
      
          # Run YOLOv8 tracking on the frame, persisting tracks between frames
          results = model.track(frame, tracker="bytetrack.yaml", persist=True)
      
          for result in results:
              boxes = result.boxes
      
              for box in boxes:
                  x1, y1, x2, y2 = box.xyxy.tolist()[0][:4]
                  cls = box.cls.tolist()[0]
                  if cls == 0:  # Person class in COCO dataset
                      # Check if the center of the person is inside the ROI
                      cx, cy = int((x1 + x2) / 2), int((y1 + y2) / 2)
                      if is_inside_roi(cx, cy, roi_start[idx], roi_end[idx]):
                          # Check if this person is already tracked
                          person_id = box.id.tolist()[0] if box.id is not None else None
                          
                          if person_id not in tracked_persons[idx]:
                              tracked_persons[idx].append(person_id)
                              # Crop and save the frame
                              crop = frame[int(y1):int(y2), int(x1):int(x2)]
                              cv2.imwrite(f"cropped_camera{idx}_person{person_id}_{int(time.time())}.jpg", crop)
                              # Draw a label on the person
                              cv2.putText(frame, "Person in Dangerous Zone", (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
                              cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)
      
          cv2.imshow(window_name, frame)
      
      if cv2.waitKey(1) & 0xFF == ord('q'):
          break

      Release all video captures

      for cap in caps: cap.release() cv2.destroyAllWindows()

    2. Glenn JocherUltralytics

      Your approach looks solid for setting up a security program to track and save images of individuals entering a designated "dangerous zone" across multiple cameras. To enhance your implementation, ensure you're using the latest versions of the Ultralytics package for optimal performance and bug fixes. For more detailed guidance on tracking configurations and additional features, you can refer to the Ultralytics tracking documentation. If you encounter any specific issues or need further assistance, feel free to ask!

    3. mariem158GitHub

      File "", line 91 results = model.track(frame, persist=True, tracker="botsort.yaml") ^ IndentationError: unexpected indent COMMENT CORRIGER CETTE ERREUR

    4. Glenn JocherUltralytics

      The error you're encountering is due to an unexpected indent in your code. Ensure that the indentation is consistent throughout your script. If the issue persists, please verify it with the latest version of the Ultralytics package. For more details on tracking configurations, you can refer to the Ultralytics tracking documentation.

  5. GKYofficeGitHub

    How can I get the tracking metrics of a tracker such as MOTA, IDF1, etc.

    1
    1. GKYofficeGitHub

      Can I set the parameter ''save_txt'' to True in the track function, and then write code to evaluate the tracking data?

    2. Paula DerrengerUltralytics

      Currently, the Ultralytics YOLO framework doesn't provide built-in functionality for computing tracking metrics like MOTA or IDF1 directly through the API or command line. However, you can utilize external libraries such as MOTChallenge eval for calculating these metrics.

      After running your tracking with YOLOv8, you'd typically export your tracking results in a format compatible with these libraries (usually a .txt format with frame ID, object ID, bounding boxes, etc.). Then, use the external library to compute the desired metrics by providing it with both the ground truth and your results file.

      Here's a generic example on how you might save tracking results (modify based on your actual use case):

      from ultralytics import YOLO
      
      # Initialize and load your model
      model = YOLO("path/to/your/model.pt")
      
      # Tracking
      results = model.track(source='path/to/video.mp4', save_txt=True, project='runs/track', name='exp')
      
      # results are saved in 'runs/track/exp' in a format that can be used with MOTChallenge eval tools

      Afterwards, follow the documentation of the MOTChallenge eval toolkit to compute the metrics using the outputs stored in 'runs/track/exp'.

      If you encounter any specific issues while implementing this, feel free to ask!🛠️

  6. AdadAlShababGitHub

    Can I run two models simultaneously in one video? Ex: model = YOLO('E:/Ultralytics/best.pt') model = YOLO('yolov8m-pose.pt') results = model.track(source="file.mp4", show=True, conf=0.3, save=False) results = model.track(source="file.mp4", show=True, conf=0.3, save=False)

    I want that two models will works simultaneously with cumulative results? Is it possible? Please let me know. Thanks in advance!!

    1
    1. Paula DerrengerUltralytics

      @AdadAlShabab yes, you can run two models simultaneously on one video, but you'll need to manage the inference in a way that allows both models to process the video frames concurrently. Here's a simplified example using threading to achieve this:

      import threading
      from ultralytics import YOLO
      
      # Load the models
      model1 = YOLO('E:/Ultralytics/best.pt')
      model2 = YOLO('yolov8m-pose.pt')
      
      # Function to run tracking
      def track_video(model, source, conf, show, save):
          results = model.track(source=source, show=show, conf=conf, save=save)
          # Process results here or return them
      
      # Create threads for each model
      thread1 = threading.Thread(target=track_video, args=(model1, "file.mp4", 0.3, True, False))
      thread2 = threading.Thread(target=track_video, args=(model2, "file.mp4", 0.3, True, False))
      
      # Start the threads
      thread1.start()
      thread2.start()
      
      # Wait for both threads to finish
      thread1.join()
      thread2.join()

      This script will run both models in separate threads. If you want to combine the results from both models, you'll need to implement a mechanism to synchronize and merge the results from both threads. Keep in mind that displaying the results (show=True) from two threads might not work as expected, and you might need to handle the visualization separately.

      Remember to handle the GPU memory usage carefully, as running two models simultaneously will require more memory. If you encounter any issues, consider running the models sequentially or on separate GPUs if available.

      4
  7. Journey2-20GitHub

    Hello I'm newer to Opencv and I'm trying to run a tracking camera for airsoft. How would i select specific bounding boxes?

    1. Paula DerrengerUltralytics

      Use model.track(frame, persist=True) and inspect results[0].boxes.xyxy with results[0].boxes.id; select the box containing your OpenCV mouse-click coordinates, store its track ID, then process or draw only boxes whose boxes.id matches that ID. Feel free to continue posting questions here so the Ultralytics team can help.

  8. yashpatel2010GitHub

    In my jetson orin nano super developer kit with jetpack6.1 and deepstream7.1 i want to do cross camera person tracking. Is there any default way in deepstream configs to do it? Or any other lightweight thing that can be easily doable in jetson orin nano 8 gb super dev kit.

    1. Glenn JocherUltralytics

      Ultralytics track is single-camera MOT, so cross-camera person IDs are not built in; on DeepStream 7.1 the practical Orin Nano path is NvDeepSORT/ReID per stream plus downstream association from the exported embeddings described in the DeepStream gst-nvtracker docs, or NVIDIA’s separate Multi-Camera Tracking workflow for full MTMC. Please keep the details here in Discussions and share your current tracker config if you want a minimal setup suggestion. (docs.nvidia.com)

  9. anvi97GitHub(editado)

    Hi @glenn-jocher,

    I am building a road surface detection system using YOLO segmentation.

    My pipeline:

    Apply bird eye view using cv2.getPerspectiveTransform()

    Mask only road area

    Detect potholes, zebra crossings, and speed bumps

    I am facing the following issues:

    1️⃣ Overlapping Potholes Not Merging Properly

    I want overlapping potholes to merge into one bounding box.

    In many cases it works, but sometimes:

    Two boxes are still shown for the same pothole

    Even when they overlap visually

    I am using YOLO with:

    results = model(frame, conf=0.45, iou=0.4)

    Is YOLO’s internal NMS preventing full merging? Should I apply custom merging after inference? Is segmentation-based merging better than bounding box merging for potholes?

    2️⃣ Object Size Changing After Bird Eye View

    I calculate pothole size using:

    pixels_per_foot = 220

    But I selected this value randomly (no real-world measurement).

    Because of this:

    Object size changes depending on frame position

    Same pothole appears different size

    Is it correct that without real-world calibration, size cannot be accurate? What is the correct method to calculate real-world size in a monocular dashcam setup?

    3️⃣ Zebra Crossing vs Black–White Speed Bump Confusion

    Black–white speed bumps are getting confused with zebra crossings because both have parallel white-black stripes.

    Currently I am detecting only yellow speed bumps to avoid confusion.

    What is the better approach to separate them?

    Use segmentation instead of boxes?

    Add geometry-based filtering?

    Train with more hard-negative examples?

    1. anvi97GitHub

      this is my code ..... from ultralytics import YOLO import cv2 import numpy as np

      model = YOLO("runs/segment/pothole_seg_model3/weights/best.pt") pixels_per_foot = 220

      video_path = "sample_video.mp4" cap = cv2.VideoCapture(video_path)

      if not cap.isOpened(): print(" Cannot open video") exit()

      width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = cap.get(cv2.CAP_PROP_FPS) or 25.0

      fourcc = cv2.VideoWriter_fourcc(*'avc1') out = cv2.VideoWriter("pothole5.mp4", fourcc, fps, (width, height))

      STRETCH_AMOUNT = 50

      src = np.float32([ [0, height],
      [width, height],
      [922, 183],
      [265, 183]
      ])

      dst = np.float32([ [0, height], [width, height], [width + STRETCH_AMOUNT, 0], [0 - STRETCH_AMOUNT, 0] ])

      matrix = cv2.getPerspectiveTransform(src, dst) def compute_iou(box1, box2): x1 = max(box1[0], box2[0]) y1 = max(box1[1], box2[1]) x2 = min(box1[2], box2[2]) y2 = min(box1[3], box2[3])

      inter_area = max(0, x2 - x1) * max(0, y2 - y1)
      
      box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
      box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
      
      union = box1_area + box2_area - inter_area
      
      if union == 0:
          return 0
      
      return inter_area / union

      def should_merge(box1, box2, iou_thresh=0.1, dist_thresh=150): # Containment check - if one box is inside the other if (box1[0] >= box2[0] and box1[1] >= box2[1] and box1[2] <= box2[2] and box1[3] <= box2[3]): return True if (box2[0] >= box1[0] and box2[1] >= box1[1] and box2[2] <= box1[2] and box2[3] <= box1[3]): return True

      iou = compute_iou(box1, box2)
      if iou > iou_thresh:
          return True
      
      cx1, cy1 = (box1[0]+box1[2])/2, (box1[1]+box1[3])/2
      cx2, cy2 = (box2[0]+box2[2])/2, (box2[1]+box2[3])/2
      
      if np.sqrt((cx1-cx2)**2 + (cy1-cy2)**2) < dist_thresh:
          return True
      
      return False

      while True: ret, frame = cap.read() if not ret: break

      bird_eye = cv2.warpPerspective(frame, matrix, (width, height))
      
      results = model(bird_eye, conf=0.45, iou=0.4)[0]
      annotated = results.plot()
      
      if results.boxes is not None:
          for box in results.boxes:
              cls_id = int(box.cls.item())
      
              if cls_id == 0:  # pothole only
                  x1, y1, x2, y2 = map(int, box.xyxy.cpu().numpy()[0])
      
                  w_px = x2 - x1
                  h_px = y2 - y1
      
                  w_ft = w_px / pixels_per_foot
                  h_ft = h_px / pixels_per_foot
      
                  label = f"{w_ft:.2f}ft x {h_ft:.2f}ft"
      
                  cv2.putText(
                      annotated,
                      label,
                      (x1, y1 - 15),
                      cv2.FONT_HERSHEY_SIMPLEX,
                      0.6,
                      (0, 255, 255),
                      2
                  )
      
      cv2.imshow("Bird Eye + Pothole Detection", annotated)
      out.write(annotated)
      
      if cv2.waitKey(1) & 0xFF == 27:
          break

      cap.release() out.release() cv2.destroyAllWindows()

    2. Glenn JocherUltralytics

      For (1), YOLO’s NMS will only suppress duplicate detections based on iou=...—it won’t “merge” two overlapping detections into a larger union box, and in your snippet compute_iou() / should_merge() aren’t actually applied to results.boxes, so you’re still visualizing the raw post-NMS output; since you’re using a Segment model, the most robust way to merge “split” potholes is to union the pothole masks and re-extract connected components (then box/measure those) rather than trying to union boxes.

      import cv2
      import numpy as np
      
      r = model(bird_eye, conf=0.45, iou=0.4)[0]
      
      if r.masks is not None and r.boxes is not None:
          cls = r.boxes.cls.int().cpu().numpy()
          pothole_idx = np.where(cls == 0)[0]
          if pothole_idx.size:
              m = r.masks.data[pothole_idx].cpu().numpy()  # (N,H,W), 0/1
              union = (m.sum(0) > 0).astype(np.uint8) * 255
              n, labels = cv2.connectedComponents(union)
              for k in range(1, n):
                  ys, xs = np.where(labels == k)
                  x1, y1, x2, y2 = xs.min(), ys.min(), xs.max(), ys.max()
                  cv2.rectangle(bird_eye, (x1, y1), (x2, y2), (0, 255, 255), 2)

      For (2), yes—without real-world calibration (and a valid “road plane” assumption), pixels_per_foot=220 can’t be physically meaningful, and even with a BEV warp you only get consistent scale if your homography is tied to metric coordinates; the usual monocular approach is: calibrate camera intrinsics, estimate the road plane, build a homography to a top-down plane in real units (or derive scale from at least one known road-plane measurement like lane width/stripe spacing), then measure in the BEV plane.

      For (3), the best fix is usually data: train both classes explicitly with lots of “hard negatives” (zebra crossings that look like bumps and vice versa) and keep labels consistent; segmentation often helps because you can then add simple shape/location constraints on the mask (zebra = large repeated pattern region, bump = single narrow band across lane) and optionally smooth decisions over time (if you’re doing video, using model.track(..., persist=True) from the Track mode docs can help stabilize per-frame flicker, even though it won’t merge instances within a frame).

      If you can paste !yolo checks output and one representative frame (plus what you consider the “correct” merged result), I can suggest concrete thresholds/post-processing for your exact outputs.

    3. anvi97GitHub

      Representative frame In the attached frame:

      The large water-filled pothole on the left should be treated as a single instance.

      The small region in the top-left corner (currently detected as separate) should be merged with the large region.

      Essentially, all visually continuous damaged area should result in one bounding box / one connected component.

      Currently:

      Mask union + connected components splits them due to small segmentation gaps

      Goal:

      Treat visually continuous pothole surface as one instance for measurement stability.

    4. Glenn JocherUltralytics

      That split is expected because connectedComponents() treats any 1–2 px “mask hole” as a hard break, so add a small gap-closing step on the union mask (morphological close / dilate→erode) before components, with the kernel sized to the largest gap you still consider “visually continuous” (see Ultralytics YOLO segmentation docs for more mask/seg usage details):

      # union: uint8 {0,255}
      union = (m.sum(0) > 0).astype(np.uint8) * 255
      
      # bridge small gaps (tune kernel size to your expected mask discontinuities)
      k_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (25, 25))
      union_closed = cv2.morphologyEx(union, cv2.MORPH_CLOSE, k_close, iterations=1)
      
      # optional: remove tiny speckles after closing
      k_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
      union_closed = cv2.morphologyEx(union_closed, cv2.MORPH_OPEN, k_open, iterations=1)
      
      n, labels = cv2.connectedComponents(union_closed)
  10. mslabdelhak29GitHub

    Reid doesn't work how can i fix it i tried to change it True in botsort.yaml but it doesn't work

    1. Glenn JocherUltralytics(editado)

      @mslabdelhak29 ReID is only supported by some trackers (for example BoT-SORT), not ByteTrack, and it’s enabled via the tracker YAML you pass at runtime. Copy the default config, enable ReID explicitly, and point track() to your copy:

      # custom_botsort.yaml
      tracker_type: botsort
      with_reid: True
      model: yolo26n-cls.pt  # or another YOLO classification weight you have locally
      from ultralytics import YOLO
      model = YOLO("yolo26n.pt")  # any YOLO detector
      results = model.track(source="path/to/video.mp4", tracker="custom_botsort.yaml", persist=True, show=False)

      If it still doesn’t work, you’re likely editing a different YAML than the one being loaded; always pass the path as above. Also share the output of yolo checks and the exact custom_botsort.yaml you used so we can verify your environment and keys. See the ReID section in the tracking guide and the BoT-SORT config for details: Multi‑Object Tracking docs and botsort.yaml config.