Triton Servidor de inferencia con Ultralytics YOLOv8

El Triton Inference Server (antes conocido como TensorRT Inference Server) es una solución de software de código abierto desarrollada por NVIDIA. Proporciona una solución de inferencia en la nube optimizada para GPUs NVIDIA . Triton simplifica el despliegue de modelos de IA a escala en producción. La integración de Ultralytics YOLOv8 con Triton Inference Server te permite desplegar cargas de trabajo de inferencia de aprendizaje profundo escalables y de alto rendimiento. Esta guía proporciona los pasos para configurar y probar la integración.

Observa: Primeros pasos con NVIDIA Triton Servidor de Inferencia.

¿Qué es Triton Servidor de Inferencia?

Triton Inference Server está diseñado para desplegar diversos modelos de IA en producción. Es compatible con una amplia gama de marcos de aprendizaje profundo y aprendizaje automático, como TensorFlow, PyTorch, ONNX Runtime y muchos otros. Sus principales casos de uso son:

• Servir varios modelos desde una única instancia de servidor.
• Carga y descarga dinámica de modelos sin reiniciar el servidor.
• Inferencia conjunta, que permite utilizar varios modelos juntos para obtener resultados.
• Versionado de modelos para pruebas A/B y actualizaciones continuas.

Requisitos previos

Asegúrate de que tienes los siguientes requisitos previos antes de proceder:

• Docker instalado en tu máquina.
• Instala tritonclient:

  pip install tritonclient[all]
  

Exportar YOLOv8 al formato ONNX

Antes de desplegar el modelo en Triton, hay que exportarlo al formato ONNX . ONNX (Open Neural Network Exchange) es un formato que permite transferir modelos entre distintos marcos de aprendizaje profundo. Utiliza el formato export de la función YOLO clase:

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n.pt")  # load an official model

# Export the model
onnx_file = model.export(format="onnx", dynamic=True)

Configuración del repositorio de modelos Triton

El repositorio de modelos de Triton es un lugar de almacenamiento al que Triton puede acceder y cargar modelos.

1. Crea la estructura de directorios necesaria:

   from pathlib import Path
   
   # Define paths
   model_name = "yolo"
   triton_repo_path = Path("tmp") / "triton_repo"
   triton_model_path = triton_repo_path / model_name
   
   # Create directories
   (triton_model_path / "1").mkdir(parents=True, exist_ok=True)
   

2. Mueve el modelo ONNX exportado al repositorio Triton :

   from pathlib import Path
   
   # Move ONNX model to Triton Model path
   Path(onnx_file).rename(triton_model_path / "1" / "model.onnx")
   
   # Create config file
   (triton_model_path / "config.pbtxt").touch()
   

Ejecutando Triton Servidor de Inferencia

Ejecuta el Servidor de Inferencia Triton utilizando Docker:

import contextlib
import subprocess
import time

from tritonclient.http import InferenceServerClient

# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
tag = "nvcr.io/nvidia/tritonserver:23.09-py3"  # 6.4 GB

# Pull the image
subprocess.call(f"docker pull {tag}", shell=True)

# Run the Triton server and capture the container ID
container_id = (
    subprocess.check_output(
        f"docker run -d --rm -v {triton_repo_path}:/models -p 8000:8000 {tag} tritonserver --model-repository=/models",
        shell=True,
    )
    .decode("utf-8")
    .strip()
)

# Wait for the Triton server to start
triton_client = InferenceServerClient(url="localhost:8000", verbose=False, ssl=False)

# Wait until model is ready
for _ in range(10):
    with contextlib.suppress(Exception):
        assert triton_client.is_model_ready(model_name)
        break
    time.sleep(1)

A continuación, ejecuta la inferencia utilizando el modelo Triton Server:

from ultralytics import YOLO

# Load the Triton Server model
model = YOLO("http://localhost:8000/yolo", task="detect")

# Run inference on the server
results = model("path/to/image.jpg")

Limpia el contenedor:

# Kill and remove the container at the end of the test
subprocess.call(f"docker kill {container_id}", shell=True)

Siguiendo los pasos anteriores, puedes desplegar y ejecutar eficientemente modelos Ultralytics YOLOv8 en Triton Inference Server, proporcionando una solución escalable y de alto rendimiento para tareas de inferencia de aprendizaje profundo. Si tienes algún problema o alguna duda, consulta la documentación oficial de Triton o ponte en contacto con la comunidad de Ultralytics para obtener ayuda.

PREGUNTAS FRECUENTES

¿Cómo configuro Ultralytics YOLOv8 con NVIDIA Triton Inference Server?

La configuración Ultralytics YOLOv8 con NVIDIA Triton Inference Server implica unos cuantos pasos clave:

1. Exporta YOLOv8 al formato ONNX :

   from ultralytics import YOLO
   
   # Load a model
   model = YOLO("yolov8n.pt")  # load an official model
   
   # Export the model to ONNX format
   onnx_file = model.export(format="onnx", dynamic=True)
   

