Implementar um modelo TensorFlow servido com TF Servir usando um recipiente personalizado em um ponto final on-line

APLICA-SE A:Extensão Azure CLI ml v2 (corrente)

APLICA A: Python SDK azure-ai-ml v2 (corrente)

Saiba como implantar um recipiente personalizado como ponto final on-line em Azure Machine Learning.

As implementações personalizadas de contentores podem utilizar servidores web que não o servidor padrão do Python Flask utilizado pela Azure Machine Learning. Os utilizadores destas implementações ainda podem tirar partido da monitorização, escala, alerta e autenticação incorporada da Azure Machine Learning.

Este artigo centra-se em servir um modelo TensorFlow com Serviço TensorFlow. Pode encontrar vários exemplos para TorchServe, Triton Inference Server, Plumber R e AzureML Inference Minimal image.

Aviso

Microsoft pode não ser capaz de ajudar a resolver problemas causados por uma imagem personalizada. Se encontrar problemas, poderá ser-lhe pedido que utilize a imagem padrão ou uma das imagens Microsoft fornece para ver se o problema é específico da sua imagem.

Pré-requisitos

Antes de seguir os passos deste artigo, certifique-se de que tem os seguintes pré-requisitos:

  • Você, ou o principal de serviço que utiliza, deve ter Contributor acesso ao Grupo de Recursos Azure que contém o seu espaço de trabalho. Terá um grupo de recursos desse tipo se configurar o seu espaço de trabalho utilizando o artigo de arranque rápido.

  • Para implantar localmente, deve ter o motor docker a funcionar localmente. Este passo é altamente recomendado. Vai ajudá-lo a depurar problemas.

Código fonte de download

Para acompanhar este tutorial, descarregue o código fonte abaixo.

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

Inicializar variáveis ambientais

Definir variáveis ambientais:

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

Faça o download de um modelo TensorFlow

Descarregue e desaperte 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 de serviço de TF localmente para testar que funciona

Use o estivador para executar a sua imagem localmente para testes:

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 pode enviar pedidos de vida e pontuação para a imagem

Primeiro, verifique se o contentor está "vivo", o que significa que o processo dentro do contentor ainda está em funcionamento. Deve obter uma resposta de 200 (OK).

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

Em seguida, verifique se 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

Pare a imagem

Agora que testou localmente, pare a imagem:

docker stop tfserving-test

Implemente o seu ponto final on-line para Azure

Em seguida, desloque o seu ponto final on-line para Azure.

Crie um ficheiro YAML para o seu ponto final e implantação

Pode configurar a sua implementação em nuvem utilizando YAML. Veja a amostra 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_DS2_v2
instance_count: 1

Existem alguns conceitos importantes a notar neste parâmetro YAML/Python:

Rota de prontidão vs. rota de vida

Um servidor HTTP define caminhos tanto para a vivacidade como para a prontidão. Uma rota de vida é usada para verificar se o servidor está em funcionamento. Uma rota de prontidão é usada para verificar se o servidor está pronto para funcionar. Na inferência de machine learning, um servidor poderia responder 200 OK a um pedido de vida antes de carregar um modelo. O servidor só pode responder a 200 OK a um pedido de prontidão depois de o modelo ter sido carregado na memória.

Reveja a documentação de Kubernetes para obter mais informações sobre as sondas de prontidão e prontidão.

Note que esta implementação usa o mesmo caminho tanto para a vivacidade como para a prontidão, uma vez que a TF Serving apenas define uma rota de vida.

Localizar o modelo montado

Quando implementa um modelo como ponto final on-line, o Azure Machine Learning monta o seu modelo no seu ponto final. A montagem do modelo permite-lhe implementar novas versões do modelo sem ter de criar uma nova imagem do Docker. Por predefinição, um modelo registado com o nome foo e a versão 1 estaria localizado no seguinte caminho dentro do seu contentor implantado: /var/azureml-app/azureml-models/foo/1

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

Diagrama mostrando uma vista de árvore da estrutura do diretório local.

e tfserving-deployment.yml contém:

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

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

Diagrama mostrando uma vista de árvore da estrutura do diretório de implantação.

Pode configurar opcionalmente o seu model_mount_path. Permite-lhe alterar o caminho onde o modelo está montado.

Importante

Deve model_mount_path ser um caminho absoluto válido em Linux (o SO da imagem do recipiente).

Por exemplo, pode ter model_mount_path um parâmetro na sua implantação tfserving.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
.....

então o seu modelo estará localizado na /var/tfserving-model-mount/tfserving-deployment/1 sua implantação. Note que já não está em baixo azureml-app/azureml-models, mas sob o caminho de montagem que especificou:

Diagrama que mostra uma visão da árvore da estrutura do diretório de implantação ao utilizar mount_model_path.

Crie o seu ponto final e implantação

Agora que compreendeu como a YAML foi construída, crie o seu ponto final.

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

Criar uma implantação pode demorar alguns minutos.

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

Invocar o ponto final

Uma vez concluída a sua implementação, veja se consegue fazer um pedido de pontuação para o ponto final implantado.

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

Eliminar o ponto final

Agora que marcou com sucesso com o seu ponto final, pode eliminá-lo:

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

Passos seguintes