Seguimiento multiobjeto con Ultralytics YOLO

El seguimiento de objetos en el ámbito de la analítica de vídeo es una tarea crítica que no sólo identifica la ubicación y clase de los objetos dentro del fotograma, sino que también mantiene un ID único para cada objeto detectado a medida que avanza el vídeo. Las aplicaciones son ilimitadas: desde la vigilancia y la seguridad hasta el análisis deportivo en tiempo real.

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

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

• Eficacia: Procesa flujos de vídeo en tiempo real sin comprometer la precisión.
• Flexibilidad: Admite múltiples algoritmos y configuraciones de seguimiento.
• Facilidad de uso: API Python sencilla y opciones CLI para una integración e implantación rápidas.
• Personalizabilidad: Fácil de usar con modelos YOLO entrenados a medida, lo que permite la integración en aplicaciones específicas del dominio.

Observa: Detección y seguimiento de objetos con Ultralytics YOLOv8 .

Aplicaciones en el mundo real

Transporte	Venta al por menor	Acuicultura
Seguimiento de vehículos	Seguimiento de personas	Seguimiento de peces

Características

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

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

Seguidores disponibles

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

• BoT-SORT - Utiliza botsort.yaml para activar este rastreador.
• ByteTrack - Utiliza bytetrack.yaml para activar este rastreador.

El rastreador por defecto es BoT-SORT.

Seguimiento

Para ejecutar el rastreador en secuencias de vídeo, utiliza un modelo entrenado de Detección, Segmento o Pose, como YOLOv8n, YOLOv8n-seg y YOLOv8n-pose.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO('yolov8n.pt')  # Load an official Detect model
model = YOLO('yolov8n-seg.pt')  # Load an official Segment model
model = YOLO('yolov8n-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(source="https://youtu.be/LNwODJXcvt4", show=True)  # Tracking with default tracker
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # Tracking with ByteTrack tracker

# Perform tracking with various models using the command line interface
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4"  # Official Detect model
yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4"  # Official Segment model
yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4"  # Official Pose model
yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4"  # Custom trained model

# Track using ByteTrack tracker
yolo track model=path/to/best.pt tracker="bytetrack.yaml"

Como puede verse en el uso anterior, el seguimiento está disponible para todos los modelos Detectar, Segmentar y Pose ejecutados en vídeos o fuentes de streaming.

Configuración

Argumentos de seguimiento

La configuración de seguimiento comparte propiedades con el modo Predecir, como conf, iouy show. Para más configuraciones, consulta Predecir página modelo.

from ultralytics import YOLO

# Configure the tracking parameters and run the tracker
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)

# Configure tracking parameters and run the tracker using the command line interface
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show

Selección del rastreador

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

from ultralytics import YOLO

# Load the model and run the tracker with a custom configuration file
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')

# Load the model and run the tracker with a custom configuration file using the command line interface
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'

Para obtener una lista completa de argumentos de seguimiento, consulta la página ultralytics/cfg/trackers.

Python Ejemplos

Bucle de pistas persistentes

