Suivi de plusieurs objets avec Ultralytics YOLO

Le suivi des objets dans le domaine de l'analyse vidéo est une tâche essentielle qui permet non seulement d'identifier l'emplacement et la classe des objets dans l'image, mais aussi de conserver un identifiant unique pour chaque objet détecté au fur et à mesure de la progression de la vidéo. Les applications sont illimitées, allant de la surveillance et de la sécurité à l'analyse sportive en temps réel.

Pourquoi choisir Ultralytics YOLO pour le suivi d'objets ?

Le résultat des trackers Ultralytics est cohérent avec la détection d'objets standard, mais il a la valeur ajoutée des identifiants d'objets. Cela permet de suivre facilement les objets dans les flux vidéo et d'effectuer des analyses ultérieures. Voici pourquoi tu devrais envisager d'utiliser Ultralytics YOLO pour tes besoins en matière de suivi d'objets :

• Efficacité : Traite les flux vidéo en temps réel sans compromettre la précision.
• Flexibilité : Prend en charge plusieurs algorithmes et configurations de suivi.
• Facilité d'utilisation : API simple Python et options CLI pour une intégration et un déploiement rapides.
• Personnalisation : Facile à utiliser avec des modèles YOLO formés sur mesure, permettant l'intégration dans des applications spécifiques à un domaine.

Regarde : Détection et suivi d'objets avec Ultralytics YOLOv8 .

Applications dans le monde réel

Transport	Vente au détail	Aquaculture
Suivi des véhicules	Suivi des personnes	Suivi des poissons

Aperçu des caractéristiques

Ultralytics YOLO étend ses fonctions de détection d'objets pour offrir un suivi d'objets robuste et polyvalent :

• Suivi en temps réel : Effectue un suivi transparent des objets dans les vidéos à haute fréquence d'images.
• Prise en charge de plusieurs traqueurs : Choisis parmi une variété d'algorithmes de suivi établis.
• Configurations personnalisables du traqueur : Adapte l'algorithme de suivi aux besoins spécifiques en ajustant divers paramètres.

Traqueurs disponibles

Ultralytics YOLO prend en charge les algorithmes de suivi suivants. Ils peuvent être activés en passant le fichier de configuration YAML correspondant tel que tracker=tracker_type.yaml:

• BoT-SORT - Utilise botsort.yaml pour activer ce tracker.
• ByteTrack - Utilise bytetrack.yaml pour activer ce tracker.

Le tracker par défaut est BoT-SORT.

Suivi

Pour faire fonctionner le traqueur sur des flux vidéo, utilise un modèle entraîné de détection, de segmentation ou de pose tel que YOLOv8n, YOLOv8n-seg et 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"

Comme on peut le voir dans l'utilisation ci-dessus, le suivi est disponible pour tous les modèles Detect, Segment et Pose exécutés sur des vidéos ou des sources de streaming.

Configuration

Suivi des arguments

La configuration du suivi partage des propriétés avec le mode prédictif, telles que conf, iouet show. Pour d'autres configurations, voir le Prévoir modèle de page.

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

Sélection du traceur

