Suy luận an toàn với luồng (Thread-Safe) bằng các model YOLO

Việc chạy các model YOLO trong môi trường đa luồng đòi hỏi sự cân nhắc kỹ lưỡng để đảm bảo tính an toàn cho luồng. Mô-đun threading của Python cho phép bạn chạy nhiều luồng đồng thời, nhưng khi sử dụng các model YOLO trên các luồng này, có những vấn đề bảo mật quan trọng cần lưu ý. Trang này sẽ hướng dẫn bạn cách tạo suy luận model YOLO an toàn cho luồng.

Watch: How to Perform Thread Safe Inference with Ultralytics YOLO Models in Python | Multi-Threading 🚀

Tìm hiểu về Threading trong Python

Các luồng (thread) trong Python là một dạng song song cho phép chương trình của bạn thực hiện nhiều thao tác cùng lúc. Tuy nhiên, Global Interpreter Lock (GIL) của Python có nghĩa là tại một thời điểm chỉ có một luồng có thể thực thi bytecode của Python.

Single-thread vs multi-thread inference

Mặc dù nghe có vẻ là một hạn chế, nhưng các luồng vẫn có thể cung cấp khả năng xử lý đồng thời, đặc biệt là đối với các thao tác liên quan đến I/O hoặc khi sử dụng các thao tác giải phóng GIL, giống như các thao tác được thực hiện bởi các thư viện C bên dưới của YOLO.

Mối nguy hiểm của việc chia sẻ các instance model

Việc khởi tạo một model YOLO bên ngoài các luồng và chia sẻ instance này giữa nhiều luồng có thể dẫn đến race conditions, nơi trạng thái nội bộ của model bị sửa đổi không nhất quán do việc truy cập đồng thời. Điều này đặc biệt gây ra vấn đề khi model hoặc các thành phần của nó giữ các trạng thái không được thiết kế để an toàn cho luồng.

Ví dụ không an toàn cho luồng: Một instance model duy nhất

Khi sử dụng luồng trong Python, điều quan trọng là phải nhận ra các mô hình có thể dẫn đến vấn đề về đồng thời. Đây là điều bạn nên tránh: chia sẻ một instance model YOLO duy nhất giữa nhiều luồng.

# 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()

Trong ví dụ trên, shared_model được sử dụng bởi nhiều luồng, điều này có thể dẫn đến kết quả không dự đoán trước được vì predict có thể được thực thi đồng thời bởi nhiều luồng.

Ví dụ không an toàn cho luồng: Nhiều instance model

Tương tự, đây là một mô hình không an toàn với nhiều instance model YOLO:

# 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()

Mặc dù có hai instance model riêng biệt, rủi ro về vấn đề đồng thời vẫn tồn tại. Nếu việc triển khai nội bộ của YOLO không an toàn cho luồng, việc sử dụng các instance riêng biệt có thể không ngăn được race conditions, đặc biệt nếu các instance này chia sẻ bất kỳ tài nguyên hoặc trạng thái cơ bản nào không thuộc phạm vi cục bộ của luồng.

Suy luận an toàn luồng (Thread-Safe Inference)

Để thực hiện suy luận an toàn cho luồng, bạn nên khởi tạo một model YOLO riêng biệt trong mỗi luồng. Điều này đảm bảo rằng mỗi luồng có instance model riêng biệt, giúp loại bỏ rủi ro về race conditions.

Ví dụ an toàn cho luồng

Dưới đây là cách khởi tạo một model YOLO bên trong mỗi luồng để suy luận song song an toàn:

# 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()

Trong ví dụ này, mỗi luồng tạo ra instance YOLO của riêng nó. Điều này ngăn chặn bất kỳ luồng nào can thiệp vào trạng thái model của luồng khác, do đó đảm bảo rằng mỗi luồng thực hiện suy luận một cách an toàn và không có các tương tác không mong muốn với các luồng khác.

Sử dụng decorator ThreadingLocked

Ultralytics cung cấp một decorator ThreadingLocked có thể được sử dụng để đảm bảo việc thực thi các hàm an toàn cho luồng. Decorator này sử dụng khóa (lock) để đảm bảo rằng tại một thời điểm chỉ có một luồng có thể thực thi hàm được gắn decorator.

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

Decorator ThreadingLocked đặc biệt hữu ích khi bạn cần chia sẻ một instance model giữa các luồng nhưng muốn đảm bảo rằng chỉ một luồng có thể truy cập nó tại một thời điểm. Cách tiếp cận này có thể tiết kiệm bộ nhớ so với việc tạo một instance model mới cho mỗi luồng, nhưng nó có thể làm giảm tính đồng thời vì các luồng sẽ cần đợi khóa được giải phóng.

