Självstudie: träna bild klassificerings modeller med MNIST-data och scikit-lärTutorial: Train image classification models with MNIST data and scikit-learn

gäller för:  Ja Basic Edition  Ja Enterprise Edition                               (Uppgradera till Enterprise Edition) APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

I den här självstudien ska du träna en maskininlärningsmodell på fjärranslutna beräkningsresurser.In this tutorial, you train a machine learning model on remote compute resources. Du använder arbets flödet för utbildning och distribution för Azure Machine Learning i en python Jupyter Notebook.You'll use the training and deployment workflow for Azure Machine Learning in a Python Jupyter notebook. Du kan sedan använda anteckningsboken som en mall för att träna din egen maskininlärningsmodell med egna data.You can then use the notebook as a template to train your own machine learning model with your own data. Den här självstudien är del ett i en själv studie serie i två delar.This tutorial is part one of a two-part tutorial series.

Den här självstudien tränar en enkel logistik regression med hjälp av MNIST -datauppsättningen och scikit – lära med Azure Machine Learning.This tutorial trains a simple logistic regression by using the MNIST dataset and scikit-learn with Azure Machine Learning. MNIST är en populär datauppsättning som består av 70 000 gråskalebilder.MNIST is a popular dataset consisting of 70,000 grayscale images. Varje bild är en handskriven siffra på 28 × 28 pixlar, som representerar ett tal från noll till nio.Each image is a handwritten digit of 28 x 28 pixels, representing a number from zero to nine. Målet är att skapa en klassificerare för flera klasser som identifierar siffran som en viss bild representerar.The goal is to create a multi-class classifier to identify the digit a given image represents.

Läs hur du vidtar följande åtgärder:Learn how to take the following actions:

  • Konfigurera din utvecklingsmiljö.Set up your development environment.
  • Kom åt och utforska data.Access and examine the data.
  • Träna en enkel logistik Regressions modell på ett fjärran slutet kluster.Train a simple logistic regression model on a remote cluster.
  • Granska träningsresultaten och registrera den bästa modellen.Review training results and register the best model.

Du lär dig hur du väljer en modell och distribuerar den i del två av den här självstudien.You learn how to select a model and deploy it in part two of this tutorial.

Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.If you don't have an Azure subscription, create a free account before you begin. Prova den kostnads fria eller betalda versionen av Azure Machine Learning idag.Try the free or paid version of Azure Machine Learning today.

Anteckning

Koden i den här artikeln har testats med Azure Machine Learning SDK -version 1.0.83.Code in this article was tested with Azure Machine Learning SDK version 1.0.83.

FörutsättningarPrerequisites

Självstudien och den medföljande utils.py -filen finns också på GitHub om du vill använda den i din egen lokala miljö.The tutorial and accompanying utils.py file is also available on GitHub if you wish to use it on your own local environment. Kör pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib för att installera beroenden för den här självstudien.Run pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib to install dependencies for this tutorial.

Viktigt

Resten av den här artikeln innehåller samma innehåll som du ser i antecknings boken.The rest of this article contains the same content as you see in the notebook.

Växla till antecknings boken för Jupyter nu om du vill läsa den samtidigt som du kör koden.Switch to the Jupyter notebook now if you want to read along as you run the code. Om du vill köra en enda kod cell i en bärbar dator klickar du på cellen kod och trycker på SKIFT + RETUR.To run a single code cell in a notebook, click the code cell and hit Shift+Enter. Du kan också köra hela antecknings boken genom att välja Kör alla från det översta verktygsfältet.Or, run the entire notebook by choosing Run all from the top toolbar.

Ställt in din utvecklingsmiljöSet up your development environment

All konfiguration under utvecklingsarbetet kan utföras i en Python-anteckningsbok.All the setup for your development work can be accomplished in a Python notebook. Konfigurationen inkluderar följande åtgärder:Setup includes the following actions:

  • Importera Python-paket.Import Python packages.
  • Ansluta till en arbetsyta så att din lokala dator kan kommunicera med fjärranslutna resurser.Connect to a workspace, so that your local computer can communicate with remote resources.
  • Skapa ett experiment för att spåra alla dina körningar.Create an experiment to track all your runs.
  • Skapa ett fjärrberäkningsmål som ska användas för träning.Create a remote compute target to use for training.

Importera paketImport packages

Importera Python-paket som du behöver i den här sessionen.Import Python packages you need in this session. Visa även Azure Machine Learning SDK-versionen: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)

