Trem tensorFlow modelos em escala com Azure Machine Learning

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

Neste artigo, aprenda a executar os seus scripts de treino TensorFlow em escala utilizando Azure Machine Learning Python SDK v2.

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

Quer esteja a desenvolver um modelo TensorFlow a partir do solo ou a trazer um modelo existente para a nuvem, pode utilizar o Azure Machine Learning para escalar trabalhos de formação de código aberto utilizando recursos de computação em nuvem elástica. Pode construir, implementar, ver versão e monitorizar modelos de nível de produção com Azure Machine Learning.

Pré-requisitos

Para se beneficiar deste artigo, terá de:

  • Aceda a uma assinatura Azure. Se ainda não tem uma, crie uma conta gratuita.
  • Execute o código neste artigo utilizando um caso de cálculo Azure Machine Learning ou o seu próprio caderno Jupyter.
    • Azure Machine Learning compute instance — sem downloads ou instalação necessária
      • Complete o Quickstart: Começa com o Azure Machine Learning para criar um servidor de portátil dedicado pré-carregado com o SDK e o repositório de amostras.
      • Nas amostras de aprendizagem profunda no servidor do portátil, encontre um caderno completo e expandido navegando para este diretório: v2 > sdk > python > jobs > single-step > tensorflow > train-hyperparameter-deploy-with-tensorflow.
    • O seu servidor de cadernos Jupyter
  • Descarregue os seguintes ficheiros:

Também pode encontrar uma versão Jupyter Notebook completa deste guia na página de amostras do GitHub.

Antes de poder executar o código neste artigo para criar um cluster GPU, terá de solicitar um aumento de quota para o seu espaço de trabalho.

Configurar o trabalho

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

Ligar-se ao espaço de trabalho

Primeiro, terá de se ligar ao seu espaço de trabalho AzureML. O espaço de trabalho AzureML é o recurso de topo para o serviço. Proporciona-lhe um lugar centralizado para trabalhar com todos os artefactos que cria quando utiliza a Azure Machine Learning.

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

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 sação e autenticação, deve descodificá-lo e usá-lo.

# Handle to the workspace
# from azure.ai.ml import MLClient

# Authentication package
# from azure.identity import InteractiveBrowserCredential
# credential = InteractiveBrowserCredential()

Em seguida, manuseie o espaço de trabalho fornecendo o seu ID de subscrição, 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 estúdio do Azure Machine Learning.
  2. Selecione o nome do seu espaço de trabalho para mostrar o seu Grupo de Recursos e ID de assinatura.
  3. Copie os valores do Grupo de Recursos e do ID de assinatura no 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 manípulo de espaço de trabalho que você usará para gerir outros recursos e empregos.

Nota

  • A criação MLClient não ligará o cliente ao espaço de trabalho. A inicialização do cliente é preguiçosa e vai esperar pela primeira vez que precisar de fazer uma chamada. Neste artigo, isto acontecerá durante a criação de cálculo.

Criar um recurso computacional para executar o trabalho

A AzureML precisa de um recurso computacional para gerir um trabalho. Este recurso pode ser máquinas individuais ou multi-nós com Linux ou Windows OS, ou um tecido computacional específico como o Spark.

No seguinte guião de exemplo, nós disponibilizamos um Linux compute cluster. Pode ver a Azure Machine Learning pricing página para ver a lista completa de tamanhos e preços de VM. Uma vez que precisamos de um cluster GPU para este exemplo, vamos escolher um modelo STANDARD_NC6 e criar um computo 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 gerir um trabalho da AzureML, vai precisar de um ambiente. Um ambiente AzureML encapsula as dependências (como o tempo de execução do software e as bibliotecas) necessárias para executar o seu script de formação de machine learning no seu recurso compute. Este ambiente é semelhante a um ambiente Python na sua máquina local.

O AzureML permite-lhe utilizar um ambiente curado (ou pronto) — útil para cenários comuns de treino e inferência — ou criar um ambiente personalizado utilizando uma imagem de Docker ou uma configuração Conda.

Neste artigo, você vai reutilizar o ambiente AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpuAzureML curado. Usará a versão mais recente deste ambiente usando a @latest diretiva.

curated_env_name = "AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu@latest"

Configure e submeta o seu trabalho de formação

Nesta secção, começaremos por introduzir os dados para o treino. Depois, cobriremos como fazer um trabalho de treino, usando um roteiro de treino que fornecemos. Vais aprender a construir o trabalho de treino configurando o comando para executar o guião de treino. Então, vais submeter o trabalho de treino para correr em AzureML.

