Usar um contêiner personalizado para implantar um modelo em um ponto de extremidade online

APLICA-SE A:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

Saiba como usar um contêiner personalizado para implantar um modelo em um ponto de extremidade online no Aprendizado de Máquina do Azure.

As implantações de contêiner personalizadas podem usar servidores Web diferentes do servidor Python Flask padrão usado pelo Azure Machine Learning. Os usuários dessas implantações ainda podem aproveitar o monitoramento, o dimensionamento, o alerta e a autenticação internos do Azure Machine Learning.

A tabela a seguir lista vários exemplos de implantação que usam contêineres personalizados, como TensorFlow Serving, TorchServe, Triton Inference Server, Plumber R package e Azure Machine Learning Inference Minimal image.

Exemplo	Script (CLI)	Description
mínimo/multimodelo	deploy-custom-container-minimal-multimodel	Implante vários modelos em uma única implantação estendendo a imagem mínima de inferência do Azure Machine Learning.
mínimo/modelo único	deploy-custom-container-minimal-single-model	Implante um único modelo estendendo a imagem mínima de inferência do Azure Machine Learning.
mlflow/multideployment-scikit	deploy-custom-container-mlflow-multideployment-scikit	Implante dois modelos MLFlow com requisitos Python diferentes em duas implantações separadas atrás de um único ponto de extremidade usando a Imagem Mínima de Inferência do Azure Machine Learning.
r/multimodelo-canalizador	deploy-custom-container-r-multimodel-encanador	Implantar três modelos de regressão em um ponto de extremidade usando o pacote Plumber R
tfserving/meio-mais-dois	deploy-custom-container-tfserving-half-plus-two	Implante um modelo Half Plus Two usando um contêiner personalizado do TensorFlow Serving usando o processo de registro de modelo padrão.
tfserving/meio mais dois integrados	deploy-custom-container-tfserving-half-plus-two-integrated	Implante um modelo Half Plus Two usando um contêiner personalizado do TensorFlow Serving com o modelo integrado à imagem.
Tocha/densenet	deploy-custom-container-torchserve-densenet	Implante um único modelo usando um contêiner personalizado do TorchServe.
tocha/abraçoface-textgen	deploy-custom-container-torchserve-huggingface-textgen	Implante modelos Hugging Face em um endpoint online e acompanhe o exemplo Hugging Face Transformers TorchServe.
Tritão/modelo único	deploy-custom-container-triton-single-model	Implantar um modelo Triton usando um contêiner personalizado

Este artigo se concentra em servir um modelo do TensorFlow com o TensorFlow (TF) Serving.

Aviso

A Microsoft pode não conseguir ajudar a solucionar problemas causados por uma imagem personalizada. Se encontrar problemas, poderá ser-lhe pedido que utilize a imagem predefinida ou uma das imagens fornecidas pela Microsoft para ver se o problema é específico da sua imagem.

Pré-requisitos

Antes de seguir as etapas neste artigo, verifique se você tem os seguintes pré-requisitos:

• Uma área de trabalho do Azure Machine Learning. Se você não tiver um, use as etapas no artigo Guia de início rápido: criar recursos do espaço de trabalho para criar um.

• A CLI do Azure e a ml extensão ou o SDK do Python do Azure Machine Learning v2:

  • Para instalar a CLI e a extensão do Azure, consulte Instalar, configurar e usar a CLI (v2).

    Importante

    Os exemplos de CLI neste artigo pressupõem que você esteja usando o shell Bash (ou compatível). Por exemplo, de um sistema Linux ou Subsistema Windows para Linux.

  • Para instalar o Python SDK v2, use o seguinte comando:

    pip install azure-ai-ml azure-identity
    

    Para atualizar uma instalação existente do SDK para a versão mais recente, use o seguinte comando:

    pip install --upgrade azure-ai-ml azure-identity
    

    Para obter mais informações, consulte Instalar o Python SDK v2 para Azure Machine Learning.

