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

Artigo
04/11/2024

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

Saiba como usar um contêiner personalizado para implantar um modelo em um ponto de extremidade online no Azure Machine Learning.

As implantações de contêineres personalizados 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, dimensionamento, alerta e autenticação integrados do Azure Machine Learning.

A tabela a seguir lista vários exemplos de implantação que usam contêineres personalizados, como o Serviço do TensorFlow, o TorchServe, o Triton Inference Server, o pacote Plumber do R e a imagem Mínima de Inferência do Azure Machine Learning.

Exemplo	Script (CLI)	Descrição
minimal/multimodel	deploy-custom-container-minimal-multimodel	Implante vários modelos em uma só implantação estendendo a imagem Mínima de Inferência do Azure Machine Learning.
minimal/single-model	deploy-custom-container-minimal-single-model	Implante um só 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 do MLFlow com requisitos diferentes do Python em duas implantações separadas com a proteção de um ponto de extremidade individual usando a imagem Mínima de Inferência do Azure Machine Learning.
r/multimodel-plumber	deploy-custom-container-r-multimodel-plumber	Implante três modelos de regressão em um ponto de extremidade usando o pacote Plumber R
tfserving/half-plus-two	deploy-custom-container-tfserving-half-plus-two	Implante um modelo do Half Plus Two usando um contêiner personalizado do TensorFlow Serving usando o processo de registro de modelo padrão.
tfserving/half-plus-two-integrated	deploy-custom-container-tfserving-half-plus-two-integrated	Implante um modelo do Half Plus Two usando um contêiner personalizado do TensorFlow Serving com o modelo integrado à imagem.
torchserve/densenet	deploy-custom-container-torchserve-densenet	Implante um único modelo usando um contêiner personalizado do TorchServe.
torchserve/huggingface-textgen	deploy-custom-container-torchserve-huggingface-textgen	Implante modelos de Rosto Abraçando em um ponto de extremidade online e acompanhe o exemplo de TorchServe Abraçando Transformadores Faciais.
triton/single-model	deploy-custom-container-triton-single-model	Implante um modelo do Triton usando um contêiner personalizado

Este artigo se concentra no atendimento de 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 você encontrar problemas, pode ser solicitado a usar a imagem padrão ou uma das imagens que a Microsoft oferece para ver se o problema é específico da imagem.

Pré-requisitos

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

Um Workspace do Azure Machine Learning. Se você não tiver um, use as etapas do artigo Início Rápido: criar recursos de workspace para criar.
A CLI do Azure e a extensão mlou o SDK do Python v2 do Azure Machine Learning:
- Para instalar a extensão e a CLI 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 do Windows para Linux.
- Para instalar o SDK do Python v2, use o seguinte comando:
```
pip install azure-ai-ml azure-identity
```
  Para atualizar uma instalação do SDK existente para a versão mais recente, use o seguinte comando:
```
pip install --upgrade azure-ai-ml azure-identity
```
  Para saber mais, confira Instalar o SDK do Python v2 para Azure Machine Learning.

Você, ou a entidade de serviço que você usa, deve ter acesso de Colaborador ao grupo de recursos do Azure que contém seu workspace. Você tem esse grupo de recursos se tiver configurado o workspace de acordo com o artigo de início rápido.
Para fazer a implantação localmente, o mecanismo do Docker precisa ser executado localmente. Este passo é altamente recomendado. Ele ajuda você a depurar problemas.

Fazer download do código-fonte

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

CLI do Azure
SDK do Python

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

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

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

Inicializar variáveis de ambiente

Defina 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

Implantar um modelo do TensorFlow

Baixe e descompacte um modelo que divide uma entrada por dois 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

Executar uma imagem do TF Serving localmente para testar seu funcionamento

Use o docker para executar a 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

Verificar se você pode enviar solicitações de investigação de atividade e pontuação para a imagem

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

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

Em seguida, verifique se você pode obter previsões sobre dados sem rótulo:

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 o ponto de extremidade online no Azure

Depois, implante o ponto de extremidade online no Azure.

CLI do Azure
SDK do Python

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

Você pode configurar sua implantação de nuvem usando o YAML. Confira o exemplo de YAML para esse 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

