Saltar al contenido

Triton Servidor de inferencias con Ultralytics YOLO11

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 NVIDIA GPUs. Triton simplifica el despliegue de modelos de IA a escala en producción. La integración de Ultralytics YOLO11 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, PyTorchONNX 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 YOLO11 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("yolo11n.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()

# (Optional) Enable TensorRT for GPU inference
# First run will be slow due to TensorRT engine conversion
data = """
optimization {
  execution_accelerators {
    gpu_execution_accelerator {
      name: "tensorrt"
      parameters {
        key: "precision_mode"
        value: "FP16"
      }
      parameters {
        key: "max_workspace_size_bytes"
        value: "3221225472"
      }
      parameters {
        key: "trt_engine_cache_enable"
        value: "1"
      }
      parameters {
        key: "trt_engine_cache_path"
        value: "/models/yolo/1"
      }
    }
  }
}
"""

with open(triton_model_path / "config.pbtxt", "w") as f:
    f.write(data)

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:24.09-py3"  # 8.57 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 --gpus 0 -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 YOLO11 en Triton Servidor de Inferencia, proporcionando una solución escalable y de alto rendimiento para tareas de inferencia de aprendizaje profundo. Si te encuentras con algún problema o tienes más dudas, 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 YOLO11 con NVIDIA Triton Inference Server?

Configurar Ultralytics YOLO11 con NVIDIA Triton Inference Server implica unos cuantos pasos clave:

  1. Exporta YOLO11 al formato ONNX :

    from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.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:24.09-py3"

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

container_id = (
    subprocess.check_output(
        f"docker run -d --rm --gpus 0 -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 YOLO11 a escala en Triton Inference Server para la inferencia de modelos de IA de alto rendimiento.

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

Integrar Ultralytics YOLO11 con NVIDIA Triton Inference Server proporciona 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 YOLO11 con Triton, puedes consultar la guía de configuración.

¿Por qué debo exportar mi modelo YOLO11 al formato ONNX antes de utilizar Triton Inference Server?

Utilizar el formato ONNX (Open Neural Network Exchange) para tu modelo Ultralytics YOLO11 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("yolo11n.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 YOLO11 en Triton Inference Server?

Sí, puedes ejecutar la inferencia utilizando el modelo Ultralytics YOLO11 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 en 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 YOLO11, consulta la sección sobre el funcionamiento del servidor de inferencia triton .

¿Cómo se compara Ultralytics YOLO11 con TensorFlow y PyTorch modelos de despliegue?

Ultralytics YOLO11 ofrece varias ventajas únicas en comparación con los modelos TensorFlow y PyTorch para el despliegue:

  • Rendimiento en tiempo real: Optimizado para tareas de detección de objetos en tiempo real, YOLO11 proporciona una 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: YOLO11 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: YOLO11 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.

📅 C reado hace 1 año ✏️ Actualizado hace 20 días
Y-T-G UltralíticoAsistente glenn-jocher

Comentarios