Servidor de Inferência Triton com Ultralytics YOLO11

Q: How do I set up Ultralytics YOLO11 with NVIDIA Triton Inference Server?

Configurar o Ultralytics YOLO11 com o NVIDIA Triton Inference Server envolve algumas etapas principais: Esta configuração pode ajudá-lo a implementar modelos YOLO11 em escala de forma eficiente no Triton Inference Server para inferência de modelos de IA de alto desempenho.

Q: What benefits does using Ultralytics YOLO11 with NVIDIA Triton Inference Server offer?

A integração do Ultralytics YOLO11 com o NVIDIA Triton Inference Server oferece várias vantagens: Para obter instruções detalhadas sobre como configurar e executar o YOLO11 com o Triton, você pode consultar o guia de configuração.

O Triton Inference Server (anteriormente conhecido como TensorRT Inference Server) é uma solução de software de código aberto desenvolvida pela NVIDIA. Ele fornece uma solução de inferência em nuvem otimizada para GPUs NVIDIA. O Triton simplifica a implantação de modelos de IA em escala na produção. A integração do Ultralytics YOLO11 com o Triton Inference Server permite que você implemente cargas de trabalho de inferência de aprendizado profundo 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 Servidor de Inferência Triton foi projetado para implantar uma variedade de modelos de IA em produção. Ele suporta uma ampla gama de estruturas de aprendizado profundo e aprendizado de máquina, incluindo TensorFlow, PyTorch, ONNX Runtime 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

Usar o Triton Inference Server com Ultralytics YOLO11 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 TensorFlow, PyTorch, ONNX 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 instalado em sua máquina
Instalar tritonclient:
```
pip install tritonclient[all]
```

Exportando YOLO11 para o Formato ONNX

Antes de implantar o modelo no Triton, ele deve ser exportado para o formato ONNX. ONNX (Open Neural Network Exchange) é um formato que permite que os modelos sejam transferidos entre diferentes frameworks de deep learning. Use o export função do YOLO classe:

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)

Configurando o Repositório de Modelos Triton

O Triton Model Repository é um local de armazenamento onde o Triton pode acessar e carregar modelos.

Criar a estrutura de diretórios necessária:

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)

Mova o modelo ONNX exportado para o repositório 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)

Executando o Servidor de Inferência Triton

Execute o Servidor de Inferência Triton usando o 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)

Em seguida, execute a inferência usando o modelo do 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")

Limpar o contêiner:

# Kill and remove the container at the end of the test
subprocess.call(f"docker kill {container_id}", 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 o TensorRT com o 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 YOLO11 para o 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 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 YOLO11 de forma eficiente 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 algum problema ou tiver mais dúvidas, consulte a documentação oficial do Triton ou entre em contato com a comunidade Ultralytics para obter suporte.

FAQ

Como configurar o Ultralytics YOLO11 com o NVIDIA Triton Inference Server?

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

Exportar YOLO11 para o 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)

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

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: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 configuração pode ajudá-lo a implantar de forma eficiente modelos YOLO11 em escala no Triton Inference Server para inferência de modelo de IA de alto desempenho.

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

Integrar o Ultralytics YOLO11 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 obter instruções detalhadas sobre como configurar e executar o YOLO11 com Triton, você pode consultar o guia de configuração.

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

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

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("yolo11n.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 a inferência usando o modelo Ultralytics YOLO11 no Triton Inference Server?

Sim, você pode executar a inferência usando o modelo Ultralytics YOLO11 no NVIDIA Triton Inference Server. Depois que o seu modelo estiver configurado no Triton Model Repository e o servidor estiver em execução, você pode carregar e executar a inferência no seu modelo da seguinte forma:

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

Esta abordagem permite que você aproveite as otimizações do Triton enquanto usa a interface familiar do Ultralytics YOLO. Para um guia detalhado sobre como configurar e executar o Triton Server com YOLO11, consulte a seção executando o servidor de inferência Triton.

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

Ultralytics YOLO11 oferece várias vantagens exclusivas em comparação com os modelos TensorFlow e PyTorch para implementação:

Desempenho em Tempo Real: Otimizado para tarefas de deteção de objetos em tempo real, o YOLO11 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: O YOLO11 integra-se perfeitamente com o Triton Inference Server e suporta diversos formatos de exportação (ONNX, TensorRT, CoreML), tornando-o flexível para vários cenários de implantação.
Recursos Avançados: YOLO11 inclui recursos como carregamento dinâmico de modelos, versionamento de modelos e inferência de conjunto, que são cruciais para implementaçõ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 Edge: Os modelos YOLO11 são projetados com a implantação de edge 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á 1 ano ✏️ Atualizado há 3 meses