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 ?
The output from Ultralytics trackers is consistent with standard object detection but has the added value of object IDs. This makes it easy to track objects in video streams and perform subsequent analytics. Here's why you should consider using Ultralytics YOLO for your object tracking needs:
- Efficiency: Process video streams in real-time without compromising accuracy.
- 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 : Object Detection and Tracking with Ultralytics YOLO.
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.yamlpour activer ce tracker. - ByteTrack - Utilise
bytetrack.yamlpour activer ce tracker.
Le tracker par défaut est BoT-SORT.
Suivi
Informations sur le seuil de suivi
Si le score de confiance de l'objet est faible, c'est-à-dire inférieur à track_high_threshalors aucune piste ne sera renvoyée et mise à jour avec succès.
To run the tracker on video streams, use a trained Detect, Segment or Pose model such as YOLO11n, YOLO11n-seg and 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 streaming.
Configuration
Informations sur le seuil de suivi
Si le score de confiance de l'objet est faible, c'est-à-dire inférieur à track_high_threshalors aucune piste ne sera renvoyée et mise à jour avec succès.
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.
Exemple
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.
Exemple
Pour obtenir une liste complète des arguments de suivi, reporte-toi à la page ultralytics/cfg/trackers.
Python Exemples
Boucle de pistes persistantes
Here is a Python script using OpenCV (cv2) and YOLO11 to run object tracking on video frames. This script still assumes you have already installed the necessary packages (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.
Boucle en flux continu 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()
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
Visualizing object tracks over consecutive frames can provide valuable insights into the movement patterns and behavior of detected objects within a video. With Ultralytics YOLO11, plotting these tracks is a seamless and efficient process.
In the following example, we demonstrate how to utilize YOLO11's tracking capabilities to plot the movement of detected objects across multiple video frames. This script involves opening a video file, reading it frame by frame, and utilizing the YOLO model to identify and track various objects. By retaining the center points of the detected bounding boxes and connecting them, we can draw lines that represent the paths followed by the tracked objects.
Tracer des pistes sur plusieurs images 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
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("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()
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 : yolo11n.pt et yolo11n-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().
Boucle en flux continu avec suivi
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 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 🙏 !
FAQ
Qu'est-ce que le suivi d'objets multiples et comment Ultralytics YOLO le prend-il en charge ?
Le suivi d'objets multiples dans l'analyse vidéo implique à la fois l'identification des objets et le maintien d'un identifiant unique pour chaque objet détecté sur l'ensemble des images vidéo. Ultralytics YOLO prend en charge ce suivi en temps réel avec les identifiants des objets, facilitant ainsi des tâches telles que la surveillance de la sécurité et l'analyse des sports. Le système utilise des trackers tels que 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 ex, custom_tracker.yaml) de la Ultralytics répertoire de configuration du tracker et en modifiant les paramètres si nécessaire, à l'exception de l'option tracker_type. Utilise ce fichier dans ton modèle de suivi comme suit :
Exemple
Comment puis-je effectuer un suivi d'objet sur plusieurs flux vidéo simultanément ?
Pour effectuer un suivi d'objet sur plusieurs flux vidéo simultanément, tu peux utiliser Python's threading module. Chaque thread gérera un flux vidéo distinct. Voici un exemple de la façon dont tu peux mettre cela en place :
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 réelles du suivi d'objets multiples avec Ultralytics YOLO ?
Le suivi de plusieurs objets à l'aide de Ultralytics YOLO a de nombreuses applications, notamment :
- Transport : Suivi des véhicules pour la gestion du trafic et la conduite autonome.
- Commerce de détail : Suivi des personnes pour l'analyse et la sécurité en magasin.
- Aquaculture : Le suivi des poissons pour la surveillance des milieux aquatiques.
Ces applications bénéficient de la capacité de Ultralytics YOLO à traiter des vidéos à haute fréquence d'images en temps réel.
Comment puis-je visualiser des pistes d'objets sur plusieurs images vidéo avec Ultralytics YOLO ?
Pour visualiser les trajectoires d'objets sur plusieurs images vidéo, tu peux utiliser les fonctions de suivi du modèle YOLO avec OpenCV pour dessiner les trajectoires des objets détectés. Voici un exemple de script qui en fait la démonstration :
Tracer des pistes sur plusieurs images 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 de déplacement des objets suivis au fil du temps.
