Multi-Objektverfolgung mit Ultralytics YOLO
Die Objektverfolgung im Bereich der Videoanalyse ist eine wichtige Aufgabe, bei der nicht nur der Ort und die Klasse von Objekten innerhalb des Bildes identifiziert, sondern auch eine eindeutige ID für jedes erkannte Objekt im Verlauf des Videos beibehalten wird. Die Anwendungsmöglichkeiten sind grenzenlos und reichen von der Überwachung und Sicherheit bis hin zur Echtzeit-Sportanalyse.
Warum Ultralytics YOLO für die Objektverfolgung wählen?
Die Ausgabe der Ultralytics Tracker entspricht der standardmäßigen Objekterkennung, hat aber den zusätzlichen Vorteil von Objekt-IDs. Dies erleichtert die Verfolgung von Objekten in Videoströmen und die anschließende Analyse. Hier erfahren Sie, warum Sie Ultralytics YOLO für Ihre Anforderungen an die Objektverfolgung verwenden sollten:
- Effizient: Verarbeiten Sie Videoströme in Echtzeit, ohne die Genauigkeit zu beeinträchtigen.
- Flexibel: Unterstützt mehrere Tracking-Algorithmen und Konfigurationen.
- Benutzerfreundlichkeit: Einfache Python API und CLI Optionen für eine schnelle Integration und Bereitstellung.
- Anpassungsfähigkeit: Einfache Verwendung mit individuell trainierten YOLO Modellen, die die Integration in domänenspezifische Anwendungen ermöglichen.
Beobachten: Objekterkennung und -verfolgung mit Ultralytics YOLO .
Anwendungen in der realen Welt
| Transport | Einzelhandel | Aquakultur |
|---|---|---|
| Fahrzeugverfolgung | Personen-Tracking | Fisch-Ortung |
Merkmale auf einen Blick
Ultralytics YOLO erweitert seine Objekterkennungsfunktionen, um eine robuste und vielseitige Objektverfolgung zu ermöglichen:
- Verfolgung in Echtzeit: Verfolgen Sie nahtlos Objekte in Videos mit hoher Bildrate.
- Unterstützung mehrerer Tracker: Wählen Sie aus einer Vielzahl von etablierten Tracking-Algorithmen.
- Anpassbare Tracker-Konfigurationen: Passen Sie den Tracking-Algorithmus durch die Einstellung verschiedener Parameter an die jeweiligen Anforderungen an.
Verfügbare Tracker
Ultralytics YOLO unterstützt die folgenden Tracking-Algorithmen. Sie können durch Übergabe der entsprechenden YAML-Konfigurationsdatei aktiviert werden, z.B. tracker=tracker_type.yaml:
- BoT-SORT - Verwendung
botsort.yamlum diesen Tracker zu aktivieren. - ByteTrack - Verwendung
bytetrack.yamlum diesen Tracker zu aktivieren.
Der Standard-Tracker ist BoT-SORT.
Nachverfolgung
Informationen zum Tracker-Schwellenwert
Wenn das Objektvertrauen niedrig ist, d. h. niedriger als track_high_threshdann werden keine Titel erfolgreich zurückgegeben und aktualisiert.
Um den Tracker auf Videoströmen laufen zu lassen, verwenden Sie ein trainiertes Detect-, Segment- oder Pose-Modell wie YOLO11n, YOLO11n-seg und YOLO11n-pose.
Beispiel
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"
Wie in der obigen Anwendung zu sehen ist, ist das Tracking für alle Detect-, Segment- und Pose-Modelle verfügbar, die auf Videos oder Streaming-Quellen ausgeführt werden.
Konfiguration
Informationen zum Tracker-Schwellenwert
Wenn das Objektvertrauen niedrig ist, d. h. niedriger als track_high_threshdann werden keine Titel erfolgreich zurückgegeben und aktualisiert.
Verfolgung von Argumenten
Die Nachverfolgungskonfiguration hat die gleichen Eigenschaften wie der Vorhersagemodus, z. B. conf, iouund show. Weitere Konfigurationen finden Sie in der Vorhersage Modellseite.
Beispiel
Tracker-Auswahl
Ultralytics ermöglicht es Ihnen auch, eine geänderte Tracker-Konfigurationsdatei zu verwenden. Dazu erstellen Sie einfach eine Kopie einer Tracker-Konfigurationsdatei (z. B., custom_tracker.yaml) von ultralytics/cfg/tracker und ändern Sie alle Konfigurationen (außer die tracker_type) nach Ihren Bedürfnissen.
Beispiel
Eine umfassende Liste der Tracking-Argumente finden Sie auf der Seite ultralytics/cfg/trackers.
Python Beispiele
Fortlaufende Spuren Schleife
Hier ist ein Python Skript mit OpenCV (cv2) und YOLO11 , um die Objektverfolgung auf Videobildern durchzuführen. Dieses Skript geht immer noch davon aus, dass Sie die notwendigen Pakete bereits installiert haben (opencv-python und ultralytics). Die Website persist=True sagt dem Tracker, dass das aktuelle Bild oder der aktuelle Frame der nächste in einer Sequenz ist und dass er Spuren vom vorherigen Bild im aktuellen Bild erwarten soll.
Streaming for-loop mit Verfolgung
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()
Bitte beachten Sie die Änderung von model(frame) zu model.track(frame)das die Objektverfolgung anstelle der einfachen Erkennung ermöglicht. Dieses geänderte Skript führt den Tracker für jedes Bild des Videos aus, visualisiert die Ergebnisse und zeigt sie in einem Fenster an. Die Schleife kann durch Drücken von "q" beendet werden.
Spuren über die Zeit aufzeichnen
Die Visualisierung von Objektspuren über aufeinanderfolgende Frames kann wertvolle Einblicke in die Bewegungsmuster und das Verhalten von erkannten Objekten in einem Video liefern. Mit Ultralytics YOLO11 ist das Plotten dieser Spuren ein nahtloser und effizienter Prozess.
Im folgenden Beispiel wird demonstriert, wie die Verfolgungsfunktionen von YOLO11 genutzt werden können, um die Bewegung von erkannten Objekten über mehrere Videobilder hinweg aufzuzeichnen. In diesem Skript wird eine Videodatei geöffnet, Bild für Bild gelesen und das Modell YOLO verwendet, um verschiedene Objekte zu identifizieren und zu verfolgen. Indem wir die Mittelpunkte der erkannten Bounding Boxes beibehalten und sie miteinander verbinden, können wir Linien zeichnen, die die Pfade darstellen, denen die verfolgten Objekte folgen.
Zeichnen von Spuren über mehrere Videobilder
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()
Multithreading-Verfolgung
Die Multithreading-Verfolgung bietet die Möglichkeit, die Objektverfolgung für mehrere Videoströme gleichzeitig durchzuführen. Dies ist besonders nützlich bei der Verarbeitung mehrerer Videoeingänge, z. B. von mehreren Überwachungskameras, bei denen die gleichzeitige Verarbeitung die Effizienz und Leistung erheblich steigern kann.
In dem mitgelieferten Python Skript verwenden wir Python's threading Modul, um mehrere Instanzen des Trackers gleichzeitig auszuführen. Jeder Thread ist für die Ausführung des Trackers für eine Videodatei verantwortlich, und alle Threads werden gleichzeitig im Hintergrund ausgeführt.
Um sicherzustellen, dass jeder Thread die richtigen Parameter erhält (die Videodatei, das zu verwendende Modell und den Dateiindex), definieren wir eine Funktion run_tracker_in_thread die diese Parameter annimmt und die Hauptverfolgungsschleife enthält. Diese Funktion liest das Video Bild für Bild, führt den Tracker aus und zeigt die Ergebnisse an.
In diesem Beispiel werden zwei verschiedene Modelle verwendet: yolo11n.pt und yolo11n-seg.pt, die jeweils Objekte in einer anderen Videodatei verfolgen. Die Videodateien werden in video_file1 und video_file2.
Die daemon=True Parameter in threading.Thread bedeutet, dass diese Threads geschlossen werden, sobald das Hauptprogramm beendet ist. Wir starten dann die Threads mit start() und verwenden join() um den Hauptthread warten zu lassen, bis beide Tracker-Threads beendet sind.
Nachdem alle Threads ihre Aufgabe erfüllt haben, werden die Fenster, die die Ergebnisse anzeigen, mit cv2.destroyAllWindows().
Streaming for-loop mit Verfolgung
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()
Dieses Beispiel kann leicht erweitert werden, um mehr Videodateien und Modelle zu verarbeiten, indem weitere Threads erstellt und dieselbe Methodik angewendet wird.
Neue Tracker beisteuern
Haben Sie Erfahrung mit der Verfolgung von mehreren Objekten und haben Sie einen Verfolgungsalgorithmus mit Ultralytics YOLO erfolgreich implementiert oder angepasst? Wir laden Sie ein, zu unserem Trackers-Bereich unter ultralytics/cfg/trackers beizutragen! Ihre praktischen Anwendungen und Lösungen könnten für Benutzer, die an Tracking-Aufgaben arbeiten, von unschätzbarem Wert sein.
Indem Sie zu diesem Bereich beitragen, tragen Sie dazu bei, den Umfang der im Rahmen von Ultralytics YOLO verfügbaren Tracking-Lösungen zu erweitern und der Community eine weitere Funktionsebene und Nützlichkeit zu bieten.
Um Ihren Beitrag zu initiieren, lesen Sie bitte unseren Contributing Guide mit umfassenden Anweisungen zum Einreichen eines Pull Request (PR) 🛠️. Wir sind gespannt, was Sie beitragen werden!
Lassen Sie uns gemeinsam die Verfolgungsmöglichkeiten des Ultralytics YOLO Ökosystems verbessern 🙏!
FAQ
Was ist Multi-Object-Tracking und wie wird es von Ultralytics YOLO unterstützt?
Die Verfolgung mehrerer Objekte in der Videoanalyse erfordert sowohl die Identifizierung von Objekten als auch die Beibehaltung einer eindeutigen ID für jedes erkannte Objekt über alle Videobilder hinweg. Ultralytics YOLO unterstützt dies, indem es die Verfolgung in Echtzeit zusammen mit den Objekt-IDs bereitstellt und so Aufgaben wie Sicherheitsüberwachung und Sportanalyse erleichtert. Das System verwendet Tracker wie BoT-SORT und ByteTrack, die über YAML-Dateien konfiguriert werden können.
Wie konfiguriere ich einen benutzerdefinierten Tracker für Ultralytics YOLO ?
Sie können einen benutzerdefinierten Tracker konfigurieren, indem Sie eine bestehende Tracker-Konfigurationsdatei kopieren (z.B., custom_tracker.yaml) aus dem Ultralytics Tracker-Konfigurationsverzeichnis und ändern die Parameter je nach Bedarf, mit Ausnahme der tracker_type. Verwenden Sie diese Datei in Ihrem Tracking-Modell wie folgt:
Beispiel
Wie kann ich die Objektverfolgung mit mehreren Videoströmen gleichzeitig durchführen?
Um die Objektverfolgung für mehrere Videoströme gleichzeitig auszuführen, können Sie die Funktion Python verwenden. threading Modul. Jeder Thread wird einen separaten Videostrom verarbeiten. Hier ist ein Beispiel, wie Sie dies einrichten können:
Multithreading-Verfolgung
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()
Welche realen Anwendungen gibt es für die Verfolgung mehrerer Objekte mit Ultralytics YOLO ?
Die Verfolgung von mehreren Objekten mit Ultralytics YOLO hat zahlreiche Anwendungsmöglichkeiten, darunter:
- Verkehrswesen: Fahrzeugverfolgung für Verkehrsmanagement und autonomes Fahren.
- Einzelhandel: Personenverfolgung für Analysen und Sicherheit im Geschäft.
- Aquakultur: Fischverfolgung zur Überwachung der aquatischen Umwelt.
Diese Anwendungen profitieren von der Fähigkeit von Ultralytics YOLO , Videos mit hoher Bildrate in Echtzeit zu verarbeiten.
Wie kann ich Objektspuren über mehrere Videobilder mit Ultralytics YOLO visualisieren?
Um Objektspuren über mehrere Videobilder hinweg zu visualisieren, können Sie die Tracking-Funktionen des Modells YOLO zusammen mit OpenCV verwenden, um die Pfade der erkannten Objekte zu zeichnen. Hier ist ein Beispielskript, das dies demonstriert:
Zeichnen von Spuren über mehrere Videobilder
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()
Dieses Skript stellt die Verfolgungslinien dar, die die Bewegungspfade der verfolgten Objekte im Laufe der Zeit zeigen.