• Você, ou a entidade de serviço usada, deve ter acesso de Colaborador ao grupo de recursos do Azure que contém seu espaço de trabalho. Você tem esse grupo de recursos se configurou seu espaço de trabalho usando o artigo de início rápido.

• Para implantar localmente, você deve ter o mecanismo Docker em execução localmente. Este passo é altamente recomendado. Ele ajuda você a depurar problemas.

Download do código-fonte

Para acompanhar este tutorial, clone o código-fonte do GitHub.

CLI do Azure

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Python SDK

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Consulte também o bloco de anotações de exemplo, mas observe que 3. Test locally a seção no bloco de anotações pressupõe que ele seja executado sob o azureml-examples/sdk diretório.

Inicializar variáveis de ambiente

Definir variáveis de ambiente:

BASE_PATH=endpoints/online/custom-container/tfserving/half-plus-two
AML_MODEL_NAME=tfserving-mounted
MODEL_NAME=half_plus_two
MODEL_BASE_PATH=/var/azureml-app/azureml-models/$AML_MODEL_NAME/1

Baixar um modelo do TensorFlow

Baixe e descompacte um modelo que divide uma entrada por duas e adiciona 2 ao resultado:

wget https://aka.ms/half_plus_two-model -O $BASE_PATH/half_plus_two.tar.gz
tar -xvf $BASE_PATH/half_plus_two.tar.gz -C $BASE_PATH

Execute uma imagem TF Serving localmente para testar se ela funciona

Use o docker para executar sua imagem localmente para teste:

docker run --rm -d -v $PWD/$BASE_PATH:$MODEL_BASE_PATH -p 8501:8501 \
 -e MODEL_BASE_PATH=$MODEL_BASE_PATH -e MODEL_NAME=$MODEL_NAME \
 --name="tfserving-test" docker.io/tensorflow/serving:latest
sleep 10

Verifique se você pode enviar solicitações de vivacidade e pontuação para a imagem

Primeiro, verifique se o contêiner está vivo, o que significa que o processo dentro do contêiner ainda está em execução. Você deve receber uma resposta 200 (OK).

curl -v http://localhost:8501/v1/models/$MODEL_NAME

Em seguida, verifique se você pode obter previsões sobre dados não rotulados:

curl --header "Content-Type: application/json" \
  --request POST \
  --data @$BASE_PATH/sample_request.json \
  http://localhost:8501/v1/models/$MODEL_NAME:predict

Parar a imagem

Agora que você testou localmente, pare a imagem:

docker stop tfserving-test

Implantar seu ponto de extremidade online no Azure

Em seguida, implante seu ponto de extremidade online no Azure.

CLI do Azure

Criar um arquivo YAML para seu ponto de extremidade e implantação

Você pode configurar sua implantação na nuvem usando YAML. Dê uma olhada no exemplo de YAML para este exemplo:

tfserving-endpoint.yml

$schema: https://azuremlsdk2.blob.core.windows.net/latest/managedOnlineEndpoint.schema.json
name: tfserving-endpoint
auth_mode: aml_token

tfserving-deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: {{MODEL_VERSION}}
  path: ./half_plus_two
environment_variables:
  MODEL_BASE_PATH: /var/azureml-app/azureml-models/tfserving-mounted/{{MODEL_VERSION}}
  MODEL_NAME: half_plus_two
environment:
  #name: tfserving
  #version: 1
  image: docker.io/tensorflow/serving:latest
  inference_config:
    liveness_route:
      port: 8501
      path: /v1/models/half_plus_two
    readiness_route:
      port: 8501
      path: /v1/models/half_plus_two
    scoring_route:
      port: 8501
      path: /v1/models/half_plus_two:predict
instance_type: Standard_DS3_v2
instance_count: 1

Python SDK

Conectar-se ao espaço de trabalho do Azure Machine Learning

Conecte-se ao seu espaço de trabalho do Azure Machine Learning, configure os detalhes do espaço de trabalho e obtenha um identificador para o espaço de trabalho da seguinte maneira:

