Ir para o conteúdo

Triton Inference Server com Ultralytics YOLO26

O Triton Inference Server (anteriormente conhecido como TensorRT Inference Server) é uma solução de software de código aberto desenvolvida pela NVIDIA. Ele oferece uma solução de inferência em nuvem otimizada para GPUs NVIDIA. O Triton simplifica a implementação de modelos de IA em escala na produção. A integração do Ultralytics YOLO26 com o Triton Inference Server permite implementar cargas de trabalho de inferência de deep learning escaláveis e de alto desempenho. Este guia fornece os passos para configurar e testar a integração.



Assista: Começando com o Servidor de Inferência NVIDIA Triton.

O que é o Triton Inference Server?

O Triton Inference Server foi projetado para implantar uma variedade de modelos de IA em produção. Ele suporta uma ampla gama de frameworks de deep learning e machine learning, incluindo PyTorch, TensorFlow, ONNX, OpenVINO, TensorRT e muitos outros. Seus principais casos de uso são:

  • Servindo vários modelos a partir de uma única instância de servidor
  • Carregamento e descarregamento dinâmico de modelos sem reiniciar o servidor
  • Inferência de ensemble, permitindo que vários modelos sejam usados juntos para alcançar resultados
  • Versionamento de modelos para testes A/B e atualizações contínuas

Principais Benefícios do Triton Inference Server

Utilizar o Triton Inference Server com Ultralytics YOLO26 oferece várias vantagens:

  • Loteamento automático: Agrupa várias solicitações de IA antes de processá-las, reduzindo a latência e melhorando a velocidade de inferência
  • Integração com Kubernetes: O design nativo da nuvem funciona perfeitamente com o Kubernetes para gerir e escalar aplicações de IA
  • Otimizações específicas de hardware: Aproveita ao máximo as GPUs NVIDIA para obter o máximo desempenho
  • Flexibilidade de Framework: Suporta múltiplos frameworks de IA, incluindo PyTorch, TensorFlow, ONNX, OpenVINO e TensorRT
  • Código aberto e personalizável: Pode ser modificado para se adequar a necessidades específicas, garantindo flexibilidade para várias aplicações de IA.

Pré-requisitos

Certifique-se de que tem os seguintes pré-requisitos antes de prosseguir:

  • Docker ou Podman instalados na sua máquina
  • Instalar ultralytics: 
    pip install ultralytics
  • Instalar tritonclient: 
    pip install tritonclient[all]

Configurando o Servidor de Inferência Triton

Execute este bloco de configuração completo para exportar Ultralytics YOLO26 para ONNX, construir o repositório de modelos Triton e iniciar o Triton Inference Server:

Nota

Use o comando runtime altere no script para escolher seu motor de contêiner:

  • Definir runtime = "docker" para Docker
  • Definir 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)

Executando a Inferência

Executar inferência usando o modelo do Triton Server:

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

Limpar o contêiner (runtime e container_name são definidos no bloco de configuração acima):

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)

Otimização TensorRT (Opcional)

Para um desempenho ainda maior, você pode usar TensorRT com o Triton Inference Server. TensorRT é um otimizador de aprendizado profundo de alto desempenho construído especificamente para GPUs NVIDIA que pode aumentar significativamente a velocidade de inferência.

Os principais benefícios de usar TensorRT com Triton incluem:

  • Inferência até 36x mais rápida em comparação com modelos não otimizados
  • Otimizações específicas de hardware para máxima utilização da GPU
  • Suporte para formatos de precisão reduzida (INT8, FP16) mantendo a precisão
  • Fusão de camadas para reduzir a sobrecarga computacional

Para usar o TensorRT diretamente, você pode exportar seu modelo Ultralytics YOLO26 para o 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 obter mais informações sobre a otimização do TensorRT, consulte o guia de integração do TensorRT.

Ao seguir os passos acima, você pode implantar e executar modelos Ultralytics YOLO26 eficientemente no Triton Inference Server, fornecendo uma solução escalável e de alto desempenho para tarefas de inferência de deep learning. Se você enfrentar quaisquer problemas ou tiver mais perguntas, consulte a documentação oficial do Triton ou entre em contato com a comunidade Ultralytics para obter suporte.

FAQ

Como configuro o Ultralytics YOLO26 com o NVIDIA Triton Inference Server?

A configuração de Ultralytics YOLO26 com NVIDIA Triton Inference Server envolve algumas etapas principais:

  1. Exportar YOLO26 para o 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 o Repositório de Modelos 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. Executar o 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 configuração pode ajudar a implantar eficientemente modelos Ultralytics YOLO26 em escala no Triton Inference Server para inferência de modelos de IA de alto desempenho.

