Salta para o conteúdo

Triton Servidor de inferência com Ultralytics YOLO11

O Triton Inference Server (anteriormente conhecido como TensorRT Inference Server) é uma solução de software de código aberto desenvolvida pela NVIDIA. Fornece uma solução de inferência na nuvem optimizada para NVIDIA GPUs. Triton simplifica a implementação de modelos de IA em escala na produção. A integração do Ultralytics YOLO11 com o Triton Inference Server permite-te implementar cargas de trabalho de inferência de aprendizagem profunda escaláveis e de elevado desempenho. Este guia fornece etapas para configurar e testar a integração.



Observa: Introdução ao NVIDIA Triton Inference Server.

O que é o Triton Inference Server?

Triton O Servidor de Inferência foi concebido para implementar uma variedade de modelos de IA na produção. Suporta uma vasta gama de estruturas de aprendizagem profunda e de aprendizagem automática, incluindo TensorFlow, PyTorchONNX Runtime, e muitos outros. Os seus principais casos de utilização são:

  • Serve vários modelos a partir de uma única instância de servidor.
  • Carrega e descarrega modelos dinâmicos sem reiniciar o servidor.
  • Inferência de conjunto, que permite a utilização de vários modelos em conjunto para obter resultados.
  • Modelo de versões para testes A/B e actualizações contínuas.

Pré-requisitos

Certifica-te de que tens os seguintes pré-requisitos antes de prosseguires:

  • Docker instalado na tua máquina.
  • Instala tritonclient: 
    pip install tritonclient[all]

Exportação de YOLO11 para o formato ONNX

Antes de implementares o modelo em Triton, tens de o exportar para o formato ONNX . ONNX (Open Neural Network Exchange) é um formato que permite a transferência de modelos entre diferentes estruturas de aprendizagem profunda. Utiliza o formato export da função YOLO classe:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n.pt")  # load an official model

# Export the model
onnx_file = model.export(format="onnx", dynamic=True)

Configura o repositório de modelos Triton

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

  1. Cria a estrutura de directó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)

  2. Move 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()

# (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"
      }
    }
  }
}
"""

with open(triton_model_path / "config.pbtxt", "w") as f:
    f.write(data)

Executa Triton Servidor de Inferência

Executa o servidor de inferência Triton utilizando 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, executa a inferência utilizando o modelo do servidor Triton :

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

Limpa o contentor:

# Kill and remove the container at the end of the test
subprocess.call(f"docker kill {container_id}", shell=True)

Seguindo as etapas acima, é possível implantar e executar Ultralytics modelos YOLO11 com eficiência em Triton Servidor de inferência, fornecendo uma solução escalonável e de alto desempenho para tarefas de inferência de aprendizado profundo. Se tiveres algum problema ou outras dúvidas, consulta a documentação oficial Triton ou entra em contacto com a comunidade Ultralytics para obteres apoio.

FAQ

Como é que configuro Ultralytics YOLO11 com NVIDIA Triton Inference Server?

A configuração do Ultralytics YOLO11 com o NVIDIA Triton Inference Server envolve alguns passos importantes:

  1. Exporta o 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)

  2. Configura o 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. Executa 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 ajudar-te a implementar eficientemente modelos YOLO11 em escala no Triton Inference Server para inferência de modelos de IA de elevado desempenho.

Que vantagens oferece a utilização de Ultralytics YOLO11 com NVIDIA Triton Inference Server?

A integração do Ultralytics YOLO11 com o NVIDIA Triton Inference Server oferece várias vantagens:

  • Inferência de IA escalável: 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: Optimizado para NVIDIA GPUs, o Triton Inference Server garante operações de inferência de alta velocidade, perfeitas para aplicações em tempo real, como a deteção de objectos.
  • Ensemble e versionamento de modelos: O modo ensemble do Triton permite combinar vários modelos para melhorar os resultados e o versionamento de modelos suporta testes A/B e actualizações contínuas.

Para obter instruções detalhadas sobre como configurar e executar o YOLO11 com Triton, podes consultar o guia de configuração.

Porque é que devo exportar o meu modelo YOLO11 para o formato ONNX antes de utilizar o Servidor de Inferência Triton ?

A utilização do formato ONNX (Open Neural Network Exchange) para o teu modelo Ultralytics YOLO11 antes de o implantares no NVIDIA Triton Inference Server oferece várias vantagens importantes:

  • Interoperabilidade: o formato ONNX suporta a transferência entre diferentes quadros de aprendizagem profunda (como PyTorch, TensorFlow), assegurando uma maior compatibilidade.
  • Otimização: Muitos ambientes de implementação, incluindo Triton, optimizam para ONNX, permitindo uma inferência mais rápida e um melhor desempenho.
  • Facilidade de implementação: ONNX é amplamente suportado em estruturas e plataformas, simplificando o processo de implementação em vários sistemas operativos e configurações de hardware.

Para exportar o teu modelo, utiliza:

from ultralytics import YOLO

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

Podes seguir os passos do guia de exportação para concluir o processo.

Posso efetuar a inferência utilizando o modelo Ultralytics YOLO11 no servidor de inferência Triton ?

Sim, podes executar a inferência utilizando o modelo Ultralytics YOLO11 em NVIDIA Triton Servidor de Inferência. Quando o teu modelo estiver configurado no Repositório de Modelos Triton e o servidor estiver a funcionar, podes carregar e executar a inferência no teu 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")

Para obter um guia detalhado sobre a configuração e execução do servidor Triton com o YOLO11, consulta a secção sobre a execução do servidor de inferência triton .

Como é que o Ultralytics YOLO11 se compara aos modelos TensorFlow e PyTorch modelos de implantação?

Ultralytics O YOLO11 oferece várias vantagens únicas em comparação com os modelos TensorFlow e PyTorch para implantação:

  • Desempenho em tempo real: Optimizado para tarefas de deteção de objectos em tempo real, o YOLO11 fornece precisão e velocidade de ponta, tornando-o ideal para aplicações que requerem análise de vídeo em direto.
  • Facilidade de utilização: 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 implementação.
  • Funcionalidades avançadas: O YOLO11 inclui funcionalidades como o carregamento dinâmico de modelos, a versão de modelos e a inferência de conjuntos, que são cruciais para implementações de IA escaláveis e fiáveis.

Para mais detalhes, compara as opções de implantação no guia de implantação do modelo.

📅 C riado há 1 ano ✏️ Atualizado há 20 dias
Y-T-G UltralyticsAssistant glenn-jocher

Comentários