Como exibir previsões com o NVIDIA Triton

Nesta página, descrevemos como exibir solicitações de previsão com o servidor de inferência NVIDIA Triton usando a Vertex AI Prediction. O servidor de inferência NVIDIA Triton (Triton) é uma solução de exibição de inferência de código aberto da NVIDIA otimizada para CPUs e GPUs e simplifica o processo de exibição de inferências.

NVIDIA Triton na Vertex AI Prediction

A Vertex AI Prediction é compatível com a implantação de modelos no servidor de inferência Triton em execução em um contêiner personalizado publicado pelo NVIDIA GPU Cloud (NGC): Imagem do servidor de inferência NVIDIA Triton. As imagens do Triton da NVIDIA têm todos os pacotes e configurações necessários que atendem aos requisitos da Vertex AI para imagens de contêiner de exibição personalizadas. A imagem contém o servidor de inferência Triton compatível com os modelos do TensorFlow, PyTorch, TensorRT, ONNX e OpenVINO. A imagem também inclui o back-end FIL (Forest Inference Library) que é compatível com a execução de frameworks de ML, como XGBoost, LightGBM e Scikit-Learn.

O Triton carrega os modelos e expõe os endpoints REST de gerenciamento de inferência, integridade e modelos que usam protocolos de inferência padrão. Ao implantar um modelo na Vertex AI, o Triton reconhece ambientes da Vertex AI e adota o protocolo da Vertex AI Prediction para verificações de integridade e solicitações de previsão.

A lista a seguir descreve os principais recursos e casos de uso do servidor de inferência NVIDIA Triton:

  • Compatibilidade com vários frameworks de aprendizado profundo e machine learning: o Triton é compatível com a implantação de vários modelos e uma combinação de frameworks e formatos de modelos: TensorFlow (SavedModel e GraphDef), PyTorch (TorchScript), TensorRT, ONNX, OpenVINO e back-ends FIL para oferecer compatibilidade com frameworks como XGBoost, LightGBM, Scikit-Learn e qualquer formato de modelo personalizado Python ou C++.
  • Execução simultânea de vários modelos: o Triton permite que vários modelos, várias instâncias do mesmo modelo ou ambos sejam executados simultaneamente no mesmo recurso de computação com zero ou mais GPUs.
  • Ensemble de modelos (cadeia ou pipeline): o ensemble do Triton é compatível com casos de uso em que vários modelos são compostos como um pipeline (ou um DAG, gráfico acíclico dirigido) com entradas e tensores de saída conectados entre eles. Além disso, com um back-end em Python do Triton, é possível incluir qualquer lógica de pré-processamento, pós-processamento ou fluxo de controle definida pelo script de lógica de negócios (BLS, na sigla em inglês).
  • Execução em back-ends de CPU e GPU: o Triton é compatível com inferências para modelos implantados em nós com CPUs e GPUs.
  • Agrupamento em lote dinâmico de solicitações de previsão: para modelos compatíveis com agrupamento em lote, o Triton tem algoritmos integrados de programação e agrupamento em lote. Esses algoritmos combinam dinamicamente solicitações de inferência individuais em lotes do lado do servidor para melhorar a capacidade de processamento de inferência e aumentar a utilização da GPU.

Para mais informações sobre o servidor de inferência NVIDIA Triton, consulte a documentação do Triton.

Imagens de contêiner NVIDIA Triton disponíveis

A tabela a seguir mostra as imagens do Docker do Triton disponíveis no Catálogo do NVIDIA NGC. Escolha uma imagem com base no framework do modelo, no back-end e no tamanho da imagem do contêiner que você usa.

xx e yy referem-se às versões principais e secundárias do Triton, respectivamente.

