Tutorial: Treinar e implantar um modelo de classificação de imagem com um exemplo de Jupyter Notebook

APLICA-SE A: SDK do Python azureml v1

Neste tutorial, você treina um modelo de machine learning em recursos remotos de computação. Use o fluxo de trabalho de treinamento e implantação do Aprendizado de Máquina do Azure em um Bloco de Anotações Jupyter Python. Você pode usar o notebook como um modelo para treinar seu próprio modelo de aprendizado de máquina com seus próprios dados.

Este tutorial treina uma regressão logística simples usando o conjunto de dados do MNIST e o Scikit-learn com o Azure Machine Learning. MNIST é um conjunto de dados popular que consiste em 70.000 imagens em escala de cinza. Cada imagem é um dígito manuscrito de 28 x 28 pixels, representando um número de zero a nove. O objetivo é criar um classificador de várias classes para identificar o dígito que uma determinada imagem representa.

Saiba como executar as seguintes ações:

Pré-requisitos

• Conclua o Guia de início rápido: Introdução ao Azure Machine Learning para:
  • Crie um workspace.
  • Criar uma instância de computação baseada em nuvem e usá-la para seu ambiente de desenvolvimento.

Executar um notebook no seu workspace

O Azure Machine Learning inclui um servidor de notebook de nuvem em seu workspace para uma experiência pré-configurada sem necessidade de instalação. Use seu ambiente se preferir ter controle sobre ele e sobre pacotes e dependências.

Clonar uma pasta do notebook

Conclua as etapas de instalação e execução de teste a seguir no Estúdio do Azure Machine Learning. Essa interface consolidada inclui ferramentas de machine learning para executar cenários de ciência de dados para profissionais de ciência de dados de todos os níveis de habilidade.

1. Entre no Estúdio do Azure Machine Learning.

2. Selecione a assinatura e o workspace criado.

3. À esquerda, selecione Notebooks.

4. Na parte superior, selecione a guia Amostras.

5. Abra a pasta do SDK v1.

6. Selecione o botão ... à direita da pasta tutorials e, em seguida, selecione Clonar.

   

7. Uma lista de pastas mostra cada usuário que acessa o workspace. Selecione sua pasta para clonar a pasta tutoriais nela.

Abrir o notebook clonado

1. Abra a pasta tutoriais que foi clonada na seção Arquivos do usuário.

2. Selecione o arquivo quickstart-azureml-in-10mins.ipynb na pasta tutorials/compute-instance-quickstarts/quickstart-azureml-in-10mins.

   

Instalar Pacotes

Depois que a instância de computação estiver em execução e o kernel for exibido, adicione uma nova célula de código para instalar os pacotes necessários para este tutorial.

1. Na parte superior do bloco de anotações, adicione uma célula de código.

2. Adicione o seguinte à célula e execute a célula usando a ferramenta Executar ou usando Shift+Enter.

   %pip install scikit-learn==0.22.1
   %pip install scipy==1.5.2
   

Você pode ver alguns avisos de instalação. Isso podem ser ignorados.

Executar o notebook

Este tutorial e o arquivo complementar utils.py também está disponível no GitHub caso deseje usá-lo em um ambiente local próprio. Se você não estiver usando a instância de computação, adicione %pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib à instalação acima.

Importar dados

Antes de treinar um modelo, você precisa entender os dados que está usando para treiná-lo. Nesta seção, você aprenderá a:

• Baixe o conjunto de dados MNIST
• Exibir algumas imagens de exemplo

Use o Azure Open Datasets para obter os arquivos de dados MNIST brutos. O Azure Open Datasets são conjuntos de dados públicos coletados que você pode usar para adicionar recursos específicos do cenário a soluções de machine learning a fim de obter modelos melhores. Cada conjunto de dados tem uma classe correspondente, MNIST nesse caso, para recuperar os dados de maneiras diferentes.

import os
from azureml.opendatasets import MNIST

data_folder = os.path.join(os.getcwd(), "/tmp/qs_data")
os.makedirs(data_folder, exist_ok=True)

mnist_file_dataset = MNIST.get_file_dataset()
mnist_file_dataset.download(data_folder, overwrite=True)

Examinar os dados

