मल्टी-ऑब्जेक्ट ट्रैकिंग के साथ Ultralytics YOLO

वीडियो एनालिटिक्स के दायरे में ऑब्जेक्ट ट्रैकिंग एक महत्वपूर्ण कार्य है जो न केवल फ्रेम के भीतर वस्तुओं के स्थान और वर्ग की पहचान करता है, बल्कि वीडियो की प्रगति के रूप में प्रत्येक ज्ञात वस्तु के लिए एक अद्वितीय आईडी भी रखता है। एप्लिकेशन असीमित हैं - निगरानी और सुरक्षा से लेकर रीयल-टाइम स्पोर्ट्स एनालिटिक्स तक।

क्यों चुनें Ultralytics YOLO ऑब्जेक्ट ट्रैकिंग के लिए?

से आउटपुट Ultralytics ट्रैकर्स मानक ऑब्जेक्ट डिटेक्शन के अनुरूप हैं लेकिन ऑब्जेक्ट आईडी का अतिरिक्त मूल्य है। इससे वीडियो स्ट्रीम में ऑब्जेक्ट को ट्रैक करना और बाद में विश्लेषण करना आसान हो जाता है। यहां बताया गया है कि आपको उपयोग करने पर विचार क्यों करना चाहिए Ultralytics YOLO आपकी ऑब्जेक्ट ट्रैकिंग आवश्यकताओं के लिए:

• दक्षता: सटीकता से समझौता किए बिना वास्तविक समय में वीडियो स्ट्रीम संसाधित करें।
• लचीलापन: कई ट्रैकिंग एल्गोरिदम और कॉन्फ़िगरेशन का समर्थन करता है।
• उपयोग में आसानी: सरल Python API और CLI त्वरित एकीकरण और परिनियोजन के लिए विकल्प।
• अनुकूलनशीलता: कस्टम प्रशिक्षित के साथ प्रयोग करने में आसान YOLO मॉडल, डोमेन-विशिष्ट अनुप्रयोगों में एकीकरण की अनुमति देता है।

सतर्कता: ऑब्जेक्ट डिटेक्शन और ट्रैकिंग के साथ Ultralytics YOLOv8.

वास्तविक दुनिया के अनुप्रयोग

परिवहन	फुटकर	एक्वाकल्चर
वाहन ट्रैकिंग	लोग ट्रैकिंग	मछली ट्रैकिंग

सुविधाएँ एक नज़र में

Ultralytics YOLO मजबूत और बहुमुखी ऑब्जेक्ट ट्रैकिंग प्रदान करने के लिए अपनी ऑब्जेक्ट डिटेक्शन सुविधाओं का विस्तार करता है:

• रीयल-टाइम ट्रैकिंग: उच्च-फ़्रेम-दर वाले वीडियो में वस्तुओं को निर्बाध रूप से ट्रैक करें।
• एकाधिक ट्रैकर समर्थन: विभिन्न प्रकार के स्थापित ट्रैकिंग एल्गोरिदम में से चुनें।
• अनुकूलन ट्रैकर कॉन्फ़िगरेशन: विभिन्न मापदंडों को समायोजित करके विशिष्ट आवश्यकताओं को पूरा करने के लिए ट्रैकिंग एल्गोरिथ्म को दर्जी करें।

उपलब्ध ट्रैकर्स

Ultralytics YOLO निम्नलिखित ट्रैकिंग एल्गोरिदम का समर्थन करता है। उन्हें प्रासंगिक YAML कॉन्फ़िगरेशन फ़ाइल पास करके सक्षम किया जा सकता है जैसे कि tracker=tracker_type.yaml:

• बीओटी-सॉर्ट -प्रयोग botsort.yaml इस ट्रैकर को सक्षम करने के लिए।
• बाइटट्रैक -प्रयोग bytetrack.yaml इस ट्रैकर को सक्षम करने के लिए।

डिफ़ॉल्ट ट्रैकर BoT-SORT है।

नज़र रखना

ट्रैकर को वीडियो स्ट्रीम पर चलाने के लिए, प्रशिक्षित डिटेक्ट, सेगमेंट या पोज़ मॉडल का उपयोग करें जैसे कि YOLOv8n, YOLOv8n-seg और YOLOv8n-भंगिमा।

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(source="https://youtu.be/LNwODJXcvt4", show=True)  # Tracking with default tracker
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")  # Tracking with ByteTrack tracker