Imagem do NVIDIA Triton Suportes
xx.yy-py3 Contêiner completo compatível com modelos do TensorFlow, PyTorch, TensorRT, ONNX e OpenVINO
xx.yy-pyt-python-py3 Somente back-ends PyTorch e Python
xx.yy-tf2-python-py3 Somente back-ends TensorFlow 2.x e Python
xx.yy-py3-min Personalizar o contêiner do Triton conforme necessário

Primeiros passos: como exibir previsões com o NVIDIA Triton

A figura a seguir mostra a arquitetura de alto nível do Triton na Vertex AI Prediction:

triton-on-vertex-ai-prediction

  • Um modelo de ML a ser exibido pelo Triton é registrado no Vertex AI Model Registry. Os metadados do modelo referencia um local dos artefatos do modelo no Cloud Storage, o contêiner de exibição personalizado e a respectiva configuração.
  • O modelo do Vertex AI Model Registry é implantado em um endpoint da Vertex AI Prediction que executa o servidor de inferência Triton como um contêiner personalizado em nós de computação com CPU e GPU.
  • As solicitações de inferência chegam ao servidor de inferência Triton por meio de um endpoint da Vertex AI Prediction e roteadas para o programador apropriado.
  • O back-end realiza inferências usando as entradas provisionadas nas solicitações em lote e retorna uma resposta.
  • O Triton fornece endpoints de integridade de prontidão e atividade, que permitem a integração do Triton em ambientes de implantação, como a Vertex AI Prediction.

Neste tutorial, mostramos como usar um contêiner personalizado que executa o servidor de inferência NVIDIA Triton para implantar um modelo de machine learning (ML) na Vertex AI Prediction, que exibe previsões on-line. Implante um contêiner que esteja executando o Triton para exibir previsões de um modelo de detecção de objetos do TensorFlow Hub que foi pré-treinado no Conjunto de dados COCO 2017. É possível usar a Vertex AI Prediction para detectar objetos em uma imagem.

É possível também executar o tutorial no Vertex AI Workbench seguindo este Jupyter Notebook.

Antes de começar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Vertex AI API and Artifact Registry API APIs.

    Enable the APIs

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Vertex AI API and Artifact Registry API APIs.

    Enable the APIs

    8.

  8. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Neste tutorial, recomendamos que você use o Cloud Shell para interagir com o Google Cloud. Se você quiser usar um shell Bash diferente em vez do Cloud Shell, execute a seguinte configuração extra:

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command: 

    gcloud init
  3. Siga a documentação do Artifact Registry para instalar o Docker.

Crie e envie a imagem do contêiner

Para usar um contêiner personalizado, especifique uma imagem de contêiner do Docker que atenda aos requisitos de contêiner personalizado. Nesta seção, descrevemos como criar a imagem do contêiner e enviá-la para o Artifact Registry.

Faça o download dos artefatos de modelo

Os artefatos de modelo são arquivos criados pelo treinamento de ML que podem ser usados para exibir previsões. Eles contêm, no mínimo, a estrutura e os pesos do seu modelo de ML treinado. O formato dos artefatos de modelo depende do framework de ML usado para treinamento.

Para este tutorial, em vez de treinar um modelo do zero, faça o download do modelo de detecção de objetos do TensorFlow Hub que foi treinado no conjunto de dados COCO 2017. O Triton espera que o repositório de modelos seja organizado na seguinte estrutura para exibir o formato SavedModel do TensorFlow:

└── model-repository-path
       └── model_name
              ├── config.pbtxt
              └── 1
                  └── model.savedmodel
                        └── <saved-model-files>

O arquivo config.pbtxt descreve a configuração do modelo. Por padrão, o arquivo de configuração do modelo que contém as configurações necessárias precisa ser provisionado. No entanto, se o Triton for iniciado com a opção --strict-model-config=false, em alguns casos, a configuração do modelo poderá ser gerada automaticamente pelo Triton e não precisará ser provisionada explicitamente. Especificamente, os modelos TensorRT, TensorFlow SavedModel e ONNX não exigem um arquivo de configuração de modelo porque o Triton pode derivar todas as configurações necessárias automaticamente. Todos os outros tipos de modelo precisam provisionar um arquivo de configuração.

