YOLO Modelleriyle İş Parçacığı Güvenli Çıkarım

YOLO modellerini çok iş parçacıklı bir ortamda çalıştırmak, iş parçacığı güvenliğini sağlamak için dikkatli bir değerlendirme gerektirir. Python's threading modülü birkaç iş parçacığını aynı anda çalıştırmanıza olanak tanır, ancak bu iş parçacıkları arasında YOLO modellerini kullanmak söz konusu olduğunda, dikkat edilmesi gereken önemli güvenlik sorunları vardır. Bu sayfa, iş parçacığı güvenli YOLO model çıkarımı oluşturma konusunda size rehberlik edecektir.

Python Threading'i Anlama

Python iş parçacıkları, programınızın aynı anda birden fazla işlemi çalıştırmasına olanak tanıyan bir paralellik biçimidir. Ancak, Python'un Global Yorumlayıcı Kilidi (GIL), bir seferde yalnızca bir iş parçacığının Python bayt kodunu yürütebileceği anlamına gelir.

Bu bir sınırlama gibi görünse de, iş parçacıkları özellikle G/Ç'ye bağlı işlemler için veya YOLO'un temel C kütüphaneleri tarafından gerçekleştirilenler gibi GIL'i serbest bırakan işlemler kullanılırken eşzamanlılık sağlayabilir.

Paylaşılan Model Örnekleri Tehlikesi

İş parçacıklarınızın dışında bir YOLO modelini Instantiate etmek ve bu örneği birden fazla iş parçacığı arasında paylaşmak, eşzamanlı erişimler nedeniyle modelin dahili durumunun tutarsız bir şekilde değiştirildiği yarış koşullarına yol açabilir. Bu durum özellikle model veya bileşenleri iş parçacığı güvenli olacak şekilde tasarlanmamış durumlara sahip olduğunda sorun yaratır.

İş Parçacığı Güvenli Olmayan Örnek: Tek Model Örneği

Python adresinde iş parçacıkları kullanırken, eşzamanlılık sorunlarına yol açabilecek kalıpları tanımak önemlidir. Kaçınmanız gerekenler şunlardır: tek bir YOLO model örneğini birden fazla iş parçacığı arasında paylaşmak.

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

Yukarıdaki örnekte shared_model birden fazla iş parçacığı tarafından kullanılır, bu da öngörülemeyen sonuçlara yol açabilir çünkü predict birden fazla iş parçacığı tarafından aynı anda yürütülebilir.

İş Parçacığı Güvenli Olmayan Örnek: Çoklu Model Örnekleri

Benzer şekilde, burada birden fazla YOLO model örneği içeren güvenli olmayan bir model bulunmaktadır:

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

İki ayrı model örneği olsa bile, eşzamanlılık sorunları riski hala mevcuttur. Eğer dahili uygulama YOLO iş parçacığı güvenli değilse, ayrı örnekler kullanmak, özellikle bu örnekler iş parçacığı yerel olmayan herhangi bir temel kaynağı veya durumu paylaşıyorsa, yarış koşullarını engellemeyebilir.

İş Parçacığı Güvenli Çıkarım

İş parçacığı güvenli çıkarım yapmak için, her iş parçacığı içinde ayrı bir YOLO modeli örneklemelisiniz. Bu, her iş parçacığının kendi yalıtılmış model örneğine sahip olmasını sağlayarak yarış koşulları riskini ortadan kaldırır.

İş Parçacığı Güvenli Örnek

Güvenli paralel çıkarım için her bir iş parçacığının içinde bir YOLO modelinin nasıl örnekleneceği aşağıda açıklanmıştır:

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

Bu örnekte, her iş parçacığı kendi YOLO örneği. Bu, herhangi bir iş parçacığının başka bir iş parçacığının model durumuna müdahale etmesini önler, böylece her iş parçacığının güvenli bir şekilde ve diğer iş parçacıklarıyla beklenmedik etkileşimler olmadan çıkarım yapmasını sağlar.

Sonuç

YOLO modellerini Python's ile kullanırken threading, iş parçacığı güvenliğini sağlamak için modellerinizi her zaman onları kullanacak iş parçacığı içinde örnekleyin. Bu uygulama yarış koşullarını önler ve çıkarım görevlerinizin güvenilir bir şekilde çalışmasını sağlar.

Daha gelişmiş senaryolar için ve çok iş parçacıklı çıkarım performansınızı daha da optimize etmek için, aşağıdakilerle işlem tabanlı paralelliği kullanmayı düşünün multiprocessing veya özel çalışan süreçleri olan bir görev kuyruğundan yararlanmak.

Yorumlar