Overslaan naar inhoud

Volgen van meerdere objecten met Ultralytics YOLO

Voorbeelden van volgen van meerdere objecten

Objecttracering op het gebied van videoanalyse is een kritieke taak die niet alleen de locatie en klasse van objecten binnen het frame identificeert, maar ook een unieke ID bijhoudt voor elk gedetecteerd object terwijl de video vordert. De toepassingen zijn grenzeloos, van surveillance en beveiliging tot real-time sportanalyse.

Waarom Ultralytics YOLO kiezen voor het volgen van objecten?

De uitvoer van Ultralytics trackers komt overeen met standaard objectdetectie, maar heeft de toegevoegde waarde van object ID's. Dit maakt het eenvoudig om objecten in videostromen te volgen en daaropvolgende analyses uit te voeren. Dit is waarom je zou moeten overwegen om Ultralytics YOLO te gebruiken voor het volgen van objecten:

  • EfficiĆ«ntie: Verwerk videostromen in realtime zonder in te leveren op nauwkeurigheid.
  • Flexibiliteit: Ondersteunt meerdere volgalgoritmen en configuraties.
  • Gebruiksgemak: Eenvoudige Python API en CLI opties voor snelle integratie en implementatie.
  • Aanpasbaarheid: Eenvoudig te gebruiken met aangepaste getrainde YOLO modellen, waardoor integratie in domeinspecifieke toepassingen mogelijk is.



Kijken: Objecten detecteren en volgen met Ultralytics YOLOv8 .

Toepassingen in de echte wereld

Vervoer Detailhandel Aquacultuur
Voertuig volgen Mensen volgen Vissen volgen
Voertuig volgen Mensen volgen Vissen volgen

Kenmerken in een oogopslag

Ultralytics YOLO breidt de objectdetectiefuncties uit om robuuste en veelzijdige objecttracering te bieden:

  • Volgen in realtime: Objecten naadloos volgen in video's met hoge framesnelheden.
  • Ondersteuning voor meerdere trackers: Kies uit een groot aantal gevestigde trackingalgoritmen.
  • Aanpasbare trackerconfiguraties: Pas het trackingalgoritme aan om aan specifieke eisen te voldoen door verschillende parameters aan te passen.

Beschikbare Trackers

Ultralytics YOLO ondersteunt de volgende volgalgoritmen. Ze kunnen worden ingeschakeld door het relevante YAML-configuratiebestand door te geven, zoals tracker=tracker_type.yaml:

  • BoT-SORT - Gebruik botsort.yaml om deze tracker in te schakelen.
  • ByteTrack - Gebruik bytetrack.yaml om deze tracker in te schakelen.

De standaard tracker is BoT-SORT.

Volgen

Drempelinformatie voor trackers

Als de vertrouwensscore voor het object laag is, d.w.z. lager dan track_high_threshdan worden er geen sporen succesvol teruggestuurd en bijgewerkt.

Om de tracker op videostromen uit te voeren, gebruik je een getraind Detect, Segment of Pose model zoals YOLOv8n, YOLOv8n-seg en YOLOv8n-pose.

Voorbeeld

from ultralytics import YOLO