Obter os dados de formação

Utilizará dados da base de dados do Instituto Nacional de Normalização e Tecnologia Modificado (MNIST) de dígitos manuscritos. Estes dados são obtidos a partir do site de Yan LeCun e armazenados numa conta de armazenamento Azure.

web_path = "wasbs://datasets@azuremlexamples.blob.core.windows.net/mnist/"

Para mais informações sobre o conjunto de dados do MNIST, visite o site da Yan LeCun.

Preparar o roteiro de treino

Neste artigo, fornecemos o roteiro de treino tf_mnist.py. Na prática, você deve ser capaz de pegar em qualquer script de treino personalizado como está e executá-lo com AzureML sem ter que modificar o seu código.

O roteiro de formação fornecido faz o seguinte:

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

Durante a execução do gasoduto, utilizará o MLFlow para registar os parâmetros e métricas. Para aprender a ativar o rastreio de MLFlow, consulte experiências e modelos track ML com MLflow.

No roteiro tf_mnist.pyde treino, criamos uma simples rede neural profunda (DNN). Este DNN tem:

  • Uma camada de entrada com 28 * 28 = 784 neurónios. Cada neurónio representa um pixel de imagem.
  • Duas camadas escondidas. 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.

Diagrama mostrando uma rede neural profunda com 784 neurónios na camada de entrada, duas camadas escondidas e 10 neurónios na camada de saída.

Construir o trabalho de formação

Agora que tem todos os ativos necessários para gerir o seu trabalho, está na hora de construí-lo usando o AzureML Python SDK v2. Por exemplo, vamos criar um command.

Um AzureML command é um recurso que especifica todos os detalhes necessários para executar o seu código de treino na nuvem. Estes detalhes incluem as entradas e saídas, tipo de hardware para usar, software para instalar e como executar o seu código. A command informação contém para executar um único comando.

Configure o comando

Você usará o propósito command geral para executar o roteiro de treino e executar as suas tarefas desejadas. Crie um Command objeto para especificar os detalhes de configuração do seu trabalho de treino.

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 de dados, o tamanho do lote, o número de neurónios na primeira e segunda camada e a taxa de aprendizagem. Note 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 cálculo que criou para executar este comando;
    • fornecer o ambiente curated_env_name curado que declarou anteriormente;
    • Configure a ação da linha de comando em si — neste caso, o comando é python tf_mnist.py. Pode aceder às entradas e saídas no comando através da ${{ ... }} notação;
    • configure metadados como o nome de exibição e o nome da experiência; onde uma experiência é um recipiente para todas as iterações que se faz num determinado projeto. Todos os trabalhos submetidos com o mesmo nome de experiência seriam listados ao lado um do outro no estúdio AzureML.
  • Neste exemplo, usará o para executar o UserIdentity comando. A utilização de uma identidade de utilizador significa que o comando utilizará a sua identidade para executar o trabalho e aceder aos dados a partir da bolha.

Submeter o trabalho

Está na hora de submeter o trabalho a funcionar na AzureML. Desta vez, vais usarcreate_or_update.ml_client.jobs

ml_client.jobs.create_or_update(job)

Uma vez concluído, o trabalho registará um modelo no seu espaço de trabalho (como resultado da formação) e irá emitir um link para visualizar o trabalho no estúdio AzureML.

Aviso

A Azure Machine Learning executa scripts de formação copiando todo o diretório de origem. Se tiver dados sensíveis que não pretende fazer o upload, utilize um ficheiro .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, passa pelas seguintes fases:

  • Preparação: Uma imagem de estivador é criada de acordo com o ambiente definido. A imagem é enviada para o registo do contentor do espaço de trabalho e em cache para posteriores execuções. Os registos também são transmitidos para o histórico de trabalho e podem ser vistos para monitorizar o progresso. Se for especificado um ambiente curado, será utilizado o suporte de imagem em cache que o ambiente curado será utilizado.

  • Dimensionamento: O cluster tenta aumentar se necessitar de mais nós para executar a execução do que estão atualmente disponíveis.

  • Execução: Todos os scripts na pasta de script src são carregados para o alvo do cálculo, as lojas de dados são montadas ou copiadas, e o script é executado. As saídas da sesto e a pasta ./logs são transmitidas para o histórico de trabalho e podem ser utilizadas para monitorizar o trabalho.

Sintonizar hiperparmetros de modelo

Agora que viu como fazer um treino de tensorFlow usando o SDK, vamos ver se consegue melhorar ainda mais a precisão do seu modelo. Pode sintonizar e otimizar os hiperparímetros do seu modelo utilizando as capacidades do sweep Azure Machine Learning.

Para sintonizar os hiperparmetros do modelo, defina o espaço dos parâmetros para procurar durante o treino. Fá-lo-á substituindo alguns dos parâmetros (batch_size, first_layer_neuronssecond_layer_neuronselearning_rate) passados para o trabalho de formação com 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 a varredura no trabalho de comando, usando alguns parâmetros específicos de varrimento, tais como a métrica primária para observar e o algoritmo de amostragem para usar.

No seguinte código, usamos amostragem aleatória para experimentar diferentes conjuntos de configurações de hiperparímetros numa tentativa de maximizar a nossa métrica primária, validation_acc.

Também definimos uma política de rescisão antecipada - a BanditPolicy. Esta política funciona verificando o trabalho a cada duas iterações. Se a métrica primária, validation_acc, ficar fora do intervalo de 10%, a AzureML terminará o trabalho. Isto evita que o modelo continue a explorar hiperparímetros que não mostram nenhuma promessa de ajudar a atingir 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, pode submeter este trabalho como antes. Desta vez, vais fazer um trabalho de varredura 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 o trabalho utilizando o link de interface do utilizador do estúdio que é apresentado durante o funcionaário.

Encontre e registe o melhor modelo

Uma vez concluídas todas as corridas, pode encontrar a corrida 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)

Implemente o modelo como um ponto final online

Depois de ter registado o seu modelo, pode implantá-lo como um ponto final online , isto é, como um serviço web na nuvem Azure.

Para implementar um serviço de aprendizagem automática, normalmente necessitará:

  • Os modelos que quer implantar. Estes ativos incluem o ficheiro do modelo e metadados que já registou no seu trabalho de formação.
  • Algum código para funcionar como um serviço. O código executa o modelo num dado pedido de entrada (um script de entrada). Este script de entrada recebe dados submetidos a um serviço web implantado e passa-os para o modelo. Após o modelo processar os dados, o script devolve a resposta do modelo ao cliente. O script é específico do seu modelo e deve entender os dados que o modelo espera e devolve. Quando utiliza um modelo MLFlow, a AzureML cria automaticamente este script para si.

Para obter mais informações sobre a implementação, consulte Implementar e marcar um modelo de machine learning com um ponto final online gerido utilizando Python SDK v2.

Criar um novo ponto final online

Como primeiro passo para implementar o seu modelo, precisa de criar o seu ponto final online. O nome final deve ser único em toda a região de Azure. Para este artigo, você vai criar um nome único usando um identificador universalmente único (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}")

Uma vez criado o ponto final, pode recuperá-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 múltiplas implementações. Utilizando regras, o ponto final pode então direcionar o tráfego para estas implementações.

No seguinte código, irá criar uma única implantação que lida com 100% do tráfego de entrada. Especificamos um nome de cor arbitrário (azul-tff) para a implantação. Também pode utilizar qualquer outro nome, como tff-green ou tff-red para a implantação. O código para implantar o modelo no ponto final faz o seguinte:

  • implementa a melhor versão do modelo que registou anteriormente;
  • pontuar o modelo, usando o score.py arquivo;
  • usa o mesmo ambiente curado (que declarou anteriormente) para realizar inferencing.
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 implantação leve algum tempo para terminar.

Testar a colocação com uma consulta de amostra

Agora que implementou o modelo para o ponto final, pode prever a saída do modelo implantado, utilizando o invoke método no ponto final. Para executar a inferência, utilize o ficheiro sample-request.json de pedido de amostra da pasta de pedido .

# # predict using the deployed model
result = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./request.json",
    deployment_name="tff-blue",
)

Em seguida, pode imprimir as previsões devolvidas e deserá-las juntamente com as imagens de entrada. Use a cor da fonte vermelha e a imagem invertida (branca em preto) para destacar 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

Como a precisão do modelo é elevada, pode ter de executar a célula algumas vezes antes de ver uma amostra mal classificada.

Limpar os recursos

Se não utilizar o ponto final, elimine-o para parar de utilizar o recurso. Certifique-se de que não há outras implementações que utilizem o ponto final antes de o eliminar.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Nota

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

Passos seguintes

Neste artigo, treinou e registou um modelo TensorFlow. Também implementou o modelo para um ponto final online. Veja estes outros artigos para saber mais sobre Azure Machine Learning.