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

Ultralytics YOLO çıkarımını Python iş parçacıkları arasında güvenli bir şekilde çalıştırmak için, tek bir örneği iş parçacıkları arasında paylaşmak yerine her iş parçacığının içinde ayrı bir YOLO modeli oluştur. Tek bir modelin paylaşılması, iç durumunu bozan ve öngörülemeyen sonuçlara yol açan yarış koşullarına neden olur; bunun nedeni Python'ın threading modülünün iş parçacıklarını aynı nesne üzerinde eşzamanlı olarak çalıştırmasıdır. Bu kılavuz, paylaşımın neden başarısız olduğunu açıklar, iş parçacığı başına güvenli düzeni gösterir ve bir örneği paylaşman gereken durumlar için ThreadingLocked dekoratörünü ele alır.

Bir modelin paylaşılmasının neden başarısız olduğunu, iş parçacığı güvenli düzeni veya ThreadingLocked dekoratörünü görmek için ilgili bölüme git.

Python İş Parçacığını Anlama#

Python iş parçacıkları, programının birden çok işlemi aynı anda çalıştırmasını sağlayan bir paralellik biçimidir. Ancak Python'ın Global Interpreter Lock (GIL) mekanizması, aynı anda yalnızca bir iş parçacığının Python bayt kodunu yürütmesine izin verir.

Bu bir sınırlama gibi görünse de iş parçacıkları, özellikle G/Ç ağırlıklı işlemlerde veya YOLO'nun temel C kitaplıkları tarafından gerçekleştirilen ve GIL'i serbest bırakan işlemler kullanıldığında eşzamanlılık sağlayabilir.

Paylaşılan Model Örneklerinin Tehlikesi#

Bir YOLO modelini iş parçacıklarının dışında oluşturup bu örneği birden çok iş parçacığı arasında paylaşmak, eşzamanlı erişimler nedeniyle modelin iç durumunun tutarsız biçimde değiştirilmesine ve yarış koşullarına yol açabilir. Bu durum, model veya bileşenleri iş parçacığı güvenli olacak şekilde tasarlanmamış bir durum tuttuğunda özellikle sorunludur.

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

Python'da iş parçacıklarını kullanırken eşzamanlılık sorunlarına yol açabilecek düzenleri tanımak önemlidir. Kaçınman gereken düzen şudur: tek bir YOLO26 model örneğini birden çok iş parçacığı arasında paylaşmak.

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

from ultralytics import YOLO

# Instantiate the model outside the thread
shared_model = YOLO("yolo26n.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 çok iş parçacığı tarafından kullanılır; bu da öngörülemeyen sonuçlara yol açabilir, çünkü predict birden çok iş parçacığı tarafından aynı anda yürütülebilir.

Güvenli Örnek: İş Parçacığı Başına Ayrı Bir Örnek#

Her iş parçacığı kendi örneğine sahip olduğu ve bunu başka bir iş parçacığıyla paylaşmadığı sürece birden çok ayrı model örneğinin kullanılması uygundur. Aşağıdaki örneklerin iş parçacıkları başlatılmadan önce oluşturulmuş olması sorun değildir — güvenli olmayan tek düzen, bir örneğin iş parçacıkları arasında paylaşılmasıdır:

# Safe: each thread uses its own dedicated model instance
from threading import Thread

from ultralytics import YOLO

# Instantiate one model per thread
model_1 = YOLO("yolo26n.pt")
model_2 = YOLO("yolo26n.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

# Each thread uses a separate, dedicated model instance
Thread(target=predict, args=(model_1, "image1.jpg")).start()
Thread(target=predict, args=(model_2, "image2.jpg")).start()

Her iş parçacığı kendisine ayrılmış örnekle çalıştığı için, iş parçacıklarının bozabileceği paylaşılan bir model durumu yoktur. Modeli sonraki örnekte gösterildiği gibi her iş parçacığının içinde oluşturmak, bir örneğin yanlışlıkla paylaşılmamasını garanti etmenin en kolay yoludur.

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

İş parçacığı güvenli çıkarım gerçekleştirmek için her iş parçacığının içinde ayrı bir YOLO modeli oluşturmalısın. Bu, her iş parçacığının yalıtılmış kendi 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 iş parçacığının içinde YOLO modelini şu şekilde oluşturabilirsin:

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

from ultralytics import YOLO

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("yolo26n.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ğini oluşturur. Böylece hiçbir iş parçacığının başka bir iş parçacığının model durumuna müdahale etmesi önlenir; dolayısıyla her iş parçacığı çıkarımı güvenli bir şekilde ve diğer iş parçacıklarıyla beklenmedik etkileşimler olmadan gerçekleştirir.

ThreadingLocked Dekoratörünü Kullanma#

Ultralytics, işlevlerin iş parçacığı güvenli yürütülmesini sağlamak için kullanılabilecek bir ThreadingLocked dekoratörü sağlar. Bu dekoratör, aynı anda yalnızca bir iş parçacığının dekoratör uygulanmış işlevi yürütmesini sağlamak için bir kilit kullanır.

from ultralytics import YOLO
from ultralytics.utils import ThreadingLocked

# Create a model instance
model = YOLO("yolo26n.pt")

# Decorate the prediction function to make it thread-safe
@ThreadingLocked()
def thread_safe_predict(image_path):
    """Thread-safe prediction using a shared model instance."""
    results = model.predict(image_path)
    return results

# Now you can safely call this function from multiple threads

ThreadingLocked dekoratörü, iş parçacıkları arasında bir model örneğini paylaşman gerektiğinde ancak aynı anda yalnızca bir iş parçacığının bu örneğe erişmesini istediğinde özellikle kullanışlıdır.

Sonuç#

YOLO modellerini Python'ın threading modülüyle kullanırken her iş parçacığına kendisine ayrılmış bir model örneği ver ve tek bir örneği iş parçacıkları arasında asla paylaşma. Modeli onu kullanan iş parçacığının içinde oluşturmak, bunu garanti etmenin en basit yoludur; böylece yarış koşullarını önler ve çıkarım görevlerinin güvenilir kalmasını sağlarsın.

Daha gelişmiş senaryolar ve çok iş parçacıklı çıkarım performansını daha da optimize etmek için multiprocessing ile işlem tabanlı paralellik kullanmayı veya kendisine ayrılmış çalışan işlemlere sahip bir görev kuyruğundan yararlanmayı düşünebilirsin.

SSS#