Treinar modelos do TensorFlow em escala com o Azure Machine Learning

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

Neste artigo, saiba como executar seus scripts de treinamento do TensorFlow em escala usando o SDK do Python do Azure Machine Learning v2.

O código de exemplo neste artigo treina um modelo TensorFlow para classificar dígitos manuscritos, usando uma rede neural profunda (DNN); registar o modelo; e implantá-lo em um ponto de extremidade online.

Quer esteja a desenvolver um modelo TensorFlow a partir do zero ou a trazer um modelo existente para a nuvem, pode utilizar o Azure Machine Learning para expandir trabalhos de formação de código aberto utilizando recursos de computação em nuvem elástica. Você pode criar, implantar, versionar e monitorar modelos de nível de produção com o Azure Machine Learning.

Pré-requisitos

Para se beneficiar deste artigo, você precisa:

• Acesse uma assinatura do Azure. Se ainda não tiver uma, crie uma conta gratuita.
• Execute o código neste artigo usando uma instância de computação do Azure Machine Learning ou seu próprio bloco de anotações Jupyter.
  • Instância de computação do Azure Machine Learning — sem necessidade de downloads ou instalação
    • Conclua o tutorial Criar recursos para introdução para criar um servidor de notebook dedicado pré-carregado com o SDK e o repositório de exemplo.
    • Na pasta de aprendizado profundo de exemplos no servidor de notebook, localize um bloco de anotações concluído e expandido navegando até este diretório: v2 > sdk > python > jobs > single-step > tensorflow > train-hyperparameter-tune-deploy-with-tensorflow.
  • Seu servidor de notebook Jupyter
    • Instale o SDK do Azure Machine Learning (v2).
• Transfira os seguintes ficheiros:
  • roteiro de treinamento tf_mnist.py
  • roteiro de pontuação score.py
  • Exemplo de arquivo de solicitação sample-request.json

Você também pode encontrar uma versão completa do Jupyter Notebook deste guia na página de exemplos do GitHub.

Antes de executar o código neste artigo para criar um cluster de GPU, você precisará solicitar um aumento de cota para seu espaço de trabalho.

Configurar o trabalho

Esta seção configura o trabalho para treinamento carregando os pacotes Python necessários, conectando-se a um espaço de trabalho, criando um recurso de computação para executar um trabalho de comando e criando um ambiente para executar o trabalho.

Conectar-se ao espaço de trabalho

Primeiro, você precisa se conectar ao seu espaço de trabalho do Azure Machine Learning. O espaço de trabalho do Azure Machine Learning é o recurso de nível superior para o serviço. Ele fornece um local centralizado para trabalhar com todos os artefatos criados quando você usa o Aprendizado de Máquina do Azure.

Estamos usando DefaultAzureCredential para ter acesso ao espaço de trabalho. Essa credencial deve ser capaz de lidar com a maioria dos cenários de autenticação do SDK do Azure.

Se DefaultAzureCredential não funcionar para você, 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 usar um navegador para entrar e autenticar, você deve descomentar o código a seguir e usá-lo em vez disso.

# 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 o espaço de trabalho fornecendo sua ID de Assinatura, nome do Grupo de Recursos e nome do espaço de trabalho. Para encontrar estes parâmetros:

1. Procure o nome do seu espaço de trabalho no canto superior direito da barra de ferramentas do estúdio do Azure Machine Learning.
2. Selecione o nome do espaço de trabalho para mostrar o Grupo de Recursos e a ID da Assinatura.
3. Copie os valores para Grupo de Recursos e ID de Assinatura 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 desse script é um identificador de espaço de trabalho que você usa para gerenciar outros recursos e trabalhos.

Nota

• A criação MLClient não conectará o cliente ao espaço de trabalho. A inicialização do cliente é preguiçosa e aguardará a primeira vez que precisar fazer uma chamada. Neste artigo, isso acontecerá durante a criação da computação.

