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.
  • Versionado de modelos para pruebas A/B y actualizaciones continuas.

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

# Retreive metadata during export
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()

# (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"
      }
    }
  }
}
parameters {
  key: "metadata"
  value: {
    string_value: "%s"
  }
}
""" % metadata[0]

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)

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 ofrece 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.

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?

El uso del formato ONNX (Open Neural Network Exchange) para su Ultralytics YOLO11 modelo antes de desplegarlo 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 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.

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铆, puede ejecutar la inferencia utilizando el Ultralytics YOLO11 en NVIDIA Triton Servidor de Inferencia. Una vez que su modelo est谩 configurado en el Repositorio de Modelos Triton y el servidor est谩 funcionando, puede cargar y ejecutar la 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")

Para obtener una gu铆a detallada sobre la configuraci贸n y el funcionamiento de Triton Server con YOLO11, consulte la secci贸n sobre el funcionamiento de triton inference server.

驴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 de implantaci贸n TensorFlow y PyTorch :

  • 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.

Para m谩s detalles, compare las opciones de despliegue en la gu铆a de despliegue del modelo.

Creado hace 1 a帽o 鉁忥笍 Actualizado hace 5 d铆as
Y-T-G Ultral铆ticoAsistente glenn-jocher

Comentarios