Kết luận

Khi sử dụng các model YOLO với threading của Python, hãy luôn khởi tạo các model của bạn trong luồng sẽ sử dụng chúng để đảm bảo tính an toàn cho luồng. Thực hành này tránh được race conditions và đảm bảo các tác vụ suy luận của bạn chạy một cách đáng tin cậy.

Đối với các kịch bản nâng cao hơn và để tối ưu hóa thêm hiệu suất suy luận đa luồng của bạn, hãy cân nhắc sử dụng tính song song dựa trên tiến trình với multiprocessing hoặc tận dụng hàng đợi tác vụ với các tiến trình worker chuyên dụng.

Câu hỏi thường gặp (FAQ)

Làm thế nào tôi có thể tránh race conditions khi sử dụng các model YOLO trong môi trường Python đa luồng?

Để ngăn chặn race conditions khi sử dụng các model Ultralytics YOLO trong môi trường Python đa luồng, hãy khởi tạo một model YOLO riêng biệt trong mỗi luồng. Điều này đảm bảo rằng mỗi luồng có instance model riêng biệt, tránh việc sửa đổi trạng thái model đồng thời.

Ví dụ:

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()

Để biết thêm thông tin về việc đảm bảo tính an toàn cho luồng, hãy truy cập Thread-Safe Inference with YOLO Models.

Các phương pháp hay nhất để chạy suy luận model YOLO đa luồng trong Python là gì?

Để chạy suy luận model YOLO đa luồng một cách an toàn trong Python, hãy tuân theo các phương pháp hay nhất sau:

Khởi tạo các model YOLO trong mỗi luồng thay vì chia sẻ một instance model duy nhất giữa các luồng.
Sử dụng mô-đun multiprocessing của Python để xử lý song song nhằm tránh các vấn đề liên quan đến Global Interpreter Lock (GIL).
Giải phóng GIL bằng cách sử dụng các thao tác được thực hiện bởi các thư viện C bên dưới của YOLO.
Cân nhắc sử dụng decorator ThreadingLocked cho các instance model được chia sẻ khi bộ nhớ là một mối quan tâm.

Ví dụ về việc khởi tạo model an toàn cho luồng:

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()

Để biết thêm ngữ cảnh, hãy tham khảo phần Thread-Safe Inference.

Tại sao mỗi luồng nên có instance model YOLO riêng?

Mỗi luồng nên có instance model YOLO riêng để ngăn chặn race conditions. Khi một instance model duy nhất được chia sẻ giữa nhiều luồng, việc truy cập đồng thời có thể dẫn đến hành vi không thể dự đoán và làm thay đổi trạng thái nội bộ của model. Bằng cách sử dụng các instance riêng biệt, bạn đảm bảo sự cô lập luồng, làm cho các tác vụ đa luồng của bạn đáng tin cậy và an toàn.

Để được hướng dẫn chi tiết, hãy xem các phần Non-Thread-Safe Example: Single Model Instance và Thread-Safe Example.

Global Interpreter Lock (GIL) của Python ảnh hưởng như thế nào đến suy luận model YOLO?

Global Interpreter Lock (GIL) của Python chỉ cho phép một luồng thực thi bytecode Python tại một thời điểm, điều này có thể hạn chế hiệu suất của các tác vụ đa luồng phụ thuộc vào CPU. Tuy nhiên, đối với các thao tác liên quan đến I/O hoặc các tiến trình sử dụng các thư viện giải phóng GIL, như các thư viện C bên dưới của YOLO, bạn vẫn có thể đạt được sự đồng thời. Để có hiệu suất nâng cao, hãy cân nhắc sử dụng tính song song dựa trên tiến trình với mô-đun multiprocessing của Python.

Để biết thêm về threading trong Python, hãy xem phần Understanding Python Threading.

Liệu việc sử dụng tính song song dựa trên tiến trình có an toàn hơn thay vì threading cho suy luận model YOLO không?

Có, việc sử dụng mô-đun multiprocessing của Python an toàn hơn và thường hiệu quả hơn để chạy suy luận model YOLO song song. Tính song song dựa trên tiến trình tạo ra các không gian bộ nhớ riêng biệt, tránh được Global Interpreter Lock (GIL) và giảm nguy cơ xảy ra các vấn đề về đồng thời. Mỗi tiến trình sẽ hoạt động độc lập với instance model YOLO của riêng nó.

Để biết thêm chi tiết về tính song song dựa trên tiến trình với các model YOLO, hãy tham khảo trang về Thread-Safe Inference.

Contributors

GLglenn-jocher⁹ RIRizwanMunawar²

Created 12 thg 11, 2023Updated 3 tháng trước