# Download and organize model artifacts according to the Triton model repository spec
mkdir -p models/object_detector/1/model.savedmodel/
curl -L "https://tfhub.dev/tensorflow/faster_rcnn/resnet101_v1_640x640/1?tf-hub-format=compressed" | \
    tar -zxvC ./models/object_detector/1/model.savedmodel/
ls -ltr ./models/object_detector/1/model.savedmodel/

Depois de fazer o download do modelo localmente, o repositório de modelos será organizado da seguinte maneira:

./models
└── object_detector
    └── 1
        └── model.savedmodel
            ├── saved_model.pb
            └── variables
                ├── variables.data-00000-of-00001
                └── variables.index

Copiar artefatos do modelo para um bucket do Cloud Storage

Os artefatos do modelo transferidos por download, incluindo o arquivo de configuração do modelo, são enviados para um bucket do Cloud Storage especificado por MODEL_ARTIFACTS_REPOSITORY, que pode ser usado ao criar o recurso de modelo da Vertex AI.

gcloud storage cp ./models/object_detector MODEL_ARTIFACTS_REPOSITORY/ --recursive

Crie um repositório do Artifact Registry

Crie um repositório do Artifact Registry para armazenar a imagem do contêiner que você criará na próxima seção.

Ative o serviço da API Artifact Registry para o projeto.

gcloud services enable artifactregistry.googleapis.com

Execute o seguinte comando no shell para criar o repositório do Artifact Registry:

gcloud artifacts repositories create getting-started-nvidia-triton \
    --repository-format=docker \
    --location=LOCATION_ID \
    --description="NVIDIA Triton Docker repository"

Substitua LOCATION_ID pela região em que o Artifact Registry armazena a imagem do contêiner. Mais tarde, será preciso criar um recurso de modelo da Vertex AI em um endpoint regional que corresponda a essa região. Portanto, escolha uma região em que a Vertex AI tenha um endpoint regional: como us-central1.

Depois de concluir a operação, o comando imprime a seguinte saída:

Created repository [getting-started-nvidia-triton].

Crie a imagem do contêiner

A NVIDIA fornece imagens do Docker para criar uma imagem de contêiner que está executando o Triton e está alinhada aos requisitos de contêiner personalizado da Vertex AI para exibição. É possível receber a imagem usando docker e marcar com tag o caminho do Artifact Registry para onde a imagem será enviada.

NGC_TRITON_IMAGE_URI="nvcr.io/nvidia/tritonserver:22.01-py3"
docker pull $NGC_TRITON_IMAGE_URI
docker tag $NGC_TRITON_IMAGE_URI LOCATION_ID-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference

Substitua:

  • LOCATION_ID: a região do repositório do Artifact Registry, conforme especificado em uma seção anterior.
  • PROJECT_ID: o ID do seu projeto do Google Cloud.

O comando pode ser executado por vários minutos.

Preparar o arquivo de payload para testar solicitações de previsão

Para enviar uma solicitação de previsão ao servidor do contêiner, prepare o payload com um arquivo de imagem de amostra que usa o Python. Execute o seguinte script Python para gerar o arquivo de payload:

import json
import requests

# install required packages before running
# pip install pillow numpy --upgrade
from PIL import Image
import numpy as np

# method to generate payload from image url
def generate_payload(image_url):
    # download image from url and resize
    image_inputs = Image.open(requests.get(image_url, stream=True).raw)
    image_inputs = image_inputs.resize((200, 200))

    # convert image to numpy array
    image_tensor = np.asarray(image_inputs)
    # derive image shape
    image_shape = [1] + list(image_tensor.shape)

    # create payload request
    payload = {
        "id": "0",
        "inputs": [
            {
                "name": "input_tensor",
                "shape": image_shape,
                "datatype": "UINT8",
                "parameters": {},
                "data": image_tensor.tolist(),
            }
        ],
    }

    # save payload as json file
    payload_file = "instances.json"
    with open(payload_file, "w") as f:
        json.dump(payload, f)
    print(f"Payload generated at {payload_file}")

    return payload_file