1. Importe as bibliotecas necessárias:

# import required libraries
from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
   ManagedOnlineEndpoint,
   ManagedOnlineDeployment,
   Model,
   Environment,
   CodeConfiguration,
)
from azure.identity import DefaultAzureCredential

2. Configure os detalhes do espaço de trabalho e obtenha um identificador para o espaço de trabalho:

# enter details of your Azure Machine Learning workspace
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AZUREML_WORKSPACE_NAME>"

# get a handle to the workspace
ml_client = MLClient(
   DefaultAzureCredential(), subscription_id, resource_group, workspace
)

Para obter mais informações, consulte Implantar modelos de aprendizado de máquina em endpoint online gerenciado usando o Python SDK v2.

Configurar ponto de extremidade online

Gorjeta

• name: O nome do ponto de extremidade. Ele deve ser exclusivo na região do Azure. O nome de um ponto final deve começar com uma letra maiúscula ou minúscula e consistir apenas em '-' e caracteres alfanuméricos. Para obter mais informações sobre as regras de nomenclatura, consulte Limites de pontos finais.
• auth_mode : Use key para autenticação baseada em chave. Use aml_token para autenticação baseada em token do Azure Machine Learning. A key não expira, mas aml_token expira. Para obter mais informações sobre autenticação, consulte Autenticar em um ponto de extremidade online.

Opcionalmente, você pode adicionar tags description, tags ao seu endpoint.

# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

online_endpoint_name = "endpoint-" + datetime.datetime.now().strftime("%m%d%H%M%f")

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is a sample online endpoint",
    auth_mode="key",
    tags={"foo": "bar"},
)

Configurar a implementação online

Uma implantação é um conjunto de recursos necessários para hospedar o modelo que faz a inferência real. Crie uma implantação para nosso endpoint usando a ManagedOnlineDeployment classe.

Gorjeta

• name - Nome da implantação.
• endpoint_name - Nome do ponto de extremidade para criar a implantação.
• model - O modelo a utilizar para a implantação. Esse valor pode ser uma referência a um modelo versionado > existente no espaço de trabalho ou uma especificação de modelo embutido.
• environment - O ambiente a utilizar para a implantação. Esse valor pode ser uma referência a um ambiente versionado existente > no espaço de trabalho ou uma especificação de ambiente embutido.
• code_configuration - a configuração do código fonte e do script de pontuação
  • path- Caminho para o diretório de código-fonte para pontuar o modelo
  • scoring_script - Caminho relativo para o arquivo de pontuação no diretório de código-fonte
• instance_type - O tamanho da VM a ser usado para a implantação. Para obter a lista de tamanhos suportados, consulte Lista de SKU de pontos de extremidade.
• instance_count - O número de instâncias a serem usadas para a implantação

# create a blue deployment
model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

env = Environment(
    image="docker.io/tensorflow/serving:latest",
    inference_config={
        "liveness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "readiness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "scoring_route": {"port": 8501, "path": "/v1/models/half_plus_two:predict"},
    },
)

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    environment_variables={
        "MODEL_BASE_PATH": "/var/azureml-app/azureml-models/tfserving-mounted/1",
        "MODEL_NAME": "half_plus_two",
    },
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

Há alguns conceitos importantes a serem observados neste parâmetro YAML/Python:

Rota de prontidão vs. rota de vivacidade

Um servidor HTTP define caminhos para vivacidade e prontidão. Uma rota de vivacidade é usada para verificar se o servidor está em execução. Uma rota de preparação é usada para verificar se o servidor está pronto para trabalhar. Na inferência de aprendizado de máquina, um servidor pode responder 200 OK a uma solicitação de vivacidade antes de carregar um modelo. O servidor pode responder 200 OK a uma solicitação de preparação somente depois que o modelo é carregado na memória.

Para obter mais informações sobre sondas de vivacidade e prontidão, consulte a documentação do Kubernetes.

