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 le 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?

Triton Inference Server está diseñado para desplegar una variedad de modelos de IA en producción. Soporta una amplia gama de frameworks de deep learning y machine learning, incluyendo PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT 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 de frameworks: Soporta múltiples frameworks de IA, incluyendo PyTorch, TensorFlow, ONNX, OpenVINO 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 o Podman instalados en su máquina
  • Instalar ultralytics: 
    pip install ultralytics
  • Instalar tritonclient: 
    pip install tritonclient[all]

Configuración de Triton Inference Server

Ejecute este bloque de configuración completo para exportar Ultralytics YOLO26 a ONNX, construir el repositorio de modelos de Triton e iniciar el servidor de inferencia Triton:

Nota

Utilice el runtime cambie en el script para elegir su motor de contenedores:

  • Establecer runtime = "docker" para Docker
  • Establecer runtime = "podman" para Podman
import contextlib
import subprocess
import time
from pathlib import Path

from tritonclient.http import InferenceServerClient

from ultralytics import YOLO

runtime = "docker"  # set to "podman" to use Podman

# 1) Exporting YOLO26 to ONNX Format

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


# 2) Setting Up Triton Model Repository

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

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

# 3) Running Triton Inference Server

# Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
tag = "nvcr.io/nvidia/tritonserver:26.02-py3"  # 16.17 GB (Compressed Size)

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

# GPU flags differ between Docker and Podman
gpu_flags = "--device nvidia.com/gpu=all" if runtime == "podman" else "--runtime=nvidia --gpus all"

container_name = "triton_server"

# Note: The :z flag on the volume mount is necessary for systems with SELinux (like Fedora/RHEL)
subprocess.call(
    f"{runtime} run -d --rm --name {container_name} {gpu_flags} -v {triton_repo_path.absolute()}:/models:z -p 8000:8000 {tag} tritonserver --model-repository=/models",
    shell=True,
)

# Wait for the Triton server to start
triton_client = InferenceServerClient(url="127.0.0.1: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)

Ejecutando la inferencia

Ejecute la inferencia utilizando el modelo del servidor Triton:

from ultralytics import YOLO

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

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

Limpie el contenedor (runtime y container_name se definen en el bloque de configuración anterior):

import subprocess

runtime = "docker"  # set to "podman" to use Podman
container_name = "triton_server"  # Kill the named container
subprocess.call(f"{runtime} kill {container_name}", 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 Ultralytics 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 aprendizaje profundo. 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:26.02-py3"

runtime = "docker"  # set to "podman" to use Podman
subprocess.call(f"{runtime} pull {tag}", shell=True)

# GPU flags differ between Docker and Podman
gpu_flags = "--device nvidia.com/gpu=all" if runtime == "podman" else "--runtime=nvidia --gpus all"

container_name = "triton_server"
subprocess.call(
    f"{runtime} run -d --rm --name {container_name} {gpu_flags} -v {triton_repo_path.absolute()}:/models:z -p 8000:8000 {tag} tritonserver --model-repository=/models",
    shell=True,
)

triton_client = InferenceServerClient(url="127.0.0.1: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 Ultralytics YOLO26 a escala en Triton Inference Server para 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 cómo configurar y ejecutar Ultralytics YOLO26 con Triton, consulte Configuración de Triton Inference Server y Ejecución de inferencia.

¿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://127.0.0.1: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.

¿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, Ultralytics 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: Ultralytics YOLO26 se integra perfectamente con Triton Inference Server y soporta diversos formatos de exportación (ONNX, TensorRT), lo que lo hace flexible para varios escenarios de despliegue.
  • Características avanzadas: Ultralytics 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 Ultralytics YOLO26 están diseñados pensando en el despliegue en el borde, 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 6 días
glenn-jocherY-T-GonuralpszrUltralyticsAssistantleonnil

Comentarios