# Load an official or custom model
model = YOLO("yolov8n.pt")  # Load an official Detect model
model = YOLO("yolov8n-seg.pt")  # Load an official Segment model
model = YOLO("yolov8n-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=yolov8n.pt source="https://youtu.be/LNwODJXcvt4"  # Official Detect model
yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4"  # Official Segment model
yolo track model=yolov8n-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"

Zoals te zien is in het bovenstaande gebruik, is tracking beschikbaar voor alle Detect, Segment en Pose modellen die worden uitgevoerd op video's of streaming bronnen.

Configuratie

Drempelinformatie voor trackers

Als de vertrouwensscore voor het object laag is, d.w.z. lager dan track_high_threshdan worden er geen sporen succesvol teruggestuurd en bijgewerkt.

Argumenten volgen

Traceerconfiguratie deelt eigenschappen met de modus Voorspellen, zoals conf, iouen show. Raadpleeg voor verdere configuraties de Voorspel modelpagina.

Voorbeeld

from ultralytics import YOLO

# Configure the tracking parameters and run the tracker
model = YOLO("yolov8n.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=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show

Tracker Selectie

Ultralytics staat je ook toe om een aangepast trackerconfiguratiebestand te gebruiken. Om dit te doen, maak je gewoon een kopie van een trackerconfiguratiebestand (bijvoorbeeld, custom_tracker.yaml) van ultralytics/cfg/trackers en wijzig configuraties (behalve de tracker_type) naar behoefte.

Voorbeeld

from ultralytics import YOLO

# Load the model and run the tracker with a custom configuration file
model = YOLO("yolov8n.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=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'

Raadpleeg voor een uitgebreide lijst van tracking argumenten de ultralytics/cfg/trackers pagina.

Python Voorbeelden

Persisterende sporenlus

Hier is een Python script dat OpenCV gebruikt (cv2) en YOLOv8 om het volgen van objecten op videoframes uit te voeren. Dit script gaat er nog steeds van uit dat je de benodigde pakketten al hebt geĆÆnstalleerd (opencv-python en ultralytics). De persist=True Het argument vertelt de tracker dat de huidige afbeelding of het huidige frame de volgende in een reeks is en dat hij sporen van de vorige afbeelding in de huidige afbeelding moet verwachten.

Streaming for-lus met volgen

import cv2

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO("yolov8n.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 YOLOv8 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("YOLOv8 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()

Let op de verandering van model(frame) naar model.track(frame)die het volgen van objecten mogelijk maakt in plaats van eenvoudige detectie. Dit aangepaste script zal de tracker uitvoeren op elk frame van de video, de resultaten visualiseren en weergeven in een venster. De lus kan worden verlaten door op 'q' te drukken.

Sporen uitzetten in de tijd

Het visualiseren van objectsporen over opeenvolgende frames kan waardevolle inzichten geven in de bewegingspatronen en het gedrag van gedetecteerde objecten in een video. Met Ultralytics YOLOv8 is het plotten van deze sporen een naadloos en efficiƫnt proces.

In het volgende voorbeeld laten we zien hoe je YOLOv8 kunt gebruiken om de beweging van gedetecteerde objecten over meerdere videoframes uit te zetten. Dit script bestaat uit het openen van een videobestand, het frame voor frame inlezen en het YOLO model gebruiken om verschillende objecten te identificeren en te volgen. Door de middelpunten van de gedetecteerde bounding boxes vast te houden en ze te verbinden, kunnen we lijnen tekenen die de paden voorstellen die de gevolgde objecten volgen.

Tracks plotten over meerdere videoframes

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO("yolov8n.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 YOLOv8 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("YOLOv8 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()

Multithreaded volgen

Multithreaded tracking biedt de mogelijkheid om objecttracking op meerdere videostromen tegelijk uit te voeren. Dit is vooral handig bij het verwerken van meerdere video-inputs, zoals van meerdere bewakingscamera's, waarbij gelijktijdige verwerking de efficiƫntie en prestaties enorm kan verbeteren.

In het meegeleverde script Python maken we gebruik van Python's threading module om meerdere instanties van de tracker tegelijkertijd uit te voeren. Elke thread is verantwoordelijk voor het uitvoeren van de tracker op Ć©Ć©n videobestand en alle threads draaien gelijktijdig op de achtergrond.

Om ervoor te zorgen dat elke thread de juiste parameters ontvangt (het videobestand, het te gebruiken model en de bestandsindex), definiƫren we een functie run_tracker_in_thread die deze parameters accepteert en de hoofd volglus bevat. Deze functie leest de video frame voor frame, voert de tracker uit en geeft de resultaten weer.

In dit voorbeeld worden twee verschillende modellen gebruikt: yolov8n.pt en yolov8n-seg.ptElk volgt objecten in een ander videobestand. De videobestanden worden gespecificeerd in video_file1 en video_file2.

De daemon=True parameter in threading.Thread betekent dat deze threads worden gesloten zodra het hoofdprogramma eindigt. Vervolgens starten we de threads met start() en gebruik join() om de hoofd thread te laten wachten tot beide tracker threads klaar zijn.

Tenslotte worden, nadat alle threads hun taak hebben voltooid, de vensters met de resultaten gesloten met behulp van cv2.destroyAllWindows().

Streaming for-lus met volgen

import threading

import cv2

from ultralytics import YOLO


def run_tracker_in_thread(filename, model, file_index):
    """
    Runs a video file or webcam stream concurrently with the YOLOv8 model using threading.

    This function captures video frames from a given file or camera source and utilizes the YOLOv8 model for object
    tracking. The function runs in its own thread for concurrent processing.

    Args:
        filename (str): The path to the video file or the identifier for the webcam/external camera source.
        model (obj): The YOLOv8 model object.
        file_index (int): An index to uniquely identify the file being processed, used for display purposes.

    Note:
        Press 'q' to quit the video display window.
    """
    video = cv2.VideoCapture(filename)  # Read the video file

    while True:
        ret, frame = video.read()  # Read the video frames

        # Exit the loop if no more frames in either video
        if not ret:
            break

        # Track objects in frames if available
        results = model.track(frame, persist=True)
        res_plotted = results[0].plot()
        cv2.imshow(f"Tracking_Stream_{file_index}", res_plotted)

        key = cv2.waitKey(1)
        if key == ord("q"):
            break

    # Release video sources
    video.release()


# Load the models
model1 = YOLO("yolov8n.pt")
model2 = YOLO("yolov8n-seg.pt")

# Define the video files for the trackers
video_file1 = "path/to/video1.mp4"  # Path to video file, 0 for webcam
video_file2 = 0  # Path to video file, 0 for webcam, 1 for external camera

# Create the tracker threads
tracker_thread1 = threading.Thread(target=run_tracker_in_thread, args=(video_file1, model1, 1), daemon=True)
tracker_thread2 = threading.Thread(target=run_tracker_in_thread, args=(video_file2, model2, 2), daemon=True)

# Start the tracker threads
tracker_thread1.start()
tracker_thread2.start()

# Wait for the tracker threads to finish
tracker_thread1.join()
tracker_thread2.join()

# Clean up and close windows
cv2.destroyAllWindows()

Dit voorbeeld kan eenvoudig worden uitgebreid om meer videobestanden en modellen te verwerken door meer threads te maken en dezelfde methodologie toe te passen.

Nieuwe trackers bijdragen

Ben je bedreven in het volgen van meerdere objecten en heb je met succes een volgalgoritme geĆÆmplementeerd of aangepast met Ultralytics YOLO ? We nodigen je uit om bij te dragen aan onze Trackers sectie in ultralytics/cfg/trackers! Jouw echte toepassingen en oplossingen kunnen van onschatbare waarde zijn voor gebruikers die met trackingtaken bezig zijn.

Door bij te dragen aan deze sectie, help je het bereik van trackingoplossingen die beschikbaar zijn binnen het Ultralytics YOLO framework uit te breiden, door een extra laag aan functionaliteit en nut toe te voegen voor de gemeenschap.

Om je bijdrage te initiĆ«ren, raadpleeg je onze Bijdragengids voor uitgebreide instructies over het indienen van een Pull Request (PR) šŸ› ļø. We zijn benieuwd naar wat jij aan de tafel brengt!

Laten we samen de trackingmogelijkheden van het Ultralytics YOLO ecosysteem verbeteren šŸ™!

FAQ

Wat is Multi-Object Tracking en hoe ondersteunt Ultralytics YOLO dit?

Het volgen van meerdere objecten in videoanalyse houdt zowel het identificeren van objecten in als het bijhouden van een unieke ID voor elk gedetecteerd object in verschillende videoframes. Ultralytics YOLO ondersteunt dit door real-time volgen te bieden samen met object ID's, wat taken zoals beveiligingstoezicht en sportanalyse vergemakkelijkt. Het systeem gebruikt trackers zoals BoT-SORT en ByteTrack, die via YAML-bestanden kunnen worden geconfigureerd.

Hoe configureer ik een aangepaste tracker voor Ultralytics YOLO ?

Je kunt een aangepaste tracker configureren door een bestaand trackerconfiguratiebestand te kopiƫren (bijv, custom_tracker.yaml) van de Ultralytics configuratiemap tracker en de parameters waar nodig aan te passen, behalve voor de tracker_type. Gebruik dit bestand als volgt in je volgmodel:

Voorbeeld

from ultralytics import YOLO

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

Hoe kan ik objecttracering uitvoeren op meerdere videostromen tegelijk?

Om het volgen van objecten op meerdere videostromen tegelijk uit te voeren, kun je Python gebruiken. threading module. Elke thread behandelt een aparte videostream. Hier is een voorbeeld van hoe je dit kunt instellen:

Multithreaded volgen

import threading

import cv2

from ultralytics import YOLO


def run_tracker_in_thread(filename, model, file_index):
    video = cv2.VideoCapture(filename)
    while True:
        ret, frame = video.read()
        if not ret:
            break
        results = model.track(frame, persist=True)
        res_plotted = results[0].plot()
        cv2.imshow(f"Tracking_Stream_{file_index}", res_plotted)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    video.release()


model1 = YOLO("yolov8n.pt")
model2 = YOLO("yolov8n-seg.pt")
video_file1 = "path/to/video1.mp4"
video_file2 = 0  # Path to a second video file, or 0 for a webcam

tracker_thread1 = threading.Thread(target=run_tracker_in_thread, args=(video_file1, model1, 1), daemon=True)
tracker_thread2 = threading.Thread(target=run_tracker_in_thread, args=(video_file2, model2, 2), daemon=True)

tracker_thread1.start()
tracker_thread2.start()

tracker_thread1.join()
tracker_thread2.join()

cv2.destroyAllWindows()

Wat zijn de echte toepassingen van multi-object tracking met Ultralytics YOLO ?

Het volgen van meerdere objecten met Ultralytics YOLO heeft talloze toepassingen, waaronder:

  • Vervoer: Voertuigvolgsysteem voor verkeersbeheer en autonoom rijden.
  • Detailhandel: Volgen van mensen voor analyse en beveiliging in winkels.
  • Aquacultuur: Vissen volgen voor het monitoren van aquatische milieus.

Deze toepassingen profiteren van het vermogen van Ultralytics YOLO om video's met hoge frames in realtime te verwerken.

Hoe kan ik objectsporen visualiseren over meerdere videoframes met Ultralytics YOLO ?

Om objectsporen over meerdere videoframes te visualiseren, kun je de volgfuncties van het YOLO model samen met OpenCV gebruiken om de paden van gedetecteerde objecten te tekenen. Hier is een voorbeeldscript dat dit demonstreert:

Tracks plotten over meerdere videoframes

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

model = YOLO("yolov8n.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("YOLOv8 Tracking", annotated_frame)
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break
cap.release()
cv2.destroyAllWindows()

Dit script zet de volglijnen uit die de bewegingspaden van de gevolgde objecten in de loop van de tijd laten zien.



Aangemaakt 2023-11-12, Bijgewerkt 2024-07-04
Auteurs: glenn-jocher (16), IvorZhu331 (1), Burhan-Q (1)

Reacties