Aquí tienes un script Python que utiliza OpenCV (cv2) y YOLOv8 para ejecutar el seguimiento de objetos en fotogramas de vídeo. Este script sigue suponiendo que ya tienes instalados los paquetes necesarios (opencv-python y ultralytics). En persist=True indica al rastreador que la imagen o fotograma actual es el siguiente de una secuencia y que espere las pistas de la imagen anterior en la imagen actual.

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('yolov8n.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 YOLOv8 tracking on the frame, persisting tracks between frames
        results = model.track(frame, persist=True)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLOv8 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 permite el seguimiento de objetos en lugar de la simple detección. Este script modificado ejecutará el rastreador en cada fotograma del vídeo, visualizará los resultados y los mostrará en una ventana. Se puede salir del bucle pulsando "q".

Trazar trazados a lo largo del tiempo

Visualizar los rastros de objetos en fotogramas consecutivos puede proporcionar información valiosa sobre los patrones de movimiento y el comportamiento de los objetos detectados en un vídeo. Con Ultralytics YOLOv8 , trazar estas pistas es un proceso fluido y eficaz.

En el siguiente ejemplo, demostramos cómo utilizar las funciones de seguimiento de YOLOv8 para trazar el movimiento de los objetos detectados en varios fotogramas de vídeo. Este script consiste en abrir un archivo de vídeo, leerlo fotograma a fotograma y utilizar el modelo YOLO para identificar y seguir varios objetos. Reteniendo los puntos centrales de los cuadros delimitadores detectados y conectándolos, podemos trazar líneas que representen las trayectorias seguidas por los objetos rastreados.

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('yolov8n.pt')

# Open the video file
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

# Store the track history
track_history = defaultdict(lambda: [])

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLOv8 tracking on the frame, persisting tracks between frames
        results = model.track(frame, persist=True)

        # Get the boxes and track IDs
        boxes = results[0].boxes.xywh.cpu()
        track_ids = results[0].boxes.id.int().cpu().tolist()

        # Visualize the results on the frame
        annotated_frame = results[0].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 90 tracks for 90 frames
                track.pop(0)

            # Draw the tracking lines
            points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
            cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

        # Display the annotated frame
        cv2.imshow("YOLOv8 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()

Seguimiento multihilo

El seguimiento multihilo permite ejecutar el seguimiento de objetos en varios flujos de vídeo simultáneamente. Esto es especialmente útil cuando se manejan varias entradas de vídeo, como las de varias cámaras de vigilancia, donde el procesamiento simultáneo puede mejorar mucho la eficacia y el rendimiento.

En el script Python proporcionado, utilizamos Python's threading para ejecutar varias instancias del rastreador simultáneamente. Cada hilo es responsable de ejecutar el rastreador en un archivo de vídeo, y todos los hilos se ejecutan simultáneamente en segundo plano.

Para asegurarnos de que cada hilo recibe los parámetros correctos (el archivo de vídeo, el modelo a utilizar y el índice del archivo), definimos una función run_tracker_in_thread que acepta estos parámetros y contiene el bucle de seguimiento principal. Esta función lee el vídeo fotograma a fotograma, ejecuta el rastreador y muestra los resultados.

En este ejemplo se utilizan dos modelos diferentes: yolov8n.pt y yolov8n-seg.ptcada uno de los cuales rastrea objetos en un archivo de vídeo diferente. Los archivos de vídeo se especifican en video_file1 y video_file2.

En daemon=True parámetro en threading.Thread significa que estos hilos se cerrarán en cuanto termine el programa principal. A continuación, iniciamos los hilos con start() y utiliza join() para que el hilo principal espere hasta que los dos hilos del rastreador hayan terminado.

Por último, una vez que todos los subprocesos han completado su tarea, las ventanas que muestran los resultados se cierran utilizando cv2.destroyAllWindows().

import threading
import cv2
from ultralytics import YOLO


def run_tracker_in_thread(filename, model, file_index):
    """
    Runs a video file or webcam stream concurrently with the YOLOv8 model using threading.

    This function captures video frames from a given file or camera source and utilizes the YOLOv8 model for object
    tracking. The function runs in its own thread for concurrent processing.

    Args:
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
        model (obj): The YOLOv8 model object.
        file_index (int): An index to uniquely identify the file being processed, used for display purposes.

    Note:
        Press 'q' to quit the video display window.
    """
    video = cv2.VideoCapture(filename)  # Read the video file

    while True:
        ret, frame = video.read()  # Read the video frames

        # Exit the loop if no more frames in either video
        if not ret:
            break

        # Track objects in frames if available
        results = model.track(frame, persist=True)
        res_plotted = results[0].plot()
        cv2.imshow(f"Tracking_Stream_{file_index}", res_plotted)

        key = cv2.waitKey(1)
        if key == ord('q'):
            break

    # Release video sources
    video.release()


# Load the models
model1 = YOLO('yolov8n.pt')
model2 = YOLO('yolov8n-seg.pt')

# Define the video files for the trackers
video_file1 = "path/to/video1.mp4"  # Path to video file, 0 for webcam
video_file2 = 0  # Path to video file, 0 for webcam, 1 for external camera

# Create the tracker threads
tracker_thread1 = threading.Thread(target=run_tracker_in_thread, args=(video_file1, model1, 1), daemon=True)
tracker_thread2 = threading.Thread(target=run_tracker_in_thread, args=(video_file2, model2, 2), daemon=True)

# Start the tracker threads
tracker_thread1.start()
tracker_thread2.start()

# Wait for the tracker threads to finish
tracker_thread1.join()
tracker_thread2.join()

# Clean up and close windows
cv2.destroyAllWindows()

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

Aportar nuevos seguidores

¿Eres experto en el seguimiento de múltiples objetos y has aplicado o adaptado con éxito un algoritmo de seguimiento con Ultralytics YOLO ? ¡Te invitamos a contribuir a nuestra sección Trackers en ultralytics/cfg/trackers! Tus aplicaciones y soluciones del mundo real podrían ser muy valiosas 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 en el marco Ultralytics YOLO , añadiendo otra capa de funcionalidad y utilidad para la comunidad.

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

Juntos, ¡mejoremos la capacidad de seguimiento del ecosistema Ultralytics YOLO 🙏!

Comentarios