Inferencia segura para subprocesos con modelos YOLO#

Para ejecutar inferencias de Ultralytics YOLO de forma segura en varios subprocesos de Python, crea una instancia independiente del modelo YOLO dentro de cada subproceso, en lugar de compartir una instancia entre ellos. Compartir un único modelo provoca condiciones de carrera que corrompen su estado interno y generan resultados impredecibles, porque el módulo threading de Python ejecuta los subprocesos simultáneamente sobre el mismo objeto. Esta guía explica por qué falla el uso compartido, muestra el patrón seguro por subproceso y presenta el decorador ThreadingLocked para los casos en los que tengas que compartir una instancia.

Ve directamente a por qué falla compartir un modelo, al patrón seguro para subprocesos o al decorador ThreadingLocked.

Introducción a los subprocesos de Python#

Los subprocesos de Python son una forma de paralelismo que permite que tu programa ejecute varias operaciones a la vez. Sin embargo, el bloqueo global del intérprete (GIL) de Python significa que solo se puede ejecutar bytecode de Python en un subproceso cada vez.

Aunque pueda parecer una limitación, los subprocesos pueden proporcionar concurrencia, sobre todo en operaciones limitadas por la E/S o al utilizar operaciones que liberan el GIL, como las que realizan las bibliotecas C subyacentes de YOLO.

El peligro de compartir instancias de modelos#

Crear una instancia de un modelo YOLO fuera de los subprocesos y compartirla entre varios puede provocar condiciones de carrera, en las que el estado interno del modelo se modifica de forma incoherente debido a accesos simultáneos. Esto resulta especialmente problemático cuando el modelo o sus componentes mantienen un estado que no está diseñado para ser seguro para subprocesos.

Ejemplo no seguro para subprocesos: una sola instancia de modelo#

Al utilizar subprocesos en Python, es importante reconocer los patrones que pueden provocar problemas de concurrencia. Esto es lo que debes evitar: compartir una única instancia del modelo YOLO26 entre varios subprocesos.

# # Inseguro: compartir una única instancia de modelo entre subprocesos
from threading import Thread

from ultralytics import YOLO

# # Crear una instancia del modelo fuera del subproceso
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)
    # Procesa los resultados

# # Iniciar subprocesos que comparten la misma instancia de modelo
Thread(target=predict, args=("image1.jpg",)).start()
Thread(target=predict, args=("image2.jpg",)).start()

En el ejemplo anterior, varios subprocesos utilizan shared_model, lo que puede generar resultados impredecibles porque varios subprocesos podrían ejecutar predict simultáneamente.

Ejemplo seguro: una instancia dedicada por subproceso#

Puedes utilizar varias instancias de modelo independientes siempre que cada subproceso sea propietario de su instancia y no la comparta nunca con otro subproceso. No importa que las instancias de abajo se creen antes de iniciar los subprocesos: el único patrón inseguro es compartir una instancia entre subprocesos:

# # Seguro: cada subproceso utiliza su propia instancia de modelo dedicada
from threading import Thread

from ultralytics import YOLO

# # Crear un modelo por subproceso
model_1 = YOLO("yolo26n.pt")
model_2 = YOLO("yolo26n.pt")

def predict(model, image_path):
    """Runs prediction on an image using a specified YOLO model, returning the results."""
    results = model.predict(image_path)
    # Procesa los resultados

# # Cada subproceso utiliza una instancia de modelo independiente y dedicada
Thread(target=predict, args=(model_1, "image1.jpg")).start()
Thread(target=predict, args=(model_2, "image2.jpg")).start()

Como cada subproceso trabaja con su propia instancia dedicada, no hay un estado de modelo compartido que los subprocesos puedan corromper. Crear la instancia del modelo dentro de cada subproceso, como se muestra a continuación, es simplemente la forma más sencilla de garantizar que nunca se comparta una instancia por accidente.

Inferencia segura para subprocesos#

Para realizar inferencias seguras para subprocesos, crea una instancia de un modelo YOLO independiente dentro de cada subproceso. Así te aseguras de que cada subproceso tenga su propia instancia aislada del modelo y eliminas el riesgo de condiciones de carrera.

Ejemplo seguro para subprocesos#

Así puedes crear una instancia de un modelo YOLO dentro de cada subproceso para ejecutar inferencias en paralelo de forma segura:

# # Seguro: crear una única instancia de modelo dentro de cada subproceso
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)
    # Procesa los resultados

# Inicia subprocesos, cada uno con su propia instancia del modelo
Thread(target=thread_safe_predict, args=("image1.jpg",)).start()
Thread(target=thread_safe_predict, args=("image2.jpg",)).start()

En este ejemplo, cada subproceso crea su propia instancia de YOLO. Así se evita que un subproceso interfiera con el estado del modelo de otro y se garantiza que cada uno realice inferencias de forma segura, sin interacciones inesperadas con los demás.

Uso del decorador ThreadingLocked#

Ultralytics proporciona un decorador ThreadingLocked que puedes utilizar para garantizar que las funciones se ejecuten de forma segura para subprocesos. Este decorador utiliza un bloqueo para garantizar que solo se ejecute la función decorada en un subproceso cada vez.

from ultralytics import YOLO
from ultralytics.utils import ThreadingLocked

# # Crear una instancia del modelo
model = YOLO("yolo26n.pt")

# # Aplicar el decorador a la función de predicción para que sea segura para subprocesos
@ThreadingLocked()
def thread_safe_predict(image_path):
    """Thread-safe prediction using a shared model instance."""
    results = model.predict(image_path)
    return results

# # Ahora puedes llamar a esta función de forma segura desde varios subprocesos

El decorador ThreadingLocked resulta especialmente útil cuando necesitas compartir una instancia de modelo entre subprocesos, pero quieres garantizar que solo un subproceso pueda acceder a ella cada vez.

Conclusión#

Al utilizar modelos YOLO con threading de Python, asigna a cada subproceso su propia instancia de modelo dedicada y no compartas nunca una instancia entre subprocesos. Crear el modelo dentro del subproceso que lo utiliza es la forma más sencilla de garantizarlo, evitar condiciones de carrera y mantener la fiabilidad de las tareas de inferencia.

Para escenarios más avanzados y para optimizar aún más el rendimiento de las inferencias multiproceso, plantéate utilizar el paralelismo basado en procesos con multiprocessing o una cola de tareas con procesos de trabajo dedicados.

Preguntas frecuentes#