Triton Servidor de inferência com Ultralytics YOLO11

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

A configuração de Ultralytics YOLO11 com NVIDIA Triton Servidor de Inferência envolve algumas etapas importantes: Esta configuração pode ajudá-lo a implementar eficientemente modelos YOLO11 em escala no Servidor de Inferência Triton 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 de Ultralytics YOLO11 com NVIDIA Triton Servidor de Inferência oferece várias vantagens: Para obter instruções pormenorizadas sobre como configurar e executar YOLO11 com Triton, 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 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 de modelos dinâmicos sem reiniciar o servidor
Inferência de conjunto, permitindo que vários modelos sejam utilizados em conjunto para obter resultados
Controlo de versões de modelos para testes A/B e actualizações contínuas

Principais vantagens do Servidor de Inferência Triton

A utilização do servidor de inferência Triton com o Ultralytics YOLO11 oferece várias vantagens:

Agrupamento automático: agrupa vários pedidos de IA antes de os processar, reduzindo a latência e melhorando a velocidade de inferência
Integração de Kubernetes: O design nativo da nuvem funciona perfeitamente com o Kubernetes para gerenciar e dimensionar aplicativos de IA
Otimizações específicas de hardware: Tira o máximo proveito das GPUs NVIDIA para obter o máximo desempenho
Flexibilidade da estrutura: Suporta várias estruturas de IA, incluindo TensorFlow, PyTorch, ONNX e TensorRT
Código aberto e personalizável: Pode ser modificado para se adaptar 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 no seu computador
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

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

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.

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)

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)

Otimização TensorRT (opcional)

Para um desempenho ainda melhor, pode utilizar o TensorRT com o Servidor de Inferência Triton . TensorRT é um optimizador de aprendizagem profunda de alto desempenho criado especificamente para GPUs NVIDIA que pode aumentar significativamente a velocidade de inferência.

As principais vantagens da utilização do TensorRT com o Triton incluem:

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

Para utilizar diretamente o TensorRT , pode exportar o 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 mais informações sobre a otimização TensorRT , consulte o guia de integraçãoTensorRT .

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:

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

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 do Ultralytics YOLO11 com o Servidor de InferênciaNVIDIA Triton 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.
Agrupamento automático: Triton agrupa automaticamente vários pedidos de inferência, melhorando significativamente o rendimento 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 dimensionamento eficiente.

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 ?

A utilização do formato ONNX (Open Neural Network Exchange) para o seu modelo Ultralytics YOLO11 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.
Independência da estrutura: Uma vez convertido para ONNX, o seu modelo deixa de estar ligado à sua estrutura original, tornando-o mais portátil.
Normalização: ONNX fornece uma representação normalizada que ajuda a ultrapassar os problemas de compatibilidade entre diferentes estruturas de IA.

Para exportar o seu modelo, utilize:

from ultralytics import YOLO

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

Pode seguir as etapas do guia de integraçãoONNX para concluir o processo.

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

Sim, é possível executar a inferência usando o modelo Ultralytics YOLO11 no Servidor de InferênciaNVIDIA Triton . Depois que o modelo estiver configurado no Repositório de modelos Triton e o servidor estiver em execução, é possível 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")

Esta abordagem permite-lhe tirar partido das optimizações do Triton enquanto utiliza a interface familiar Ultralytics YOLO . Para obter um guia detalhado sobre a configuração e execução do servidor Triton com o YOLO11, consulte a secção Executar o servidor de inferência triton .

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

Ultralytics YOLO11 oferece várias vantagens exclusivas em comparação com o 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: 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.
API simplificada: A API Ultralytics fornece uma interface consistente em diferentes alvos de implantação, reduzindo a curva de aprendizado e o tempo de desenvolvimento.
Otimização de borda: Os modelos YOLO11 foram concebidos tendo em mente a implementação no edge, oferecendo um excelente desempenho mesmo em dispositivos com recursos limitados.

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

📅C riado há 1 ano ✏️ Atualizado há 8 dias