Tutorial: Treinar modelos de classificação de imagem usando dados MNIST e scikit-learn com o Azure Machine LearningTutorial: Train image classification models with MNIST data and scikit-learn using Azure Machine Learning

Neste tutorial, você treina um modelo de machine learning em recursos remotos de computação.In this tutorial, you train a machine learning model on remote compute resources. Você usará o fluxo de trabalho de treinamento e implantação do serviço Azure Machine Learning (versão prévia) em um Jupyter Notebook Python.You'll use the training and deployment workflow for Azure Machine Learning service (preview) in a Python Jupyter notebook. Você pode usar o notebook como um modelo para treinar seu próprio modelo de aprendizado de máquina com seus próprios dados.You can then use the notebook as a template to train your own machine learning model with your own data. Este tutorial é parte uma de uma série de tutoriais de duas partes.This tutorial is part one of a two-part tutorial series.

Este tutorial treina uma regressão logística simples, usando o conjunto de dados do MNIST e o scikit-learn com o Serviço do Azure Machine Learning.This tutorial trains a simple logistic regression by using the MNIST dataset and scikit-learn with Azure Machine Learning service. MNIST é um conjunto de dados popular que consiste em 70.000 imagens em escala de cinza.MNIST is a popular dataset consisting of 70,000 grayscale images. Cada imagem é um dígito manuscrito de 28 x 28 pixels, representando um número de zero a nove.Each image is a handwritten digit of 28 x 28 pixels, representing a number from zero to nine. A meta é criar um classificador de várias classes para identificar o dígito que uma determinada imagem representa.The goal is to create a multiclass classifier to identify the digit a given image represents.

Saiba como executar as seguintes ações:Learn how to take the following actions:

  • Configurar seu ambiente de desenvolvimento.Set up your development environment.
  • Acessar e examinar os dados.Access and examine the data.
  • Treinar um modelo de regressão logística simples em um cluster remoto.Train a simple logistic regression model on a remote cluster.
  • Analisar os resultados do treinamento e registrar o melhor modelo.Review training results and register the best model.

Você aprenderá como selecionar um modelo e implantá-lo na parte dois deste tutorial.You learn how to select a model and deploy it in part two of this tutorial.

Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.If you don’t have an Azure subscription, create a free account before you begin. Experimente a versão gratuita ou paga do Serviço do Azure Machine Learning hoje mesmo.Try the free or paid version of Azure Machine Learning service today.

Observação

O código deste artigo foi testado com a versão 1.0.41 do SDK do Azure Machine Learning.Code in this article was tested with Azure Machine Learning SDK version 1.0.41.

Pré-requisitosPrerequisites

Vá para Configurar seu ambiente de desenvolvimento para ler as etapas do notebook ou use as instruções abaixo para obter o notebook e executá-lo em Azure Notebooks ou seu próprio servidor de notebook.Skip to Set up your development environment to read through the notebook steps, or use the instructions below to get the notebook and run it on Azure Notebooks or your own notebook server. Para executar o notebook, você precisará de:To run the notebook you will need:

  • Um servidor de notebook do Python 3.6 com o seguinte instalado:A Python 3.6 notebook server with the following installed:
    • O SDK do Azure Machine Learning para PythonThe Azure Machine Learning SDK for Python
    • matplotlib e scikit-learnmatplotlib and scikit-learn
  • O notebook do tutorial e o arquivo utils.pyThe tutorial notebook and the file utils.py
  • Um workspace do machine learningA machine learning workspace
  • O arquivo de configuração para o workspace no mesmo diretório que o notebookThe configuration file for the workspace in the same directory as the notebook

Obtenha todos esses pré-requisitos de qualquer uma das seções a seguir.Get all these prerequisites from either of the sections below.

Usar um servidor de notebook de nuvem em seu workspaceUse a cloud notebook server in your workspace