Anslut till en arbetsytaConnect to a workspace

Skapa ett arbetsyteobjekt från den befintliga arbetsytan.Create a workspace object from the existing workspace. Workspace.from_config()läser filen config.jspå och läser in informationen i ett objekt med namnet 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, sep='\t')

Skapa ett experimentCreate an experiment

Skapa ett experiment för att spåra körningarna på arbetsytan.Create an experiment to track the runs in your workspace. En arbetsyta kan ha flera experiment:A workspace can have multiple experiments:

from azureml.core import Experiment
experiment_name = 'sklearn-mnist'

exp = Experiment(workspace=ws, name=experiment_name)

Skapa eller koppla ett befintligt beräknings målCreate or attach an existing compute target

Genom att använda Azure Machine Learning Compute, en hanterad tjänst så kan datavetare träna maskininlärningsmodeller i kluster med virtuella Azure-datorer.By using Azure Machine Learning Compute, a managed service, data scientists can train machine learning models on clusters of Azure virtual machines. Exempel innefattar virtuella datorer med GPU-stöd.Examples include VMs with GPU support. I den här självstudien ska du skapa Azure Machine Learning Compute som din träningsmiljö.In this tutorial, you create Azure Machine Learning Compute as your training environment. Du kommer att skicka python-kod som ska köras på den här virtuella datorn senare i självstudien.You will submit Python code to run on this VM later in the tutorial.

Koden nedan skapar beräkningsklustren åt dig om de inte redan finns på din arbetsyta.The code below creates the compute clusters for you if they don't already exist in your workspace. Det konfigurerar ett kluster som skalar ned till 0 när det inte används och kan skala upp till högst 4 noder.It sets up a cluster that will scale down to 0 when not in use, and can scale up to a maximum of 4 nodes.

Det tar cirka fem minuter att skapa beräknings målet.Creation of the compute target takes about five minutes. Om beräknings resursen redan finns i arbets ytan använder koden den och hoppar över skapande processen.If the compute resource 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())

Nu har du de nödvändiga paketen och beräkningsresurserna för att träna en modell i molnet.You now have the necessary packages and compute resources to train a model in the cloud.

Utforska dataExplore data

Innan du tränar en modell så måste du förstå de data som du använder för att träna den.Before you train a model, you need to understand the data that you use to train it. I det här avsnittet lär du dig att:In this section you learn how to:

  • Hämta MNIST-datauppsättningen.Download the MNIST dataset.
  • Visa några exempelbilder.Display some sample images.

Ladda ned MNIST-datauppsättningenDownload the MNIST dataset

Använd Azures öppna data uppsättningar för att hämta RAW MNIST-datafilerna.Use Azure Open Datasets to get the raw MNIST data files. Azure Open-datauppsättningar är granskade offentliga data uppsättningar som du kan använda för att lägga till scenario-/regionsspecifika funktioner till maskin inlärnings lösningar för mer exakta modeller.Azure Open Datasets are curated public datasets that you can use to add scenario-specific features to machine learning solutions for more accurate models. Varje data uppsättning har en motsvarande klass, MNIST i det här fallet för att hämta data på olika sätt.Each dataset has a corresponding class, MNIST in this case, to retrieve the data in different ways.

Den här koden hämtar data som ett FileDataset objekt, vilket är en underordnad klass till Dataset .This code retrieves the data as a FileDataset object, which is a subclass of Dataset. En FileDataset refererar till en eller flera filer i alla format i dina data lager eller offentliga URL: er.A FileDataset references single or multiple files of any format in your datastores or public urls. Klassen ger dig möjlighet att ladda ned eller montera filerna i beräkningen genom att skapa en referens till data käll platsen.The class provides you with the ability to download or mount the files to your compute by creating a reference to the data source location. Dessutom registrerar du data uppsättningen på din arbets yta för enkel hämtning under utbildningen.Additionally, you register the Dataset to your workspace for easy retrieval during training.

Följ anvisningarna för att lära dig mer om data uppsättningar och deras användning i SDK.Follow the how-to to learn more about Datasets and their usage in the SDK.

from azureml.core import Dataset
from azureml.opendatasets import MNIST

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

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

mnist_file_dataset = mnist_file_dataset.register(workspace=ws,
                                                 name='mnist_opendataset',
                                                 description='training and test dataset',
                                                 create_new_version=True)

Visa några exempelbilderDisplay some sample images

