İçeriğe geç

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'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.

Tek ve Çoklu İş Parçacığı Örnekleri

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 threading import Thread

from ultralytics import YOLO

# Instantiate the model outside the thread
shared_model = YOLO("yolo11n.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 threading import Thread

from ultralytics import YOLO

# Instantiate multiple models outside the thread
shared_model_1 = YOLO("yolo11n_1.pt")
shared_model_2 = YOLO("yolo11n_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 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("yolo11n.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.

SSS

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

Çok iş parçacıklı bir Python ortamında Ultralytics YOLO modellerini kullanırken yarış koşullarını önlemek için, her iş parçacığında ayrı bir YOLO modeli örnekleyin. Bu, her iş parçacığının kendi yalıtılmış model örneğine sahip olmasını sağlayarak 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("yolo11n.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ğinin sağlanması hakkında daha fazla bilgi için YOLO Modelleriyle İş Parçacığı Güvenli Çıkarım bölümünü ziyaret edin.

Python adresinde çok iş parçacıklı YOLO model çıkarımını çalıştırmak için en iyi uygulamalar nelerdir?

Çok iş parçacıklı YOLO model çıkarımını Python adresinde güvenli bir şekilde çalıştırmak için aşağıdaki en iyi uygulamaları izleyin:

  1. İş parçacıkları arasında tek bir model örneğini paylaşmak yerine her iş parçacığında YOLO modellerini örnekleyin.
  2. Python'u kullanın multiprocessing Küresel Yorumlayıcı Kilidi (GIL) ile ilgili sorunları önlemek için paralel işleme modülü.
  3. YOLO'un temel C kütüphaneleri tarafından gerçekleştirilen işlemleri kullanarak GIL'i serbest bırakın.

İş parçacığı güvenli model örneklemesi için örnek:

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("yolo11n.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 bakın.

Neden her iş parçacığı kendi YOLO model örneğine sahip olmalıdır?

Yarış koşullarını önlemek için her iş parçacığı kendi YOLO model örneğine sahip olmalıdır. Tek bir model örneği birden fazla iş parçacığı arasında paylaşıldığında, eşzamanlı erişimler öngörülemeyen davranışlara ve modelin dahili durumunda değişikliklere yol açabilir. Ayrı örnekler kullanarak iş parçacığı yalıtımı sağlar, çok iş parçacıklı görevlerinizi güvenilir ve güvenli hale getirirsiniz.

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

Python'un Global Yorumlayıcı Kilidi (GIL) YOLO model çıkarımını nasıl etkiler?

Python'in Global Interpreter Lock (GIL) özelliği aynı anda yalnızca bir iş parçacığının Python bytecode'unu çalıştırmasına izin verir, bu da CPU ile bağlantılı çok iş parçacıklı görevlerin performansını sınırlayabilir. Ancak, G/Ç'ye bağlı işlemler veya YOLO'un C kütüphaneleri gibi GIL'i serbest bırakan kütüphaneleri kullanan işlemler için yine de eşzamanlılık elde edebilirsiniz. Gelişmiş performans için, Python'un işlem tabanlı paralelliğini kullanmayı düşünün. multiprocessing Modül.

Python adresinde diş açma hakkında daha fazla bilgi için Python Diş Açmayı Anlama bölümüne bakın.

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

Evet, Python'u kullanarak multiprocessing modülü, YOLO model çıkarımını paralel olarak çalıştırmak için daha güvenli ve genellikle daha verimlidir. Süreç tabanlı paralellik ayrı bellek alanları yaratarak Global Yorumlayıcı Kilidi'nden (GIL) kaçınır ve eşzamanlılık sorunları riskini azaltır. Her süreç kendi YOLO model örneği ile bağımsız olarak çalışacaktır.

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

📅1 yıl önce oluşturuldu ✏️ 2 ay önce güncellendi
UltralitikAsistan RizwanMunawar glenn-jocher

Yorumlar