YOLO Modelleri ile İş 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'ın threading modülü, birkaç iş parçacığını eş zamanlı olarak çalıştırmanıza olanak tanır, ancak YOLO modellerini bu iş parçacıkları arasında kullanmaya gelince dikkat edilmesi gereken önemli güvenlik sorunları vardır. Bu sayfa, iş parçacığı güvenli YOLO modeli çıkarımı oluşturma konusunda sana yol gösterecektir.

Python İş Parçacıklarını Anlama

Python iş parçacıkları, programının birden fazla işlemi aynı anda çalıştırmasına olanak tanıyan bir paralellik biçimidir. Ancak, Python'ın Global Interpreter Lock (GIL) yapısı, tek 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ı yine de özellikle G/Ç ağırlıklı işlemler için veya YOLO'nun temelindeki C kütüphaneleri tarafından gerçekleştirilenler 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 ö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ış durumlarına yol açabilir. Bu, model veya bileşenleri iş parçacığı güvenli olacak şekilde tasarlanmamış durumlar barındırdığında özellikle sorunludur.

İş 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 önemlidir. Kaçınman gereken durum şudur: tek bir YOLO 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 predict işleminin birden fazla iş parçacığı tarafından aynı anda yürütülebileceği için öngörülemez sonuçlara yol açabilir.

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

Benzer şekilde, birden fazla YOLO modeli örneğiyle yapılan güvensiz bir kalıp şöyledir:

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

from ultralytics import YOLO