Läs in de komprimerade filerna i numpy-matriser.Load the compressed files into numpy arrays. Använd därefter matplotlib till att rita 30 slumpmässiga bilder från datauppsättningen med sina etiketter ovanför dem.Then use matplotlib to plot 30 random images from the dataset with their labels above them. Det här steget kräver en load_data-funktion som ingår i en util.py-fil.This step requires a load_data function that's included in an util.py file. Den här filen finns med i exempelmappen.This file is included in the sample folder. Kontrollera att den finns i samma mapp som den här anteckningsboken.Make sure it's placed in the same folder as this notebook. Funktionen load_data parsar enkelt de komprimerade filerna till numpy-matriser.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
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()

Ett slumpmässigt urval av bilder visas:A random sample of images displays:

Ett slumpmässigt urval av bilder

Nu har du en uppfattning om hur dessa bilder ser ut och det förväntade förutsägelseresultatet.Now you have an idea of what these images look like and the expected prediction outcome.

Träna i ett fjärrklusterTrain on a remote cluster

För den här uppgiften skickar du jobbet som ska köras på det kluster för fjärr utbildning som du ställer in tidigare.For this task, you submit the job to run on the remote training cluster you set up earlier. Du skickar ett jobb genom att:To submit a job you:

  • Skapa en katalogCreate a directory
  • Skapa ett träningsskriptCreate a training script
  • Skapa ett beräkningsobjektCreate an estimator object
  • Skicka jobbetSubmit the job

Skapa en katalogCreate a directory

Skapa en katalog för att leverera den nödvändiga koden från din dator till fjärresursen.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)

Skapa ett träningsskriptCreate a training script

Innan du skickar jobbet till klustret skapar du ett träningsskript.To submit the job to the cluster, first create a training script. Kör följande kod för att skapa ett träningsskript med namnet train.py i katalogen som du nyss skapade.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
import glob

from sklearn.linear_model import LogisticRegression
import joblib

from azureml.core import Run
from utils import load_data

# let user feed in 2 parameters, the dataset to mount or download, 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(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)

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')

Observera hur skriptet hämtar data och sparar modeller:Notice how the script gets data and saves models:

  • Träningsskriptet läser ett argument för att hitta katalogen som innehåller data.The training script reads an argument to find the directory that contains the data. När du skickar jobbet senare pekar du på datalagret för det här argumentet: 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')

  • Övnings skriptet sparar din modell i en katalog med namnet outputs.The training script saves your model into a directory named outputs. Allt som skrivs i den här katalogen överförs automatiskt till din arbetsyta.Anything written in this directory is automatically uploaded into your workspace. Du kommer åt din modell från den här katalogen senare i självstudien.You access your model from this directory later in the tutorial. joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

  • Utbildnings skriptet kräver utils.py att filen läser in data mängden korrekt.The training script requires the file utils.py to load the dataset correctly. Följande kod kopieras utils.py till script_folder så att filen kan nås tillsammans med övnings skriptet på fjär resursen.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)
    

Skapa ett beräkningsobjektCreate an estimator

Ett beräkningsobjekt används för att skicka körningen.An estimator object is used to submit the run. Azure Machine Learning har förkonfigurerade uppskattningar för vanliga ramverk för maskin inlärning, samt generisk uppskattning.Azure Machine Learning has pre-configured estimators for common machine learning frameworks, as well as generic Estimator. Skapa en uppskattning genom att angeCreate an estimator by specifying

  • Namnet på beräkningsobjektet, est.The name of the estimator object, est.
  • Katalogen som innehåller dina skript.The directory that contains your scripts. Alla filer i den här katalogen laddas upp till klusternoderna för körning.All the files in this directory are uploaded into the cluster nodes for execution.
  • Beräkningsmålet.The compute target. I det här fallet använder du Azure Machine Learning-beräkningsklustret som du skapade.In this case, you use the Azure Machine Learning compute cluster you created.
  • Utbildnings skriptets namn, Train.py.The training script name, train.py.
  • En miljö som innehåller de bibliotek som krävs för att köra skriptet.An environment that contains the libraries needed to run the script.
  • Parametrar som krävs från träningsskriptet.Parameters required from the training script.

