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 ?
Les résultats des trackers Ultralytics sont cohérents avec la détection d'objets standard, mais ils ont la valeur ajoutée des identifiants d'objets. Cela facilite le suivi des objets dans les flux vidéo et l'analyse qui s'ensuit. Voici pourquoi vous devriez envisager d'utiliser Ultralytics YOLO pour vos besoins en matière de suivi d'objets :
- Efficacité : Traitez les flux vidéo en temps réel sans compromettre la précision.
- Flexibilité : Prise en charge de plusieurs algorithmes et configurations de suivi.
- Facilité d'utilisation : Python API simple et CLI options 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.
Regarder : DĂ©tection et suivi d'objets avec 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 : Suivi transparent d'objets dans des vidéos à haute fréquence d'images.
- Prise en charge de plusieurs algorithmes de suivi : Choisissez parmi une variété d'algorithmes de suivi établis.
- Configurations de suivi personnalisables : Adaptez 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 approprié, tel que tracker=tracker_type.yaml:
- BoT-SORT - Utilisation
botsort.yamlpour activer ce traceur. - ByteTrack - Utilisation
bytetrack.yamlpour activer ce traceur.
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 trace ne sera renvoyée et mise à jour avec succès.
Pour faire fonctionner le tracker sur des flux vidéo, utilisez un modèle entraîné de détection, de segmentation ou de pose 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 le montre 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 trace 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, se référer au Prévoir page modèle.
Exemple
SĂ©lection du traceur
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 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 vos besoins.
Exemple
Pour obtenir une liste complète des arguments de suivi, consultez la page ultralytics/cfg/trackers.
Python Exemples
Boucle de pistes persistantes
Voici un script Python utilisant OpenCV (cv2) et YOLO11 pour effectuer le suivi d'objets sur des images vidéo. Ce script suppose que vous avez déjà installé les paquets nécessaires (opencv-python et ultralytics). Les persist=True indique au tracker que l'image ou la trame en cours est la suivante d'une séquence et qu'il doit s'attendre à des traces de l'image précédente dans l'image en cours.
Boucle for-loop en 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()
Veuillez noter le changement de model(frame) à model.track(frame)qui permet le suivi d'objets au lieu d'une simple détection. Ce script modifié exécutera le tracker 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 trajectoires d'objets sur des images 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 transparent 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 sur plusieurs images vidéo. Ce script implique l'ouverture d'un fichier vidéo, sa lecture image par image et l'utilisation du 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 trajectoires suivies par les objets suivis.
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. Cette fonction est particulièrement utile lorsqu'il s'agit de traiter plusieurs entrées vidéo, provenant par exemple de plusieurs caméras de surveillance, où le traitement simultané peut considérablement améliorer l'efficacité et les performances.
Dans le script Python fourni, nous utilisons le script Python's threading 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 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.ptchaque suivi d'objets dans 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 utiliser join() pour que le thread principal attende que les deux threads du tracker aient terminé.
Enfin, lorsque 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 for-loop en 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 à d'autres fichiers vidéo et modèles en créant davantage de fils de discussion et en appliquant la même méthodologie.
Contribuer Ă de nouveaux traqueurs
Vous maîtrisez le suivi de plusieurs objets et avez 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 ! Vos applications et solutions réelles pourraient être d'une valeur inestimable pour les utilisateurs travaillant sur des tâches de suivi.
En contribuant à cette section, vous contribuez à élargir la portée des solutions de suivi disponibles dans le cadre de Ultralytics YOLO , en ajoutant une nouvelle couche de fonctionnalité et d'utilité pour la communauté.
Pour initier votre contribution, veuillez vous référer à notre Guide de contribution pour des instructions complètes sur la soumission d'une demande d'extraction (PR) 🛠️. Nous sommes impatients de voir ce que vous apporterez à 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 cette tâche en fournissant un suivi en temps réel ainsi que des identifiants d'objets, facilitant ainsi des tâches telles que la surveillance de sécurité et l'analyse sportive. 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 ?
Vous pouvez configurer un tracker personnalisé en copiant un fichier de configuration de tracker existant (par exemple, custom_tracker.yaml) de l Ultralytics répertoire de configuration du tracker et en modifiant les paramètres si nécessaire, à l'exception de l'option tracker_type. Utilisez ce fichier dans votre 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, vous pouvez utiliser la fonction de suivi d'objet de Python. threading module. Chaque thread gérera un flux vidéo distinct. Voici un exemple de configuration :
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 : Suivi des poissons pour la surveillance des environnements 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, vous pouvez 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 trace les lignes de suivi montrant les trajectoires des objets suivis au fil du temps.
