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

Python iş parçacıkları arasında Ultralytics YOLO çıkarımını güvenli bir şekilde çalıştırmak için, aralarında tek bir örnek paylaşmak yerine her iş parçacığının içinde ayrı bir YOLO modeli başlat. Tek bir modeli paylaşmak, iç durumunu bozan ve öngörülemeyen sonuçlar üreten yarış koşullarına neden olur, çünkü Python'un threading modülü iş parçacıklarını aynı nesne üzerinde eşzamanlı olarak çalıştırır. Bu kılavuz paylaşımın neden başarısız olduğunu açıklar, güvenli iş parçacığı başına deseni gösterir ve bir örnek paylaşmanız gereken durumlar için ThreadingLocked dekoratörünü ele alır.

Bir modeli paylaşmanın neden başarısız olduğuna, iş parçacığı güvenli desene veya ThreadingLocked dekoratörüne atla.

Python İş Parçacığı Kullanımını (Threading) Anlamak#

Python iş parçacıkları, programınızın birden fazla işlemi aynı anda çalıştırmasına olanak tanıyan bir paralellik biçimidir. Ancak, Python'un Küresel Yorumlayıcı Kilidi (GIL), aynı anda 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/Ç (I/O) odaklı işlemler için veya YOLO'nun temelindeki C kütüphanelerinin gerçekleştirdiği gibi 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ızın dışında örneklendirip bu örneği birden fazla iş parçacığı arasında paylaşmak, modelin iç durumunun eş zamanlı erişimler nedeniyle tutarsız bir şekilde değiştirildiği yarış koşullarına (race conditions) yol açabilir. Bu durum, özellikle model veya bileşenleri iş parçacığı güvenli olacak şekilde tasarlanmamış bir durum tuttuğunda sorun yaratır.

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

Python'da iş parçacıkları kullanırken, eşzamanlılık sorunlarına yol açabilecek kalıpları tanımanız önemlidir. Kaçınmanız gereken şey şudur: Tek bir YOLO26 model örneğini birden fazla 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 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.

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

Her iş parçacığı kendi örneğine sahip olduğu ve onu başka bir iş parçacığıyla asla paylaşmadığı sürece birden fazla ayrı model örneği kullanmakta sorun yoktur. Aşağıdaki örneklerin iş parçacıkları başlamadan önce oluşturulmuş olması önemli değildir; tek güvenli olmayan desen, bir örneği iş parçacıkları arasında paylaşmaktı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ığı kendi özel örneğiyle çalıştığı için, iş parçacıklarının bozabileceği paylaşılan bir model durumu yoktur. Bir örneğin yanlışlıkla paylaşılmamasını garanti etmenin en kolay yolu, aşağıda gösterildiği gibi modeli her iş parçacığının içinde oluşturmaktır.

İş 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 örneklendirmelisiniz. Bu, her iş parçacığının kendi yalıtılmış model örneğine sahip olmasını sağlar ve yarış koşulları riskini ortadan kaldırır.

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

İşte güvenli paralel çıkarım için her iş parçacığının içinde bir YOLO modeli örneklendirmenin yolu:

# 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. Bu, hiçbir iş parçacığının diğerinin model durumuna müdahale etmesini engeller, böylece her iş parçacığının çıkarımı güvenli bir şekilde ve diğer iş parçacıklarıyla beklenmeyen etkileşimler olmadan gerçekleştirmesini sağlar.

ThreadingLocked Dekoratörünü Kullanma#

Ultralytics, işlevlerin iş parçacığı güvenli yürütülmesini sağlamak için kullanılabilen bir ThreadingLocked dekoratör sağlar. Bu dekoratör, aynı anda yalnızca bir iş parçacığının dekore edilmiş 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, özellikle bir model örneğini iş parçacıkları arasında paylaşmanız gerektiğinde ancak aynı anda yalnızca bir iş parçacığının erişebilmesini güvence altına almak istediğinizde oldukça yararlıdır.

Sonuç#

YOLO modellerini Python'un threading ile kullanırken, her iş parçacığına kendi özel model örneğini verin ve hiçbir zaman tek bir örneği iş parçacıkları arasında paylaşmayın. Modeli onu kullanan iş parçacığının içinde başlatmak bunu garanti etmenin en basit yoludur, yarış koşullarını önler ve çıkarım görevlerinizi güvenilir tutar.

Daha gelişmiş senaryolar için ve çok iş parçacıklı çıkarım performansınızı daha da optimize etmek amacıyla, multiprocessing ile süreç tabanlı paralellik kullanmayı veya adanmış işçi süreçleriyle bir görev kuyruğundan yararlanmayı düşünün.

SSS#