Inferencia segura con modelos YOLO

La ejecución de los modelos YOLO en un entorno multihilo requiere una cuidadosa consideración para garantizar la seguridad de los hilos. Python's threading le permite ejecutar varios subprocesos simultáneamente, pero cuando se trata de utilizar modelos YOLO en estos subprocesos, hay que tener en cuenta importantes cuestiones de seguridad. Esta página le guiará en la creación de un modelo de inferencia YOLO seguro para subprocesos.

Entendiendo Python Threading

Python Los hilos son una forma de paralelismo que permite a tu programa ejecutar múltiples operaciones a la vez. Sin embargo, Python's Global Interpreter Lock (GIL) significa que sólo un hilo puede ejecutar Python bytecode a la vez.

Aunque esto parezca una limitación, los hilos pueden proporcionar concurrencia, especialmente para operaciones de E/S o cuando se utilizan operaciones que liberan el GIL, como las realizadas por las bibliotecas C subyacentes de YOLO.

El peligro de los modelos compartidos

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

Ejemplo no seguro: Modelo único

Cuando se utilizan hilos en Python, es importante reconocer los patrones que pueden conducir a problemas de concurrencia. Esto es lo que debes evitar: compartir una única instancia del modelo YOLO entre varios subprocesos.

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

En el ejemplo anterior, el shared_model es utilizado por múltiples hilos, lo que puede conducir a resultados impredecibles porque predict podría ser ejecutado simultáneamente por múltiples hilos.

Ejemplo no seguro: Múltiples instancias del modelo

Del mismo modo, aquí hay un patrón inseguro con múltiples instancias del modelo 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()

Aunque haya dos instancias de modelo separadas, el riesgo de problemas de concurrencia sigue existiendo. Si la implementación interna de YOLO no es seguro para subprocesos, el uso de instancias separadas podría no prevenir condiciones de carrera, especialmente si estas instancias comparten recursos o estados subyacentes que no son locales para subprocesos.

Inferencia segura de subprocesos

Para realizar una inferencia segura para cada subproceso, debe instanciar un modelo YOLO independiente en cada subproceso. Esto asegura que cada hilo tiene su propia instancia aislada del modelo, eliminando el riesgo de condiciones de carrera.

Ejemplo de hilo seguro

He aquí cómo instanciar un modelo YOLO dentro de cada hilo para una inferencia paralela segura:

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

En este ejemplo, cada subproceso crea su propio YOLO instancia. Esto evita que cualquier hilo interfiera con el estado del modelo de otro, garantizando así que cada hilo realice la inferencia de forma segura y sin interacciones inesperadas con los otros hilos.

Conclusión

Al utilizar los modelos YOLO con Python's threadingSiempre instancie sus modelos dentro del subproceso que los utilizará para garantizar la seguridad del subproceso. Esta práctica evita las condiciones de carrera y garantiza que las tareas de inferencia se ejecuten de forma fiable.

Para escenarios más avanzados y para optimizar aún más el rendimiento de la inferencia multihilo, considere la posibilidad de utilizar el paralelismo basado en procesos con multiprocessing o aprovechando una cola de tareas con procesos de trabajadores dedicados.

PREGUNTAS FRECUENTES

¿Cómo puedo evitar las condiciones de carrera al utilizar modelos YOLO en un entorno multihilo Python ?

Para evitar condiciones de carrera cuando se utilizan modelos Ultralytics YOLO en un entorno multihilo Python , instancie un modelo YOLO separado dentro de cada hilo. Esto asegura que cada hilo tiene su propia instancia aislada del modelo, evitando la modificación concurrente del estado del modelo.

Por ejemplo:

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

Para más información sobre cómo garantizar la seguridad de los hilos, visite Thread-Safe Inference with YOLO Models.

¿Cuáles son las mejores prácticas para ejecutar la inferencia de modelos YOLO multihilo en Python?

Para ejecutar la inferencia de modelos YOLO multihilo de forma segura en Python, siga estas prácticas recomendadas:

1. Instanciar modelos YOLO dentro de cada subproceso en lugar de compartir una única instancia de modelo entre subprocesos.
2. Utilice Python's multiprocessing para el procesamiento paralelo con el fin de evitar problemas relacionados con el bloqueo global del intérprete (GIL).
3. Libera el GIL mediante operaciones realizadas por las bibliotecas C subyacentes de YOLO.

Ejemplo de instanciación de modelos a prueba de hilos:

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

Para más información, consulte la sección sobre Inferencia segura de subprocesos.

¿Por qué debe tener cada hilo su propia instancia del modelo YOLO ?

Cada subproceso debe tener su propia instancia del modelo YOLO para evitar condiciones de carrera. Cuando una única instancia del modelo se comparte entre varios subprocesos, los accesos simultáneos pueden provocar un comportamiento impredecible y modificaciones del estado interno del modelo. El uso de instancias separadas garantiza el aislamiento de los subprocesos y hace que las tareas multihilo sean fiables y seguras.

Para obtener información detallada, consulte las secciones Ejemplo no seguro para subprocesos: Instancia de modelo único y Ejemplo de seguridad de subprocesos.

¿Cómo afecta el bloqueo global del intérprete (GIL) de Python a la inferencia del modelo YOLO ?

PythonEl bloqueo global del intérprete (GIL) sólo permite que un subproceso ejecute el código de bytes de Python a la vez, lo que puede limitar el rendimiento de las tareas multihilo vinculadas a CPU. Sin embargo, para operaciones ligadas a E/S o procesos que utilizan bibliotecas que liberan el GIL, como las bibliotecas C de YOLO, aún se puede lograr concurrencia. Para mejorar el rendimiento, considere la posibilidad de utilizar el paralelismo basado en procesos con Python's multiprocessing módulo.

Para obtener más información sobre el enhebrado en Python, consulte la sección Comprender el enhebrado en Python .

¿Es más seguro utilizar el paralelismo basado en procesos en lugar de hilos para la inferencia de modelos YOLO ?

Sí, utilizando Python's multiprocessing es más seguro y a menudo más eficiente para ejecutar la inferencia del modelo YOLO en paralelo. El paralelismo basado en procesos crea espacios de memoria separados, evitando el Bloqueo Global del Intérprete (GIL) y reduciendo el riesgo de problemas de concurrencia. Cada proceso funcionará de forma independiente con su propia instancia del modelo YOLO .

Para más detalles sobre el paralelismo basado en procesos con modelos YOLO , consulte la página sobre Inferencia segura de subprocesos.

Creado hace 1 año ✏️ Actualizado hace 2 meses

Comentarios