Quais benefícios o uso do Ultralytics YOLO26 com o NVIDIA Triton Inference Server oferece?

A integração de Ultralytics YOLO26 com o NVIDIA Triton Inference Server oferece diversas vantagens:

  • Inferência de IA Escalável: O Triton permite servir vários modelos a partir de uma única instância de servidor, suportando o carregamento e descarregamento dinâmico de modelos, tornando-o altamente escalável para diversas cargas de trabalho de IA.
  • Alto Desempenho: Otimizado para GPUs NVIDIA, o Triton Inference Server garante operações de inferência de alta velocidade, perfeito para aplicações em tempo real, como detecção de objetos.
  • Ensemble e Versionamento de Modelo: O modo ensemble do Triton permite combinar vários modelos para melhorar os resultados, e seu versionamento de modelo oferece suporte a testes A/B e atualizações contínuas.
  • Loteamento Automático: O Triton agrupa automaticamente várias solicitações de inferência, melhorando significativamente a taxa de transferência e reduzindo a latência.
  • Implementação Simplificada: Otimização gradual dos fluxos de trabalho de IA sem exigir revisões completas do sistema, facilitando o escalonamento eficiente.

Para instruções detalhadas sobre como configurar e executar o Ultralytics YOLO26 com Triton, consulte Configurando o Servidor de Inferência Triton e Executando Inferência.

Por que devo exportar meu modelo YOLO26 para o formato ONNX antes de usar o Triton Inference Server?

Utilizar o formato ONNX (Open Neural Network Exchange) para o seu modelo Ultralytics YOLO26 antes de implantá-lo no NVIDIA Triton Inference Server oferece vários benefícios chave:

  • Interoperabilidade: O formato ONNX oferece suporte à transferência entre diferentes frameworks de deep learning (como PyTorch, TensorFlow), garantindo uma compatibilidade mais ampla.
  • Otimização: Muitos ambientes de implantação, incluindo o Triton, otimizam para ONNX, permitindo uma inferência mais rápida e melhor desempenho.
  • Facilidade de Implantação: O ONNX é amplamente suportado em frameworks e plataformas, simplificando o processo de implantação em vários sistemas operacionais e configurações de hardware.
  • Independência de Framework: Uma vez convertido para ONNX, seu modelo não está mais vinculado ao seu framework original, tornando-o mais portátil.
  • Padronização: ONNX fornece uma representação padronizada que ajuda a superar problemas de compatibilidade entre diferentes frameworks de IA.

Para exportar o seu modelo, use:

from ultralytics import YOLO

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

Você pode seguir os passos no guia de integração ONNX para completar o processo.

Posso executar inferência usando o modelo Ultralytics YOLO26 no Triton Inference Server?

Sim, você pode executar inferência usando o modelo Ultralytics YOLO26 no NVIDIA Triton Inference Server. Uma vez que seu modelo esteja configurado no Repositório de Modelos do Triton e o servidor esteja em execução, você pode carregar e executar inferência em seu modelo da seguinte forma:

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

Esta abordagem permite aproveitar as otimizações do Triton enquanto utiliza a interface familiar do Ultralytics YOLO.

Como o Ultralytics YOLO26 se compara aos modelos TensorFlow e PyTorch para implantação?

Ultralytics YOLO26 oferece diversas vantagens únicas em comparação com os modelos TensorFlow e PyTorch para implantação:

  • Desempenho em Tempo Real: Otimizado para tarefas de deteção de objetos em tempo real, o Ultralytics YOLO26 oferece precisão e velocidade de ponta, tornando-o ideal para aplicações que exigem análise de vídeo ao vivo.
  • Facilidade de Uso: Ultralytics YOLO26 integra-se perfeitamente com o Triton Inference Server e suporta diversos formatos de exportação (ONNX, TensorRT), tornando-o flexível para vários cenários de implementação.
  • Recursos Avançados: Ultralytics YOLO26 inclui recursos como carregamento dinâmico de modelos, versionamento de modelos e inferência de ensemble, que são cruciais para implantações de IA escaláveis e confiáveis.
  • API Simplificada: A API Ultralytics fornece uma interface consistente entre diferentes alvos de implementação, reduzindo a curva de aprendizado e o tempo de desenvolvimento.
  • Otimização de Borda: Os modelos Ultralytics YOLO26 são projetados com a implantação em borda em mente, oferecendo excelente desempenho mesmo em dispositivos com recursos limitados.

Para obter mais detalhes, compare as opções de implantação no guia de exportação de modelos.



📅 Criado há 2 anos ✏️ Atualizado há 5 dias
glenn-jocherY-T-GonuralpszrUltralyticsAssistantleonnil

Comentários