2. Configura Triton Repositorio de modelos:

   from pathlib import Path
   
   # Define paths
   model_name = "yolo"
   triton_repo_path = Path("tmp") / "triton_repo"
   triton_model_path = triton_repo_path / model_name
   
   # Create directories
   (triton_model_path / "1").mkdir(parents=True, exist_ok=True)
   Path(onnx_file).rename(triton_model_path / "1" / "model.onnx")
   (triton_model_path / "config.pbtxt").touch()
   

3. Ejecuta el servidor Triton :

   import contextlib
   import subprocess
   import time
   
   from tritonclient.http import InferenceServerClient
   
   # Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
   tag = "nvcr.io/nvidia/tritonserver:23.09-py3"
   
   subprocess.call(f"docker pull {tag}", shell=True)
   
   container_id = (
       subprocess.check_output(
           f"docker run -d --rm -v {triton_repo_path}/models -p 8000:8000 {tag} tritonserver --model-repository=/models",
           shell=True,
       )
       .decode("utf-8")
       .strip()
   )
   
   triton_client = InferenceServerClient(url="localhost:8000", verbose=False, ssl=False)
   
   for _ in range(10):
       with contextlib.suppress(Exception):
           assert triton_client.is_model_ready(model_name)
           break
       time.sleep(1)
   

Esta configuración puede ayudarte a desplegar eficazmente modelos YOLOv8 a escala en Triton Inference Server para la inferencia de modelos de IA de alto rendimiento.

¿Qué ventajas ofrece el uso de Ultralytics YOLOv8 con NVIDIA Triton Inference Server?

La integración de Ultralytics YOLOv8 con NVIDIA Triton Inference Server ofrece varias ventajas:

• Inferencia de IA escalable: Triton permite servir múltiples modelos desde una única instancia de servidor, soportando la carga y descarga dinámica de modelos, lo que lo hace altamente escalable para diversas cargas de trabajo de IA.
• Alto rendimiento: Optimizado para las GPU NVIDIA , Triton Inference Server garantiza operaciones de inferencia de alta velocidad, perfectas para aplicaciones en tiempo real como la detección de objetos.
• Ensemble y versionado de modelos: el modo ensemble de Triton permite combinar varios modelos para mejorar los resultados, y su versionado de modelos admite pruebas A/B y actualizaciones continuas.

Para obtener instrucciones detalladas sobre cómo configurar y ejecutar YOLOv8 con Triton, puedes consultar la guía de configuración.

¿Por qué debo exportar mi modelo YOLOv8 al formato ONNX antes de utilizar el servidor de inferencia Triton ?

Utilizar el formato ONNX (Open Neural Network Exchange) para tu Ultralytics YOLOv8 modelo antes de desplegarlo en NVIDIA Triton Inference Server ofrece varias ventajas clave:

• Interoperabilidad: el formato ONNX admite la transferencia entre distintos marcos de aprendizaje profundo (como PyTorch, TensorFlow), lo que garantiza una mayor compatibilidad.
• Optimización: Muchos entornos de implantación, incluido Triton, optimizan para ONNX, lo que permite una inferencia más rápida y un mejor rendimiento.
• Facilidad de despliegue: ONNX es ampliamente compatible con distintos marcos y plataformas, lo que simplifica el proceso de despliegue en diversos sistemas operativos y configuraciones de hardware.

Para exportar tu modelo, utiliza

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
onnx_file = model.export(format="onnx", dynamic=True)

Puedes seguir los pasos de la guía de exportación para completar el proceso.

¿Puedo ejecutar la inferencia utilizando el modelo Ultralytics YOLOv8 en Triton Inference Server?

Sí, puedes ejecutar la inferencia utilizando el Ultralytics YOLOv8 modelo en NVIDIA Triton Servidor de Inferencia. Una vez que tu modelo esté configurado en el Repositorio de Modelos Triton y el servidor esté funcionando, puedes cargar y ejecutar la inferencia sobre tu modelo de la siguiente manera:

from ultralytics import YOLO

# Load the Triton Server model
model = YOLO("http://localhost:8000/yolo", task="detect")

# Run inference on the server
results = model("path/to/image.jpg")

Para obtener una guía detallada sobre la configuración y el funcionamiento del servidor Triton con YOLOv8, consulta la sección Funcionamiento del servidor de inferencia triton .

¿Cómo se compara Ultralytics YOLOv8 con los modelos TensorFlow y PyTorch para su despliegue?

Ultralytics YOLOv8 ofrece varias ventajas únicas en comparación con los modelos de implantación TensorFlow y PyTorch :

• Rendimiento en tiempo real: Optimizado para tareas de detección de objetos en tiempo real, YOLOv8 proporciona precisión y velocidad de vanguardia, lo que lo hace ideal para aplicaciones que requieren análisis de vídeo en directo.
• Facilidad de uso: YOLOv8 se integra perfectamente con Triton Inference Server y admite diversos formatos de exportación (ONNX, TensorRT, CoreML), lo que lo hace flexible para diversos escenarios de implantación.
• Funciones avanzadas: YOLOv8 incluye funciones como la carga dinámica de modelos, el versionado de modelos y la inferencia de conjuntos, que son cruciales para implantaciones de IA escalables y fiables.

Para más detalles, compara las opciones de despliegue en la guía de despliegue del modelo.

Comentarios