if __name__ == '__main__':
  image_url = "https://github.com/tensorflow/models/raw/master/research/object_detection/test_images/image2.jpg"
  payload_file = generate_payload(image_url)

O script Python gera o payload e imprime a seguinte resposta:

Payload generated at instances.json

Execute o contêiner localmente (opcional)

Antes de enviar a imagem do contêiner ao Artifact Registry para usá-la com a Vertex AI Prediction, execute-a como um contêiner no ambiente local para verificar se o servidor funciona conforme o esperado:

  1. Para executar a imagem do contêiner localmente, execute o seguinte comando no shell:

    docker run -t -d -p 8000:8000 --rm \
  --name=local_object_detector \
  -e AIP_MODE=True \
  LOCATION_ID-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference \
  --model-repository MODEL_ARTIFACTS_REPOSITORY \
  --strict-model-config=false

    Faça o seguinte, como na seção anterior:

    • LOCATION_ID: a região do repositório do Artifact Registry, conforme especificado em uma seção anterior.
    • PROJECT_ID: o ID do projeto do Google Cloud
    • MODEL_ARTIFACTS_REPOSITORY: o caminho do Cloud Storage em que os artefatos do modelo estão localizados.

    Esse comando executa um contêiner no modo separado, mapeando a porta 8000 do contêiner para a porta 8000 do ambiente local. A imagem do Triton do NGC configura o Triton para usar a porta 8000.

  2. Para enviar uma verificação de integridade ao servidor do contêiner, execute o seguinte comando no shell:

    curl -s -o /dev/null -w "%{http_code}" http://localhost:8000/v2/health/ready

    Se for bem-sucedido, o servidor retornará o código de status como 200.

  3. Execute o comando a seguir para enviar uma solicitação de previsão ao servidor do contêiner usando o payload gerado anteriormente e receba as respostas de previsão:

    curl -X POST \
    -H "Content-Type: application/json" \
    -d @instances.json \
    localhost:8000/v2/models/object_detector/infer |
       jq -c '.outputs[] | select(.name == "detection_classes")'

    Essa solicitação usa uma das imagens de teste incluídas no exemplo de detecção de objetos do TensorFlow.

    Se for bem-sucedido, o servidor retornará a seguinte previsão:

    {"name":"detection_classes","datatype":"FP32","shape":[1,300],"data":[38,1,...,44]}

  4. Para interromper o contêiner, execute o seguinte comando no shell:

    docker stop local_object_detector

Envie a imagem do contêiner para o Artifact Registry

Configure o Docker para acessar o Artifact Registry. Em seguida, envie a imagem do contêiner para o repositório do Artifact Registry.

  1. Para conceder à instalação local do Docker permissão para transmitir ao Artifact Registry na região escolhida, execute o seguinte comando no shell:

    gcloud auth configure-docker LOCATION_ID-docker.pkg.dev
    • Substitua LOCATION_ID pela região em que você criou o repositório em uma seção anterior.

  2. Para enviar a imagem de contêiner recém-criada ao Artifact Registry, execute o seguinte comando no shell:

    docker push LOCATION_ID-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference

    Faça o seguinte, como na seção anterior:

    • LOCATION_ID: a região do repositório do Artifact Registry, conforme especificado em uma seção anterior.
    • PROJECT_ID: o ID do projeto do Google Cloud.

Implantar o modelo

Criar um modelo

Para criar um recurso Model que usa um contêiner personalizado executando o Triton, execute o seguinte comando gcloud ai models upload:

