─░├žeri─če ge├ž

YOLO Modelleriyle ─░┼č 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("yolov8n.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("yolov8n_1.pt")
shared_model_2 = YOLO("yolov8n_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("yolov8n.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.



Created 2023-11-12, Updated 2024-06-02
Authors: glenn-jocher (4)

Yorumlar