É fácil começar a usar seu próprio servidor de notebook baseado em nuvem.It's easy to get started with your own cloud-based notebook server. O SDK do Azure Machine Learning para Python já está instalado e configurado depois que você cria este recurso de nuvem.The Azure Machine Learning SDK for Python is already installed and configured for you once you create this cloud resource.

  • Depois de iniciar a página da Web do notebook, abra o notebook tutorials/img-classification-part1-training.ipynb.After you launch the notebook webpage, open the tutorials/img-classification-part1-training.ipynb notebook.

Use seu próprio servidor do Jupyter NotebookUse your own Jupyter notebook server

  1. Use as instruções descritas em Criar um workspace do Serviço do Azure Machine Learning para fazer o seguinte:Use the instructions at Create an Azure Machine Learning service workspace to do the following:

    • Criar um ambiente MinicondaCreate a Miniconda environment
    • Instalar o SDK do Azure Machine Learning para PythonInstall the Azure Machine Learning SDK for Python
    • Criar um workspaceCreate a workspace
    • Gravar um arquivo de configuração do espaço de trabalho (aml_config/config.json).Write a workspace configuration file (aml_config/config.json).
  2. Clone o repositório do GitHub.Clone the GitHub repository.

    git clone https://github.com/Azure/MachineLearningNotebooks.git
    
  3. Inicie o servidor de notebook do seu diretório clonado.Start the notebook server from your cloned directory.

    jupyter notebook
    

Depois de concluir as etapas, execute o notebook tutorials/img-classification-part1-training.ipynb no diretório clonado.After you complete the steps, run the tutorials/img-classification-part1-training.ipynb notebook from your cloned directory.

Configurar seu ambiente de desenvolvimentoSet up your development environment

Toda a configuração para o seu trabalho de desenvolvimento pode ser realizada em um bloco de anotações do Python.All the setup for your development work can be accomplished in a Python notebook. A configuração inclui as seguintes ações:Setup includes the following actions:

  • Importar pacotes do Python.Import Python packages.
  • Conectar-se ao workspace, para que seu computador local possa se comunicar com recursos remotos.Connect to a workspace, so that your local computer can communicate with remote resources.
  • Criar um experimento para acompanhar todas as suas execuções.Create an experiment to track all your runs.
  • Criar um destino de computação remota para usar no treinamento.Create a remote compute target to use for training.

Importar pacotesImport packages

Importe pacotes Python que você precisa nesta sessão.Import Python packages you need in this session. Além disso, exiba a versão do SDK do Azure Machine Learning:Also display the Azure Machine Learning SDK version:

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

import azureml.core
from azureml.core import Workspace

# check core SDK version number
print("Azure ML SDK Version: ", azureml.core.VERSION)

Conectar-se a um workspaceConnect to a workspace

Crie um objeto de workspace a partir do workspace existente.Create a workspace object from the existing workspace. Workspace.from_config() lê o arquivo config. JSON e carrega os detalhes em um objeto chamado ws:Workspace.from_config() reads the file config.json and loads the details into an object named ws:

# load workspace configuration from the config.json file in the current folder.
ws = Workspace.from_config()
print(ws.name, ws.location, ws.resource_group, ws.location, sep = '\t')

Criar uma experiênciaCreate an experiment

Crie um teste para acompanhar as execuções em seu workspace.Create an experiment to track the runs in your workspace. Um workspace pode ter vários experimentos:A workspace can have multiple experiments:

experiment_name = 'sklearn-mnist'

from azureml.core import Experiment
exp = Experiment(workspace=ws, name=experiment_name)

Criar ou anexar a um recurso de computação existenteCreate or attach an existing compute resource

Usando a Computação do Azure Machine Learning, um serviço gerenciado, os cientistas de dados podem treinar modelos de aprendizado de máquina em clusters de máquinas virtuais do Azure.By using Azure Machine Learning Compute, a managed service, data scientists can train machine learning models on clusters of Azure virtual machines. Exemplos incluem máquinas virtuais com suporte a GPU.Examples include VMs with GPU support. Neste tutorial, você cria a Computação do Azure Machine Learning como seu ambiente de treinamento.In this tutorial, you create Azure Machine Learning Compute as your training environment. O código abaixo criará clusters de computação para você se eles ainda não existirem em seu workspace.The code below creates the compute clusters for you if they don't already exist in your workspace.

