Servidor de Inferencia Triton con Ultralytics YOLO11

Q: How do I set up Ultralytics YOLO11 with NVIDIA Triton Inference Server?

La configuración de Ultralytics YOLO11 con el servidor de inferencia NVIDIA Triton implica algunos pasos clave: Esta configuración puede ayudarte a implementar eficientemente modelos YOLO11 a escala en el servidor de inferencia Triton para una inferencia de modelos de IA de alto rendimiento.

El Servidor de Inferencia Triton (anteriormente conocido como Servidor de Inferencia TensorRT) es una solución de software de código abierto desarrollada por NVIDIA. Proporciona una solución de inferencia en la nube optimizada para las GPU de NVIDIA. Triton simplifica la implementación de modelos de IA a escala en producción. La integración de Ultralytics YOLO11 con el Servidor de Inferencia Triton le permite implementar 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.

Ver: Primeros pasos con el servidor de inferencia NVIDIA Triton.

¿Qué es Triton Inference Server?

El Servidor de Inferencia Triton está diseñado para implementar una variedad de modelos de IA en producción. Es compatible con una amplia gama de frameworks de aprendizaje profundo y aprendizaje automático, incluyendo TensorFlow, PyTorch, ONNX Runtime y muchos otros. Sus principales casos de uso son:

Servir múltiples modelos desde una sola instancia de servidor
Carga y descarga dinámica de modelos sin reiniciar el servidor
Inferencia de conjunto, que permite utilizar varios modelos juntos para lograr resultados
Control de versiones de modelos para pruebas A/B y actualizaciones progresivas

Beneficios clave de Triton Inference Server

El uso de Triton Inference Server con Ultralytics YOLO11 proporciona varias ventajas:

Batching automático: Agrupa múltiples solicitudes de IA antes de procesarlas, reduciendo la latencia y mejorando la velocidad de inferencia
Integración de Kubernetes: El diseño nativo de la nube funciona a la perfección con Kubernetes para administrar y escalar aplicaciones de IA
Optimizaciones específicas de hardware: Aprovecha al máximo las GPU NVIDIA para obtener el máximo rendimiento.
Flexibilidad del framework: Admite múltiples frameworks de IA, incluidos TensorFlow, PyTorch, ONNX y TensorRT
De código abierto y personalizable: Se puede modificar para adaptarse a necesidades específicas, lo que garantiza la flexibilidad para diversas aplicaciones de IA.

Prerrequisitos

Asegúrate de tener los siguientes requisitos previos antes de continuar:

Docker instalado en su máquina
Instalar tritonclient:
```
pip install tritonclient[all]
```

Exportación de YOLO11 al formato ONNX

Antes de implementar el modelo en Triton, debe exportarse al formato ONNX. ONNX (Open Neural Network Exchange) es un formato que permite transferir modelos entre diferentes frameworks de aprendizaje profundo. Utilice el export función de YOLO clase:

from ultralytics import YOLO

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

# Retrieve metadata during export. Metadata needs to be added to config.pbtxt. See next section.
metadata = []


def export_cb(exporter):
    metadata.append(exporter.metadata)


model.add_callback("on_export_end", export_cb)

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

Configuración del repositorio de modelos de Triton

El repositorio de modelos de Triton es una ubicación de almacenamiento donde Triton puede acceder y cargar modelos.

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

Mueva el modelo ONNX exportado al repositorio de 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()

data = """
# Add metadata
parameters {
  key: "metadata"
  value {
    string_value: "%s"
  }
}

# (Optional) Enable TensorRT for GPU inference
# First run will be slow due to TensorRT engine conversion
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"
      }
    }
  }
}
""" % metadata[0]  # noqa

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

Ejecutando el servidor de inferencia Triton

Ejecute el servidor de inferencia Triton usando 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)

Luego ejecute 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")

Limpiar el contenedor:

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

Optimización TensorRT (Opcional)

Para un rendimiento aún mayor, puede utilizar TensorRT con Triton Inference Server. TensorRT es un optimizador de aprendizaje profundo de alto rendimiento creado específicamente para las GPU de NVIDIA que puede aumentar significativamente la velocidad de inferencia.

Los beneficios clave de usar TensorRT con Triton incluyen:

Inferencia hasta 36 veces más rápida en comparación con los modelos no optimizados
Optimizaciones específicas de hardware para una máxima utilización de la GPU
Soporte para formatos de precisión reducida (INT8, FP16) manteniendo la precisión
Fusión de capas para reducir la sobrecarga computacional

Para usar TensorRT directamente, puede exportar su modelo YOLO11 al formato TensorRT:

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolo11n.engine'

Para obtener más información sobre la optimización de TensorRT, consulte la guía de integración de TensorRT.

Siguiendo los pasos anteriores, puedes implementar y ejecutar modelos Ultralytics YOLO11 de manera eficiente 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 tienes más preguntas, 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 el servidor de inferencia NVIDIA Triton?

La configuración de Ultralytics YOLO11 con NVIDIA Triton Inference Server implica algunos pasos clave:

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

Configurar el repositorio de modelos de Triton:

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

Ejecutar 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 ayudarle a implementar de forma eficiente modelos YOLO11 a escala en Triton Inference Server para la inferencia de modelos de IA de alto rendimiento.

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

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

Inferencia de IA Escalable: Triton permite servir múltiples modelos desde una sola instancia de servidor, admitiendo 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 GPU NVIDIA, Triton Inference Server garantiza operaciones de inferencia de alta velocidad, perfecto para aplicaciones en tiempo real como la detección de objetos.
Ensamblaje y control de versiones del modelo: El modo de ensamblaje de Triton permite combinar múltiples modelos para mejorar los resultados, y su control de versiones del modelo admite pruebas A/B y actualizaciones progresivas.
Batching Automático: Triton agrupa automáticamente múltiples solicitudes de inferencia, mejorando significativamente el rendimiento y reduciendo la latencia.
Implementación Simplificada: Optimización gradual de los flujos de trabajo de IA sin necesidad de revisiones completas del sistema, lo que facilita el escalado eficiente.

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

¿Por qué debería exportar mi modelo YOLO11 al formato ONNX antes de usar Triton Inference Server?

El uso del formato ONNX (Open Neural Network Exchange) para tu modelo Ultralytics YOLO11 antes de implementarlo en NVIDIA Triton Inference Server ofrece varias ventajas clave:

Interoperabilidad: El formato ONNX admite la transferencia entre diferentes marcos de aprendizaje profundo (como PyTorch, TensorFlow), lo que garantiza una compatibilidad más amplia.
Optimización: Muchos entornos de implementación, incluido Triton, están optimizados para ONNX, lo que permite una inferencia más rápida y un mejor rendimiento.
Facilidad de implementación: ONNX es ampliamente compatible con marcos y plataformas, lo que simplifica el proceso de implementación en varios sistemas operativos y configuraciones de hardware.
Independencia del framework: Una vez convertido a ONNX, su modelo ya no está ligado a su framework original, lo que lo hace más portátil.
Estandarización: ONNX proporciona una representación estandarizada que ayuda a superar los problemas de compatibilidad entre los diferentes marcos de IA.

Para exportar su modelo, use:

from ultralytics import YOLO

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

Puede seguir los pasos de la guía de integración de ONNX 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 Inference Server. Una vez que tu modelo esté configurado en el Triton Model Repository y el servidor esté en funcionamiento, 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")

Este enfoque le permite aprovechar las optimizaciones de Triton mientras utiliza la interfaz familiar de Ultralytics YOLO. Para obtener una guía detallada sobre cómo configurar y ejecutar Triton Server con YOLO11, consulte la sección ejecución del servidor de inferencia de Triton.

¿Cómo se compara Ultralytics YOLO11 con los modelos de TensorFlow y PyTorch para la implementación?

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

Rendimiento en tiempo real: Optimizado para tareas de detección de objetos en tiempo real, YOLO11 proporciona precisión y velocidad de última generación, 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 implementación.
Funciones avanzadas: YOLO11 incluye funciones como la carga dinámica de modelos, el control de versiones de modelos y la inferencia de conjuntos, que son cruciales para implementaciones de IA escalables y fiables.
API Simplificada: La API de Ultralytics proporciona una interfaz consistente en diferentes objetivos de implementación, lo que reduce la curva de aprendizaje y el tiempo de desarrollo.
Optimización Edge: Los modelos YOLO11 están diseñados teniendo en cuenta la implementación edge, ofreciendo un rendimiento excelente incluso en dispositivos con recursos limitados.

Para obtener más detalles, compare las opciones de implementación en la guía de exportación de modelos.

📅 Creado hace 1 año ✏️ Actualizado hace 3 meses