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)

No Azure Machine Learning, pode usar um contentor personalizado para implantar um modelo num endpoint online. As implantações de contêiner personalizadas podem usar servidores Web diferentes do servidor Python Flask padrão que o Aprendizado de Máquina do Azure usa.

Ao usar uma implantação personalizada, você pode:

• Use várias ferramentas e tecnologias, como TensorFlow Serving (TF Serving), TorchServe, Triton Inference Server, o pacote Plumber R e a imagem mínima de inferência do Azure Machine Learning.
• Ainda aproveite o monitoramento, o dimensionamento, o alerta e a autenticação internos que o Azure Machine Learning oferece.

Este artigo mostra como usar uma imagem do TF Serving para servir um modelo TensorFlow.

Pré-requisitos

• Uma área de trabalho do Azure Machine Learning. Para obter instruções sobre como criar um espaço de trabalho, consulte Criar o espaço de trabalho.

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

  CLI do Azure

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

  Os exemplos neste artigo pressupõem que você use um shell Bash ou um shell compatível. Por exemplo, você pode usar um shell em um sistema Linux ou Subsistema Windows para Linux.

  Python SDK

  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 Biblioteca de cliente do Pacote do Azure Machine Learning para Python.

• Um grupo de recursos do Azure que contém o seu espaço de trabalho e ao qual o utilizador ou o seu principal de serviço têm acesso de colaborador. Se você usar as etapas em Criar o espaço de trabalho para configurar seu espaço de trabalho, atenderá a esse requisito.

• Docker Engine, instalado e em execução localmente. Este pré-requisito é altamente recomendado. Você precisa dele para implantar um modelo localmente e é útil para depuração.

Exemplos de implementação

A tabela a seguir lista exemplos de implantação que usam contêineres personalizados e aproveitam várias ferramentas e tecnologias.

Exemplo	Script da CLI do Azure	Descrição
mínimo/multimodelo	deploy-custom-container-minimal-multimodel	Implanta vários modelos em uma única implantação estendendo a imagem mínima de inferência do Aprendizado de Máquina do Azure.
mínimo/modelo único	deploy-custom-container-minimal-single-model	Implanta um único modelo estendendo a imagem mínima de inferência do Azure Machine Learning.
mlflow/multideployment-scikit	deploy-custom-container-mlflow-multideployment-scikit	Implanta dois modelos MLFlow com requisitos Python diferentes para duas implantações separadas atrás de um único endpoint. Usa a imagem mínima de inferência do Azure Machine Learning.
r/multimodelo-canalizador	deploy-custom-container-r-multimodel-encanador	Implanta três modelos de regressão em um ponto de extremidade. Utiliza o pacote Plumber R.
tfserving/meio-mais-dois	deploy-custom-container-tfserving-half-plus-two	Implanta um modelo Half Plus Two usando um contêiner personalizado TF Serving . Usa o processo de registro de modelo padrão.
tfserving/meio mais dois integrados	deploy-custom-container-tfserving-half-plus-two-integrated	Implanta um modelo Half Plus Two usando um contêiner personalizado TF Serving com o modelo integrado na imagem.
Tocha/densenet	deploy-custom-container-torchserve-densenet	Implanta um único modelo usando um contêiner personalizado do TorchServe.
Tritão/modelo único	desdobrar-contentor-personalizado-triton-modelo-único	Implanta um modelo Triton usando um contêiner personalizado.

Este artigo mostra como usar o exemplo tfserving/half-plus-two.

Aviso

As equipas de suporte da Microsoft poderão não conseguir ajudar a resolver 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.

Faça o download do código-fonte

As etapas neste artigo usam exemplos de código do repositório azureml-examples . Use os seguintes comandos para clonar o repositório:

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

No repositório de exemplos, a maioria das amostras Python está sob a pasta sdk/python. Para este artigo, vá para a pasta cli em vez disso. A estrutura de pastas sob a pasta cli é ligeiramente diferente da estrutura sdk/python neste caso. A maioria das etapas neste artigo requer a estrutura do CLI.

Para seguir as etapas do exemplo, consulte um notebook do Jupyter no repositório de exemplos. Mas nas seguintes seções desse bloco de anotações, as etapas são executadas a partir da pasta azureml-examples/sdk/python em vez da pasta cli:

• 3. Teste localmente
• 5. Testar o ponto de extremidade com dados de amostra

Inicializar variáveis de ambiente

Para usar um modelo TensorFlow, você precisa de várias variáveis de ambiente. Execute os seguintes comandos para definir essas variáveis:

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 um valor de entrada por dois e adiciona dois 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

Testar uma imagem do TensorFlow Serving localmente

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

Enviar pedidos de vivacidade e pontuação para a imagem

Envie um pedido de verificação de atividade para verificar se o processo dentro do contentor funciona. Você deve obter um código de status de resposta de 200 OK.

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

Envie uma solicitação de pontuação para verificar 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

Quando terminar o teste localmente, pare a imagem:

docker stop tfserving-test

Implantar seu ponto de extremidade online no Azure

Para desimplantar o seu endpoint online no Azure, siga os passos nas seções seguintes.

CLI do Azure

Crie arquivos YAML para seu endpoint e implantação

Você pode configurar sua implantação na nuvem usando YAML. Por exemplo, para configurar seu ponto de extremidade, você pode criar um arquivo YAML chamado tfserving-endpoint.yml que contém as seguintes linhas:

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

Para configurar sua implantação, você pode criar um arquivo YAML chamado tfserving-deployment.yml que contém as seguintes linhas:

$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 seu espaço de trabalho do Azure Machine Learning

Para configurar seu espaço de trabalho do Azure Machine Learning, execute as seguintes etapas:

1. Importe as bibliotecas necessárias:

   # Import the 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 as configurações do espaço de trabalho e obtenha acesso ao espaço de trabalho.

   # Enter information about your Azure Machine Learning workspace.
   subscription_id = "<subscription-ID>"
   resource_group = "<resource-group-name>"
   workspace = "<Azure-Machine-Learning-workspace-name>"
   
   # Get a handle to the workspace.
   ml_client = MLClient(
     DefaultAzureCredential(), subscription_id, resource_group, workspace
   )
   

Para obter mais informações, consulte Implantar e pontuar um modelo de aprendizado de máquina usando um ponto de extremidade online.

Configurar um ponto de extremidade online

Utilize o seguinte código para configurar um ponto de extremidade na internet. Tenha em mente os seguintes pontos:

• O nome do ponto de extremidade deve ser exclusivo em sua região do Azure. Além disso, um nome de ponto de extremidade deve começar com uma letra e consistir apenas em caracteres alfanuméricos e hífenes. Para obter mais informações sobre regras de nomenclatura, consulte Pontos de extremidade online e pontos de extremidade em lote do Azure Machine Learning.
• Para o auth_mode valor, use key para autenticação baseada em chave. Use aml_token para autenticação baseada em token do Azure Machine Learning. Uma chave não expira, mas um token expira. Para obter mais informações sobre autenticação, consulte Autenticar clientes para endpoints na internet.
• A descrição e as tags são opcionais.

# To create a unique endpoint name, use a time stamp of the current date and time.
import datetime

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

# Configure an online endpoint.
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="A sample online endpoint",
    auth_mode="key",
    tags={"env": "dev"},
)

Configurar uma implantação online

Uma implantação é um conjunto de recursos necessários para hospedar o modelo que faz a inferência real. Você pode usar a classe ManagedOnlineDeployment para configurar uma implantação para o seu ponto de extremidade. O construtor dessa classe usa os seguintes parâmetros:

• name: O nome da implantação.
• endpoint_name: O nome do endpoint no qual criar a implementação.
• model: O modelo a ser usado 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 ser usado 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.
• environment_variables: Variáveis de ambiente que são definidas durante a implantação.
  • MODEL_BASE_PATH: O caminho para o diretório superior que contém uma pasta para o seu modelo.
  • MODEL_NAME: O nome do seu modelo.
• instance_type: O tamanho da máquina virtual a ser usada para a implantação. Para obter uma lista de tamanhos suportados, consulte Lista de SKU de pontos de extremidade online gerenciados.
• instance_count: O número de instâncias a serem usadas para a implantação.

Utilize o seguinte código para configurar uma implementação para o seu endpoint:

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

As seções a seguir discutem conceitos importantes sobre os parâmetros YAML e Python.

Imagem base

Na secção environment em YAML, ou no construtor Environment em Python, especifica-se a imagem base como um parâmetro. Este exemplo usa docker.io/tensorflow/serving:latest como o image valor.

Se você inspecionar seu contêiner, poderá ver que esse servidor usa ENTRYPOINT comandos para iniciar um script de ponto de entrada. Esse script usa variáveis de ambiente como MODEL_BASE_PATH e MODEL_NAME, e expõe portas como 8501. Todos esses detalhes pertencem a esse servidor, e você pode usar essas informações para determinar como definir sua implantação. Por exemplo, se definir as variáveis de ambiente MODEL_BASE_PATH e MODEL_NAME na sua definição de implantação, o TF Serving usará esses valores para iniciar o servidor. Da mesma forma, se você definir a porta para cada rota na 8501 definição de implantação, as solicitações do usuário para essas rotas serão roteadas corretamente para o servidor de serviço TF.

Este exemplo é baseado no caso TF Serving . Mas você pode usar qualquer contêiner que permaneça ativo e responda a solicitações que vão para animação, prontidão e rotas de pontuação. Para ver como formar um Dockerfile para criar um contêiner, você pode consultar outros exemplos. Alguns servidores usam CMD instruções em vez de ENTRYPOINT instruções.

O parâmetro inference_config

environment Na seção ou na Environment classe, inference_config é um parâmetro. Ele especifica a porta e o caminho para três tipos de rotas: atividade, prontidão e avaliação. O inference_config parâmetro é necessário se você quiser executar seu próprio contêiner com um ponto de extremidade online gerenciado.

Rotas de prontidão vs. rotas de vivacidade

Alguns servidores de API fornecem uma maneira de verificar o status do servidor. Há dois tipos de rotas que você pode especificar para verificar o status:

• Rotas de vivacidade : para verificar se um servidor está em execução, use uma rota de vivacidade.
• Rotas de preparação : para verificar se um servidor está pronto para trabalhar, use uma rota de preparação.

No contexto da inferência de aprendizado de máquina, um servidor pode responder com um código de status de 200 OK a uma solicitação de vivacidade antes de carregar um modelo. O servidor pode responder com um código de status de 200 OK a uma solicitação de preparação somente depois de carregar o modelo na memória.

Para obter mais informações sobre sondas de vivacidade e prontidão, consulte Configurar sondas de animação, prontidão e inicialização.

O servidor de API que escolher determina as rotas de vivacidade e prontidão. Você identifica esse servidor em uma etapa anterior quando testa o contêiner localmente. Neste artigo, a implantação de exemplo usa o mesmo caminho para a rota de vivacidade e a rota de prontidão, porque o TF Serving define apenas uma rota de vivacidade. Para outras formas de definir as rotas, veja outros exemplos.

Rotas de pontuação

O servidor API que utiliza fornece uma forma de receber os dados para trabalhar. No contexto da inferência de aprendizado de máquina, um servidor recebe os dados de entrada por meio de uma rota específica. Identifique essa rota para seu servidor de API ao testar o contêiner localmente em uma etapa anterior. Especifique essa rota como a rota de pontuação ao definir a implantação a ser criada.

A criação bem-sucedida da implantação também atualiza o scoring_uri parâmetro do ponto de extremidade. Você pode verificar esse fato executando o seguinte comando: az ml online-endpoint show -n <endpoint-name> --query scoring_uri.

Localize 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. Quando o modelo é montado, você pode implantar novas versões do modelo sem ter que criar uma nova imagem do Docker. Por padrão, um modelo registrado com o nome my-model e versão 1 está localizado no seguinte caminho dentro do contêiner implantado: /var/azureml-app/azureml-models/my-model/1.

Por exemplo, considere a seguinte configuração:

• Uma estrutura de diretórios em sua máquina local de /azureml-examples/cli/endpoints/online/custom-container
• Um nome de modelo associado a half_plus_two

CLI do Azure

Suponha que seu arquivo tfserving-deployment.yml contenha as seguintes linhas em sua model seção. Nesta seção, o name valor refere-se ao nome que você usa para registrar o modelo no Azure Machine Learning.

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

Python SDK

Suponha que você use o código a seguir para criar uma Model classe. Neste código, o name valor refere-se ao nome que você usa para registrar o modelo no Azure Machine Learning.

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

Nesse caso, quando você cria uma implantação, seu modelo está localizado na seguinte pasta: /var/azureml-app/azureml-models/tfserving-mounted/1.

Opcionalmente, você pode configurar seu model_mount_path valor. Ao ajustar essa configuração, você pode alterar o caminho onde o modelo é montado.

Importante

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

Quando você altera o valor de , você também precisa atualizar a MODEL_BASE_PATH variável de model_mount_pathambiente. Defina MODEL_BASE_PATH com o mesmo valor que model_mount_path para evitar uma falha na implantação devido a um erro sobre o caminho base não ter sido encontrado.

CLI do Azure

Por exemplo, você pode adicionar o model_mount_path parâmetro ao seu arquivo tfserving-deployment.yml. Você também pode atualizar o MODEL_BASE_PATH valor nesse arquivo:

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

Python SDK

Por exemplo, você pode adicionar o model_mount_path parâmetro à sua ManagedOnlineDeployment classe. Você também pode atualizar o MODEL_BASE_PATH valor nesse código:

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

Em sua implantação, seu modelo está localizado em /var/tfserving-model-mount/tfserving-mounted/1. Ele não está mais em azureml-app/azureml-models, mas no caminho de montagem que especificar.

Crie seu endpoint e implantação

CLI do Azure

Depois de construir seu arquivo YAML, use o seguinte comando para criar seu ponto de extremidade:

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

Use o comando a seguir para criar sua implantação. Esta etapa pode ser executada por alguns minutos.

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

Python SDK

Use o código a seguir para criar o ponto de extremidade no espaço de trabalho. Esse código usa a instância de MLClient que você criou anteriormente. O método begin_create_or_update inicia a criação do endpoint. Em seguida, ele 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 o seguinte código:

ml_client.begin_create_or_update(blue_deployment)

Invoque o ponto de extremidade

Quando a implantação estiver concluída, faça 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

Utiliza a instância de MLClient que criaste anteriormente para obter um identificador para o endpoint. Em seguida, use o invoke método e os seguintes parâmetros para invocar o ponto de extremidade:

• endpoint_name: O nome do endpoint
• request_file: O arquivo que contém os dados da solicitação
• deployment_name: O nome da implantação que será testada no ponto de extremidade

Para os dados de solicitação, você pode usar um arquivo JSON de exemplo do repositório de exemplo.

# Test the blue deployment by using some sample data.
response = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    deployment_name="blue",
    request_file="sample_request.json",
)

Excluir o ponto de extremidade

Se você não precisar mais do ponto de extremidade, execute o seguinte comando para 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

• Realize uma distribuição segura de novas implementações para inferência em tempo real
• Solucionar problemas na implantação e avaliação de endpoints online
• Amostra de serviço de tocha