# 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"

जैसा कि उपरोक्त उपयोग में देखा जा सकता है, वीडियो या स्ट्रीमिंग स्रोतों पर चलने वाले सभी डिटेक्ट, सेगमेंट और पोज़ मॉडल के लिए ट्रैकिंग उपलब्ध है।

संरूपण

ट्रैकिंग तर्क

ट्रैकिंग कॉन्फ़िगरेशन भविष्यवाणी मोड के साथ गुण साझा करता है, जैसे conf, iouऔर show. आगे के कॉन्फ़िगरेशन के लिए, देखें भविष्‍यवाणी करना मॉडल पेज।

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

ट्रैकर चयन

Ultralytics आपको संशोधित ट्रैकर कॉन्फ़िगरेशन फ़ाइल का उपयोग करने की भी अनुमति देता है। ऐसा करने के लिए, बस एक ट्रैकर कॉन्फ़िगरेशन फ़ाइल की एक प्रति बनाएं (उदाहरण के लिए, custom_tracker.yaml) से ultralytics/सीएफजी/ट्रैकर्स और किसी भी कॉन्फ़िगरेशन को संशोधित करें (सिवाय tracker_type) अपनी आवश्यकताओं के अनुसार।

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'

ट्रैकिंग तर्कों की एक व्यापक सूची के लिए, ultralytics/cfg/trackers पृष्ठ।

Python उदाहरण

लगातार ट्रैक लूप

यहाँ एक है Python ओपनसीवी का उपयोग करने वाली स्क्रिप्ट (cv2) और YOLOv8 वीडियो फ्रेम पर ऑब्जेक्ट ट्रैकिंग चलाने के लिए। यह स्क्रिप्ट अभी भी मानती है कि आपने पहले ही आवश्यक पैकेज स्थापित कर लिए हैं (opencv-python और ultralytics). वही persist=True तर्क ट्रैकर को बताता है कि वर्तमान छवि या फ्रेम एक अनुक्रम में अगला है और वर्तमान छवि में पिछली छवि से पटरियों की अपेक्षा करता है।

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()

कृपया से परिवर्तन पर ध्यान दें model(frame) तक model.track(frame), जो सरल पहचान के बजाय ऑब्जेक्ट ट्रैकिंग को सक्षम बनाता है। यह संशोधित स्क्रिप्ट वीडियो के प्रत्येक फ्रेम पर ट्रैकर चलाएगी, परिणामों की कल्पना करेगी और उन्हें एक विंडो में प्रदर्शित करेगी। लूप को 'q' दबाकर बाहर निकाला जा सकता है।

समय के साथ पटरियों की साजिश रचना

लगातार फ्रेम पर ऑब्जेक्ट ट्रैक विज़ुअलाइज़ करना एक वीडियो के भीतर पता लगाए गए ऑब्जेक्ट्स के आंदोलन पैटर्न और व्यवहार में मूल्यवान अंतर्दृष्टि प्रदान कर सकता है। के साथ Ultralytics YOLOv8, इन पटरियों की साजिश रचना एक सहज और कुशल प्रक्रिया है।

निम्नलिखित उदाहरण में, हम प्रदर्शित करते हैं कि कैसे उपयोग करना है YOLOv8कई वीडियो फ्रेम में पता चला वस्तुओं की गति को प्लॉट करने के लिए ट्रैकिंग क्षमताएं। इस स्क्रिप्ट में एक वीडियो फ़ाइल खोलना, इसे फ्रेम दर फ्रेम पढ़ना और YOLO विभिन्न वस्तुओं को पहचानने और ट्रैक करने के लिए मॉडल। पता लगाए गए बाउंडिंग बॉक्स के केंद्र बिंदुओं को बनाए रखने और उन्हें जोड़ने से, हम उन रेखाओं को आकर्षित कर सकते हैं जो ट्रैक किए गए ऑब्जेक्ट्स द्वारा पीछा किए गए पथों का प्रतिनिधित्व करती हैं।

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()

मल्टीथ्रेडेड ट्रैकिंग

मल्टीथ्रेडेड ट्रैकिंग एक साथ कई वीडियो स्ट्रीम पर ऑब्जेक्ट ट्रैकिंग चलाने की क्षमता प्रदान करती है। यह विशेष रूप से उपयोगी है जब कई वीडियो इनपुट को संभालते हैं, जैसे कि कई निगरानी कैमरों से, जहां समवर्ती प्रसंस्करण दक्षता और प्रदर्शन को काफी बढ़ा सकता है।

प्रदान की गई में Python स्क्रिप्ट, हम का उपयोग करते हैं Pythonके एस threading ट्रैकर के कई उदाहरणों को समवर्ती रूप से चलाने के लिए मॉड्यूल। प्रत्येक थ्रेड एक वीडियो फ़ाइल पर ट्रैकर चलाने के लिए ज़िम्मेदार है, और सभी थ्रेड पृष्ठभूमि में एक साथ चलते हैं।

यह सुनिश्चित करने के लिए कि प्रत्येक थ्रेड को सही पैरामीटर (वीडियो फ़ाइल, उपयोग करने के लिए मॉडल और फ़ाइल इंडेक्स) प्राप्त होता है, हम एक फ़ंक्शन को परिभाषित करते हैं run_tracker_in_thread जो इन मापदंडों को स्वीकार करता है और इसमें मुख्य ट्रैकिंग लूप होता है। यह फ़ंक्शन वीडियो फ्रेम दर फ्रेम पढ़ता है, ट्रैकर चलाता है, और परिणाम प्रदर्शित करता है।

इस उदाहरण में दो अलग-अलग मॉडल का उपयोग किया जाता है: yolov8n.pt और yolov8n-seg.pt, प्रत्येक ट्रैकिंग ऑब्जेक्ट्स एक अलग वीडियो फ़ाइल में। वीडियो फ़ाइलें निर्दिष्ट हैं video_file1 और video_file2.

वही daemon=True पैरामीटर में threading.Thread इसका मतलब है कि मुख्य कार्यक्रम समाप्त होते ही इन धागे को बंद कर दिया जाएगा। फिर हम थ्रेड्स को शुरू करते हैं start() और उपयोग करें join() मुख्य धागा बनाने के लिए दोनों ट्रैकर धागे समाप्त होने तक प्रतीक्षा करें।

अंत में, सभी थ्रेड्स ने अपना कार्य पूरा करने के बाद, परिणाम प्रदर्शित करने वाली विंडो का उपयोग करके बंद कर दिया जाता है cv2.destroyAllWindows().

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()

इस उदाहरण को अधिक थ्रेड बनाकर और उसी पद्धति को लागू करके अधिक वीडियो फ़ाइलों और मॉडलों को संभालने के लिए आसानी से बढ़ाया जा सकता है।

नए ट्रैकर्स का योगदान करें

क्या आप मल्टी-ऑब्जेक्ट ट्रैकिंग में कुशल हैं और ट्रैकिंग एल्गोरिथ्म को सफलतापूर्वक लागू या अनुकूलित किया है Ultralytics YOLO? हम आपको हमारे ट्रैकर्स अनुभाग में योगदान करने के लिए आमंत्रित करते हैं ultralytics/cfg/ट्रैकर्स! ट्रैकिंग कार्यों पर काम करने वाले उपयोगकर्ताओं के लिए आपके वास्तविक दुनिया के एप्लिकेशन और समाधान अमूल्य हो सकते हैं।

इस अनुभाग में योगदान करके, आप के भीतर उपलब्ध ट्रैकिंग समाधानों के दायरे का विस्तार करने में मदद करते हैं Ultralytics YOLO ढांचा, समुदाय के लिए कार्यक्षमता और उपयोगिता की एक और परत जोड़ना।

अपना योगदान आरंभ करने के लिए, कृपया पुल अनुरोध (पीआर) 🛠️ सबमिट करने के व्यापक निर्देशों के लिए हमारी योगदानकर्ता मार्गदर्शिका देखें। हम यह देखने के लिए उत्साहित हैं कि आप मेज पर क्या लाते हैं!

साथ में, आइए ट्रैकिंग क्षमताओं को बढ़ाएं Ultralytics YOLO 🙏 पारिस्थितिकी तंत्र !

टिप्पणियाँ