Ir al contenido

Triton Servidor de inferencia con Ultralytics YOLO11

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 YOLO11 con Triton Inference Server 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.



Observa: Primeros pasos con NVIDIA Triton Inference Server.

¿Qué es Triton Inference Server?

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, incluidos TensorFlow, PyTorchONNX Runtime y muchos otros. Sus principales casos de uso son:

  • Servir varios modelos desde un único servidor
  • Carga y descarga dinámica de modelos sin reiniciar el servidor
  • Inferencia conjunta, que permite utilizar varios modelos a la vez para obtener resultados.
  • Versiones de modelos para pruebas A/B y actualizaciones continuas

Principales ventajas del servidor de inferencia Triton

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

  • Agrupación automática por lotes: agrupa varias solicitudes de IA antes de procesarlas, lo que reduce la latencia y mejora la velocidad de inferencia.
  • Integración con Kubernetes: El diseño nativo en la nube funciona a la perfección con Kubernetes para gestionar y escalar aplicaciones de IA.
  • Optimizaciones específicas del hardware: Aprovecha al máximo las GPU NVIDIA para obtener el máximo rendimiento.
  • Flexibilidad de marcos: Admite múltiples marcos de IA, incluidos TensorFlow, PyTorch, ONNX y TensorRT.
  • De código abierto y personalizable: Puede modificarse para adaptarse a necesidades específicas, lo que garantiza la flexibilidad para diversas aplicaciones de IA.

Requisitos previos

Asegúrese de que dispone de los siguientes requisitos previos antes de continuar:

  • Docker instalado en su máquina
  • Instale tritonclient: 
    pip install tritonclient[all]

Exportación de YOLO11 al formato ONNX

Antes de desplegar el modelo en Triton, debe exportarse al formato ONNX . ONNX (Open Neural Network Exchange) es un formato que permite transferir modelos entre diferentes marcos de aprendizaje profundo. Utilice el formato export de la función 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 Triton

El repositorio de modelos Triton es un lugar de almacenamiento en el que Triton puede acceder a los modelos y cargarlos.

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

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)

Ejecutar Triton Inference Server

Ejecute 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, 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")

Limpia 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 el servidor de inferencia Triton . TensorRT es un optimizador de aprendizaje profundo de alto rendimiento creado específicamente para las GPU NVIDIA que puede aumentar considerablemente la velocidad de inferencia.

Las principales ventajas de utilizar TensorRT con Triton incluyen:

  • Inferencia hasta 36 veces más rápida en comparación con modelos no optimizados.
  • Optimizaciones específicas del hardware para aprovechar al máximo la GPU .
  • Compatibilidad con formatos de precisión reducida (INT8, FP16) manteniendo la precisión
  • Fusión de capas para reducir la carga computacional

Para utilizar 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 más información sobre la optimización de TensorRT , consulte la guía de integración deTensorRT .

Siguiendo los pasos anteriores, puede 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 tiene algún problema o duda, consulte la documentación oficial de Triton o póngase en contacto con la comunidad de Ultralytics para obtener ayuda.

PREGUNTAS FRECUENTES

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

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

  1. Exporte 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. Configure Triton Model Repository:

    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. Ejecute 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 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?

La integración de 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 de 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.
  • Agrupación automática: Triton agrupa automáticamente varias solicitudes de inferencia, lo que mejora significativamente el rendimiento y reduce la latencia.
  • Despliegue simplificado: Optimización gradual de los flujos de trabajo de IA sin necesidad de revisar el sistema por completo, lo que facilita una ampliación eficaz.

Para obtener instrucciones detalladas sobre la configuración y el funcionamiento de YOLO11 con Triton, puede 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 modeloYOLO11 Ultralytics antes de implementarlo en el servidor de inferenciaNVIDIA Triton ofrece varias ventajas clave:

  • Interoperabilidad: el formato ONNX admite la transferencia entre diferentes 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 implantación: ONNX es ampliamente compatible con distintos marcos y plataformas, lo que simplifica el proceso de implantación en diversos sistemas operativos y configuraciones de hardware.
  • Independencia del framework: Una vez convertido a ONNX, su modelo deja de estar vinculado a su marco original, lo que lo hace más portátil.
  • Normalización: ONNX proporciona una representación estandarizada que ayuda a superar los problemas de compatibilidad entre diferentes marcos de IA.

Para exportar tu modelo, utiliza:

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 deONNX 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 el modelo está configurado en el repositorio de modelos Triton 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 permite aprovechar las optimizaciones de Triton mientras se utiliza la conocida interfazYOLO Ultralytics . Para obtener una guía detallada sobre la configuración y ejecución del servidor Triton con YOLO11, consulte la sección Ejecución del servidor de inferencia triton .

¿Cómo se comparan los modelos Ultralytics YOLO11 con TensorFlow y PyTorch para la implantación?

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

  • 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 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.
  • API simplificada: La API de Ultralytics proporciona una interfaz coherente en los distintos objetivos de implantación, lo que reduce la curva de aprendizaje y el tiempo de desarrollo.
  • Optimización de bordes: Los modelos YOLO11 se han diseñado pensando en la implantación en los bordes, por lo que ofrecen un rendimiento excelente incluso en dispositivos con recursos limitados.

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

Creado hace 1 año ✏️ Actualizado hace 8 días
glenn-jocher Y-T-G UltralíticoAsistente

Comentarios