Observe que essa implantação usa o mesmo caminho para vivacidade e prontidão, já que o TF Serving define apenas uma rota de vivacidade.

Localizando o modelo montado

Quando você implanta um modelo como um ponto de extremidade online, o Aprendizado de Máquina do Azure monta seu modelo em seu ponto de extremidade. A montagem do modelo permite que você implante novas versões do modelo sem ter que criar uma nova imagem do Docker. Por padrão, um modelo registrado com o nome foo e a versão 1 estaria localizado no seguinte caminho dentro do contêiner implantado: /var/azureml-app/azureml-models/foo/1

Por exemplo, se você tiver uma estrutura de diretórios de /azureml-examples/cli/endpoints/online/custom-container em sua máquina local, onde o modelo é nomeado half_plus_two:

CLI do Azure

E tfserving-deployment.yml contém:

model:
    name: tfserving-mounted
    version: 1
    path: ./half_plus_two

Python SDK

E Model a classe contém:

model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

Em seguida, seu modelo estará localizado em /var/azureml-app/azureml-models/tfserving-deployment/1 em sua implantação:

Opcionalmente, você pode configurar o .model_mount_path Ele permite alterar o caminho onde o modelo é montado.

Importante

O model_mount_path deve ser um caminho absoluto válido no Linux (o sistema operacional da imagem do contêiner).

CLI do Azure

Por exemplo, você pode ter model_mount_path parâmetro em seu tfserving-deployment.yml:

name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: 1
  path: ./half_plus_two
model_mount_path: /var/tfserving-model-mount
.....

Python SDK

Por exemplo, você pode ter model_mount_path um parâmetro em sua ManagedOnlineDeployment classe:

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    model_mount_path="/var/tfserving-model-mount",
    ...
)

Em seguida, seu modelo está localizado em /var/tfserving-model-mount/tfserving-deployment/1 em sua implantação. Observe que ele não está mais em azureml-app/azureml-models, mas sob o caminho de montagem que você especificou:

Crie seu endpoint e implantação

CLI do Azure

Agora que você entende como o YAML foi construído, crie seu endpoint.

az ml online-endpoint create --name tfserving-endpoint -f endpoints/online/custom-container/tfserving-endpoint.yml

Criar uma implantação pode levar alguns minutos.

az ml online-deployment create --name tfserving-deployment -f endpoints/online/custom-container/tfserving-deployment.yml --all-traffic

Python SDK

Usando o MLClient criado anteriormente, crie o ponto de extremidade no espaço de trabalho. Este comando inicia a criação do ponto de extremidade e retorna uma resposta de confirmação enquanto a criação do ponto de extremidade continua.

ml_client.begin_create_or_update(endpoint)

Crie a implantação executando:

ml_client.begin_create_or_update(blue_deployment)

Invoque o ponto de extremidade

Quando a implantação for concluída, veja se você pode fazer uma solicitação de pontuação para o ponto de extremidade implantado.

CLI do Azure

RESPONSE=$(az ml online-endpoint invoke -n $ENDPOINT_NAME --request-file $BASE_PATH/sample_request.json)

Python SDK

Usando o MLClient criado anteriormente, você obtém um identificador para o ponto de extremidade. O ponto de extremidade pode ser invocado usando o invoke comando com os seguintes parâmetros:

• endpoint_name - Nome do ponto final
• request_file - Arquivo com dados de solicitação
• deployment_name - Nome da implantação específica a ser testada em um endpoint

Envie uma solicitação de exemplo usando um arquivo JSON. O JSON de exemplo está no repositório de exemplo.

# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    deployment_name="blue",
    request_file="sample-request.json",
)

Excluir o ponto de extremidade

Agora que você pontuou com sucesso com seu endpoint, você pode excluí-lo:

CLI do Azure

az ml online-endpoint delete --name tfserving-endpoint

Python SDK

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Conteúdos relacionados

• Implementação segura para terminais online
• Resolver problemas de implementação de pontos finais online
• Amostra de serviço de tocha