使用YOLO 模型进行线程安全推理
在多线程环境中运行YOLO 模型需要仔细考虑，以确保线程安全。Python's threading 模块允许您同时运行多个线程，但在这些线程中使用YOLO 模型时，需要注意一些重要的安全问题。本页将指导您创建线程安全的YOLO 模型推理。
了解Python 线程
Python 线程是一种并行形式，允许程序同时运行多个操作。不过，Python 的全局解释器锁（GIL）意味着一次只能有一个线程执行Python 字节码。
虽然这听起来像是一种限制，但线程仍然可以提供并发性，尤其是在 I/O 绑定操作或使用释放 GIL 的操作（如由YOLO 的底层 C 库执行的操作）时。
共享模型实例的危险
在线程外实例化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 模型，以实现安全的并行推理：
# 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()
在本例中，每个线程都创建了自己的 YOLO 实例。这可以防止任何线程干扰另一个线程的模型状态，从而确保每个线程都能安全地执行推理，而不会与其他线程发生意外的交互。
结论
当使用YOLO 型号与Python'时 threading为了确保线程安全，我们总是在使用模型的线程中实例化模型。这种做法可以避免竞赛条件，确保推理任务可靠运行。
对于更高级的应用场景，要进一步优化多线程推理性能，可以考虑使用基于进程的并行性与 multiprocessing 或利用带有专用工作进程的任务队列。
常见问题
在多线程Python 环境中使用YOLO 模型时，如何避免竞赛条件？
在多线程Python 环境中使用Ultralytics YOLO 模型时，为防止出现竞赛条件，应在每个线程中实例化一个单独的YOLO 模型。这样可以确保每个线程都有自己独立的模型实例，避免并发修改模型状态。
例如
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()
有关确保线程安全的更多信息，请访问 YOLO 模型的线程安全推理。
在Python 中运行多线程YOLO 模型推理的最佳实践是什么？
要在Python 中安全运行多线程YOLO 模型推理，请遵循以下最佳实践：
- 在每个线程中实例化YOLO 模型，而不是跨线程共享单个模型实例。
- 使用Python 的
multiprocessing模块进行并行处理，以避免与全局解释器锁（GIL）相关的问题。 - 通过使用YOLO 底层 C 库执行的操作释放 GIL。
线程安全模型实例化示例
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()
有关更多信息，请参阅线程安全推理部分。
为什么每个线程都要有自己的YOLO 模型实例？
每个线程都应拥有自己的YOLO 模型实例，以防止出现竞赛条件。当多个线程共享一个模型实例时，并发访问会导致不可预测的行为和模型内部状态的修改。通过使用单独的实例，可以确保线程隔离，从而使多线程任务变得可靠和安全。
有关详细指导，请查阅非线程安全示例：单模型实例和线程安全示例章节。
Python 的全局解释器锁定（GIL）对YOLO 模型推断有何影响？
Python全局解释器锁（GIL）只允许一个线程同时执行Python 字节码，这会限制与CPU 绑定的多线程任务的性能。不过，对于 I/O 绑定操作或使用释放 GIL 的库的进程（如YOLO 的 C 库），您仍然可以实现并发。为提高性能，可考虑使用Python 的基于进程的并行功能。 multiprocessing 模块。
有关Python 中线程的更多信息，请参阅了解Python 线程部分。
在YOLO 模型推理中使用基于进程的并行性而不是线程是否更安全？
是的，使用Python 的 multiprocessing 在并行运行YOLO 模型推理时，基于进程的并行模块更安全，通常也更高效。基于进程的并行创建了独立的内存空间，避免了全局解释器锁（GIL），降低了并发问题的风险。每个进程将使用自己的YOLO 模型实例独立运行。
有关基于进程的并行性与YOLO 模型的更多详情，请参阅线程安全推理页面。
