Link to this sectionYOLO Modelleri ile İş Parçacığı Güvenli Çıkarım#

Ultralytics YOLO çıkarımını Python iş parçacıkları (threads) üzerinde 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 örneği oluştur. Tek bir modeli paylaşmak, Python'ın threading modülü iş parçacıklarını aynı nesne üzerinde eş zamanlı olarak çalıştırdığı için, modelin dahili durumunu bozan ve öngörülemeyen sonuçlar doğuran yarış durumlarına (race conditions) yol açar. Bu rehber, paylaşımın neden başarısız olduğunu açıklar, güvenli iş parçacığı başına model desenini gösterir ve bir örneği paylaşmak zorunda kaldığın durumlar için ThreadingLocked dekoratörünü ele alır.

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

Link to this sectionPython İş 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.

Link to this sectionPaylaşı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.

Link to this sectionİş 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 desenleri fark etmek önemlidir. Kaçınman gereken şey şudur: tek bir YOLO26 modeli ö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, predict işlemi birden fazla iş parçacığı tarafından aynı anda yürütülebileceği için öngörülemeyen sonuçlara yol açabilecek birden fazla iş parçacığı tarafından kullanılmaktadır.

Link to this sectionGü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.

Link to this sectionİş 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.

Link to this sectionİş 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 ve 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.

Link to this sectionThreadingLocked Dekoratörünü Kullanma#

Ultralytics, fonksiyonların iş parçacığı güvenli çalışmasını sağlamak için kullanılabilecek bir ThreadingLocked dekoratörü sunar. Bu dekoratör, dekore edilmiş fonksiyonu her seferinde yalnızca bir iş parçacığının yürütebilmesini sağlamak için bir kilit (lock) 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 gerektiğinde ancak her seferinde yalnızca bir iş parçacığının ona erişebildiğinden emin olmak istediğinde kullanışlıdır.

Link to this sectionSonuç#

YOLO modellerini Python'ın threading modülü ile kullanırken, her iş parçacığına kendi özel model örneğini ver ve hiçbir zaman tek bir örneği iş parçacıkları arasında paylaşma. Modeli onu kullanan iş parçacığının içinde oluşturmak, bunu garanti etmenin ve yarış durumlarından kaçınarak çıkarım görevlerini güvenilir tutmanın en basit yoludur.

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

Link to this sectionSSS#

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

Ultralytics YOLO modellerini çok iş parçacıklı bir Python ortamında kullanırken yarış koşullarını önlemek için, her iş parçacığı içinde ayrı bir YOLO modeli örneklendirin. Bu, her iş parçacığının model durumunun eş zamanlı değiştirilmesini önleyerek kendi yalıtılmış model örneğine sahip olmasını sağlar.

Ö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 bölümünü ziyaret edin.

Link to this sectionPython'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ı izleyin:

1. YOLO modellerini iş parçacıkları arasında tek bir model örneği paylaşmak yerine her iş parçacığı içinde örneklendirin.
2. Global Interpreter Lock (GIL) ile ilgili sorunları önlemek amacıyla paralel işleme için Python'ın multiprocessing modülünü kullan.
3. YOLO'nun temel C kütüphanelerinin (PyTorch, OpenCV) yoğun hesaplama sırasında GIL'i otomatik olarak serbest bıraktığını unutma, bu sayede iş parçacıkları yine de eş zamanlı olarak çıkarım çalıştırabilir.
4. Belleğin önemli olduğu durumlarda paylaşılan model örnekleri için ThreadingLocked dekoratörünü kullanmayı düşünün.

İş parçacığı güvenli model örneklendirme 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."""
    local_model = YOLO("yolo26n.pt")
    results = local_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şvurun.

Link to this sectionNeden her iş parçacığının kendi YOLO model örneği olmalıdır?#

Her iş parçacığının, yarış koşullarını önlemek için kendi YOLO model ö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ülemeyen davranışlara ve modelin iç durumunun bozulmasına yol açabilir. Ayrı örnekler kullanarak, çok iş parçacıklı görevlerinizi güvenilir ve güvenli hale getirerek iş parçacığı yalıtımını sağlarsınız.

Detaylı rehberlik için İş Parçacığı Güvenli Olmayan Örnek: Tek Model Örneği ve İş Parçacığı Güvenli Örnek bölümlerine göz atın.

Link to this sectionPython'un Küresel Yorumlayıcı Kilidi (GIL) YOLO modeli çıkarımını nasıl etkiler?#

Python'un Küresel Yorumlayıcı Kilidi (GIL), aynı anda 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/Ç odaklı işlemler veya YOLO'nun temelindeki C kütüphaneleri gibi GIL'i serbest bırakan kütüphaneler kullanan işlemler için yine de eş zamanlılık elde edebilirsiniz. Daha iyi performans için, Python'un multiprocessing modülüyle süreç tabanlı paralellik kullanmayı düşünün.

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

Link to this sectionYOLO modeli çıkarımı için iş parçacığı yerine süreç tabanlı paralellik kullanmak daha mı güvenli?#

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

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