Carregue os arquivos compactados em numpy matrizes. Em seguida, use matplotlib para plotar 30 imagens aleatórias do conjunto de dados com seus rótulos acima delas.

Observação Esta etapa requer uma função load_data, incluída em um arquivo utils.py. Esse arquivo foi colocado na mesma pasta deste notebook. A função load_data simplesmente analisa os arquivos compactados em matrizes numpy.

from utils import load_data
import matplotlib.pyplot as plt
import numpy as np
import glob


# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the model converge faster.
X_train = (
    load_data(
        glob.glob(
            os.path.join(data_folder, "**/train-images-idx3-ubyte.gz"), recursive=True
        )[0],
        False,
    )
    / 255.0
)
X_test = (
    load_data(
        glob.glob(
            os.path.join(data_folder, "**/t10k-images-idx3-ubyte.gz"), recursive=True
        )[0],
        False,
    )
    / 255.0
)
y_train = load_data(
    glob.glob(
        os.path.join(data_folder, "**/train-labels-idx1-ubyte.gz"), recursive=True
    )[0],
    True,
).reshape(-1)
y_test = load_data(
    glob.glob(
        os.path.join(data_folder, "**/t10k-labels-idx1-ubyte.gz"), recursive=True
    )[0],
    True,
).reshape(-1)


# now let's show some randomly chosen images from the traininng set.
count = 0
sample_size = 30
plt.figure(figsize=(16, 6))
for i in np.random.permutation(X_train.shape[0])[:sample_size]:
    count = count + 1
    plt.subplot(1, sample_size, count)
    plt.axhline("")
    plt.axvline("")
    plt.text(x=10, y=-10, s=y_train[i], fontsize=18)
    plt.imshow(X_train[i].reshape(28, 28), cmap=plt.cm.Greys)
plt.show()

O código exibe um conjunto aleatório de imagens com seus rótulos, semelhante a este:

Treinar o modelo e registrar as métricas em log com o MLflow

Treine o modelo usando o código a seguir. Esse código usa o log automático MLflow para rastrear métricas e artefatos de modelo de log.

Você usará o classificador LogisticRegression da estrutura Scikit-learn para classificar os dados.

# create the model
import mlflow
import numpy as np
from sklearn.linear_model import LogisticRegression
from azureml.core import Workspace

# connect to your workspace
ws = Workspace.from_config()

# create experiment and start logging to a new run in the experiment
experiment_name = "azure-ml-in10-mins-tutorial"

# set up MLflow to track the metrics
mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())
mlflow.set_experiment(experiment_name)
mlflow.autolog()

# set up the Logistic regression model
reg = 0.5
clf = LogisticRegression(
    C=1.0 / reg, solver="liblinear", multi_class="auto", random_state=42
)

# train the model
with mlflow.start_run() as run:
    clf.fit(X_train, y_train)

Exibir experimento

No menu à esquerda no Estúdio do Azure Machine Learning, selecione Trabalhos e escolha seu trabalho (azure-ml-in10-mins-tutorial). Um trabalho é um agrupamento de diversas execuções de um script ou um código especificados. Vários trabalhos podem ser agrupados como um experimento.

As informações da execução são armazenadas nesse trabalho. Se o nome não existir quando você enviar um trabalho, se você selecionar sua execução, verá várias guias contendo métricas, logs, explicações, etc.

Fazer o controle de versão de modelos com o registro de modelo

É possível usar o registro de modelo para armazenar seus modelos e controlar a versão deles no workspace. Modelos registrados são identificados por nome e versão. Cada vez que você registra um modelo com o mesmo nome de um já existente, o Registro incrementa a versão. O código abaixo registra o modelo treinado acima e controla a versão dele. Depois de executar a célula de código a seguir, você verá o modelo no Registro selecionando Modelos no menu à esquerda no estúdio do Aprendizado de Máquina do Azure.

# register the model
model_uri = "runs:/{}/model".format(run.info.run_id)
model = mlflow.register_model(model_uri, "sklearn_mnist_model")

Implantar o modelo para inferência em tempo real

Nesta seção, saiba como implantar um modelo para que um aplicativo possa consumir (inferência) o modelo sobre REST.