gcloud ai models upload \
    --region=LOCATION_ID \
    --display-name=DEPLOYED_MODEL_NAME \
    --container-image-uri=LOCATION_ID-docker.pkg.dev/PROJECT_ID/getting-started-nvidia-triton/vertex-triton-inference \
    --artifact-uri=MODEL_ARTIFACTS_REPOSITORY \
    --container-args='--strict-model-config=false'
  • LOCATION_ID: a região em que você está usando a Vertex AI.
  • PROJECT_ID: o ID do seu projeto do Google Cloud.
  • DEPLOYED_MODEL_NAME: um nome para DeployedModel. Também é possível usar o nome de exibição do Model para o DeployedModel.

O argumento --container-args='--strict-model-config=false' permite que o Triton gere a configuração do modelo automaticamente.

Crie um endpoint

Implante o modelo em um endpoint para que ele possa ser usado para exibir previsões on-line. Pule a etapa abaixo se você estiver implantando um modelo em um endpoint existente. O exemplo a seguir usa o comando gcloud ai endpoints create:

gcloud ai endpoints create \
    --region=LOCATION_ID \
    --display-name=ENDPOINT_NAME

Substitua:

  • LOCATION_ID: a região em que você está usando a Vertex AI.
  • ENDPOINT_NAME: o nome de exibição do endpoint.

A ferramenta CLI do Google Cloud pode levar alguns segundos para criar o endpoint.

Implantar o modelo no endpoint

Quando o endpoint estiver pronto, implante o modelo nele. Quando você implanta um modelo em um endpoint, o serviço associa recursos físicos ao modelo que executa o Triton para exibir previsões on-line.

O exemplo a seguir usa o comando gcloud ai endpoints deploy-model para implantar o Model em um endpoint que executa o Triton nas GPUs para acelerar a exibição de previsões e sem dividir o tráfego entre vários recursos DeployedModel:

ENDPOINT_ID=$(gcloud ai endpoints list \
    --region=LOCATION_ID \
    --filter=display_name=ENDPOINT_NAME \
    --format="value(name)")

MODEL_ID=$(gcloud ai models list \
    --region=LOCATION_ID \
    --filter=display_name=DEPLOYED_MODEL_NAME \
    --format="value(name)")

gcloud ai endpoints deploy-model $ENDPOINT_ID \
    --region=LOCATION_ID \
    --model=$MODEL_ID \
    --display-name=DEPLOYED_MODEL_NAME \
    --machine-type=MACHINE_TYPE \
    --min-replica-count=MIN_REPLICA_COUNT \
    --max-replica-count=MAX_REPLICA_COUNT \
    --accelerator=count=ACCELERATOR_COUNT,type=ACCELERATOR_TYPE \
    --traffic-split=0=100

Substitua:

  • LOCATION_ID: a região em que você está usando a Vertex AI.
  • ENDPOINT_NAME: o nome de exibição do endpoint.
  • DEPLOYED_MODEL_NAME: um nome para DeployedModel. Também é possível usar o nome de exibição do Model para o DeployedModel.
  • MACHINE_TYPE: opcional. Os recursos de máquina usados para cada nó desta implantação. A configuração padrão é n1-standard-2. Saiba mais sobre tipos de máquinas.
  • MIN_REPLICA_COUNT: o número mínimo de nós para esta implantação. A contagem de nós pode ser aumentada ou reduzida conforme necessário pela carga de previsão, até o número máximo de nós e nunca menos que esse número.
  • MAX_REPLICA_COUNT: o número máximo de nós para esta implantação. A contagem de nós pode ser aumentada ou reduzida conforme necessário pela carga de previsão, até esse número de nós e nunca menos que o número mínimo de nós.

  • ACCELERATOR_COUNT: o número de aceleradores a serem anexados a cada máquina que executa o job. Geralmente é 1. Se não for especificado, o valor padrão será 1.

  • ACCELERATOR_TYPE: gerencia a configuração do acelerador para exibição de GPU. Ao implantar um modelo com os tipos de máquina do Compute Engine, um acelerador de GPU também pode ser selecionado, e o tipo precisa ser especificado. As opções são nvidia-tesla-a100, nvidia-tesla-p100. nvidia-tesla-p4, nvidia-tesla-t4 e nvidia-tesla-v100.

