使用YOLO模型进行线程安全推理

概述

在多线程环境中运行YOLO 模型时需要特别注意线程安全问题。Python threading 模块允许同时运行多个线程，但在这些线程中使用YOLO 模型时，需要注意一些重要的安全问题。

Python 线程是一种并行计算形式，允许程序同时运行多个操作。不过，Python 的全局解释器锁（GIL）控制着一次只能有一个线程执行Python 字节码。

共享模型实例的危险

在线程外实例化YOLO 模型并在多个线程间共享该实例可能会导致竞赛条件，即由于并发访问，模型的内部状态会被不一致地修改。如果模型或其组件所持有的状态在设计上不是线程安全的，那么问题就会特别严重。

非线程安全示例：单个模型实例

在Python 中使用线程时，识别可能导致并发问题的模式非常重要。以下是应该避免的情况：在多个线程中共享单个YOLO 模型实例。

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

在上面的例子中 shared_model 被多个线程使用，这可能导致不可预测的结果，因为 predict 可由多个线程同时执行。

非线程安全示例：多个模型实例

同样，这里有一个不安全模式，它有多个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()

即使有两个独立的模型实例，并发问题的风险仍然存在。如果 YOLO 不是线程安全的，使用单独的实例可能无法防止竞赛条件，特别是如果这些实例共享任何非线程本地的底层资源或状态。

线程安全推理

要执行线程安全推理，应在每个线程中实例化一个单独的YOLO 模型。这样可以确保每个线程都有自己独立的模型实例，从而消除出现竞赛条件的风险。

线程安全示例

下面介绍如何在每个线程内实例化YOLO 模型，以实现安全的并行推理：

# 安全：在每个线程中实例化一个单独的模型
from threading import Thread

from ultralytics import YOLO


def thread_safe_predict(image_path):
    """在线程安全模式中，对每个图像使用一个新的YOLO模型实例"""
    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()

在本例中，每个线程都创建了自己的 YOLO 实例。这可以防止任何线程干扰另一个线程的模型状态，从而确保每个线程都能安全地执行推理，而不会与其他线程发生意外的交互。

使用 ThreadingLocked 装饰器

Ultralytics 提供了 ThreadingLocked 装饰器，可用于确保函数的线程安全执行。该装饰器使用锁来确保一次只能有一个线程执行被装饰的函数。

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

ThreadingLocked 装饰器在需要跨线程共享模型实例，但又想确保每次只有一个线程可以访问它时特别有用。与为每个线程创建一个新的模型实例相比，这种方法可以节省内存，但可能会降低并发性，因为线程需要等待锁被释放。

结论

当使用YOLO 模型与Python threading时，为了确保线程安全，应该总是在使用模型的线程中实例化模型。这种做法可以避免竞赛条件，确保推理任务可靠运行。

要在Python 中安全运行多线程YOLO 模型推理，请注意以下几点：

1. 在每个线程中实例化YOLO 模型，而不是跨线程共享单个模型实例。
2. 使用Python 的 multiprocessing 模块进行并行处理，以避免与全局解释器锁（GIL）相关的问题。
3. 通过使用YOLO 底层 C 库执行的操作释放 GIL。
4. 考虑使用 ThreadingLocked 装饰器的共享模型实例。

对于更高级的应用场景和进一步优化多线程推理性能，可以考虑使用基于进程的多进程并行或利用带有专用工作进程的任务队列。