I den här självstudien är det här målet AmlCompute.In this tutorial, this target is AmlCompute. Alla filer i skriptmappen laddas upp till klusternoderna för körning.All files in the script folder are uploaded into the cluster nodes for run. Data_folder är inställd på att använda data uppsättningen.The data_folder is set to use the dataset. "Först skapar du miljön som innehåller: scikit--biblioteket, azureml-nu krävs för att få åtkomst till data uppsättningen och AzureML-standardvärden som innehåller beroenden för loggnings mått."First, create the environment that contains: the scikit-learn library, azureml-dataprep required for accessing the dataset, and azureml-defaults which contains the dependencies for logging metrics. Azureml-defaults innehåller också de beroenden som krävs för att distribuera modellen som en webb tjänst senare i del 2 av självstudien.The azureml-defaults also contains the dependencies required for deploying the model as a web service later in the part 2 of the tutorial.

När miljön har definierats kan du registrera den med arbets ytan och sedan använda den igen i del 2 av självstudien.Once the environment is defined, register it with the Workspace to re-use it in part 2 of the tutorial.

from azureml.core.environment import Environment
from azureml.core.conda_dependencies import CondaDependencies

# to install required packages
env = Environment('tutorial-env')
cd = CondaDependencies.create(pip_packages=['azureml-dataprep[pandas,fuse]>=1.1.14', 'azureml-defaults'], conda_packages = ['scikit-learn==0.22.1'])

env.python.conda_dependencies = cd

# Register environment to re-use later
env.register(workspace = ws)

Skapa sedan uppskattningen med följande kod.Then create the estimator with the following code.

from azureml.train.estimator import Estimator

script_params = {
    # to mount files referenced by mnist dataset
    '--data-folder': mnist_file_dataset.as_named_input('mnist_opendataset').as_mount(),
    '--regularization': 0.5
}

est = Estimator(source_directory=script_folder,
              script_params=script_params,
              compute_target=compute_target,
              environment_definition=env,
              entry_script='train.py')

Skicka jobbet till klustretSubmit the job to the cluster

Kör experimentet genom att skicka in beräkningsobjektet:Run the experiment by submitting the estimator object:

run = exp.submit(config=est)
run

Eftersom anropet är asynkront så returneras statusen Förbereder eller Körs så snart jobbet har startats.Because the call is asynchronous, it returns a Preparing or Running state as soon as the job is started.

Övervaka en fjärrkörningMonitor a remote run

Den första körningen tar totalt cirka 10 minuter.In total, the first run takes about 10 minutes. Men för efterföljande körningar så länge skriptberoendena inte ändras så återanvänds samma avbildning.But for subsequent runs, as long as the script dependencies don't change, the same image is reused. Starttiden för containern är mycket snabbare.So the container startup time is much faster.

Vad händer medan du väntar:What happens while you wait:

  • Skapa avbildning: en Docker-avbildning skapas som matchar python-miljön som anges av uppskattningen.Image creation: A Docker image is created that matches the Python environment specified by the estimator. Avbildningen laddas upp till arbetsytan.The image is uploaded to the workspace. Det tar cirka fem minuter att skapa och överföra avbildningen.Image creation and uploading takes about five minutes.

    Den här fasen sker en gång för varje Python-miljö eftersom containern cachelagras för efterföljande körningar.This stage happens once for each Python environment because the container is cached for subsequent runs. När avbildningen skapas strömmas loggar till körningshistoriken.During image creation, logs are streamed to the run history. Du kan övervaka förloppet för avbildningsgenereringen med de här loggarna.You can monitor the image creation progress by using these logs.

  • Skalning: om fjärrklusteret kräver fler noder för att köra körningen än vad som är tillgängligt, läggs ytterligare noder till automatiskt.Scaling: If the remote cluster requires more nodes to do the run than currently available, additional nodes are added automatically. Skalningen tar normalt cirka fem minuter.Scaling typically takes about five minutes.

  • Körs: i det här steget skickas nödvändiga skript och filer till Compute-målet.Running: In this stage, the necessary scripts and files are sent to the compute target. Datalagren monteras eller kopieras därefter.Then datastores are mounted or copied. Och sedan körs entry_script.And then the entry_script is run. Medan jobbet körs strömmas STDOUT och katalogen ./logs till körnings historiken.While the job is running, stdout and the ./logs directory are streamed to the run history. Du kan övervaka körningens förlopp med hjälp av de här loggarna.You can monitor the run's progress by using these logs.

  • Efter bearbetning: katalogen ./outputs i körningen kopieras till körnings historiken i din arbets yta, så att du kan komma åt dessa resultat.Post-processing: The ./outputs directory of the run is copied over to the run history in your workspace, so you can access these results.

