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

Ultralytics YOLO çıkarımını Python iş parçacıklarında güvenli biçimde ç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 model örneği oluştur. Tek bir modelin paylaşılması, iç durumunu bozarak öngörülemeyen sonuçlar doğuran yarış koşullarına neden olur; çünkü Python'un threading modülü iş parçacıklarını aynı nesne üzerinde eş zamanlı çalıştırır. Bu kılavuz, paylaşımın neden başarısız olduğunu açıklar, iş parçacığı başına güvenli kullanım biçimini gösterir ve bir örneği paylaşman gereken durumlarda ThreadingLocked dekoratörünü ele alır.

Model paylaşımının neden başarısız olduğuna, iş parçacığı güvenli kullanım biçimine veya ThreadingLocked dekoratörüne geç.

Python'da İş Parçacıklarını Anlamak#

Python iş parçacıkları, programının aynı anda birden fazla işlem yürütmesini sağlayan bir paralellik biçimidir. Ancak Python'un Global Yorumlayıcı Kilidi (GIL), aynı anda yalnızca bir iş parçacığının Python bayt kodunu çalıştırabilmesi anlamına gelir.

Bu bir kısıtlama gibi görünse de iş parçacıkları, özellikle G/Ç ağırlıklı işlemlerde veya YOLO'nun temelindeki C kütüphanelerinin gerçekleştirdikleri 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ın dışında oluşturup bu örneği birden fazla iş parçacığı arasında paylaşmak, eş zamanlı erişimler nedeniyle modelin iç durumunun tutarsız biçimde değiştirilmesine yol açan yarış koşullarına neden olabilir. Bu durum, modelin veya bileşenlerinin iş parçacığı güvenli olacak şekilde tasarlanmamış bir durumu koruduğu zaman özellikle 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ı fark etmek önemlidir. İşte kaçınman gereken durum: tek bir YOLO26 model örneğini birden fazla iş parçacığında paylaşmak.

# Güvenli değil: Tek bir model örneğini iş parçacıkları arasında paylaşma
from threading import Thread

from ultralytics import YOLO

# Modeli iş parçacığının dışında oluştur
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)
    # Sonuçları işle

# Aynı model örneğini paylaşan iş parçacıklarını başlat
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ıyor; predict birden fazla iş parçacığı tarafından aynı anda çalıştırılabileceğinden bu, öngörülemeyen sonuçlara yol açabilir.

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

Her iş parçacığı kendi örneğine sahip olduğu ve bu örneği başka bir iş parçacığıyla paylaşmadığı sürece birden fazla ayrı model örneği kullanmak sorun oluşturmaz. Aşağıdaki örneklerin iş parçacıkları başlamadan önce oluşturulmuş olması önemli değildir; güvenli olmayan tek kalıp, bir örneğin iş parçacıkları arasında paylaşılmasıdır:

# Güvenli: her iş parçacığı kendine özel model örneğini kullanır
from threading import Thread

from ultralytics import YOLO

# Her iş parçacığı için bir model örneği oluştur
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)
    # Sonuçları işle

# Her iş parçacığı ayrı ve kendine özel bir model örneği kullanır
Thread(target=predict, args=(model_1, "image1.jpg")).start()
Thread(target=predict, args=(model_2, "image2.jpg")).start()

Her iş parçacığı kendine özel bir örnekle çalıştığından, iş parçacıklarının bozabileceği paylaşılan bir model durumu yoktur. Sonraki bölümde gösterildiği gibi modeli her iş parçacığının içinde oluşturmak, bir örneğin yanlışlıkla paylaşılmasını önlemenin en kolay yoludur.

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

İş parçacığı güvenli çıkarım yapmak için her iş parçacığının içinde ayrı bir YOLO modeli oluşturmalısın. Böylece her iş parçacığının kendine ait, yalıtılmış bir model örneği olur ve yarış koşulları riski ortadan kalkar.

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

İş parçacığı güvenli paralel çıkarım için her iş parçacığının içinde bir YOLO modelini şu şekilde oluşturabilirsin:

# Güvenli: Her iş parçacığının içinde tek bir model örneği oluşturma
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)
    # Sonuçları işle

# Her biri kendi model örneğine sahip iş parçacıklarını başlat
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ığı diğerinin model durumuna müdahale edemez; her iş parçacığı çıkarımı güvenli biçimde 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 biçimde çalışmasını sağlamak için kullanılabilecek bir ThreadingLocked dekoratörü sunar. Bu dekoratör, aynı anda yalnızca bir iş parçacığının süslenen işlevi çalıştırabilmesi için kilit kullanır.

from ultralytics import YOLO
from ultralytics.utils import ThreadingLocked

# Bir model örneği oluştur
model = YOLO("yolo26n.pt")

# Tahmin işlevini iş parçacığı güvenli olacak şekilde süsle
@ThreadingLocked()
def thread_safe_predict(image_path):
    """Thread-safe prediction using a shared model instance."""
    results = model.predict(image_path)
    return results

# Artık bu işlevi birden fazla iş parçacığından güvenle çağırabilirsin

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

Sonuç#

YOLO modellerini Python'un threading özelliğiyle kullanırken her iş parçacığına kendine özel bir model örneği ver ve hiçbir örneği iş parçacıkları arasında paylaşma. Bunu sağlamanın en kolay yolu, modeli kullanan iş parçacığının içinde oluşturmaktır; 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 iyileştirmek için multiprocessing ile süreç tabanlı paralelliği veya özel çalışan süreçleri olan bir görev kuyruğunu kullanmayı düşünebilirsin.

Sık Sorulan Sorular#