Conectar-se ao workspace do Azure Machine Learning

Conecte-se ao Workspace do Azure Machine Learning, configure os detalhes do workspace e obtenha um identificador para o workspace da seguinte maneira:

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

Configure os detalhes do workspace e obtenha um identificador para o workspace:

# 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 machine learning em um ponto de extremidade online gerenciado usando o SDK v2 para Python.

Configurar o ponto de extremidade online

Dica

name: o nome do ponto de extremidade. O valor precisa ser exclusivo na região do Azure. O nome de um ponto de extremidade deve começar com uma letra maiúscula ou minúscula e conter somente caracteres '-'s e alfanuméricos. Para obter mais informações sobre as regras de nomenclatura, confira os limites de ponto de extremidade.
auth_mode: use key para autenticação baseada em chave. Use aml_token para autenticação baseada em chave do Azure Machine Learning. key não expira, mas aml_token expira. Para obter mais informações sobre autenticação, confira Autenticação em um ponto de extremidade online.

Opcionalmente, você pode adicionar uma descrição e marcas para o ponto de extremidade.

# 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 implantação online

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

Dica

name - Nome da implantação.
endpoint_name – O nome do ponto de extremidade no qual a implantação deve ser criada.
model – O modelo a ser usado para a implantação. Esse valor pode ser uma referência a um modelo com versão > existente no workspace ou uma especificação de modelo embutida.
environment – O ambiente a ser usado para a implantação. Esse valor pode ser uma referência para um ambiente com versão > existente no workspace ou uma especificação de ambiente embutido.
code_configuration – A configuração do código-fonte e o script de pontuação
- path – O caminho para o diretório do código-fonte de pontuação do modelo
- scoring_script – Caminho relativo para o arquivo de pontuação no diretório do código-fonte
instance_type – O tamanho da VM a ser usado para a implantação. Para obter a lista de tamanhos com suporte, confira a 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 nesse parâmetro YAML/Python:

Rota de preparação versus rota de atividade

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

Para obter mais informações sobre investigação de preparação e atividade, confira a Documentação do Kubernetes.

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

Localizar o modelo montado

Quando você implanta um modelo como um ponto de extremidade online, o Azure Machine Learning 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 imagem do Docker. Por padrão, um modelo registrado com o nome foo e versão 1 estaria localizado no seguinte caminho dentro do seu contêiner implantado: /var/azureml-app/azureml-models/foo/1

Por exemplo, se você tiver uma estrutura de diretório de /azureml-examples/cli/endpoints/online/custom-container em seu computador local, onde o modelo é nomeado half_plus_two:

Diagrama mostrando um modo de exibição de árvore da estrutura do diretório local.

CLI do Azure
SDK do Python

E tfserving-deployment.yml contém:

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

E a classe Model 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 na sua implantação:

Diagrama mostrando um modo de exibição de árvore da estrutura do diretório de implantação.

Opcionalmente, você pode configurar seu model_mount_path. Ele permite que você altere o caminho onde o modelo está montado.

Importante

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

CLI do Azure
SDK do Python

Por exemplo, você pode ter um parâmetro model_mount_path 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
.....

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

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 estará localizado em /var/tfserving-model-mount/tfserving-deployment/1 na sua implantação. Observe que ele não está mais em azureml-app/azureml-models, mas no caminho de montagem especificado:

Diagrama mostrando uma exibição de árvore da estrutura do diretório de implantação ao usar mount_model_path.

Criar seu ponto de extremidade e implantação

CLI do Azure
SDK do Python

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

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

A criação de 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

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

ml_client.begin_create_or_update(endpoint)

Crie a implantação executando:

ml_client.begin_create_or_update(blue_deployment)

Invocar o ponto de extremidade

Assim que sua implantação for concluída, confira se você pode fazer uma solicitação de pontuação para o ponto de extremidade implantado.

CLI do Azure
SDK do Python

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

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

endpoint_name – Nome do ponto de extremidade
request_file – Arquivo com os dados de solicitação
deployment_name – Nome da implantação específica a ser testada em um ponto de extremidade

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 ponto de extremidade, você pode excluí-lo:

CLI do Azure
SDK do Python

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

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)