Criar uma configuração de implantação

A célula de código obtém um ambiente coletado, que especifica todas as dependências necessárias para hospedar o modelo (por exemplo, os pacotes como o Scikit-learn). Além disso, você criará uma configuração de implantação, que especifica a quantidade de computação necessária para hospedar o modelo. Nesse caso, a computação tem 1CPU e 1 GB de memória.

# create environment for the deploy
from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies
from azureml.core.webservice import AciWebservice

# get a curated environment
env = Environment.get(
    workspace=ws, 
    name="AzureML-sklearn-1.0"
)
env.inferencing_stack_version='latest'

# create deployment config i.e. compute resources
aciconfig = AciWebservice.deploy_configuration(
    cpu_cores=1,
    memory_gb=1,
    tags={"data": "MNIST", "method": "sklearn"},
    description="Predict MNIST with sklearn",
)

Implantar modelo

Esta próxima célula de código implantará o modelo na Instância de Contêiner do Azure.

%%time
import uuid
from azureml.core.model import InferenceConfig
from azureml.core.environment import Environment
from azureml.core.model import Model

# get the registered model
model = Model(ws, "sklearn_mnist_model")

# create an inference config i.e. the scoring script and environment
inference_config = InferenceConfig(entry_script="score.py", environment=env)

# deploy the service
service_name = "sklearn-mnist-svc-" + str(uuid.uuid4())[:4]
service = Model.deploy(
    workspace=ws,
    name=service_name,
    models=[model],
    inference_config=inference_config,
    deployment_config=aciconfig,
)

service.wait_for_deployment(show_output=True)

O arquivo de script de pontuação mencionado no código anterior pode ser encontrado na mesma pasta que este bloco de anotações e tem duas funções:

1. Uma função init que é executada uma vez quando o serviço é iniciado. Nessa função, você normalmente obterá o modelo do registro e definirá variáveis globais
2. Uma função run(data) que é executada sempre que uma chamada é feita ao serviço. Nessa função, você normalmente formatará os dados de entrada, executará uma previsão e produzirá o resultado previsto.

Exibir o ponto de extremidade

Depois que o modelo for implantado com êxito, você poderá exibir o ponto de extremidade navegando até Pontos de extremidade no menu à esquerda no estúdio do Aprendizado de Máquina do Azure. Você verá o estado do ponto de extremidade (íntegro/não íntegro), logs e consumo (como os aplicativos podem consumir o modelo).

Testar o serviço de modelo

Você pode testar o modelo enviando uma solicitação HTTP bruta para testar o serviço Web.

# send raw HTTP request to test the web service.
import requests

# send a random row from the test set to score
random_index = np.random.randint(0, len(X_test) - 1)
input_data = '{"data": [' + str(list(X_test[random_index])) + "]}"

headers = {"Content-Type": "application/json"}

resp = requests.post(service.scoring_uri, input_data, headers=headers)

print("POST to url", service.scoring_uri)
print("label:", y_test[random_index])
print("prediction:", resp.text)

Limpar recursos

Se não pretende continuar usando esse modelo, exclua o serviço de modelo usando:

# if you want to keep workspace and only delete endpoint (it will incur cost while running)
service.delete()

Caso deseje controlar ainda mais o custo, interrompa a instância de computação selecionando o botão "Parar computação" ao lado da lista suspensa Computação. Em seguida, inicie a instância de computação novamente na próxima vez que precisar.

Excluir tudo

Use estas etapas para excluir seu workspace do Azure Machine Learning e todos os recursos de computação.

Se você não pretende usar nenhum dos recursos criados, exclua-os para não gerar custos:

1. No portal do Azure, selecione Grupos de recursos no canto esquerdo.

2. Selecione o grupo de recursos que você criou por meio da lista.

3. Selecione Excluir grupo de recursos.

   

4. Insira o nome do grupo de recursos. Em seguida, selecione Excluir.

Recursos relacionados

• Saiba mais sobre todas as opções de implantação do Azure Machine Learning.
• Saiba como autenticar no modelo implantado.
• Fazer previsões sobre grandes quantidades de dados assincronamente.
• Monitorar seus modelos do Azure Machine Learning com o Application Insights.