Saltar 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. Ele fornece uma solução de inferência em nuvem otimizada para NVIDIA GPUs. Triton simplifica a implantação de modelos de IA em escala na produção. A integração do Ultralytics YOLO11 com o Servidor de Inferência Triton permite-lhe 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.



Ver: 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:

  • Servir 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 conjunto, que permite a utilização conjunta de vários modelos para obter resultados.
  • Modelo de controlo de versões para testes A/B e actualizações contínuas.

Pré-requisitos

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

  • Docker instalado na sua máquina.
  • Instalar tritonclient: 
    pip install tritonclient[all]

Exportar YOLO11 para o formato ONNX

Antes de implementar o modelo em Triton, este deve ser exportado para o formato ONNX . ONNX (Open Neural Network Exchange) é um formato que permite a transferência de modelos entre diferentes estruturas de aprendizagem profunda. Utilize o formato export da função YOLO classe:

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)

Configuração do repositório de modelos Triton

O Repositório de Modelos Triton é um local de armazenamento onde Triton pode aceder e carregar modelos.

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

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

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

Executar Triton Servidor de Inferência

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

Limpar 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, você pode implantar e executar Ultralytics YOLO11 modelos com eficiência no Triton Servidor de inferência, fornecendo uma solução escalonável e de alto desempenho para tarefas de inferência de aprendizado profundo. Se tiver problemas ou outras dúvidas, consulte a documentação oficial Triton ou entre em contacto com a comunidade Ultralytics para obter suporte.

FAQ

Como é que configuro Ultralytics YOLO11 com NVIDIA Triton Servidor de Inferência?

A configuração do Ultralytics YOLO11 com NVIDIA Triton O Servidor de Inferência envolve alguns passos importantes:

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

  2. Configurar 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. Execute 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 implementar eficazmente 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 Ultralytics YOLO11 com NVIDIA Triton O Servidor de Inferência 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 YOLO11 com Triton, pode 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 ?

Utilizar o formato ONNX (Open Neural Network Exchange) para o seu modelo Ultralytics YOLO11 modelo antes de o implementar 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), garantindo uma compatibilidade mais alargada.
  • 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 seu modelo, utilize:

from ultralytics import YOLO

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

Pode 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, pode executar a inferência utilizando o modelo Ultralytics YOLO11 modelo em NVIDIA Triton Servidor de inferência. Quando o modelo estiver configurado no Repositório de modelos Triton e o servidor estiver a funcionar, pode carregar e executar a inferência no 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 pormenorizado sobre a configuração e execução do servidor Triton com YOLO11, consulte a secção sobre a execução do servidor de inferência triton .

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

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

  • 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: YOLO11 integra-se perfeitamente com 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: YOLO11 inclui funcionalidades como o carregamento dinâmico de modelos, o controlo de versões 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, compare as opções de implantação no guia de implantação do modelo.

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

Comentários