A Google Cloud CLI pode levar alguns segundos para implantar o modelo no endpoint. Quando o modelo é implantado com sucesso, esse comando imprime a seguinte saída:

  Deployed a model to the endpoint xxxxx. Id of the deployed model: xxxxx.

Como receber previsões on-line com base no modelo implantado

Para invocar o modelo por meio do endpoint da Vertex AI Prediction, formate a solicitação de previsão usando um Objeto JSON de solicitação de inferência padrão ou um Objeto JSON de solicitação de inferência com uma extensão binária e envie uma solicitação ao endpoint REST rawPredict da Vertex AI Prediction.

O exemplo a seguir usa o comando gcloud ai endpoints raw-predict:

ENDPOINT_ID=$(gcloud ai endpoints list \
    --region=LOCATION_ID \
    --filter=display_name=ENDPOINT_NAME \
    --format="value(name)")

gcloud ai endpoints raw-predict $ENDPOINT_ID \
    --region=LOCATION_ID \
    --http-headers=Content-Type=application/json \
    --request=@instances.json

Substitua:

  • LOCATION_ID: a região em que você está usando a Vertex AI.
  • ENDPOINT_NAME: o nome de exibição do endpoint.

O endpoint retorna a seguinte resposta para uma solicitação válida:

{
    "id": "0",
    "model_name": "object_detector",
    "model_version": "1",
    "outputs": [{
        "name": "detection_anchor_indices",
        "datatype": "FP32",
        "shape": [1, 300],
        "data": [2.0, 1.0, 0.0, 3.0, 26.0, 11.0, 6.0, 92.0, 76.0, 17.0, 58.0, ...]
    }]
}

Limpar

Para evitar outras cobranças da Vertex AI e cobranças do Artifact Registry, exclua os recursos do Google Cloud criados durante este tutorial:

  1. Para cancelar a implantação do modelo do endpoint e excluir o endpoint, execute o seguinte comando no shell:

    ENDPOINT_ID=$(gcloud ai endpoints list \
    --region=LOCATION_ID \
    --filter=display_name=ENDPOINT_NAME \
    --format="value(name)")

DEPLOYED_MODEL_ID=$(gcloud ai endpoints describe $ENDPOINT_ID \
    --region=LOCATION_ID \
    --format="value(deployedModels.id)")

gcloud ai endpoints undeploy-model $ENDPOINT_ID \
    --region=LOCATION_ID \
    --deployed-model-id=$DEPLOYED_MODEL_ID

gcloud ai endpoints delete $ENDPOINT_ID \
    --region=LOCATION_ID \
    --quiet

    Substitua LOCATION_ID pela região em que você criou o modelo em uma seção anterior.

  2. Para excluir o modelo, execute o seguinte comando no shell:

    MODEL_ID=$(gcloud ai models list \
    --region=LOCATION_ID \
    --filter=display_name=DEPLOYED_MODEL_NAME \
    --format="value(name)")

gcloud ai models delete $MODEL_ID \
    --region=LOCATION_ID \
    --quiet

    Substitua LOCATION_ID pela região em que você criou o modelo em uma seção anterior.

  3. Para excluir o repositório do Artifact Registry e a imagem do contêiner nele, execute o seguinte comando no shell:

    gcloud artifacts repositories delete getting-started-nvidia-triton \
  --location=LOCATION_ID \
  --quiet

    Substitua LOCATION_ID pela região em que você criou o repositório do Artifact Registry em uma seção anterior.

Limitações

A seguir