थ्रेड-सुरक्षित अनुमान के साथ YOLO मॉडल

भागना YOLO बहु-थ्रेडेड वातावरण में मॉडल को थ्रेड सुरक्षा सुनिश्चित करने के लिए सावधानीपूर्वक विचार करने की आवश्यकता होती है। Pythonके एस threading मॉड्यूल आपको कई धागे समवर्ती रूप से चलाने की अनुमति देता है, लेकिन जब इसका उपयोग करने की बात आती है YOLO इन धागों में मॉडल, महत्वपूर्ण सुरक्षा मुद्दों के बारे में पता होना चाहिए। यह पृष्ठ थ्रेड-सुरक्षित बनाने में आपका मार्गदर्शन करेगा YOLO मॉडल अनुमान।

समझ Python सूत्रण

Python थ्रेड्स समांतरता का एक रूप है जो आपके प्रोग्राम को एक साथ कई ऑपरेशन चलाने की अनुमति देता है। फिर भी Pythonग्लोबल इंटरप्रेटर लॉक (GIL) का अर्थ है कि केवल एक थ्रेड निष्पादित हो सकता है Python एक बार में बाइटकोड।

हालांकि यह एक सीमा की तरह लगता है, धागे अभी भी समवर्ती प्रदान कर सकते हैं, विशेष रूप से I/O-बाउंड संचालन के लिए या GIL को छोड़ने वाले संचालन का उपयोग करते समय, जैसे कि द्वारा किए गए YOLOअंतर्निहित सी पुस्तकालय।

साझा मॉडल उदाहरणों का खतरा

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

गैर-थ्रेड-सुरक्षित उदाहरण: एकल मॉडल इंस्टेंस

में धागे का उपयोग करते समय Python, उन पैटर्नों को पहचानना महत्वपूर्ण है जो संगामिति मुद्दों को जन्म दे सकते हैं। यहां बताया गया है कि आपको क्या बचना चाहिए: एकल साझा करना YOLO कई थ्रेड्स में मॉडल इंस्टेंस।

# Unsafe: Sharing a single model instance across threads
from ultralytics import YOLO
from threading import Thread

# Instantiate the model outside the thread
shared_model = YOLO("yolov8n.pt")


def predict(image_path):
    """Predicts objects in an image using a preloaded YOLO model, take path string to image as argument."""
    results = shared_model.predict(image_path)
    # Process results


# Starting threads that share the same model instance
Thread(target=predict, args=("image1.jpg",)).start()
Thread(target=predict, args=("image2.jpg",)).start()

ऊपर दिए गए उदाहरण में, shared_model कई थ्रेड्स द्वारा उपयोग किया जाता है, जिससे अप्रत्याशित परिणाम हो सकते हैं क्योंकि predict कई धागे द्वारा एक साथ निष्पादित किया जा सकता है।

गैर-थ्रेड-सुरक्षित उदाहरण: एकाधिक मॉडल इंस्टेंस

इसी तरह, यहां कई के साथ एक असुरक्षित पैटर्न है YOLO मॉडल उदाहरण:

# Unsafe: Sharing multiple model instances across threads can still lead to issues
from ultralytics import YOLO
from threading import Thread

# Instantiate multiple models outside the thread
shared_model_1 = YOLO("yolov8n_1.pt")
shared_model_2 = YOLO("yolov8n_2.pt")


def predict(model, image_path):
    """Runs prediction on an image using a specified YOLO model, returning the results."""
    results = model.predict(image_path)
    # Process results


# Starting threads with individual model instances
Thread(target=predict, args=(shared_model_1, "image1.jpg")).start()
Thread(target=predict, args=(shared_model_2, "image2.jpg")).start()

भले ही दो अलग-अलग मॉडल उदाहरण हैं, फिर भी समवर्ती मुद्दों का जोखिम अभी भी मौजूद है। यदि आंतरिक कार्यान्वयन YOLO थ्रेड-सुरक्षित नहीं है, अलग-अलग उदाहरणों का उपयोग करने से दौड़ की स्थिति को रोका नहीं जा सकता है, खासकर यदि ये उदाहरण किसी भी अंतर्निहित संसाधन या राज्यों को साझा करते हैं जो थ्रेड-स्थानीय नहीं हैं।

थ्रेड-सुरक्षित अनुमान

थ्रेड-सुरक्षित अनुमान करने के लिए, आपको एक अलग तत्काल करना चाहिए YOLO प्रत्येक धागे के भीतर मॉडल। यह सुनिश्चित करता है कि प्रत्येक धागे का अपना पृथक मॉडल उदाहरण है, जो दौड़ की स्थिति के जोखिम को समाप्त करता है।

थ्रेड-सुरक्षित उदाहरण

यहां बताया गया है कि कैसे एक तत्काल करने के लिए YOLO सुरक्षित समानांतर अनुमान के लिए प्रत्येक धागे के अंदर मॉडल:

# Safe: Instantiating a single model inside each thread
from ultralytics import YOLO
from threading import Thread


def thread_safe_predict(image_path):
    """Predict on an image using a new YOLO model instance in a thread-safe manner; takes image path as input."""
    local_model = YOLO("yolov8n.pt")
    results = local_model.predict(image_path)
    # Process results


# Starting threads that each have their own model instance
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

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

समाप्ति

उपयोग करते समय YOLO के साथ मॉडल Pythonके एस threading, हमेशा अपने मॉडल को थ्रेड के भीतर तत्काल करें जो थ्रेड सुरक्षा सुनिश्चित करने के लिए उनका उपयोग करेगा। यह अभ्यास दौड़ की स्थिति से बचा जाता है और यह सुनिश्चित करता है कि आपके अनुमान कार्य मज़बूती से चलते हैं।

अधिक उन्नत परिदृश्यों के लिए और अपने बहु-थ्रेडेड अनुमान प्रदर्शन को और अनुकूलित करने के लिए, प्रक्रिया-आधारित समांतरता का उपयोग करने पर विचार करें multiprocessing या समर्पित कार्यकर्ता प्रक्रियाओं के साथ एक कार्य कतार का लाभ उठाना।

टिप्पणियाँ