# Instantiate multiple models outside the thread
shared_model_1 = YOLO("yolo26n_1.pt")
shared_model_2 = YOLO("yolo26n_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 YOLO'nun dahili uygulaması iş parçacığı güvenli değilse, ayrı örnekler kullanmak, özellikle bu örnekler iş parçacığına özgü olmayan temel kaynakları veya durumları paylaşıyorsa, yarış durumlarını önlemeyebilir.

İş parçacığı (Thread-Safe) Güvenli Çıkarım

İş parçacığı güvenli çıkarım yapmak için, her iş parçacığı içinde ayrı bir YOLO modeli örneği oluşturmalısın. Bu, her iş parçacığının kendi izole edilmiş model örneğine sahip olmasını sağlar ve yarış durumu riskini ortadan kaldırır.

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

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

# 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 beklenmedik etkileşimler olmadan gerçekleştirmesini sağlar.

ThreadingLocked Dekoratorunu Kullanma

Ultralytics, işlevlerin iş parçacığı güvenli yürütülmesini sağlamak için kullanılabilecek bir ThreadingLocked dekoratoru sunar. Bu dekorator, dekore edilmiş işlevi tek seferde yalnızca bir iş parçacığının yürütebilmesini 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 predict method 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 dekoratoru, özellikle bir model örneğini iş parçacıkları arasında paylaşman gerektiğinde ancak tek seferde yalnızca bir iş parçacığının ona erişebildiğinden emin olmak istediğinde kullanışlıdır. Bu yaklaşım, her iş parçacığı için yeni bir model örneği oluşturmaya kıyasla bellek tasarrufu sağlayabilir, ancak iş parçacıkları kilidin serbest bırakılmasını beklemek zorunda kalacağından eş zamanlılığı azaltabilir.

Sonuç

YOLO modellerini Python'ın threading modülü ile kullanırken, iş parçacığı güvenliğini sağlamak için modellerini her zaman onları kullanacak olan iş parçacığının içinde örneklendir. Bu uygulama yarış durumlarını önler ve çıkarım görevlerinin güvenilir bir şekilde çalışmasını sağlar.

Daha ileri düzey senaryolar ve çok iş parçacıklı çıkarım performansını daha da optimize etmek için, multiprocessing ile süreç tabanlı paralelliği kullanmayı veya özel çalışan süreçlerle bir görev kuyruğundan yararlanmayı düşün.

SSS

Çok iş parçacıklı bir Python ortamında YOLO modellerini kullanırken yarış durumlarından nasıl kaçınabilirim?

Ultralytics YOLO modellerini çok iş parçacıklı bir Python ortamında kullanırken yarış durumlarını önlemek için, her iş parçacığı içinde ayrı bir YOLO modeli örneği oluştur. Bu, her iş parçacığının kendi izole edilmiş model örneğine sahip olmasını sağlar ve model durumunun eş zamanlı olarak değiştirilmesini önler.

Örnek:

from threading import Thread

from ultralytics import YOLO

def thread_safe_predict(image_path):
    """Predict on an image in a thread-safe manner."""
    local_model = YOLO("yolo26n.pt")
    results = local_model.predict(image_path)
    # Process results

Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

İş parçacığı güvenliğini sağlama hakkında daha fazla bilgi için YOLO Modelleri ile İş Parçacığı Güvenli Çıkarım sayfasına göz at.

Python'da çok iş parçacıklı YOLO modeli çıkarımı çalıştırmak için en iyi uygulamalar nelerdir?

Python'da çok iş parçacıklı YOLO modeli çıkarımını güvenli bir şekilde çalıştırmak için şu en iyi uygulamaları takip et:

1. Tek bir model örneğini iş parçacıkları arasında paylaşmak yerine YOLO modellerini her iş parçacığı içinde örneklendir.
2. Global Interpreter Lock (GIL) ile ilgili sorunlardan kaçınmak için paralel işleme amacıyla Python'ın multiprocessing modülünü kullan.
3. YOLO'nun temelindeki C kütüphaneleri tarafından gerçekleştirilen işlemleri kullanarak GIL'i serbest bırak.
4. Bellek sorun olduğunda paylaşılan model örnekleri için ThreadingLocked dekoratorunu kullanmayı düşün.

İş parçacığı güvenli model örneklendirme örneği:

from threading import Thread

from ultralytics import YOLO

def thread_safe_predict(image_path):
    """Runs inference in a thread-safe manner with a new YOLO model instance."""
    model = YOLO("yolo26n.pt")
    results = model.predict(image_path)
    # Process results

# Initiate multiple threads
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

Ek bağlam için İş Parçacığı Güvenli Çıkarım bölümüne başvur.

Neden her iş parçacığının kendi YOLO modeli örneği olmalı?

Her iş parçacığının yarış durumlarını önlemek için kendi YOLO modeli örneği olmalıdır. Tek bir model örneği birden fazla iş parçacığı arasında paylaşıldığında, eş zamanlı erişimler öngörülemez davranışlara ve modelin iç durumunun değiştirilmesine yol açabilir. Ayrı örnekler kullanarak iş parçacığı izolasyonunu sağlarsın, bu da çok iş parçacıklı görevlerini güvenilir ve güvenli hale getirir.

Ayrıntılı rehberlik için İş Parçacığı Güvenli Olmayan Örnek: Tek Model Örneği ve İş Parçacığı Güvenli Örnek bölümlerini kontrol et.

Python'ın Global Interpreter Lock (GIL) yapısı YOLO modeli çıkarımını nasıl etkiler?

Python'ın Global Interpreter Lock (GIL) yapısı, tek seferde yalnızca bir iş parçacığının Python bayt kodunu yürütmesine izin verir, bu da CPU ağırlıklı çok iş parçacıklı görevlerin performansını sınırlayabilir. Ancak, G/Ç ağırlıklı işlemler veya YOLO'nun temelindeki C kütüphaneleri gibi GIL'i serbest bırakan kütüphaneleri kullanan süreçler için hala eş zamanlılık elde edebilirsin. Performansı artırmak için Python'ın multiprocessing modülü ile süreç tabanlı paralelliği kullanmayı düşün.

Python'da iş parçacığı kullanımı hakkında daha fazla bilgi için Python İş Parçacıklarını Anlama bölümüne bak.

YOLO modeli çıkarımı için iş parçacığı yerine süreç tabanlı paralellik kullanmak daha mı güvenli?

Evet, Python'ın multiprocessing modülünü kullanmak, YOLO modeli çıkarımını paralel olarak çalıştırmak için daha güvenli ve genellikle daha verimlidir. Süreç tabanlı paralellik, ayrı bellek alanları oluşturarak Global Interpreter Lock (GIL) yapısından kaçınır ve eş zamanlılık sorunları riskini azaltır. Her süreç kendi YOLO modeli örneğiyle bağımsız olarak çalışacaktır.

YOLO modelleri ile süreç tabanlı paralellik hakkında daha fazla ayrıntı için İş Parçacığı Güvenli Çıkarım sayfasına başvur.