Suy luận an toàn luồng với các mô hình YOLO

Q: Is it safer to use process-based parallelism instead of threading for YOLO model inference?

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

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

Xem: Cách Thực hiện Suy luận An toàn theo Luồng với các Mô hình Ultralytics YOLO trong Python | Đa luồng 🚀

Tìm hiểu về luồng Python

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

Ví dụ về đơn luồng so với đa luồng

Mặc dù điều này nghe có vẻ là một hạn chế, nhưng các luồng vẫn có thể cung cấp tính đồng thời, đặc biệt đối với các hoạt động bị ràng buộc bởi I/O hoặc khi sử dụng các hoạt động giải phóng GIL, chẳng hạn như các hoạt động được thực hiện bởi các thư viện C cơ bản của YOLO.

Sự Nguy Hiểm của Các Thể Hiện Mô Hình Được Chia Sẻ

Khởi tạo mô hình YOLO bên ngoài các luồng của bạn và chia sẻ phiên bản này trên nhiều luồng có thể dẫn đến các điều kiện chạy đua, trong đó trạng thái bên trong của mô hình bị sửa đổi không nhất quán do truy cập đồng thời. Điều này đặc biệt có vấn đề khi mô hình hoặc các thành phần của nó giữ trạng thái không được thiết kế để an toàn cho luồng.

Ví dụ không an toàn luồng: Một phiên bản mô hình

Khi sử dụng các luồng trong Python, điều quan trọng là phải nhận ra các mẫu có thể dẫn đến các vấn đề về đồng thời. Dưới đây là những điều bạn nên tránh: chia sẻ một phiên bản mô hình YOLO duy nhất trên 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("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()

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 thể đoán trướ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 luồng: Nhiều phiên bản mô hình

Tương tự, đây là một mẫu không an toàn với nhiều instance mô hình 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("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()

Mặc dù có hai phiên bản mô hình riêng biệt, nguy cơ về các 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 phiên bản riêng biệt có thể không ngăn chặn được tình trạng tranh chấp dữ liệu, đặc biệt nếu các phiên bản này chia sẻ bất kỳ tài nguyên hoặc trạng thái cơ bản nào không phải là cục bộ luồng.

Suy luận An toàn luồng

Để thực hiện suy luận an toàn theo luồng, bạn nên khởi tạo một mô hình YOLO riêng biệt trong mỗi luồng. Điều này đảm bảo rằng mỗi luồng có một phiên bản mô hình riêng biệt, loại bỏ nguy cơ xảy ra tình trạng tranh chấp dữ liệu.

Ví dụ về luồng an toàn

Đây là cách khởi tạo một mô hình 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("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()

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

Sử dụng ThreadingLocked Decorator

Ultralytics cung cấp một ThreadingLocked decorator có thể được sử dụng để đảm bảo thực thi an toàn theo luồng của các hàm. Decorator này sử dụng một khóa để đảm bảo rằng chỉ một luồng tại một thời điểm có thể thực thi hàm được trang trí.

from ultralytics import YOLO
from ultralytics.utils import ThreadingLocked

# Create a model instance
model = YOLO("yolo11n.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

Hàm ThreadingLocked decorator đặc biệt hữu ích khi bạn cần chia sẻ một instance mô hình trên 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 mô hình 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 phải đợi khóa được giải phóng.

Kết luận

Khi sử dụng các mô hình YOLO với Python threading, luôn khởi tạo các mô hình của bạn trong thread sẽ sử dụng chúng để đảm bảo an toàn cho thread. Thao tác này giúp tránh các race condition và đảm bảo rằng 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 tình huống nâng cao hơn và để tối ưu hóa hơn nữa 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 quy trình với multiprocessing hoặc tận dụng hàng đợi tác vụ với các quy trình worker chuyên dụng.

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

Làm cách nào để tránh tình trạng tranh chấp dữ liệu (race conditions) khi sử dụng các mô hình YOLO trong môi trường Python đa luồng?

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

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

Để biết thêm thông tin về việc đảm bảo an toàn cho luồng, hãy truy cập Suy luận An toàn Luồng với Mô hình YOLO.

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

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

Khởi tạo các mô hình YOLO trong mỗi luồng thay vì chia sẻ một instance mô hình duy nhất trên các luồng.
Sử dụng Python multiprocessing module để 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 hoạt động được thực hiện bởi các thư viện C cơ bản của YOLO.
Cân nhắc sử dụng ThreadingLocked decorator cho các instance mô hình dùng chung khi bộ nhớ là một vấn đề cần quan tâm.

Ví dụ về khởi tạo mô hình 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("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()

Để biết thêm thông tin, hãy tham khảo phần về Suy luận An toàn theo Luồng.

Tại sao mỗi luồng nên có một phiên bản mô hình YOLO riêng?

Mỗi luồng (thread) nên có một thể hiện (instance) mô hình YOLO riêng để ngăn chặn tình trạng xung đột dữ liệu (race conditions). Khi một thể hiện mô hình 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ể đoán trước và sửa đổi trạng thái bên trong của mô hình. Bằng cách sử dụng các thể hiện riêng biệt, bạn đảm bảo sự cô lập giữa các luồng, làm cho các tác vụ đa luồng của bạn trở nên đáng tin cậy và an toàn.

Để được hướng dẫn chi tiết, hãy xem các phần Ví dụ không an toàn theo luồng: Một phiên bản mô hình và Ví dụ an toàn theo luồng.

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

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 bị ràng buộc bởi CPU. Tuy nhiên, đối với các hoạt động bị ràng buộc bởi I/O hoặc các quy trình sử dụng các thư viện giải phóng GIL, như các thư viện C cơ bản của YOLO, bạn vẫn có thể đạt được tính đồng thời. Để tăng cường hiệu suất, hãy cân nhắc sử dụng tính song song dựa trên quy trình với mô-đun multiprocessing của Python. multiprocessing module.

Để tìm hiểu thêm về luồng trong Python, hãy xem phần Tìm hiểu về luồng Python.

Có an toàn hơn khi sử dụng song song hóa dựa trên tiến trình thay vì phân luồng cho suy luận mô hình YOLO không?

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

Để biết thêm chi tiết về tính song song dựa trên quy trình với các mô hình YOLO, hãy tham khảo trang về Suy luận an toàn theo luồng.

📅 Đã tạo 1 năm trước ✏️ Cập nhật 4 tháng trước