Criar um recurso de computação

O Azure Machine Learning precisa de um recurso de computação para executar um trabalho. Esse recurso pode ser máquinas de um ou vários nós com Linux ou sistema operacional Windows, ou uma malha de computação específica, como o Spark.

No script de exemplo a seguir, provisionamos um Linux compute cluster. Você pode ver a Azure Machine Learning pricing página para obter a lista completa de tamanhos e preços de VM. Como precisamos de um cluster de GPU para este exemplo, vamos escolher um modelo de STANDARD_NC6 e criar uma computação do Azure Machine Learning.

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_NC6s_v3",
        # 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 um trabalho do Azure Machine Learning, você precisa de um ambiente. Um ambiente do Azure Machine Learning encapsula as dependências (como tempo de execução de software e bibliotecas) necessárias para executar seu script de treinamento de aprendizado de máquina em seu recurso de computação. Esse ambiente é semelhante a um ambiente Python em sua máquina local.

O Azure Machine Learning permite que você use um ambiente com curadoria (ou pronto) — útil para cenários comuns de treinamento e inferência — ou crie um ambiente personalizado usando uma imagem do Docker ou uma configuração Conda.

Neste artigo, você reutiliza o ambiente AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpudo Azure Machine Learning com curadoria. Você usa a versão mais recente deste ambiente usando a @latest diretiva .

curated_env_name = "AzureML-tensorflow-2.12-cuda11@latest"

Configurar e enviar seu trabalho de treinamento

Nesta seção, começamos apresentando os dados para treinamento. Em seguida, abordamos como executar um trabalho de treinamento, usando um script de treinamento que fornecemos. Você aprende a criar o trabalho de treinamento configurando o comando para executar o script de treinamento. Em seguida, envie o trabalho de treinamento para ser executado no Azure Machine Learning.

Obter os dados de treinamento

Você usará dados do banco de dados de dígitos manuscritos do Modified National Institute of Standards and Technology (MNIST). Esses dados são provenientes do site de Yan LeCun e armazenados em uma 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 guião de formação

Neste artigo, fornecemos o script de treinamento tf_mnist.py. Na prática, você deve ser capaz de usar qualquer script de treinamento personalizado como está e executá-lo com o Azure Machine Learning sem precisar modificar seu código.

O script de treinamento fornecido faz o seguinte:

• trata do pré-processamento de dados, dividindo-os em dados de teste e de comboio;
• treina um modelo, usando os dados; e ainda
• Retorna o modelo de saída.

Durante a execução do pipeline, você usa MLFlow para registrar os parâmetros e métricas. Para saber como habilitar o rastreamento MLFlow, consulte Rastrear experimentos e modelos de ML com MLflow.

No script tf_mnist.pyde treinamento, criamos uma rede neural profunda (DNN) simples. Esta 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 oculta tem 300 neurónios e a segunda camada oculta tem 100 neurónios.
• Uma camada de saída com 10 neurónios. Cada neurônio representa um rótulo alvo de 0 a 9.

Construa o trabalho de formação

Agora que você tem todos os ativos necessários para executar seu trabalho, é hora de criá-lo usando o SDK do Python do Azure Machine Learning v2. Para este exemplo, estamos criando um commandarquivo .

Um Aprendizado command de Máquina do Azure é um recurso que especifica todos os detalhes necessários para executar seu código de treinamento na nuvem. Esses detalhes incluem as entradas e saídas, tipo de hardware a ser usado, software a ser instalado e como executar seu código. O command contém informações para executar um único comando.

Configurar o comando

Você usa o propósito command geral para executar o script de treinamento e executar as tarefas desejadas. Crie um Command objeto para especificar os detalhes de configuração do seu trabalho de treinamento.

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 camadas e a taxa de aprendizagem. Observe que passamos no caminho da Web diretamente como uma entrada.

• Para os valores dos parâmetros:

  • fornecer o cluster gpu_compute_target = "gpu-cluster" de computação que você criou para executar esse comando;
  • fornecer o ambiente curated_env_name com curadoria que você declarou anteriormente;
  • Configure a própria ação da linha de comando — nesse caso, o comando é python tf_mnist.py. Você pode acessar as entradas e saídas no comando através da ${{ ... }} notação;
  • configurar metadados, como o nome para exibição e o nome do experimento; onde um experimento é um contêiner para todas as iterações que se faz em um determinado projeto. Todos os trabalhos enviados com o mesmo nome de experimento seriam listados um ao lado do outro no estúdio do Azure Machine Learning.

• Neste exemplo, você usará o UserIdentity para executar o comando. Usar uma identidade de usuário significa que o comando usará sua identidade para executar o trabalho e acessar os dados do blob.

Submeter o trabalho

Agora é hora de enviar o trabalho para ser executado no Azure Machine Learning. Desta vez, você usará create_or_update em ml_client.jobs.

ml_client.jobs.create_or_update(job)

Depois de concluído, o trabalho registrará um modelo em seu espaço de trabalho (como resultado do treinamento) e produzirá um link para exibir o trabalho no estúdio do Azure Machine Learning.

Aviso

O Azure Machine Learning executa scripts de treinamento copiando todo o diretório de origem. Se você tiver dados confidenciais que não deseja carregar, use um arquivo .ignore ou não o inclua no diretório de origem.

O que acontece durante a execução do trabalho

À medida que o trabalho é executado, ele passa pelas seguintes etapas:

• Preparação: Uma imagem docker é criada de acordo com o ambiente definido. A imagem é carregada no registro de contêiner do espaço de trabalho e armazenada em cache para execuções posteriores. Os logs também são transmitidos para o histórico de trabalhos e podem ser visualizados para monitorar o progresso. Se um ambiente com curadoria for especificado, a imagem armazenada em cache que faz o backup desse ambiente curado será usada.

• Dimensionamento: o cluster tenta aumentar a escala se precisar de mais nós para executar a execução do que os disponíveis no momento.

• Em execução: Todos os scripts na pasta de script src são carregados no destino de computação, os armazenamentos de dados são montados ou copiados e o script é executado. As saídas do stdout e da pasta ./logs são transmitidas para o histórico do trabalho e podem ser usadas para monitorar o trabalho.

Ajustar hiperparâmetros do modelo

Agora que você já viu como fazer uma execução de treinamento do TensorFlow usando o SDK, vamos ver se você pode melhorar ainda mais a precisão do seu modelo. Você pode ajustar e otimizar os hiperparâmetros do seu modelo usando os sweep recursos do Azure Machine Learning.

Para ajustar os hiperparâmetros do modelo, defina o espaço de parâmetros no qual pesquisar durante o treinamento. Você fará isso substituindo alguns dos parâmetros (batch_size, first_layer_neurons, second_layer_neurons, e learning_rate) passados para o trabalho de treinamento 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, você configura a varredura no trabalho de comando, usando alguns parâmetros específicos da varredura, como a métrica primária a ser observada e o algoritmo de amostragem a ser usado.

No código a seguir, usamos amostragem aleatória para tentar diferentes conjuntos de configuração de hiperparâmetros na tentativa de maximizar nossa métrica primária, validation_acc.

Também definimos uma política de rescisão antecipada — o BanditPolicy. Esta política funciona verificando o trabalho a cada duas iterações. Se a métrica principal, validation_acc, estiver fora do intervalo de 10% superior, o Azure Machine Learning encerrará o trabalho. Isso evita que o modelo continue a explorar hiperparâmetros que não mostram nenhuma promessa de ajudar a alcançar a métrica alvo.

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, você pode enviar este trabalho como antes. Desta vez, você estará executando um trabalho de varredura que varre seu trabalho de trem.

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)

Você pode monitorar o trabalho usando o link da interface do usuário do estúdio que é apresentado durante a execução do trabalho.

Encontre e registe o melhor modelo

Uma vez concluídas todas as execuções, você pode encontrar a execução que produziu o modelo com a mais alta 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)

Implantar o modelo como um ponto de extremidade online

Depois de registrar seu modelo, você pode implantá-lo como um ponto de extremidade online, ou seja, como um serviço Web na nuvem do Azure.

Para implantar um serviço de aprendizado de máquina, você normalmente precisa:

• Os ativos de modelo que você deseja implantar. Esses ativos incluem o arquivo do modelo e metadados que você já registrou em seu trabalho de treinamento.
• Algum código para ser executado como um serviço. O código executa o modelo em uma determinada solicitação de entrada (um script de entrada). Esse script de entrada recebe dados enviados a um serviço Web implantado e os passa para o modelo. Depois que o modelo processa os dados, o script retorna a resposta do modelo ao cliente. O script é específico para seu modelo e deve entender os dados que o modelo espera e retorna. Quando você usa um modelo MLFlow, o Aprendizado de Máquina do Azure cria automaticamente esse script para você.

Para obter mais informações sobre implantação, consulte Implantar e pontuar um modelo de aprendizado de máquina com ponto de extremidade online gerenciado usando o Python SDK v2.

Criar um novo ponto de extremidade online

Como primeira etapa para implantar seu modelo, você precisa criar seu endpoint online. O nome do ponto de extremidade deve ser exclusivo em toda a região do Azure. Para este artigo, você cria um nome exclusivo usando 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 de extremidade, você pode recuperá-lo da seguinte maneira:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Implantar o modelo no ponto de extremidade

Depois de criar o ponto de extremidade, você pode implantar o modelo com o script de entrada. Um ponto de extremidade pode ter várias implantações. Usando regras, o ponto de extremidade pode direcionar o tráfego para essas implantações.

No código a seguir, você cria uma única implantação que lida com 100% do tráfego de entrada. Usamos um nome de cor arbitrário (tff-blue) para a implantação. Você também pode usar qualquer outro nome, como tff-green ou tff-red para a implantação. O código para implantar o modelo no ponto de extremidade faz o seguinte:

• implanta a melhor versão do modelo que você registrou anteriormente;
• pontua o modelo, usando o score.py arquivo;
• usa o mesmo ambiente curado (que você declarou anteriormente) para executar inferências.

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 essa implantação leve um pouco de tempo para ser concluída.

Testar a implantação com uma consulta de exemplo

Depois de implantar o modelo no ponto de extremidade, você pode prever a saída do modelo implantado, usando o invoke método no ponto de extremidade. Para executar a inferência, use o arquivo sample-request.json de solicitação de exemplo da pasta de solicitação .

# # 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, você pode imprimir as previsões retornadas e plotá-las junto com as imagens de entrada. Use a cor da fonte vermelha e a imagem invertida (branco sobre preto) para destacar as amostras classificadas incorretamente.

# 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

Como a precisão do modelo é alta, talvez seja necessário executar a célula algumas vezes antes de ver uma amostra classificada incorretamente.

Clean up resources (Limpar recursos)

Se você não estiver usando o ponto de extremidade, exclua-o para parar de usar o recurso. Certifique-se de que nenhuma outra implantação esteja usando o ponto de extremidade antes de excluí-lo.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Nota

Espere que essa limpeza leve um pouco de tempo para terminar.

Próximos passos

Neste artigo, você treinou e registrou um modelo do TensorFlow. Você também implantou o modelo em um ponto de extremidade online. Consulte estes outros artigos para saber mais sobre o Azure Machine Learning.

• Acompanhe as métricas de execução durante o treinamento
• Ajustar hiperparâmetros
• Arquitetura de referência para treinamento distribuído de aprendizado profundo no Azure