Suivi multi-objets avec Ultralytics YOLO

Le suivi d'objets dans le domaine de l'analyse vidéo est une tâche critique qui non seulement identifie l'emplacement et la classe des objets dans l'image, mais maintient également un identifiant unique pour chaque objet détecté au fil 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 avec la valeur ajoutée des identifiants d'objets. Cela facilite le suivi d'objets dans les flux vidéo et permet d'effectuer des analyses ultérieures. Voici pourquoi tu devrais envisager d'utiliser Ultralytics YOLO pour tes besoins 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 Python et options CLI simples pour une intégration et un déploiement rapides.
• Personnalisation : Facile à utiliser avec des modèles YOLO personnalisés, permettant une intégration dans des applications spécifiques à un domaine.

Applications concrètes

Transport	Commerce de détail	Aquaculture
Suivi de véhicules	Suivi de personnes	Suivi de poissons

Aperçu des fonctionnalités

Ultralytics YOLO étend ses fonctionnalités de détection d'objets pour fournir un suivi d'objets robuste et polyvalent :

• Suivi en temps réel : Suis les objets de manière fluide dans des vidéos à haute fréquence d'images.
• Prise en charge de plusieurs trackers : Choisis parmi une variété d'algorithmes de suivi établis.
• Configurations de tracker personnalisables : Adapte l'algorithme de suivi pour répondre à des exigences spécifiques en ajustant divers paramètres.

Trackers disponibles

Ultralytics YOLO prend en charge les algorithmes de suivi suivants. Ils peuvent être activés en transmettant le fichier de configuration YAML pertinent 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 exécuter le tracker sur des flux vidéo, utilise un modèle entraîné de détection (Detect), segmentation (Segment) ou pose (Pose) tel que YOLO26n, YOLO26n-seg, ou YOLO26n-pose. Tu peux entraîner des modèles personnalisés localement ou sur des GPU cloud via Ultralytics Platform.

from ultralytics import YOLO

# Load an official or custom model
model = YOLO("yolo26n.pt")  # Load an official Detect model
model = YOLO("yolo26n-seg.pt")  # Load an official Segment model
model = YOLO("yolo26n-pose.pt")  # Load an official Pose model
model = YOLO("path/to/best.pt")  # Load a custom-trained model

# Perform tracking with the model
results = model.track("https://youtu.be/LNwODJXcvt4", show=True)  # Tracking with default tracker
results = model.track("https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # with ByteTrack

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

Arguments de suivi

La configuration du suivi partage des propriétés avec le mode Predict, comme conf, iou et show. Pour plus de configurations, reporte-toi à la page du modèle Predict.

from ultralytics import YOLO

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

Sélection du tracker

Ultralytics te permet également d'utiliser un fichier de configuration de tracker modifié. Pour ce faire, fais simplement une copie d'un fichier de configuration de tracker (par exemple, custom_tracker.yaml) depuis ultralytics/cfg/trackers et modifie les configurations (sauf le tracker_type) selon tes besoins.

from ultralytics import YOLO

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

Reporte-toi à la section Arguments du tracker pour une description détaillée de chaque paramètre.

Arguments du tracker

Certains comportements de suivi peuvent être affinés en modifiant les fichiers de configuration YAML spécifiques à chaque algorithme de suivi. Ces fichiers définissent des paramètres tels que les seuils, les tampons et la logique de correspondance :

• botsort.yaml
• bytetrack.yaml

Le tableau suivant fournit une description de chaque paramètre :

Activation de la ré-identification (ReID)

Par défaut, la ReID est désactivée pour minimiser la surcharge de performance. L'activer est simple : définis simplement with_reid: True dans la configuration du tracker. Tu peux également personnaliser le model utilisé pour la ReID, ce qui te permet de faire un compromis entre précision et vitesse en fonction de ton cas d'utilisation :

• Fonctionnalités natives (model: auto) : Cela exploite les caractéristiques directement depuis le détecteur YOLO pour la ReID, ajoutant une surcharge minimale. C'est idéal lorsque tu as besoin d'un certain niveau de ReID sans impacter significativement les performances. Si le détecteur ne prend pas en charge les fonctionnalités natives, il revient automatiquement à l'utilisation de yolo26n-cls.pt.
• Modèles de classification YOLO : Tu peux définir explicitement un modèle de classification (par exemple yolo26n-cls.pt) pour l'extraction de caractéristiques ReID. Cela fournit des embeddings plus discriminants, mais introduit une latence supplémentaire due à l'étape d'inférence supplémentaire.

Pour de meilleures performances, surtout lors de l'utilisation d'un modèle de classification séparé pour la ReID, tu peux l'exporter vers un backend plus rapide comme TensorRT :

from torch import nn

from ultralytics import YOLO

# Load the classification model
model = YOLO("yolo26n-cls.pt")

# Add average pooling layer
head = model.model.model[-1]
pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(start_dim=1))
pool.f, pool.i = head.f, head.i
model.model.model[-1] = pool