A criação do cluster de computação leva cerca de cinco minutos.Creation of the compute takes about five minutes. Se o cluster de computação já estiver no workspace, o código o usará e ignorará o processo de criação.If the compute is already in the workspace, the code uses it and skips the creation process.

from azureml.core.compute import AmlCompute
from azureml.core.compute import ComputeTarget
import os

# choose a name for your cluster
compute_name = os.environ.get("AML_COMPUTE_CLUSTER_NAME", "cpucluster")
compute_min_nodes = os.environ.get("AML_COMPUTE_CLUSTER_MIN_NODES", 0)
compute_max_nodes = os.environ.get("AML_COMPUTE_CLUSTER_MAX_NODES", 4)

# This example uses CPU VM. For using GPU VM, set SKU to STANDARD_NC6
vm_size = os.environ.get("AML_COMPUTE_CLUSTER_SKU", "STANDARD_D2_V2")


if compute_name in ws.compute_targets:
    compute_target = ws.compute_targets[compute_name]
    if compute_target and type(compute_target) is AmlCompute:
        print('found compute target. just use it. ' + compute_name)
else:
    print('creating a new compute target...')
    provisioning_config = AmlCompute.provisioning_configuration(vm_size = vm_size,
                                                                min_nodes = compute_min_nodes,
                                                                max_nodes = compute_max_nodes)

    # create the cluster
    compute_target = ComputeTarget.create(ws, compute_name, provisioning_config)

    # can poll for a minimum number of nodes and for a specific timeout.
    # if no min node count is provided it will use the scale settings for the cluster
    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

     # For a more detailed view of current AmlCompute status, use get_status()
    print(compute_target.get_status().serialize())

Agora você tem os pacotes necessários e recursos de computação para treinar um modelo na nuvem.You now have the necessary packages and compute resources to train a model in the cloud.

Explorar dadosExplore data

Antes de treinar um modelo, você precisa entender os dados que você usa para treiná-lo.Before you train a model, you need to understand the data that you use to train it. Você também precisa copiar os dados para a nuvem.You also need to copy the data into the cloud. Em seguida, eles podem ser acessados pelo seu ambiente de treinamento de nuvem.Then it can be accessed by your cloud training environment. Nesta seção, você aprende como executar as seguintes ações:In this section, you learn how to take the following actions:

  • Baixar o conjunto de dados do MNIST.Download the MNIST dataset.
  • Exibir algumas imagens de exemplo.Display some sample images.
  • Carregar dados para a nuvem.Upload data to the cloud.

Baixe o conjunto de dados MNISTDownload the MNIST dataset

Baixe o conjunto de dados MNIST e salvar os arquivos em um data directory localmente.Download the MNIST dataset and save the files into a data directory locally. Imagens e rótulos, tanto para treinamento quanto para teste, são baixados:Images and labels for both training and testing are downloaded:

import urllib.request
import os

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

urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz', filename=os.path.join(data_folder, 'train-images.gz'))
urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz', filename=os.path.join(data_folder, 'train-labels.gz'))
urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz', filename=os.path.join(data_folder, 'test-images.gz'))
urllib.request.urlretrieve('http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz', filename=os.path.join(data_folder, 'test-labels.gz'))

Você verá uma saída semelhante a esta: ('./data/test-labels.gz', <http.client.HTTPMessage at 0x7f40864c77b8>)You will see output similar to this: ('./data/test-labels.gz', <http.client.HTTPMessage at 0x7f40864c77b8>)

Exibir algumas imagens de exemploDisplay some sample images

Carregue os arquivos compactados em numpy matrizes.Load the compressed files into numpy arrays. Em seguida, use matplotlib para plotar 30 imagens aleatórias do conjunto de dados com seus rótulos acima delas.Then use matplotlib to plot 30 random images from the dataset with their labels above them. Esta etapa exige uma função load_data, que está incluída em um arquivo util.py.This step requires a load_data function that's included in an util.py file. Esse arquivo está incluído na pasta de exemplo.This file is included in the sample folder. Verifique se ele foi colocado na mesma pasta que este notebook.Make sure it's placed in the same folder as this notebook. A função load_data simplesmente analisa os arquivos compactados em matrizes numpy:The load_data function simply parses the compressed files into numpy arrays:

# make sure utils.py is in the same directory as this code
from utils import load_data

# note we also shrink the intensity values (X) from 0-255 to 0-1. This helps the model converge faster.
X_train = load_data(os.path.join(data_folder, 'train-images.gz'), False) / 255.0
X_test = load_data(os.path.join(data_folder, 'test-images.gz'), False) / 255.0
y_train = load_data(os.path.join(data_folder, 'train-labels.gz'), True).reshape(-1)
y_test = load_data(os.path.join(data_folder, 'test-labels.gz'), 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()

Uma amostra aleatória de imagens é exibida:A random sample of images displays:

Amostra aleatória das imagens

Agora você tem uma ideia de como essas imagens se parecem e o resultado esperado da previsão.Now you have an idea of what these images look like and the expected prediction outcome.

Carregar dados para a nuvemUpload data to the cloud

Agora, torne os dados acessíveis remotamente enviando-os do computador local para o Azure.Now make the data accessible remotely by uploading that data from your local machine into Azure. Então, ele pode ser acessado para treinamento remoto.Then it can be accessed for remote training. O armazenamento de dados é um constructo prático associado ao seu workspace para você fazer upload/download de dados.The datastore is a convenient construct associated with your workspace for you to upload or download data. Você também pode interagir com ele de seus destinos de computação remotos.You can also interact with it from your remote compute targets. Ele tem suporte de uma conta de Armazenamento de Blobs do Azure.It's backed by an Azure Blob storage account.

Os arquivos do MNIST são carregados em um diretório chamado mnist na raiz do armazenamento de dados:The MNIST files are uploaded into a directory named mnist at the root of the datastore:

ds = ws.get_default_datastore()
print(ds.datastore_type, ds.account_name, ds.container_name)

ds.upload(src_dir=data_folder, target_path='mnist', overwrite=True, show_progress=True)

Agora você tem tudo de que precisa para começar a treinar um modelo.You now have everything you need to start training a model.

Treinar em um cluster remotoTrain on a remote cluster

Para esta tarefa, envie o trabalho para o cluster de treinamento remoto que você configurou anteriormente.For this task, submit the job to the remote training cluster you set up earlier. Para enviar um trabalho é:To submit a job you:

  • Criar um diretórioCreate a directory
  • Criar um script de treinamentoCreate a training script
  • Criar um objeto avaliadorCreate an estimator object
  • Enviar o trabalhoSubmit the job

Criar um diretórioCreate a directory

Crie um diretório para entregar o código necessário do seu computador para o recurso remoto.Create a directory to deliver the necessary code from your computer to the remote resource.

import os
script_folder  = os.path.join(os.getcwd(), "sklearn-mnist")
os.makedirs(script_folder, exist_ok=True)

Criar um script de treinamentoCreate a training script

Para enviar o trabalho para o cluster, primeiro crie um script de treinamento.To submit the job to the cluster, first create a training script. Execute o seguinte código para criar o script de treinamento chamado train.py no diretório que você acabou de criar.Run the following code to create the training script called train.py in the directory you just created.

%%writefile $script_folder/train.py

import argparse
import os
import numpy as np

from sklearn.linear_model import LogisticRegression
from sklearn.externals import joblib

from azureml.core import Run
from utils import load_data

# let user feed in 2 parameters, the location of the data files (from datastore), and the regularization rate of the logistic regression model
parser = argparse.ArgumentParser()
parser.add_argument('--data-folder', type=str, dest='data_folder', help='data folder mounting point')
parser.add_argument('--regularization', type=float, dest='reg', default=0.01, help='regularization rate')
args = parser.parse_args()

data_folder = args.data_folder
print('Data folder:', data_folder)

# load train and test set into numpy arrays
# note we scale the pixel intensity values to 0-1 (by dividing it with 255.0) so the model can converge faster.
X_train = load_data(os.path.join(data_folder, 'train-images.gz'), False) / 255.0
X_test = load_data(os.path.join(data_folder, 'test-images.gz'), False) / 255.0
y_train = load_data(os.path.join(data_folder, 'train-labels.gz'), True).reshape(-1)
y_test = load_data(os.path.join(data_folder, 'test-labels.gz'), True).reshape(-1)
print(X_train.shape, y_train.shape, X_test.shape, y_test.shape, sep = '\n')

# get hold of the current run
run = Run.get_context()

print('Train a logistic regression model with regularization rate of', args.reg)
clf = LogisticRegression(C=1.0/args.reg, solver="liblinear", multi_class="auto", random_state=42)
clf.fit(X_train, y_train)

print('Predict the test set')
y_hat = clf.predict(X_test)

# calculate accuracy on the prediction
acc = np.average(y_hat == y_test)
print('Accuracy is', acc)

run.log('regularization rate', np.float(args.reg))
run.log('accuracy', np.float(acc))

os.makedirs('outputs', exist_ok=True)
# note file saved in the outputs folder is automatically uploaded into experiment record
joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

Observe como o script obtém dados e salva modelos:Notice how the script gets data and saves models:

  • O script de treinamento lê um argumento para localizar o diretório que contém os dados.The training script reads an argument to find the directory that contains the data. Quando você envia o trabalho mais tarde, você aponta para o armazenamento de dados para este argumento: parser.add_argument('--data-folder', type=str, dest='data_folder', help='data directory mounting point')When you submit the job later, you point to the datastore for this argument: parser.add_argument('--data-folder', type=str, dest='data_folder', help='data directory mounting point')

  • O script de treinamento salva o modelo em um diretório chamado outputs.The training script saves your model into a directory named outputs. Qualquer coisa escrita neste diretório é automaticamente enviada para o seu workspace.Anything written in this directory is automatically uploaded into your workspace. Você acessará seu modelo desse diretório posteriormente no tutorial.You access your model from this directory later in the tutorial. joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

  • O script de treinamento exige o arquivo utils.py para carregar o conjunto de dados corretamente.The training script requires the file utils.py to load the dataset correctly. O código a seguir copia utils.py em script_folder, de modo que o arquivo possa ser acessado juntamente com o script de treinamento no recurso remoto.The following code copies utils.py into script_folder so that the file can be accessed along with the training script on the remote resource.

    import shutil
    shutil.copy('utils.py', script_folder)
    

Criar um estimadorCreate an estimator

Um objeto Estimador do SKLearn é usado para enviar a execução.An SKLearn estimator object is used to submit the run. Crie seu estimador executando o seguinte código para definir estes itens:Create your estimator by running the following code to define these items:

  • O nome do objeto estimador, est.The name of the estimator object, est.
  • O diretório que contém seus scripts.The directory that contains your scripts. Todos os arquivos neste diretório são carregados nos nós do cluster para execução.All the files in this directory are uploaded into the cluster nodes for execution.
  • O destino de computação.The compute target. Nesse caso, você usará o cluster de computação do Azure Machine Learning que criou.In this case, you use the Azure Machine Learning compute cluster you created.
  • O nome do script de treinamento, train.py.The training script name, train.py.
  • Parâmetros necessários do script de treinamento.Parameters required from the training script.

Neste tutorial, esse destino é o AmlCompute.In this tutorial, this target is AmlCompute. Todos os arquivos na pasta de scripts são carregados em nós de cluster para execução.All files in the script folder are uploaded into the cluster nodes for run. O data_folder está configurado para usar o armazenamento de dados, ds.path('mnist').as_mount():The data_folder is set to use the datastore, ds.path('mnist').as_mount():

from azureml.train.sklearn import SKLearn

script_params = {
    '--data-folder': ds.path('mnist').as_mount(),
    '--regularization': 0.5
}

est = SKLearn(source_directory=script_folder,
                script_params=script_params,
                compute_target=compute_target,
                entry_script='train.py')

Enviar o trabalho para o clusterSubmit the job to the cluster

Execute o experimento enviando o objeto avaliador:Run the experiment by submitting the estimator object:

run = exp.submit(config=est)
run

Já que a chamada é assíncrona, ela retorna um estado Preparando ou Em execução assim que o trabalho é iniciado.Because the call is asynchronous, it returns a Preparing or Running state as soon as the job is started.

Monitorar uma execução remotaMonitor a remote run

No total, a primeira execução leva aproximadamente 10 minutos.In total, the first run takes about 10 minutes. Mas para execuções subsequentes, desde que as dependências do script não mudem, a mesma imagem é reutilizada.But for subsequent runs, as long as the script dependencies don't change, the same image is reused. Assim, o tempo de inicialização do contêiner é muito mais rápido.So the container startup time is much faster.

O que acontece enquanto você espera:What happens while you wait:

  • Criação de imagem: Uma imagem do Docker é criada, correspondendo ao ambiente Python especificado pelo estimador.Image creation: A Docker image is created that matches the Python environment specified by the estimator. A imagem é carregada no workspace.The image is uploaded to the workspace. A criação e o envio da imagem leva cerca de cinco minutos.Image creation and uploading takes about five minutes.

    Este estágio ocorre uma vez para cada ambiente Python, pois o contêiner é armazenado em cache para execuções subsequentes.This stage happens once for each Python environment because the container is cached for subsequent runs. Durante a criação da imagem, os logs são transmitidos para o histórico de execução.During image creation, logs are streamed to the run history. Você pode monitorar o progresso da criação da imagem usando esses logs.You can monitor the image creation progress by using these logs.

  • Dimensionamento: Se o cluster remoto exigir mais nós para realizar a execução que está disponível, mais nós serão adicionados automaticamente.Scaling: If the remote cluster requires more nodes to do the run than currently available, additional nodes are added automatically. O dimensionamento normalmente leva cerca de cinco minutos.Scaling typically takes about five minutes.

  • Executando: Neste estágio, os arquivos e scripts necessários são enviados para o destino de computação.Running: In this stage, the necessary scripts and files are sent to the compute target. Em seguida, armazenamentos de dados são montados ou copiados.Then datastores are mounted or copied. Em seguida, o entry_script é executado.And then the entry_script is run. Enquanto o trabalho está em execução, o stdout e o diretório ./logs são transmitidos para o histórico de execução.While the job is running, stdout and the ./logs directory are streamed to the run history. Você pode monitorar o progresso da execução usando esses logs.You can monitor the run's progress by using these logs.

  • Pós-processamento: O diretório ./outputs da execução é copiado para o histórico de execução em seu workspace para que você possa acessar esses resultados.Post-processing: The ./outputs directory of the run is copied over to the run history in your workspace, so you can access these results.

Você pode verificar o andamento de um trabalho em execução de várias maneiras.You can check the progress of a running job in several ways. Este tutorial usa um widget do Jupyter, bem como um método wait_for_completion.This tutorial uses a Jupyter widget and a wait_for_completion method.

Widget de JupyterJupyter widget

Assista ao progresso da corrida com um widget Jupyter.Watch the progress of the run with a Jupyter widget. Como o envio de execução, o widget é assíncrono e fornece atualizações ao vivo a cada 10 a 15 segundos até o trabalho ser concluído:Like the run submission, the widget is asynchronous and provides live updates every 10 to 15 seconds until the job finishes:

from azureml.widgets import RunDetails
RunDetails(run).show()

O widget terá a seguinte aparência ao final do treinamento:The widget will look like the following at the end of training:

Widget de notebook

Se você precisar cancelar uma execução, poderá seguir estas instruções.If you need to cancel a run, you can follow these instructions.

Obter resultados de log após a conclusãoGet log results upon completion

O treinamento e monitoramento do modelo acontecem em segundo plano.Model training and monitoring happen in the background. Aguarde até que o modelo tenha concluído o treinamento antes de você executar mais código.Wait until the model has finished training before you run more code. Use wait_for_completion para mostrar quando o treinamento do modelo estiver concluído:Use wait_for_completion to show when the model training is finished:

run.wait_for_completion(show_output=False) # specify True for a verbose log

Exibir resultados de execuçãoDisplay run results

Agora você tem um modelo treinado em um cluster remoto.You now have a model trained on a remote cluster. Recupere a precisão do modelo:Retrieve the accuracy of the model:

print(run.get_metrics())

A saída mostra que o modelo remoto tem precisão de 0,9204:The output shows the remote model has accuracy of 0.9204:

{'regularization rate': 0.8, 'accuracy': 0.9204}

No próximo tutorial, você explorará esse modelo com mais detalhes.In the next tutorial, you explore this model in more detail.

Registrar modeloRegister model

A última etapa do script de treinamento escreveu o arquivo outputs/sklearn_mnist_model.pkl em um diretório chamado outputs na VM do cluster em que a tarefa é executada.The last step in the training script wrote the file outputs/sklearn_mnist_model.pkl in a directory named outputs in the VM of the cluster where the job is run. outputs é um diretório especial em que todo o conteúdo deste diretório é automaticamente carregado para o seu workspace.outputs is a special directory in that all content in this directory is automatically uploaded to your workspace. Esse conteúdo aparece no registro de execução no experimento em seu workspace.This content appears in the run record in the experiment under your workspace. Portanto, o arquivo de modelo agora também está disponível em seu workspace.So the model file is now also available in your workspace.

Você pode ver os arquivos associados que são executados:You can see files associated with that run:

print(run.get_file_names())

Registre o modelo no workspace para que você (ou outros colaboradores) possa consultar, examinar e implantar posteriormente esse modelo:Register the model in the workspace, so that you or other collaborators can later query, examine, and deploy this model:

# register model
model = run.register_model(model_name='sklearn_mnist', model_path='outputs/sklearn_mnist_model.pkl')
print(model.name, model.id, model.version, sep = '\t')

Limpar recursosClean up resources

Importante

Os recursos que você criou podem ser usados como pré-requisitos em outros tutoriais e artigos de instruções do Serviço do Azure Machine Learning.The resources you created can be used as prerequisites to other Azure Machine Learning service tutorials and how-to articles.

Se você não pretende usar os recursos criados, exclua-os para não gerar encargos:If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. No portal do Azure, selecione Grupos de recursos no canto esquerdo.In the Azure portal, select Resource groups on the far left.

    Exclusão no portal do Azure

  2. Selecione o grupo de recursos criado na lista.From the list, select the resource group you created.

  3. Selecione Excluir grupo de recursos.Select Delete resource group.

  4. Insira o nome do grupo de recursos.Enter the resource group name. Em seguida, selecione Excluir.Then select Delete.

Você também pode excluir apenas o cluster de Computação do Azure Machine Learning.You can also delete just the Azure Machine Learning Compute cluster. No entanto, o dimensionamento automático está ativado e o cluster mínimo é zero.However, autoscale is turned on, and the cluster minimum is zero. Portanto, esse recurso específico não incorrerá em encargos de computação adicionais quando não estiver em uso:So this particular resource won't incur additional compute charges when not in use:

# optionally, delete the Azure Machine Learning Compute cluster
compute_target.delete()

Próximas etapasNext steps

Neste tutorial do Serviço do Azure Machine Learning, você usou o Python para as seguintes tarefas:In this Azure Machine Learning service tutorial, you used Python for the following tasks:

  • Configurar seu ambiente de desenvolvimento.Set up your development environment.
  • Acessar e examinar os dados.Access and examine the data.
  • Treinar vários modelos em um cluster remoto usando a popular biblioteca de aprendizado de máquina scikit-learnTrain multiple models on a remote cluster using the popular scikit-learn machine learning library
  • Analise os detalhes do treinamento e registre o melhor modelo.Review training details and register the best model.

Você está pronto para implantar este modelo registrado usando as instruções na próxima parte da série de tutoriais:You're ready to deploy this registered model by using the instructions in the next part of the tutorial series: