Treinar modelos Keras 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 Keras usando o SDK do Python do Azure Machine Learning v2.

O código de exemplo neste artigo usa o Aprendizado de Máquina do Azure para treinar, registrar e implantar um modelo Keras criado usando o back-end do TensorFlow. O modelo, uma rede neural profunda (DNN) construída com a biblioteca Keras Python em execução sobre o TensorFlow, classifica dígitos manuscritos do popular conjunto de dados MNIST.

Keras é uma API de rede neural de alto nível capaz de executar o topo de outras estruturas DNN populares para simplificar o desenvolvimento. Com o Azure Machine Learning, você pode expandir rapidamente trabalhos de treinamento usando recursos de computação em nuvem elástica. Você também pode acompanhar suas execuções de treinamento, modelos de versão, implantar modelos e muito mais.

Quer esteja a desenvolver um modelo Keras a partir do zero ou a trazer um modelo existente para a nuvem, o Azure Machine Learning pode ajudá-lo a criar modelos prontos para produção.

Nota

Se você estiver usando a API Keras tf.keras integrada ao TensorFlow e não o pacote Keras autônomo, consulte Train TensorFlow models.

Pré-requisitos

Para se beneficiar deste artigo, você precisará:

• 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 Crie recursos para começar a 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-keras.
  • Seu servidor de notebook Jupyter
    • Instale o SDK do Azure Machine Learning (v2).
• Baixe os scripts de treinamento keras_mnist.py e utils.py.

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ê precisará 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ê usará 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 para executar o trabalho

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ê precisará 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) ou crie um ambiente personalizado usando uma imagem do Docker ou uma configuração Conda. Neste artigo, você criará um ambiente Conda personalizado para seus trabalhos, usando um arquivo Conda YAML.

Criar um ambiente personalizado

Para criar seu ambiente personalizado, você definirá suas dependências do Conda em um arquivo YAML. Primeiro, crie um diretório para armazenar o arquivo. Neste exemplo, nomeamos o diretório dependencies.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Em seguida, crie o arquivo no diretório dependencies. Neste exemplo, nomeamos o arquivo conda.ymlcomo .

%%writefile {dependencies_dir}/conda.yaml
name: keras-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - pip=21.2.4
  - pip:
    - protobuf~=3.20
    - numpy==1.22
    - tensorflow-gpu==2.2.0
    - keras<=2.3.1
    - matplotlib
    - azureml-mlflow==1.42.0

A especificação contém alguns pacotes usuais (como numpy e pip) que você usará em seu trabalho.

Em seguida, use o arquivo YAML para criar e registrar esse ambiente personalizado em seu espaço de trabalho. O ambiente será empacotado em um contêiner do Docker em tempo de execução.

from azure.ai.ml.entities import Environment

custom_env_name = "keras-env"

job_env = Environment(
    name=custom_env_name,
    description="Custom environment for keras image classification",
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
job_env = ml_client.environments.create_or_update(job_env)

print(
    f"Environment with name {job_env.name} is registered to workspace, the environment version is {job_env.version}"
)

Para obter mais informações sobre como criar e usar ambientes, consulte Criar e usar ambientes de software no Azure Machine Learning.

Configurar e enviar seu trabalho de treinamento

Nesta seção, começaremos apresentando os dados para treinamento. Em seguida, abordaremos como executar um trabalho de treinamento, usando um script de treinamento que fornecemos. Você aprenderá a criar o trabalho de treinamento configurando o comando para executar o script de treinamento. Em seguida, você enviará 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 keras_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ê usará 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 keras_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, criaremos 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ê usará 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=50,
        first_layer_neurons=300,
        second_layer_neurons=100,
        learning_rate=0.001,
    ),
    compute=gpu_compute_target,
    environment=f"{job_env.name}:{job_env.version}",
    code="./src/",
    command="python keras_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="keras-dnn-image-classify",
    display_name="keras-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 keras-env personalizado que você criou para executar o trabalho do Azure Machine Learning;
  • Configure a própria ação da linha de comando — nesse caso, o comando é python keras_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

Você treinou o modelo com um conjunto de parâmetros, vamos agora 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=[25, 50, 100]),
    first_layer_neurons=Choice(values=[10, 50, 200, 300, 500]),
    second_layer_neurons=Choice(values=[10, 50, 200, 500]),
    learning_rate=LogUniform(min_value=-6, max_value=-1),
)

Em seguida, você configurará 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, ficar fora do intervalo superior de dez por cento, 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="Accuracy",
    goal="Maximize",
    max_total_trials=20,
    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 "keras_dnn_mnist_model"
        path="azureml://jobs/{}/outputs/artifacts/paths/keras_dnn_mnist_model/".format(
            best_run
        ),
        name="run-model-example",
        description="Model created from run.",
        type="mlflow_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, normalmente você precisará:

• 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ê criará um nome exclusivo usando um identificador universalmente exclusivo (UUID).

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "keras-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 Keras",
    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ê criará uma única implantação que lida com 100% do tráfego de entrada. Especificamos um nome de cor arbitrária (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 ambiente personalizado (que você criou anteriormente) para executar inferências.

from azure.ai.ml.entities import ManagedOnlineDeployment, CodeConfiguration

model = registered_model

# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name="keras-blue-deployment",
    endpoint_name=online_endpoint_name,
    model=model,
    # code_configuration=CodeConfiguration(code="./src", scoring_script="score.py"),
    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 o modelo implementado

Agora que você implantou 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 testar o ponto de extremidade, você precisa de alguns dados de teste. Vamos baixar localmente os dados de teste que usamos em nosso script de treinamento.

import urllib.request

data_folder = os.path.join(os.getcwd(), "data")
os.makedirs(data_folder, exist_ok=True)

urllib.request.urlretrieve(
    "https://azureopendatastorage.blob.core.windows.net/mnist/t10k-images-idx3-ubyte.gz",
    filename=os.path.join(data_folder, "t10k-images-idx3-ubyte.gz"),
)
urllib.request.urlretrieve(
    "https://azureopendatastorage.blob.core.windows.net/mnist/t10k-labels-idx1-ubyte.gz",
    filename=os.path.join(data_folder, "t10k-labels-idx1-ubyte.gz"),
)

Carregue-os em um conjunto de dados de teste.

from src.utils import load_data

X_test = load_data(os.path.join(data_folder, "t10k-images-idx3-ubyte.gz"), False)
y_test = load_data(
    os.path.join(data_folder, "t10k-labels-idx1-ubyte.gz"), True
).reshape(-1)

Escolha 30 amostras aleatórias do conjunto de teste e escreva-as em um arquivo JSON.

import json
import numpy as np

# find 30 random samples from test set
n = 30
sample_indices = np.random.permutation(X_test.shape[0])[0:n]

test_samples = json.dumps({"input_data": X_test[sample_indices].tolist()})
# test_samples = bytes(test_samples, encoding='utf8')

with open("request.json", "w") as outfile:
    outfile.write(test_samples)

Em seguida, você pode invocar o ponto de extremidade, 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.

import matplotlib.pyplot as plt

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

# compare actual value vs. the predicted values:
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 Keras. 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