Ultralytics te permet également d'utiliser un fichier de configuration de tracker modifié. Pour cela, il suffit de faire une copie d'un fichier de configuration du tracker (par exemple, custom_tracker.yaml) de ultralytics/cfg/trackers et de modifier toutes les configurations (à l'exception de la tracker_type) en fonction de tes besoins.

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'

Pour obtenir une liste complète des arguments de suivi, reporte-toi à la page ultralytics/cfg/trackers.

Python Exemples

Boucle de pistes persistantes

Voici un script Python utilisant OpenCV (cv2) et YOLOv8 pour effectuer le suivi des objets sur les images vidéo. Ce script suppose que tu as déjà installé les paquets nécessaires (opencv-python et ultralytics). Les persist=True indique au traceur que l'image ou la trame actuelle est la suivante d'une séquence et qu'il doit s'attendre à ce que les pistes de l'image précédente se trouvent dans l'image actuelle.

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

Note que le changement de model(frame) à model.track(frame)qui permet le suivi des objets au lieu d'une simple détection. Ce script modifié exécutera le traqueur sur chaque image de la vidéo, visualisera les résultats et les affichera dans une fenêtre. La boucle peut être quittée en appuyant sur 'q'.

Tracer des pistes dans le temps

La visualisation des traces d'objets sur des images consécutives peut fournir des indications précieuses sur les modèles de mouvement et le comportement des objets détectés dans une vidéo. Avec Ultralytics YOLOv8 , le traçage de ces pistes est un processus transparent et efficace.

Dans l'exemple suivant, nous montrons comment utiliser les capacités de suivi de YOLOv8 pour tracer le mouvement des objets détectés sur plusieurs images vidéo. Ce script consiste à ouvrir un fichier vidéo, à le lire image par image et à utiliser le modèle YOLO pour identifier et suivre divers objets. En conservant les points centraux des boîtes de délimitation détectées et en les reliant, nous pouvons tracer des lignes qui représentent les chemins suivis par les objets suivis.

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

Suivi multithread

Le suivi multithread permet d'exécuter le suivi d'objets sur plusieurs flux vidéo simultanément. Ceci est particulièrement utile lors du traitement de plusieurs entrées vidéo, comme celles provenant de plusieurs caméras de surveillance, où le traitement simultané peut grandement améliorer l'efficacité et les performances.

Dans le script Python fourni, nous utilisons le script de Python. threading pour faire fonctionner plusieurs instances du tracker simultanément. Chaque thread est responsable de l'exécution du tracker sur un fichier vidéo, et tous les threads s'exécutent simultanément en arrière-plan.

Pour que chaque thread reçoive les bons paramètres (le fichier vidéo, le modèle à utiliser et l'index du fichier), nous définissons une fonction run_tracker_in_thread qui accepte ces paramètres et contient la boucle principale de suivi. Cette fonction lit la vidéo image par image, exécute le tracker et affiche les résultats.

Deux modèles différents sont utilisés dans cet exemple : yolov8n.pt et yolov8n-seg.ptChacun d'entre eux suit les objets d'un fichier vidéo différent. Les fichiers vidéo sont spécifiés dans video_file1 et video_file2.

Le daemon=True paramètre dans threading.Thread signifie que ces threads seront fermés dès que le programme principal se terminera. Nous démarrons ensuite les threads avec start() et utilise join() pour que le thread principal attende que les deux threads du tracker aient terminé.

Enfin, une fois que tous les threads ont terminé leur tâche, les fenêtres affichant les résultats sont fermées à l'aide de la fonction 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()

Cet exemple peut facilement être étendu pour traiter plus de fichiers vidéo et de modèles en créant plus de fils et en appliquant la même méthodologie.

Contribuer à de nouveaux traqueurs

Tu maîtrises le suivi de plusieurs objets et tu as réussi à mettre en œuvre ou à adapter un algorithme de suivi à l'aide de Ultralytics YOLO ? Nous vous invitons à contribuer à notre section Trackers sur ultralytics/cfg/trackers ! Tes applications et solutions réelles pourraient être d'une valeur inestimable pour les utilisateurs qui travaillent sur des tâches de suivi.

En contribuant à cette section, tu contribues à élargir la portée des solutions de suivi disponibles dans le cadre de Ultralytics YOLO , en ajoutant une autre couche de fonctionnalité et d'utilité pour la communauté.

Pour initier ta contribution, reporte-toi à notre Guide de contribution pour obtenir des instructions complètes sur la soumission d'une demande de tirage (PR) 🛠️. Nous sommes impatients de voir ce que tu apporteras à la table !

Ensemble, améliorons les capacités de suivi de l'écosystème Ultralytics YOLO 🙏 !

Commentaires