Потокобезопасный инференс с моделями YOLO

Запуск моделей YOLO в многопоточной среде требует осторожности для обеспечения потокобезопасности. Модуль threading в Python позволяет запускать несколько потоков одновременно, но при использовании моделей YOLO в этих потоках важно учитывать серьезные проблемы безопасности. Эта страница поможет тебе настроить потокобезопасный инференс моделей YOLO.

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

Понимание многопоточности в Python

Потоки в Python — это форма параллелизма, позволяющая программе выполнять несколько операций одновременно. Однако глобальная блокировка интерпретатора (GIL) в Python означает, что только один поток может выполнять байт-код Python в конкретный момент времени.

Single-thread vs multi-thread inference

Хотя это звучит как ограничение, потоки всё равно могут обеспечить параллелизм, особенно для операций, ограниченных вводом-выводом (I/O-bound), или при использовании операций, освобождающих GIL, например тех, что выполняются базовыми библиотеками C для YOLO.

Опасность использования общих экземпляров моделей

Создание экземпляра модели 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("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()

В приведенном выше примере 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("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()

Даже если создано два отдельных экземпляра модели, риск возникновения проблем с параллелизмом сохраняется. Если внутренняя реализация YOLO не является потокобезопасной, использование раздельных экземпляров может не предотвратить состояния гонки, особенно если эти экземпляры совместно используют какие-либо базовые ресурсы или состояния, не являющиеся локальными для потока.

Потокобезопасный вывод (Inference)

Чтобы обеспечить потокобезопасный инференс, тебе следует создавать отдельный экземпляр модели 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("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()

В этом примере каждый поток создает свой собственный экземпляр YOLO. Это предотвращает вмешательство одного потока в состояние модели другого, обеспечивая безопасное выполнение инференса в каждом потоке без непредсказуемого взаимодействия между ними.

Использование декоратора ThreadingLocked

Ultralytics предоставляет декоратор ThreadingLocked, который можно использовать для обеспечения потокобезопасного выполнения функций. Этот декоратор использует блокировку, чтобы гарантировать, что только один поток может выполнять декорированную функцию в каждый момент времени.

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

Декоратор ThreadingLocked особенно полезен, когда тебе нужно предоставить общий доступ к экземпляру модели между потоками, но ты хочешь быть уверен, что только один поток может обращаться к нему одновременно. Этот подход может сэкономить память по сравнению с созданием нового экземпляра модели для каждого потока, но он может снизить параллелизм, так как потокам придется ждать освобождения блокировки.

Заключение

При использовании моделей YOLO с threading в Python всегда создавай экземпляры своих моделей внутри потока, который будет их использовать, чтобы обеспечить потокобезопасность. Эта практика позволяет избежать состояний гонки и гарантирует надежную работу твоих задач инференса.

Для более сложных сценариев и дальнейшей оптимизации производительности многопоточного инференса рассмотри возможность использования параллелизма на основе процессов с помощью multiprocessing или использования очереди задач с выделенными рабочими процессами.

Часто задаваемые вопросы (FAQ)

Как избежать состояний гонки при использовании моделей YOLO в многопоточной среде Python?

Чтобы предотвратить состояния гонки при использовании моделей Ultralytics YOLO в многопоточной среде Python, создавай отдельный экземпляр модели 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("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()

Для получения дополнительной информации об обеспечении потокобезопасности посети страницу Потокобезопасный инференс с моделями YOLO.

Каковы лучшие практики для выполнения многопоточного инференса моделей YOLO в Python?

Для безопасного выполнения многопоточного инференса моделей YOLO в Python следуй этим лучшим практикам:

Создавай экземпляры моделей YOLO внутри каждого потока, а не делись одним экземпляром модели между потоками.
Используй модуль multiprocessing в Python для параллельной обработки, чтобы избежать проблем, связанных с глобальной блокировкой интерпретатора (GIL).
Освобождай GIL, используя операции, выполняемые базовыми библиотеками C для YOLO.
Рассмотри возможность использования декоратора ThreadingLocked для общих экземпляров моделей, если экономия памяти критична.

Пример потокобезопасного создания экземпляра модели:

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

Для получения дополнительного контекста обратись к разделу Потокобезопасный инференс.

Почему у каждого потока должен быть свой собственный экземпляр модели YOLO?

У каждого потока должен быть свой собственный экземпляр модели YOLO, чтобы предотвратить состояния гонки. Когда один экземпляр модели используется совместно несколькими потоками, одновременный доступ может привести к непредсказуемому поведению и изменениям внутреннего состояния модели. Используя отдельные экземпляры, ты обеспечиваешь изоляцию потоков, делая свои многопоточные задачи надежными и безопасными.

Подробные рекомендации ты найдешь в разделах Пример нарушения потокобезопасности: один экземпляр модели и Пример потокобезопасности.

Как глобальная блокировка интерпретатора (GIL) в Python влияет на инференс моделей YOLO?

Глобальная блокировка интерпретатора (GIL) в Python позволяет выполнять только один поток байт-кода Python за раз, что может ограничивать производительность задач многопоточности, связанных с нагрузкой на CPU. Однако для операций, ограниченных вводом-выводом (I/O), или процессов, использующих библиотеки, освобождающие GIL (как базовые C-библиотеки YOLO), ты всё равно можешь достичь параллелизма. Для повышения производительности рассмотри возможность использования параллелизма на уровне процессов с помощью модуля multiprocessing в Python.

Подробнее о многопоточности в Python читай в разделе Понимание многопоточности в Python.

Безопаснее ли использовать параллелизм на основе процессов вместо многопоточности для инференса моделей YOLO?

Да, использование модуля multiprocessing в Python безопаснее и зачастую эффективнее для выполнения инференса моделей YOLO параллельно. Параллелизм на основе процессов создает отдельные области памяти, избегая глобальной блокировки интерпретатора (GIL) и снижая риск проблем с параллелизмом. Каждый процесс будет работать независимо, имея собственный экземпляр модели YOLO.

Дополнительные сведения о параллелизме на основе процессов с использованием моделей YOLO см. на странице Потокобезопасный инференс.

Contributors

GLglenn-jocher⁹ RIRizwanMunawar²

Created 12 нояб. 2023 г.