Suivi multi-objets avec Ultralytics YOLO
Le suivi d'objets dans le domaine de l'analyse vidéo est une tâche essentielle qui non seulement identifie l'emplacement et la classe des objets dans le cadre, mais conserve également un ID unique pour chaque objet détecté au fur et à mesure que la vidéo progresse. 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 ?
La sortie des trackers Ultralytics est cohérente avec la détection d'objets standard, mais a la valeur ajoutée des ID d'objets. Cela facilite le suivi des objets dans les flux vidéo et l'exécution d'analyses ultérieures. Voici pourquoi vous devriez envisager d'utiliser Ultralytics YOLO pour vos besoins de suivi d'objets :
- Efficacité : Traitez 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 simple et options CLI pour une intégration et un déploiement rapides.
- Personnalisation : Facile à utiliser avec des modèles YOLO entraînés personnalisés, permettant l'intégration dans des applications spécifiques au domaine.
Regarder : Détection et suivi d'objets avec Ultralytics YOLO.
Applications concrètes
Transport | Vente au détail | Aquaculture |
---|---|---|
Suivi de véhicules | Suivi de personnes | Suivi de poissons |
Fonctionnalités en un coup d'œil
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 : Suivez les objets en toute transparence dans les vidéos à fréquence d’images élevée.
- Prise en charge de plusieurs trackers : Choisissez parmi une variété d’algorithmes de suivi établis.
- Configurations de tracker personnalisables : Adaptez 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 approprié, tel que tracker=tracker_type.yaml
:
- BoT-SORT - Utilisez
botsort.yaml
pour activer ce tracker. - ByteTrack - Utilisez
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, utilisez un modèle Detect, Segment ou Pose entraîné tel que YOLO11n, YOLO11n-seg et YOLO11n-pose.
Exemple
from ultralytics import YOLO
# Load an official or custom model
model = YOLO("yolo11n.pt") # Load an official Detect model
model = YOLO("yolo11n-seg.pt") # Load an official Segment model
model = YOLO("yolo11n-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
# Perform tracking with various models using the command line interface
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" # Official Detect model
yolo track model=yolo11n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Official Segment model
yolo track model=yolo11n-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 diffusion.
Configuration
Arguments de suivi
La configuration du suivi partage des propriétés avec le mode Predict, telles que conf
, iou
, et show
. Pour plus de configurations, consultez la page du Prédire modèle.
Exemple
from ultralytics import YOLO
# Configure the tracking parameters and run the tracker
model = YOLO("yolo11n.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=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
Sélection du tracker
Ultralytics vous permet également d’utiliser un fichier de configuration de tracker modifié. Pour ce faire, il suffit de faire une copie d’un fichier de configuration de tracker (par exemple, custom_tracker.yaml
) à partir de ultralytics/cfg/trackers et de modifier toutes les configurations (à l’exception de tracker_type
) selon vos besoins.
Exemple
from ultralytics import YOLO
# Load the model and run the tracker with a custom configuration file
model = YOLO("yolo11n.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=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
Consultez 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 :
Le tableau suivant fournit une description de chaque paramètre :
Informations sur le seuil du tracker
Si le score de confiance de l’objet est faible, c’est-à-dire inférieur à track_high_thresh
, aucune piste ne sera renvoyée et mise à jour.
Paramètre | Valeurs ou plages valides | Description |
---|---|---|
tracker_type |
botsort , bytetrack |
Spécifie le type de tracker. Les options sont botsort ou bytetrack . |
track_high_thresh |
0.0-1.0 |
Seuil pour la première association lors du suivi utilisé. Affecte la confiance avec laquelle une détection est mise en correspondance avec une piste existante. |
track_low_thresh |
0.0-1.0 |
Seuil pour la deuxième association lors du suivi. Utilisé lorsque la première association échoue, avec des critères plus permissifs. |
new_track_thresh |
0.0-1.0 |
Seuil pour initialiser une nouvelle piste si la détection ne correspond à aucune piste existante. Contrôle le moment où un nouvel objet est considéré comme apparaissant. |
track_buffer |
>=0 |
Tampon utilisé pour indiquer le nombre d'images pendant lesquelles les pistes perdues doivent être maintenues en vie avant d'être supprimées. Une valeur plus élevée signifie une plus grande tolérance à l'occlusion. |
match_thresh |
0.0-1.0 |
Seuil de correspondance des pistes. Des valeurs plus élevées rendent la correspondance plus permissive. |
fuse_score |
True , False |
Détermine s'il faut fusionner les scores de confiance avec les distances IoU avant la mise en correspondance. Aide à équilibrer les informations spatiales et de confiance lors de l'association. |
gmc_method |
orb , sift , ecc , sparseOptFlow , None |
Méthode utilisée pour la compensation globale de mouvement. Aide à tenir compte du mouvement de la caméra pour améliorer le suivi. |
proximity_thresh |
0.0-1.0 |
IoU minimum requis pour une correspondance valide avec ReID (ré-identification). Assure une proximité spatiale avant d'utiliser les indices d'apparence. |
appearance_thresh |
0.0-1.0 |
Similarité d'apparence minimale requise pour ReID. Définit le degré de similarité visuelle que deux détections doivent avoir pour être liées. |
with_reid |
True , False |
Indique s'il faut utiliser ReID. Active la correspondance basée sur l'apparence pour un meilleur suivi à travers les occlusions. Uniquement pris en charge par BoTSORT. |
model |
auto , yolo11[nsmlx]-cls.pt |
Spécifie le modèle à utiliser. La valeur par défaut est auto , qui utilise les fonctionnalités natives si le détecteur est YOLO, sinon utilise yolo11n-cls.pt . |
Activation de la réidentification (ReID)
Par défaut, ReID est désactivé pour minimiser la surcharge de performance. L'activer est simple—il suffit de définir with_reid: True
dans le configuration du tracker. Vous pouvez également personnaliser le model
utilisé pour ReID, ce qui vous permet de faire des compromis entre la précision et la vitesse en fonction de votre cas d’utilisation :
- Fonctionnalités natives (
model: auto
): Ceci exploite les caractéristiques directement du détecteur YOLO pour la ReID, ajoutant une surcharge minimale. C'est idéal lorsque vous avez besoin d'un certain niveau de ReID sans impacter significativement les performances. Si le détecteur ne prend pas en charge les caractéristiques natives, il revient automatiquement à l'utilisation deyolo11n-cls.pt
. - Modèles de classification YOLO: Vous pouvez définir explicitement un modèle de classification (par exemple,
yolo11n-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, en particulier lors de l'utilisation d'un modèle de classification distinct pour ReID, vous pouvez l'exporter vers un backend plus rapide comme TensorRT:
Exporter un modèle ReID vers TensorRT
from torch import nn
from ultralytics import YOLO
# Load the classification model
model = YOLO("yolo11n-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é, vous pouvez pointer vers le chemin du modèle TensorRT dans votre configuration de suivi, et il sera utilisé pour le ReID pendant le suivi.
Exemples Python
Boucle de persistance des suivis
Voici un script Python utilisant module DNN d'OpenCV (cv2
) et YOLO11 pour exécuter le suivi d’objets sur des trames vidéo. Ce script suppose toujours que vous avez déjà installé les packages nécessaires (opencv-python
et ultralytics
). Le 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 pistes de l'image précédente dans l'image actuelle.
Boucle for de streaming avec suivi
import cv2
from ultralytics import YOLO
# Load the YOLO11 model
model = YOLO("yolo11n.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 YOLO11 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("YOLO11 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()
Veuillez noter le changement de model(frame)
à model.track(frame)
, ce qui permet 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'.
Traçage des suivis dans le temps
La visualisation des pistes 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 YOLO11, le traçage de ces pistes est un processus simple et efficace.
Dans l'exemple suivant, nous montrons comment utiliser les capacités de suivi de YOLO11 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 connectant, nous pouvons dessiner des lignes qui représentent les chemins suivis par les objets suivis.
Traçage des pistes sur plusieurs trames vidéo
from collections import defaultdict
import cv2
import numpy as np
from ultralytics import YOLO
# Load the YOLO11 model
model = YOLO("yolo11n.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 YOLO11 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("YOLO11 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 possibilité d'exécuter le suivi d'objets sur plusieurs flux vidéo simultanément. Ceci 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 la performance.
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 paramètres corrects (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 : yolo11n.pt
et yolo11n-seg.pt
, chacun suivant des objets dans un fichier vidéo différent. Les fichiers vidéo sont spécifiés dans le paramètre SOURCES
.
L'argument daemon=True
dans threading.Thread
signifie que ces threads seront fermés dès que le programme principal se termine. Nous démarrons ensuite les threads avec start()
et utilisons 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 cv2.destroyAllWindows()
.
Implémentation du suivi multithread
import threading
import cv2
from ultralytics import YOLO
# Define model names and video sources
MODEL_NAMES = ["yolo11n.pt", "yolo11n-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 YOLO11 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 plus 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
Êtes-vous compétent dans le suivi multi-objets et avez-vous implémenté ou adapté avec succès un algorithme de suivi avec Ultralytics YOLO ? Nous vous invitons à contribuer à notre section Trackers dans ultralytics/cfg/trackers ! Vos applications et solutions du monde réel pourraient être inestimables pour les utilisateurs travaillant sur des tâches de suivi.
En contribuant à cette section, vous aidez à élargir la portée des solutions de suivi disponibles dans le framework Ultralytics YOLO, ajoutant une autre couche de fonctionnalité et d'utilité pour la communauté.
Pour initier votre contribution, veuillez 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 vous apporterez !
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 trames vidéo. Ultralytics YOLO prend en charge cela en fournissant un suivi en temps réel avec des ID d'objet, 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 ?
Vous pouvez configurer un tracker personnalisé en copiant un fichier de configuration de tracker existant (par exemple, custom_tracker.yaml
) à partir du répertoire de configuration du tracker Ultralytics et en modifiant les paramètres selon les besoins, à l'exception du tracker_type
. Utilisez ce fichier dans votre modèle de suivi comme ceci :
Exemple
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml")
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
Comment puis-je 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, vous pouvez utiliser le module threading
de python. Chaque thread gérera un flux vidéo distinct. Voici un exemple de la façon dont vous pouvez configurer cela :
Suivi multithread
import threading
import cv2
from ultralytics import YOLO
# Define model names and video sources
MODEL_NAMES = ["yolo11n.pt", "yolo11n-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 YOLO11 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 :
- Transport : Suivi des véhicules pour la gestion du trafic et la conduite autonome.
- Vente au détail : Suivi des personnes pour l'analyse et la sécurité en magasin.
- Aquaculture : Suivi des poissons pour la surveillance des environnements aquatiques.
- Analyse sportive : Suivi des joueurs et de l’équipement pour l’analyse des performances.
- Systèmes de sécurité : Surveillance des 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 à fréquence d'images élevée en temps réel avec une précision exceptionnelle.
Comment puis-je visualiser les pistes d'objets sur plusieurs trames vidéo avec Ultralytics YOLO ?
Pour visualiser les pistes d'objets sur plusieurs trames vidéo, vous pouvez utiliser les fonctionnalités de suivi du modèle YOLO avec OpenCV pour dessiner les trajectoires des objets détectés. Voici un exemple de script qui illustre cela :
Traçage des pistes sur plusieurs trames vidéo
from collections import defaultdict
import cv2
import numpy as np
from ultralytics import YOLO
model = YOLO("yolo11n.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("YOLO11 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 des objets suivis au fil du temps, fournissant des informations précieuses sur le comportement et les modèles des objets.