Preparar modelos do TensorFlow em escala com o Azure Machine Learning
APLICA-SE A: SDK python azure-ai-ml v2 (atual)
Neste artigo, saiba como executar os scripts de preparação do TensorFlow em escala com o SDK Python v2 do Azure Machine Learning.
O código de exemplo neste artigo prepara um modelo do TensorFlow para classificar dígitos manuscritos com uma rede neural profunda (DNN); registar o modelo; e implemente-o num ponto final online.
Quer esteja a desenvolver um modelo do TensorFlow a partir do zero ou esteja a trazer um modelo existente para a cloud, pode utilizar o Azure Machine Learning para aumentar horizontalmente as tarefas de preparação open source com recursos de computação na cloud elástica. Pode criar, implementar, versão e monitorizar modelos de nível de produção com o Azure Machine Learning.
Pré-requisitos
Para beneficiar deste artigo, terá de:
- Aceder a uma subscrição do Azure. Se ainda não tiver uma, crie uma conta gratuita.
- Execute o código neste artigo com uma instância de computação do Azure Machine Learning ou o seu próprio bloco de notas do Jupyter.
- Instância de computação do Azure Machine Learning – não são necessárias transferências ou instalações
- Conclua o Início Rápido: Introdução ao Azure Machine Learning para criar um servidor de blocos de notas dedicado pré-carregado com o SDK e o repositório de exemplo.
- Na pasta de aprendizagem profunda de exemplos no servidor de blocos de notas, localize um bloco de notas concluído e expandido ao navegar para este diretório: trabalhos python de sdk > v2 > trabalhos de tensorflow >>> de passo > único train-hyperparameter-tune-deploy-with-tensorflow.
- O seu servidor de blocos de notas do Jupyter
- Instância de computação do Azure Machine Learning – não são necessárias transferências ou instalações
- Transfira os seguintes ficheiros:
- script de preparação tf_mnist.py
- score.py de script de classificação
- sample request file sample-request.json
Também pode encontrar uma versão Jupyter Notebook concluída deste guia na página de exemplos do GitHub.
Antes de poder executar o código neste artigo para criar um cluster de GPU, terá de pedir um aumento de quota para a área de trabalho.
Configurar a tarefa
Esta secção configura a tarefa de preparação ao carregar os pacotes Python necessários, ligar a uma área de trabalho, criar um recurso de computação para executar uma tarefa de comando e criar um ambiente para executar a tarefa.
Ligar à área de trabalho
Primeiro, terá de se ligar à área de trabalho do AzureML. A área de trabalho do AzureML é o recurso de nível superior do serviço. Fornece-lhe um local centralizado para trabalhar com todos os artefactos que cria quando utiliza o Azure Machine Learning.
Estamos a utilizar DefaultAzureCredential
para obter acesso à área de trabalho. Esta credencial deve ser capaz de processar a maioria dos cenários de autenticação do SDK do Azure.
Se DefaultAzureCredential
não funcionar para si, consulte azure-identity reference documentation
ou Set up authentication
para obter mais credenciais disponíveis.
# Handle to the workspace
from azure.ai.ml import MLClient
# Authentication package
from azure.identity import DefaultAzureCredential
credential = DefaultAzureCredential()
Se preferir utilizar um browser para iniciar sessão e autenticar, deve anular o comentário do seguinte código e utilizá-lo.
# Handle to the workspace
# from azure.ai.ml import MLClient
# Authentication package
# from azure.identity import InteractiveBrowserCredential
# credential = InteractiveBrowserCredential()
Em seguida, obtenha um identificador para a área de trabalho ao fornecer o ID da Subscrição, o nome do Grupo de Recursos e o nome da área de trabalho. Para localizar estes parâmetros:
- Procure o nome da área de trabalho no canto superior direito da barra de ferramentas estúdio do Azure Machine Learning.
- Selecione o nome da área de trabalho para mostrar o Grupo de Recursos e o ID da Subscrição.
- Copie os valores de Grupo de Recursos e ID de Subscrição para o código.
# Get a handle to the workspace
ml_client = MLClient(
credential=credential,
subscription_id="<SUBSCRIPTION_ID>",
resource_group_name="<RESOURCE_GROUP>",
workspace_name="<AML_WORKSPACE_NAME>",
)
O resultado da execução deste script é um identificador de área de trabalho que irá utilizar para gerir outros recursos e tarefas.
Nota
- A criação
MLClient
não ligará o cliente à área de trabalho. A inicialização do cliente é lenta e aguardará pela primeira vez que precisar de fazer uma chamada. Neste artigo, isto acontecerá durante a criação da computação.
Criar um recurso de computação para executar a tarefa
O AzureML precisa de um recurso de computação para executar uma tarefa. Este recurso pode ser um computador de nó único ou com vários nós com Linux ou SO Windows, ou um recurso de infraestrutura de computação específico, como o Spark.
No script de exemplo seguinte, aprovisionamos um Linux compute cluster
. Pode ver a página para obter a Azure Machine Learning pricing
lista completa dos tamanhos e preços das VMs. Uma vez que precisamos de um cluster de GPU para este exemplo, vamos escolher um modelo de STANDARD_NC6 e criar uma computação do AzureML.
from azure.ai.ml.entities import AmlCompute
gpu_compute_target = "gpu-cluster"
try:
# let's see if the compute target already exists
gpu_cluster = ml_client.compute.get(gpu_compute_target)
print(
f"You already have a cluster named {gpu_compute_target}, we'll reuse it as is."
)
except Exception:
print("Creating a new gpu compute target...")
# Let's create the Azure ML compute object with the intended parameters
gpu_cluster = AmlCompute(
# Name assigned to the compute cluster
name="gpu-cluster",
# Azure ML Compute is the on-demand VM service
type="amlcompute",
# VM Family
size="STANDARD_NC6",
# Minimum running nodes when there is no job running
min_instances=0,
# Nodes in cluster
max_instances=4,
# How many seconds will the node running after the job termination
idle_time_before_scale_down=180,
# Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
tier="Dedicated",
)
# Now, we pass the object to MLClient's create_or_update method
gpu_cluster = ml_client.begin_create_or_update(gpu_cluster).result()
print(
f"AMLCompute with name {gpu_cluster.name} is created, the compute size is {gpu_cluster.size}"
)
Criar um ambiente de trabalho
Para executar uma tarefa do AzureML, precisará de um ambiente. Um ambiente do AzureML encapsula as dependências (como o runtime de software e bibliotecas) necessárias para executar o script de preparação de machine learning no recurso de computação. Este ambiente é semelhante a um ambiente Python no seu computador local.
O AzureML permite-lhe utilizar um ambiente organizado (ou pronto a utilizar), útil para cenários comuns de preparação e inferência, ou criar um ambiente personalizado com uma imagem do Docker ou uma configuração Conda.
Neste artigo, vai reutilizar o ambiente AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu
do AzureML organizado. Irá utilizar a versão mais recente deste ambiente com a @latest
diretiva .
curated_env_name = "AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu@latest"
Configurar e submeter a tarefa de preparação
Nesta secção, vamos começar por introduzir os dados para preparação. Em seguida, vamos abordar como executar um trabalho de preparação com um script de preparação que fornecemos. Irá aprender a criar a tarefa de preparação ao configurar o comando para executar o script de preparação. Em seguida, irá submeter a tarefa de preparação para ser executada no AzureML.
Obter os dados de preparação
Irá utilizar dados da base de dados modificado do Instituto Nacional de Normas e Tecnologia (MNIST) de dígitos manuscritos. Estes dados são obtidos a partir do site de Yan LeCun e armazenados numa conta de armazenamento do Azure.
web_path = "wasbs://datasets@azuremlexamples.blob.core.windows.net/mnist/"
Para obter mais informações sobre o conjunto de dados MNIST, visite o site de Yan LeCun.
Preparar o script de preparação
Neste artigo, fornecemos o script de preparação tf_mnist.py. Na prática, deve ser capaz de utilizar qualquer script de preparação personalizado tal como está e executá-lo com o AzureML sem ter de modificar o código.
O script de preparação fornecido faz o seguinte:
- processa o pré-processamento de dados, dividindo os dados em dados de teste e de preparação;
- prepara um modelo, utilizando os dados; e
- devolve o modelo de saída.
Durante a execução do pipeline, irá utilizar o MLFlow para registar os parâmetros e as métricas. Para saber como ativar o controlo do MLFlow, veja Controlar experimentações e modelos ML com o MLflow.
No script tf_mnist.py
de preparação , criamos uma rede neural profunda (DNN) simples. Este DNN tem:
- Uma camada de entrada com 28 * 28 = 784 neurónios. Cada neurónio representa um pixel de imagem.
- Duas camadas ocultas. A primeira camada escondida tem 300 neurónios e a segunda camada escondida tem 100 neurónios.
- Uma camada de saída com 10 neurónios. Cada neurónio representa uma etiqueta direcionada de 0 a 9.
Criar a tarefa de preparação
Agora que tem todos os recursos necessários para executar a tarefa, está na altura de o criar com o SDK Python v2 do AzureML. Neste exemplo, vamos criar um command
.
Um AzureML command
é um recurso que especifica todos os detalhes necessários para executar o código de preparação na cloud. Estes detalhes incluem as entradas e saídas, o tipo de hardware a utilizar, o software a instalar e como executar o código. Contém command
informações para executar um único comando.
Configurar o comando
Irá utilizar o objetivo command
geral para executar o script de preparação e realizar as tarefas pretendidas. Crie um Command
objeto para especificar os detalhes de configuração da tarefa de preparação.
from azure.ai.ml import command
from azure.ai.ml import UserIdentityConfiguration
from azure.ai.ml import Input
web_path = "wasbs://datasets@azuremlexamples.blob.core.windows.net/mnist/"
job = command(
inputs=dict(
data_folder=Input(type="uri_folder", path=web_path),
batch_size=64,
first_layer_neurons=256,
second_layer_neurons=128,
learning_rate=0.01,
),
compute=gpu_compute_target,
environment=curated_env_name,
code="./src/",
command="python tf_mnist.py --data-folder ${{inputs.data_folder}} --batch-size ${{inputs.batch_size}} --first-layer-neurons ${{inputs.first_layer_neurons}} --second-layer-neurons ${{inputs.second_layer_neurons}} --learning-rate ${{inputs.learning_rate}}",
experiment_name="tf-dnn-image-classify",
display_name="tensorflow-classify-mnist-digit-images-with-dnn",
)
As entradas para este comando incluem a localização dos dados, o tamanho do lote, o número de neurónios na primeira e segunda camada e a taxa de aprendizagem. Repare que transmitimos o caminho web diretamente como uma entrada.
Para os valores dos parâmetros:
- indique o cluster
gpu_compute_target = "gpu-cluster"
de cálculo que criou para executar este comando; - fornecer o ambiente
curated_env_name
organizado que declarou anteriormente; - configure a ação da linha de comandos em si— neste caso, o comando é
python tf_mnist.py
. Pode aceder às entradas e saídas no comando através da${{ ... }}
notação; e - configurar metadados, como o nome a apresentar e o nome da experimentação; em que uma experimentação é um contentor para todas as iterações que se faz num determinado projeto. Todas as tarefas submetidas com o mesmo nome de experimentação seriam listadas entre si no AzureML Studio.
- indique o cluster
Neste exemplo, irá utilizar o
UserIdentity
para executar o comando. Utilizar uma identidade de utilizador significa que o comando utilizará a sua identidade para executar a tarefa e aceder aos dados a partir do blob.
Submeter o trabalho
Chegou a altura de submeter a tarefa a ser executada no AzureML. Desta vez, irá utilizar create_or_update
em ml_client.jobs
.
ml_client.jobs.create_or_update(job)
Depois de concluída, a tarefa registará um modelo na área de trabalho (como resultado da preparação) e produzirá uma ligação para ver a tarefa no AzureML Studio.
Aviso
O Azure Machine Learning executa scripts de preparação ao copiar todo o diretório de origem. Se tiver dados confidenciais que não pretende carregar, utilize um ficheiro .ignore ou não os inclua no diretório de origem.
O que acontece durante a execução do trabalho
À medida que a tarefa é executada, passa pelas seguintes fases:
Preparação: é criada uma imagem do docker de acordo com o ambiente definido. A imagem é carregada para o registo de contentor da área de trabalho e colocada em cache para execuções posteriores. Os registos também são transmitidos para o histórico de tarefas e podem ser visualizados para monitorizar o progresso. Se for especificado um ambiente organizado, será utilizada a cópia de segurança da imagem em cache que o ambiente organizado.
Dimensionamento: o cluster tenta aumentar verticalmente se precisar de mais nós para executar a execução do que está atualmente disponível.
Em execução: todos os scripts na pasta de script src são carregados para o destino de computação, os arquivos de dados são montados ou copiados e o script é executado. As saídas do stdout e da pasta ./logs são transmitidas em fluxo para o histórico de tarefas e podem ser utilizadas para monitorizar a tarefa.
Otimizar hiperparâmetros de modelo
Agora que já viu como fazer uma execução de preparação do TensorFlow com o SDK, vamos ver se consegue melhorar ainda mais a precisão do modelo. Pode otimizar e otimizar os hiperparâmetros do modelo com as capacidades do sweep
Azure Machine Learning.
Para otimizar os hiperparâmetros do modelo, defina o espaço de parâmetros no qual pretende procurar durante a preparação. Irá fazê-lo ao substituir alguns dos parâmetros (batch_size
, , first_layer_neurons
second_layer_neurons
e learning_rate
) transmitidos para a tarefa de preparação por entradas especiais do azure.ml.sweep
pacote.
from azure.ai.ml.sweep import Choice, LogUniform
# we will reuse the command_job created before. we call it as a function so that we can apply inputs
# we do not apply the 'iris_csv' input again -- we will just use what was already defined earlier
job_for_sweep = job(
batch_size=Choice(values=[32, 64, 128]),
first_layer_neurons=Choice(values=[16, 64, 128, 256, 512]),
second_layer_neurons=Choice(values=[16, 64, 256, 512]),
learning_rate=LogUniform(min_value=-6, max_value=-1),
)
Em seguida, irá configurar o varrimento na tarefa de comando, utilizando alguns parâmetros específicos de varrimento, como a métrica primária a observar e o algoritmo de amostragem a utilizar.
No código seguinte, utilizamos a amostragem aleatória para experimentar diferentes conjuntos de configuração de hiperparâmetros numa tentativa de maximizar a nossa métrica primária, validation_acc
.
Também definimos uma política de cessação antecipada: o BanditPolicy
. Esta política funciona ao verificar a tarefa a cada duas iterações. Se a métrica primária, validation_acc
, ficar fora do intervalo de 10%, o AzureML terminará a tarefa. Isto impede o modelo de continuar a explorar hiperparâmetros que não mostram nenhuma promessa de ajudar a alcançar a métrica de destino.
from azure.ai.ml.sweep import BanditPolicy
sweep_job = job_for_sweep.sweep(
compute=gpu_compute_target,
sampling_algorithm="random",
primary_metric="validation_acc",
goal="Maximize",
max_total_trials=8,
max_concurrent_trials=4,
early_termination_policy=BanditPolicy(slack_factor=0.1, evaluation_interval=2),
)
Agora, pode submeter esta tarefa como anteriormente. Desta vez, vais fazer um trabalho de limpeza que varre o teu trabalho de comboio.
returned_sweep_job = ml_client.create_or_update(sweep_job)
# stream the output and wait until the job is finished
ml_client.jobs.stream(returned_sweep_job.name)
# refresh the latest status of the job after streaming
returned_sweep_job = ml_client.jobs.get(name=returned_sweep_job.name)
Pode monitorizar a tarefa utilizando a ligação de interface de utilizador do estúdio que é apresentada durante a execução da tarefa.
Localizar e registar o melhor modelo
Depois de todas as execuções serem concluídas, pode encontrar a execução que produziu o modelo com a maior precisão.
from azure.ai.ml.entities import Model
if returned_sweep_job.status == "Completed":
# First let us get the run which gave us the best result
best_run = returned_sweep_job.properties["best_child_run_id"]
# lets get the model from this run
model = Model(
# the script stores the model as "model"
path="azureml://jobs/{}/outputs/artifacts/paths/outputs/model/".format(
best_run
),
name="run-model-example",
description="Model created from run.",
type="custom_model",
)
else:
print(
"Sweep job status: {}. Please wait until it completes".format(
returned_sweep_job.status
)
)
Em seguida, pode registar este modelo.
registered_model = ml_client.models.create_or_update(model=model)
Implementar o modelo como um ponto final online
Depois de registar o modelo, pode implementá-lo como um ponto final online, ou seja, como um serviço Web na cloud do Azure.
Para implementar um serviço de machine learning, normalmente precisará de:
- Os recursos de modelo que pretende implementar. Estes recursos incluem o ficheiro e os metadados do modelo que já registou na sua tarefa de preparação.
- Algum código para ser executado como um serviço. O código executa o modelo num determinado pedido de entrada (um script de entrada). Este script de entrada recebe dados submetidos para um serviço Web implementado e transmite-os para o modelo. Depois de o modelo processar os dados, o script devolve a resposta do modelo ao cliente. O script é específico do seu modelo e tem de compreender os dados esperados e devolvidos pelo modelo. Quando utiliza um modelo MLFlow, o AzureML cria automaticamente este script automaticamente.
Para obter mais informações sobre a implementação, veja Implementar e classificar um modelo de machine learning com o ponto final online gerido com o SDK Python v2.
Criar um novo ponto final online
Como primeiro passo para implementar o seu modelo, tem de criar o seu ponto final online. O nome do ponto final tem de ser exclusivo em toda a região do Azure. Para este artigo, irá criar um nome exclusivo com um identificador universalmente exclusivo (UUID).
import uuid
# Creating a unique name for the endpoint
online_endpoint_name = "tff-dnn-endpoint-" + str(uuid.uuid4())[:8]
from azure.ai.ml.entities import (
ManagedOnlineEndpoint,
ManagedOnlineDeployment,
Model,
Environment,
)
# create an online endpoint
endpoint = ManagedOnlineEndpoint(
name=online_endpoint_name,
description="Classify handwritten digits using a deep neural network (DNN) using TensorFlow",
auth_mode="key",
)
endpoint = ml_client.begin_create_or_update(endpoint).result()
print(f"Endpint {endpoint.name} provisioning state: {endpoint.provisioning_state}")
Depois de criar o ponto final, pode obtê-lo da seguinte forma:
endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)
print(
f'Endpint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)
Implementar o modelo no ponto final
Depois de criar o ponto final, pode implementar o modelo com o script de entrada. Um ponto final pode ter várias implementações. Com as regras, o ponto final pode direcionar o tráfego para estas implementações.
No código seguinte, irá criar uma única implementação que processa 100% do tráfego de entrada. Especificámos um nome de cor arbitrário (tff-blue) para a implementação. Também pode utilizar qualquer outro nome, como tff-green ou tff-red para a implementação. O código para implementar o modelo no ponto final faz o seguinte:
- implementa a melhor versão do modelo que registou anteriormente;
- classifica o modelo, utilizando o
score.py
ficheiro; e - utiliza o mesmo ambiente organizado (que declarou anteriormente) para efetuar a inferência.
model = registered_model
from azure.ai.ml.entities import CodeConfiguration
# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
name="tff-blue",
endpoint_name=online_endpoint_name,
model=model,
code_configuration=CodeConfiguration(code="./src", scoring_script="score.py"),
environment=curated_env_name,
instance_type="Standard_DS3_v2",
instance_count=1,
)
blue_deployment = ml_client.begin_create_or_update(blue_deployment).result()
Nota
Espere que esta implementação dedure um pouco de tempo para concluir.
Testar a implementação com uma consulta de exemplo
Agora que implementou o modelo no ponto final, pode prever a saída do modelo implementado, utilizando o invoke
método no ponto final. Para executar a inferência, utilize o ficheiro sample-request.json
de pedido de exemplo da pasta de pedidos .
# # predict using the deployed model
result = ml_client.online_endpoints.invoke(
endpoint_name=online_endpoint_name,
request_file="./request/sample-request.json",
deployment_name="tff-blue",
)
Em seguida, pode imprimir as predições devolvidas e desenhá-las juntamente com as imagens de entrada. Utilize a cor do tipo de letra vermelho e a imagem invertida (branco a preto) para realçar as amostras mal classificadas.
# compare actual value vs. the predicted values:
import matplotlib.pyplot as plt
i = 0
plt.figure(figsize=(20, 1))
for s in sample_indices:
plt.subplot(1, n, i + 1)
plt.axhline("")
plt.axvline("")
# use different color for misclassified sample
font_color = "red" if y_test[s] != result[i] else "black"
clr_map = plt.cm.gray if y_test[s] != result[i] else plt.cm.Greys
plt.text(x=10, y=-10, s=result[i], fontsize=18, color=font_color)
plt.imshow(X_test[s].reshape(28, 28), cmap=clr_map)
i = i + 1
plt.show()
Nota
Uma vez que a precisão do modelo é elevada, poderá ter de executar a célula algumas vezes antes de ver uma amostra mal classificada.
Limpar os recursos
Se não estiver a utilizar o ponto final, elimine-o para parar de utilizar o recurso. Certifique-se de que nenhuma outra implementação está a utilizar o ponto final antes de o eliminar.
ml_client.online_endpoints.begin_delete(name=online_endpoint_name)
Nota
Espere que esta limpeza leve algum tempo a concluir.
Passos seguintes
Neste artigo, preparou e registou um modelo do TensorFlow. Também implementou o modelo num ponto final online. Veja estes outros artigos para saber mais sobre o Azure Machine Learning.