Du kan kontrollera förloppet för ett jobb som körs på flera olika sätt.You can check the progress of a running job in several ways. Den här självstudien använder en Jupyter-widget samt en wait_for_completion-metod.This tutorial uses a Jupyter widget and a wait_for_completion method.

Jupyter-widgetJupyter widget

Se förloppet för widgetenkör med en Jupyter-widget.Watch the progress of the run with a Jupyter widget. Precis som körningsöverföringen så är widgeten asynkron och tillhandahåller liveuppdateringar var 10:e till 15:e sekund tills jobbet slutförts: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()

Widgeten kommer att se ut så här i slutet av utbildningen:The widget will look like the following at the end of training:

Anteckningsbok-widget

Om du vill avbryta en körning kan du följa instruktionerna.If you need to cancel a run, you can follow these instructions.

Hämta loggresultat när åtgärden har slutförtsGet log results upon completion

Modellträningen och övervakningen sker i bakgrunden.Model training and monitoring happen in the background. Vänta tills modellen har slutfört träningen innan du kör mer kod.Wait until the model has finished training before you run more code. Använd wait_for_completion för att visa när modellträningen är klar: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

Visa körningsresultatDisplay run results

Nu har du en modell som har tränats på ett fjärrkluster.You now have a model trained on a remote cluster. Hämta modellens precision:Retrieve the accuracy of the model:

print(run.get_metrics())

Resultatet visar att fjärrmodellen har en riktighet på 0.9204:The output shows the remote model has accuracy of 0.9204:

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

I nästa självstudie får du analysera den här modellen i detalj.In the next tutorial, you explore this model in more detail.

Registrera modellenRegister model

Det sista steget i träningsskriptet skrev filen outputs/sklearn_mnist_model.pkl i en katalog med namnet outputs på den virtuella datorn i klustret där jobbet körs.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 är en särskild katalog i det avseende att allt innehåll i den här katalogen överförs automatiskt till din arbetsyta.outputs is a special directory in that all content in this directory is automatically uploaded to your workspace. Det här innehållet visas i körningsposten i experimentet under din arbetsyta.This content appears in the run record in the experiment under your workspace. Därför är modellfilen nu även tillgänglig på din arbetsyta.So the model file is now also available in your workspace.

Du kan se filer som hör till den körningen:You can see files associated with that run:

print(run.get_file_names())

Registrera modellen på arbetsytan så att du eller andra medarbetare senare kan fråga, utforska och distribuera modellen: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')

Rensa resurserClean up resources

Viktigt

Resurser som har skapats kan användas som förutsättningar för att andra självstudier och instruktionsartiklar om Azure Machine Learning.The resources you created can be used as prerequisites to other Azure Machine Learning tutorials and how-to articles.

Om du inte planerar att använda de resurser som du skapade, tar du bort dem så att du inte debiteras:If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. I Azure-portalen väljer du Resursgrupper längst till vänster.In the Azure portal, select Resource groups on the far left.

    Ta bort i Azure PortalDelete in the Azure portal

  2. Välj den resursgrupp i listan som du har skapat.From the list, select the resource group you created.

  3. Välj Ta bort resursgrupp.Select Delete resource group.

  4. Ange resursgruppsnamnet.Enter the resource group name. Välj sedan Ta bort.Then select Delete.

Du kan också ta bort bara Azure Machine Learning-beräkningsklustret.You can also delete just the Azure Machine Learning Compute cluster. Autoskalning är dock aktiverat och det minsta antalet kluster är noll.However, autoscale is turned on, and the cluster minimum is zero. Så den här resursen debiteras inte ytterligare beräkningsavgifter när den inte används: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()

Nästa stegNext steps

I den här Azure Machine Learning själv studie kursen har du använt python för följande uppgifter:In this Azure Machine Learning tutorial, you used Python for the following tasks:

  • Konfigurera din utvecklingsmiljö.Set up your development environment.
  • Kom åt och utforska data.Access and examine the data.
  • Träna flera modeller i ett fjärrkluster med det populära scikit-learn-maskininlärningsbiblioteketTrain multiple models on a remote cluster using the popular scikit-learn machine learning library
  • Granska träningsinformationen och registrera den bästa modellen.Review training details and register the best model.

Nu är du redo att distribuera den registrerade modellen genom att följa anvisningarna i nästa del av den här självstudieserien:You're ready to deploy this registered model by using the instructions in the next part of the tutorial series: