Ir al contenido

Triton Inference Server con Ultralytics YOLO26

El Triton Inference Server (anteriormente 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 YOLO26 con Triton Inference Server permite desplegar cargas de trabajo de inferencia de deep learning 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 YOLO26 ofrece 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 YOLO26 a 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("yolo26n.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.

  1. 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)

  2. 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 --runtime=nvidia --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 YOLO26 al formato TensorRT:

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolo26n.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, puede desplegar y ejecutar modelos Ultralytics YOLO26 de manera eficiente en Triton Inference Server, proporcionando una solución escalable y de alto rendimiento para tareas de inferencia de deep learning. Si encuentra algún problema o tiene más preguntas, consulte la documentación oficial de Triton o póngase en contacto con la comunidad de Ultralytics para obtener soporte.

Preguntas frecuentes

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

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

  1. Exportar YOLO26 a formato ONNX:

    from ultralytics import YOLO

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

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

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

  3. 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 --runtime=nvidia --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 desplegar eficientemente modelos YOLO26 a escala en Triton Inference Server para una inferencia de modelos de IA de alto rendimiento.

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

La integración de Ultralytics YOLO26 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 la configuración y ejecución de YOLO26 con Triton, puede consultar la guía de configuración.

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

El uso del formato ONNX (Open Neural Network Exchange) para su modelo Ultralytics YOLO26 antes de desplegarlo en NVIDIA Triton Inference Server ofrece varios beneficios 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("yolo26n.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 inferencia utilizando el modelo Ultralytics YOLO26 en Triton Inference Server?

Sí, puede ejecutar inferencia utilizando el modelo Ultralytics YOLO26 en NVIDIA Triton Inference Server. Una vez que su modelo esté configurado en el Repositorio de Modelos de Triton y el servidor esté en funcionamiento, puede cargar y ejecutar inferencia en su 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 una guía detallada sobre la configuración y ejecución de Triton Server con YOLO26, consulte la sección de ejecución del servidor de inferencia de Triton.

¿Cómo se compara Ultralytics YOLO26 con los modelos de TensorFlow y PyTorch para el despliegue?

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

  • Rendimiento en tiempo real: Optimizado para tareas de detección de objetos en tiempo real, YOLO26 proporciona una precisión y velocidad de vanguardia, lo que lo hace ideal para aplicaciones que requieren análisis de video en vivo.
  • Facilidad de Uso: YOLO26 se integra perfectamente con Triton Inference Server y admite diversos formatos de exportación (ONNX, TensorRT, CoreML), lo que lo hace flexible para varios escenarios de despliegue.
  • Características Avanzadas: YOLO26 incluye características como carga dinámica de modelos, versionado de modelos e inferencia de conjuntos, que son cruciales para despliegues 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 para Edge: Los modelos YOLO26 están diseñados pensando en el despliegue en el 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 2 años ✏️ Actualizado hace 13 días
glenn-jocherY-T-GUltralyticsAssistantonuralpszrleonnil

Comentarios