# Export to TensorRT
model.export(format="engine", half=True, dynamic=True, batch=32)

Une fois exporté, tu peux pointer vers le chemin du modèle TensorRT dans ta configuration de tracker, et il sera utilisé pour la ReID pendant le suivi.

Exemples Python

Boucle de persistance des suivis

Voici un script Python utilisant OpenCV (cv2) et YOLO26 pour exécuter le suivi d'objets sur des trames vidéo. Ce script suppose que les packages nécessaires (opencv-python et ultralytics) sont déjà installés. L'argument persist=True indique au tracker que l'image ou la trame actuelle est la suivante dans une séquence et qu'il doit s'attendre à des suivis de l'image précédente dans l'image actuelle.

import cv2

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

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

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

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

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

        # Display the annotated frame
        cv2.imshow("YOLO26 Tracking", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Note le passage de model(frame) à model.track(frame), qui active le suivi d'objets au lieu d'une simple détection. Ce script modifié exécutera le tracker sur chaque trame 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'.

Tracé des suivis au fil du temps

La visualisation des suivis d'objets sur des trames consécutives peut fournir des informations précieuses sur les modèles de mouvement et le comportement des objets détectés dans une vidéo. Avec Ultralytics YOLO26, le tracé de ces suivis est un processus fluide et efficace.

Dans l'exemple suivant, nous montrons comment utiliser les capacités de suivi de YOLO26 pour tracer le mouvement des objets détectés à travers plusieurs trames vidéo. Ce script implique l'ouverture d'un fichier vidéo, sa lecture trame par trame, et l'utilisation du modèle YOLO pour identifier et suivre divers objets. En conservant les points centraux des boîtes englobantes détectées et en les reliant, nous pouvons dessiner 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 YOLO26 model
model = YOLO("yolo26n.pt")

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

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

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

    if success:
        # Run YOLO26 tracking on the frame, persisting tracks between frames
        result = model.track(frame, persist=True)[0]

        # Get the boxes and track IDs
        if result.boxes and result.boxes.is_track:
            boxes = result.boxes.xywh.cpu()
            track_ids = result.boxes.id.int().cpu().tolist()

            # Visualize the result on the frame
            frame = result.plot()

            # Plot the tracks
            for box, track_id in zip(boxes, track_ids):
                x, y, w, h = box
                track = track_history[track_id]
                track.append((float(x), float(y)))  # x, y center point
                if len(track) > 30:  # retain 30 tracks for 30 frames
                    track.pop(0)

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

        # Display the annotated frame
        cv2.imshow("YOLO26 Tracking", frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

Suivi multithread

Le suivi multithread offre la capacité d'exécuter le suivi d'objets sur plusieurs flux vidéo simultanément. C'est particulièrement utile lors de la gestion 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 module threading de Python pour exécuter 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 s'assurer que chaque thread reçoit 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 de suivi principale. Cette fonction lit la vidéo trame par trame, exécute le tracker et affiche les résultats.

Deux modèles différents sont utilisés dans cet exemple : yolo26n.pt et yolo26n-seg.pt, chacun suivant des objets dans un fichier vidéo différent. Les fichiers vidéo sont spécifiés dans SOURCES.

Le paramètre daemon=True 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 utilisons join() pour faire en sorte 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 en utilisant cv2.destroyAllWindows().

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # local video, 0 for webcam

def run_tracker_in_thread(model_name, filename):
    """Run YOLO tracker in its own thread for concurrent processing.

    Args:
        model_name (str): The YOLO26 model object.
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
    """
    model = YOLO(model_name)
    results = model.track(filename, save=True, stream=True)
    for r in results:
        pass

# Create and start tracker threads using a for loop
tracker_threads = []
for video_file, model_name in zip(SOURCES, MODEL_NAMES):
    thread = threading.Thread(target=run_tracker_in_thread, args=(model_name, video_file), daemon=True)
    tracker_threads.append(thread)
    thread.start()

# Wait for all tracker threads to finish
for thread in tracker_threads:
    thread.join()

# Clean up and close windows
cv2.destroyAllWindows()

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

Contribuer à de nouveaux trackers

Es-tu compétent en suivi multi-objets et as-tu déjà implémenté ou adapté un algorithme de suivi avec Ultralytics YOLO ? Nous t'invitons à contribuer à notre section Trackers dans ultralytics/cfg/trackers ! Tes applications et solutions concrètes pourraient être précieuses pour les utilisateurs travaillant sur des tâches de suivi.

En contribuant à cette section, tu aides à élargir le champ des solutions de suivi disponibles au sein du framework Ultralytics YOLO, ajoutant une couche supplémentaire de fonctionnalité et d'utilité pour la communauté.

Pour initier ta contribution, merci de consulter notre Guide de contribution pour des instructions complètes sur la soumission d'une Pull Request (PR) 🛠️. Nous sommes impatients de voir ce que tu vas proposer !

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

FAQ

Qu'est-ce que le suivi multi-objets et comment Ultralytics YOLO le prend-il en charge ?

Le suivi multi-objets dans l'analyse vidéo implique à la fois l'identification des objets et le maintien d'un ID unique pour chaque objet détecté à travers les images vidéo. Ultralytics YOLO prend cela en charge en fournissant un suivi en temps réel ainsi que des IDs d'objets, facilitant des tâches telles que la surveillance de sécurité et l'analyse sportive. Le système utilise des trackers comme BoT-SORT et ByteTrack, qui peuvent être configurés via des fichiers YAML.

Comment configurer un tracker personnalisé pour Ultralytics YOLO ?

Tu peux configurer un tracker personnalisé en copiant un fichier de configuration de tracker existant (par exemple, custom_tracker.yaml) depuis le répertoire de configuration des trackers Ultralytics et en modifiant les paramètres si nécessaire, à l'exception de tracker_type. Utilise ce fichier dans ton modèle de suivi comme ceci :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")

Comment exécuter le suivi d'objets sur plusieurs flux vidéo simultanément ?

Pour exécuter le suivi d'objets sur plusieurs flux vidéo simultanément, tu peux utiliser le module threading de Python. Chaque thread gérera un flux vidéo séparé. Voici un exemple de la façon dont tu peux configurer cela :

import threading

import cv2

from ultralytics import YOLO

# Define model names and video sources
MODEL_NAMES = ["yolo26n.pt", "yolo26n-seg.pt"]
SOURCES = ["path/to/video.mp4", "0"]  # local video, 0 for webcam

def run_tracker_in_thread(model_name, filename):
    """Run YOLO tracker in its own thread for concurrent processing.

    Args:
        model_name (str): The YOLO26 model object.
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
    """
    model = YOLO(model_name)
    results = model.track(filename, save=True, stream=True)
    for r in results:
        pass

# Create and start tracker threads using a for loop
tracker_threads = []
for video_file, model_name in zip(SOURCES, MODEL_NAMES):
    thread = threading.Thread(target=run_tracker_in_thread, args=(model_name, video_file), daemon=True)
    tracker_threads.append(thread)
    thread.start()

# Wait for all tracker threads to finish
for thread in tracker_threads:
    thread.join()

# Clean up and close windows
cv2.destroyAllWindows()

Quelles sont les applications concrètes du suivi multi-objets avec Ultralytics YOLO ?

Le suivi multi-objets avec Ultralytics YOLO a de nombreuses applications, notamment :

• Transports : Suivi de véhicules pour la gestion du trafic et la conduite autonome.
• Commerce de détail : Suivi des personnes pour l'analyse en magasin et la sécurité.
• Aquaculture : Suivi des poissons pour surveiller les environnements aquatiques.
• Analyse sportive : Suivi des joueurs et de l'équipement pour l'analyse de performance.
• Systèmes de sécurité : Surveillance d'activités suspectes et création d'alarmes de sécurité.

Ces applications bénéficient de la capacité d'Ultralytics YOLO à traiter des vidéos à haute fréquence d'images en temps réel avec une précision exceptionnelle.

Comment visualiser les trajectoires des objets sur plusieurs images vidéo avec Ultralytics YOLO ?

Pour visualiser les trajectoires des objets sur plusieurs images vidéo, tu peux utiliser les fonctionnalités de suivi du modèle YOLO avec OpenCV pour dessiner les chemins des objets détectés. Voici un exemple de script qui démontre cela :

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(lambda: [])

while cap.isOpened():
    success, frame = cap.read()
    if success:
        results = model.track(frame, persist=True)
        boxes = results[0].boxes.xywh.cpu()
        track_ids = results[0].boxes.id.int().cpu().tolist()
        annotated_frame = results[0].plot()
        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()

Ce script tracera les lignes de suivi montrant les trajectoires de mouvement des objets suivis au fil du temps, fournissant des informations précieuses sur le comportement et les modèles des objets.