Kurz: analýza modelů klasifikace obrázků pomocí MNIST ručně zapsaných dat a scikit – učeníTutorial: Train image classification models with MNIST data and scikit-learn

platí pro:  Ano , Basic edice  Yes Enterprise Edition                               (upgrade na Enterprise Edition) APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

V tomto kurzu se naučíte model strojového učení ve vzdálených výpočetních prostředcích.In this tutorial, you train a machine learning model on remote compute resources. Pracovní postup školení a nasazení budete používat pro Azure Machine Learning v Jupyter poznámkovém bloku Pythonu.You'll use the training and deployment workflow for Azure Machine Learning in a Python Jupyter notebook. Poznámkový blok poté můžete použít jako šablonu k trénování vlastního modelu strojového učení s vlastními daty.You can then use the notebook as a template to train your own machine learning model with your own data. Tento kurz je první částí z dvoudílné série kurzů.This tutorial is part one of a two-part tutorial series.

V tomto kurzu se učí jednoduchá Logistická regrese s využitím datové sady mnist ručně zapsaných a scikit-učení s Azure Machine Learning.This tutorial trains a simple logistic regression by using the MNIST dataset and scikit-learn with Azure Machine Learning. MNIST je oblíbená datová sada obsahující 70 000 obrázků ve stupních šedi.MNIST is a popular dataset consisting of 70,000 grayscale images. Každý obrázek je ručně psaná číslice o 28 × 28 pixelech, která představuje číslo od 0 do 9.Each image is a handwritten digit of 28 x 28 pixels, representing a number from zero to nine. Cílem je vytvoření klasifikátoru s více třídami pro identifikaci číslice, kterou představuje daný obrázek.The goal is to create a multi-class classifier to identify the digit a given image represents.

Přečtěte si, jak provést následující akce:Learn how to take the following actions:

  • Nastavte vývojové prostředí.Set up your development environment.
  • Přístup k datům a jejich kontrolaAccess and examine the data.
  • Výukové jednoduché modely logistické regrese na vzdáleném clusteru.Train a simple logistic regression model on a remote cluster.
  • Zkontrolujte výsledky školení a zaregistrujte nejlepší model.Review training results and register the best model.

Naučíte se, jak vybrat model a nasadit ho v části 2 tohoto kurzu.You learn how to select a model and deploy it in part two of this tutorial.

Pokud ještě nemáte předplatné Azure, vytvořte si bezplatný účet, ještě než začnete.If you don't have an Azure subscription, create a free account before you begin. Vyzkoušení bezplatné nebo placené verze Azure Machine Learning dnesTry the free or paid version of Azure Machine Learning today.

Poznámka

Kód v tomto článku byl testován pomocí sady Azure Machine Learning SDK 1.0.83 verze.Code in this article was tested with Azure Machine Learning SDK version 1.0.83.

PožadavkyPrerequisites

  • Dokončete kurz: Začínáme s vytvořením prvního experimentu Azure ml :Complete the Tutorial: Get started creating your first Azure ML experiment to:

    • Vytvoření pracovního prostoruCreate a workspace
    • Naklonujte Poznámkový blok kurzů do složky v pracovním prostoru.Clone the tutorials notebook to your folder in the workspace.
    • Vytvořte cloudovou instanci Compute.Create a cloud-based compute instance.
  • Ve složce s naklonovánými kurzy/imagí-mnist ručně zapsaných-data otevřete Poznámkový blok img-Classification-part1-Training. ipynb .In your cloned tutorials/image-classification-mnist-data folder, open the img-classification-part1-training.ipynb notebook.

Kurz a doprovodný soubor utils.py je také k dispozici na GitHubu , pokud ho chcete použít ve svém vlastním místním prostředí.The tutorial and accompanying utils.py file is also available on GitHub if you wish to use it on your own local environment. Spusťte pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib pro instalaci závislostí pro tento kurz.Run pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib to install dependencies for this tutorial.

Důležité

Zbývající část tohoto článku obsahuje stejný obsah, jaký vidíte v poznámkovém bloku.The rest of this article contains the same content as you see in the notebook.

Pokud chcete při spuštění kódu číst společně, přepněte do poznámkového bloku Jupyter.Switch to the Jupyter notebook now if you want to read along as you run the code. Pokud chcete na poznámkovém bloku spustit jednu buňku kódu, klikněte na buňku kódu a stiskněte SHIFT + ENTER.To run a single code cell in a notebook, click the code cell and hit Shift+Enter. Případně spusťte celý Poznámkový blok výběrem možnosti Spustit vše na horním panelu nástrojů.Or, run the entire notebook by choosing Run all from the top toolbar.

Nastavení vývojového prostředíSet up your development environment

Veškeré nastavení pro vaši vývojovou práci se dá provést v poznámkovém bloku Pythonu.All the setup for your development work can be accomplished in a Python notebook. Instalační program zahrnuje následující akce:Setup includes the following actions:

  • Importujte balíčky Pythonu.Import Python packages.
  • Připojte se k pracovnímu prostoru, aby váš místní počítač mohl komunikovat se vzdálenými prostředky.Connect to a workspace, so that your local computer can communicate with remote resources.
  • Vytvořte experiment pro sledování všech vašich spuštění.Create an experiment to track all your runs.
  • Vytvořte vzdálený výpočetní cíl, který se bude používat pro školení.Create a remote compute target to use for training.

Import balíčkůImport packages

Naimportujte balíčky Pythonu, které potřebujete v této relaci.Import Python packages you need in this session. Zobrazit také Azure Machine Learning verzi sady SDK: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)

Připojení k pracovnímu prostoruConnect to a workspace

Vytvořte objekt pracovního prostoru z existujícího pracovního prostoru.Create a workspace object from the existing workspace. Workspace.from_config()přečte soubor config. JSON a načte podrobnosti do objektu s názvem 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')

Vytvoření experimentuCreate an experiment

Vytvořte experiment pro sledování spuštění ve vašem pracovním prostoru.Create an experiment to track the runs in your workspace. Pracovní prostor může mít více experimentů:A workspace can have multiple experiments:

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

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

Vytvořit nebo připojit existující cíl služby COMPUTECreate or attach an existing compute target

Pomocí Azure Machine Learning výpočetní služby, spravované služby, mohou odborníci na data poučení modely strojového učení v clusterech virtuálních počítačů Azure.By using Azure Machine Learning Compute, a managed service, data scientists can train machine learning models on clusters of Azure virtual machines. Mezi příklady patří virtuální počítače s podporou GPU.Examples include VMs with GPU support. V tomto kurzu vytvoříte Azure Machine Learning COMPUTE jako školicí prostředí.In this tutorial, you create Azure Machine Learning Compute as your training environment. Později v tomto kurzu odešlete kód Pythonu, který se bude spouštět na tomto virtuálním počítači.You will submit Python code to run on this VM later in the tutorial.

Následující kód vytvoří výpočetní clustery za vás, pokud už ve vašem pracovním prostoru neexistují.The code below creates the compute clusters for you if they don't already exist in your workspace. Nastaví cluster, který se bude škálovat dolů na 0, pokud se nepoužívá, a může škálovat až na 4 uzly.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.

Vytvoření cíle výpočtů trvá asi pět minut.Creation of the compute target takes about five minutes. Pokud je výpočetní prostředek již v pracovním prostoru, kód ho použije a přeskočí proces vytváření.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())

Nyní máte k dispozici potřebné balíčky a výpočetní prostředky pro trénink modelu v cloudu.You now have the necessary packages and compute resources to train a model in the cloud.

Zkoumání datExplore data

Než začnete pracovat s modelem, potřebujete pochopit data, která používáte k jeho učení.Before you train a model, you need to understand the data that you use to train it. V této části získáte informace o následujících postupech:In this section you learn how to:

  • Stáhněte si datovou sadu MNIST ručně zapsaných.Download the MNIST dataset.
  • Zobrazí některé ukázkové obrázky.Display some sample images.

Stáhnutí datové sady MNISTDownload the MNIST dataset

K získání nezpracovaných datových souborů MNIST ručně zapsaných použijte Azure Open DataSets.Use Azure Open Datasets to get the raw MNIST data files. Otevřené datové sady v Azure jsou spravované veřejné datové sady, které můžete použít k přidání funkcí specifických pro konkrétní scénář do řešení Machine Learning pro přesnější modely.Azure Open Datasets are curated public datasets that you can use to add scenario-specific features to machine learning solutions for more accurate models. Každá datová sada má odpovídající třídu, MNIST v tomto případě pro načtení dat různými způsoby.Each dataset has a corresponding class, MNIST in this case, to retrieve the data in different ways.

Tento kód načte data jako FileDataset objekt, který je podtřídou třídy Dataset .This code retrieves the data as a FileDataset object, which is a subclass of Dataset. FileDatasetOdkazuje na jeden nebo více souborů libovolného formátu v úložišti dat nebo veřejných adresách URL.A FileDataset references single or multiple files of any format in your datastores or public urls. Třída poskytuje možnost stahovat nebo připojovat soubory do výpočetních prostředků tím, že vytvoří odkaz na umístění zdroje dat.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. Navíc zaregistrujete datovou sadu do svého pracovního prostoru pro snadné načtení během školení.Additionally, you register the Dataset to your workspace for easy retrieval during training.

Pokud chcete získat další informace o datových sadách a jejich využití v sadě SDK, postupujte podle pokynů.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)

Zobrazení některých ukázkových obrázkůDisplay some sample images

Načtěte komprimované soubory do pole numpy.Load the compressed files into numpy arrays. Pak pomocí matplotlib vykreslete 30 náhodných obrázků z datové sady s jejich popisky nad nimi.Then use matplotlib to plot 30 random images from the dataset with their labels above them. Tento krok vyžaduje load_data funkci, která je součástí util.py souboru.This step requires a load_data function that's included in an util.py file. Tento soubor je umístěný ve složce s ukázkou.This file is included in the sample folder. Ujistěte se, že je umístěn ve stejné složce jako tento poznámkový blok.Make sure it's placed in the same folder as this notebook. load_dataFunkce jednoduše analyzuje komprimované soubory do polí 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
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()

Náhodná ukázka obrázků:A random sample of images displays:

Náhodný vzorek imagí

Nyní máte představu o tom, jak tyto obrázky vypadají, a o očekávaném výstupu predikce.Now you have an idea of what these images look like and the expected prediction outcome.

Trénování na vzdáleném clusteruTrain on a remote cluster

Pro tuto úlohu odešlete úlohu, která se má spustit v clusteru vzdáleného školení, který jste nastavili dříve.For this task, you submit the job to run on the remote training cluster you set up earlier. K odeslání úlohy je potřeba provést:To submit a job you:

  • Vytvoření adresářeCreate a directory
  • Vytvoření trénovacího skriptuCreate a training script
  • Vytvoření objektu EstimatorCreate an estimator object
  • Odeslání úlohySubmit the job

Vytvoření adresářeCreate a directory

Vytvořte adresář, ze kterého bude dodán potřebný kód z počítače do vzdáleného prostředku.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)

Vytvoření trénovacího skriptuCreate a training script

Pokud chcete odeslat úlohu do clusteru, vytvořte nejprve trénovací skript.To submit the job to the cluster, first create a training script. Spuštěním následujícího kódu vytvořte trénovací skript s názvem train.py v adresáři, který jste právě vytvořili.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')

Všimněte si, jak skript získává data a ukládá modely:Notice how the script gets data and saves models:

  • Školicí skript čte argument pro vyhledání adresáře, který obsahuje data.The training script reads an argument to find the directory that contains the data. Když později odešlete úlohu, bude odkázána na úložiště dat pro tento argument: 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')

  • Školicí skript uloží model do adresáře s názvem výstupy.The training script saves your model into a directory named outputs. Vše, co je v tomto adresáři zapsáno, se automaticky nahraje do vašeho pracovního prostoru.Anything written in this directory is automatically uploaded into your workspace. K vašemu modelu přistupujete z tohoto adresáře později v tomto kurzu.You access your model from this directory later in the tutorial. joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

  • Školicí skript vyžaduje, aby soubor utils.py správně načetl datovou sadu.The training script requires the file utils.py to load the dataset correctly. Následující kód zkopíruje utils.py do script_folder , aby k souboru bylo možné přihlédnout společně se školicím skriptem na vzdáleném prostředku.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)
    

Vytvoření estimátoruCreate an estimator

Objekt estimátoru se používá k odeslání spuštění.An estimator object is used to submit the run. Azure Machine Learning má předem nakonfigurovanou odhady pro běžné architektury strojového učení a také pro obecné Estimator.Azure Machine Learning has pre-configured estimators for common machine learning frameworks, as well as generic Estimator. Vytvoření Estimator zadánímCreate an estimator by specifying

  • Název objektu estimátoru je est.The name of the estimator object, est.
  • Adresář, který obsahuje vaše skripty.The directory that contains your scripts. Všechny soubory v tomto adresáři se nahrají do uzlů clusteru ke spuštění.All the files in this directory are uploaded into the cluster nodes for execution.
  • Cílové výpočetní prostředí.The compute target. V tomto případě používáte cluster pro výpočty služby Azure Machine Learning, který jste vytvořili.In this case, you use the Azure Machine Learning compute cluster you created.
  • Název školicího skriptu, Train.py.The training script name, train.py.
  • Prostředí obsahující knihovny potřebné ke spuštění skriptu.An environment that contains the libraries needed to run the script.
  • Parametry požadované z trénovacího skriptu.Parameters required from the training script.

V tomto kurzu je tento cíl AmlCompute.In this tutorial, this target is AmlCompute. Všechny soubory ve složce skriptu se nahrají do uzlů clusteru pro spuštění.All files in the script folder are uploaded into the cluster nodes for run. Data_folder je nastaveno na použití datové sady.The data_folder is set to use the dataset. "Nejprve vytvořte prostředí, které obsahuje: knihovna scikit-učení, AzureML-dataprep požadovaná pro přístup k datové sadě a AzureML – výchozí, který obsahuje závislosti pro metriky protokolování."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. Služba AzureML-výchozí také obsahuje závislosti potřebné pro nasazení modelu jako webové služby později v části 2 tohoto kurzu.The azureml-defaults also contains the dependencies required for deploying the model as a web service later in the part 2 of the tutorial.

Jakmile je prostředí definované, zaregistrujte ho v pracovním prostoru a znovu ho použijte v části 2 tohoto kurzu.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)

Pak vytvořte Estimator pomocí následujícího kódu.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')

Odeslání úlohy do clusteruSubmit the job to the cluster

Spusťte experiment odesláním objektu Estimator:Run the experiment by submitting the estimator object:

run = exp.submit(config=est)
run

Vzhledem k tomu, že volání je asynchronní, vrátí stav Příprava nebo spuštění ihned po spuštění úlohy.Because the call is asynchronous, it returns a Preparing or Running state as soon as the job is started.

Monitorování vzdáleného spuštěníMonitor a remote run

V celkovém případě trvá první spuštění přibližně 10 minut.In total, the first run takes about 10 minutes. U následných spuštění, pokud se závislosti skriptů nezmění, je stejný obrázek znovu použit.But for subsequent runs, as long as the script dependencies don't change, the same image is reused. Proto je čas spuštění kontejneru mnohem rychlejší.So the container startup time is much faster.

Co se stane, když počkáte:What happens while you wait:

  • Vytvoření bitové kopie: vytvoří se image Docker, která odpovídá prostředí Pythonu určenému parametrem Estimator.Image creation: A Docker image is created that matches the Python environment specified by the estimator. Image se nahraje do pracovního prostoru.The image is uploaded to the workspace. Vytvoření a nahrání obrázku trvá přibližně pět minut.Image creation and uploading takes about five minutes.

    Tato fáze se u každého prostředí Pythonu provede jednou, protože kontejner je uložený v mezipaměti pro další spuštění.This stage happens once for each Python environment because the container is cached for subsequent runs. Při vytváření image se streamují protokoly do historie spuštění.During image creation, logs are streamed to the run history. Pomocí těchto protokolů můžete monitorovat průběh vytváření imagí.You can monitor the image creation progress by using these logs.

  • Škálování: Pokud vzdálený cluster vyžaduje více uzlů, než kolik je aktuálně k dispozici, přidají se další uzly automaticky.Scaling: If the remote cluster requires more nodes to do the run than currently available, additional nodes are added automatically. Škálování obvykle trvá přibližně pět minut.Scaling typically takes about five minutes.

  • Spuštěno: v této fázi jsou nezbytné skripty a soubory odeslány do cíle výpočtů.Running: In this stage, the necessary scripts and files are sent to the compute target. Pak jsou úložiště dat připojená nebo zkopírovaná.Then datastores are mounted or copied. A pak se spustí entry_script .And then the entry_script is run. Když je úloha spuštěná, stdout a adresář ./logs se streamují do historie spuštění.While the job is running, stdout and the ./logs directory are streamed to the run history. Průběh běhu můžete monitorovat pomocí těchto protokolů.You can monitor the run's progress by using these logs.

  • Následné zpracování: adresář ./Outputs tohoto spuštění se kopíruje do historie spuštění ve vašem pracovním prostoru, takže můžete získat přístup k těmto výsledkům.Post-processing: The ./outputs directory of the run is copied over to the run history in your workspace, so you can access these results.

Průběh spuštěné úlohy můžete sledovat několika způsoby.You can check the progress of a running job in several ways. V tomto kurzu se používá widget Jupyter a wait_for_completion metoda.This tutorial uses a Jupyter widget and a wait_for_completion method.

Widget JupyterJupyter widget

Sledujte průběh běhu pomocí widgetu Jupyter.Watch the progress of the run with a Jupyter widget. Podobně jako odeslání běhu je pomůcka asynchronní a poskytuje aktualizace za provozu každých 10 až 15 sekund, dokud se nedokončí úloha: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()

Pomůcka bude vypadat jako na konci školení jako na následujícím místě:The widget will look like the following at the end of training:

Widget Poznámkový blok

Pokud potřebujete běh zrušit, můžete postupovat podle těchto pokynů.If you need to cancel a run, you can follow these instructions.

Získání protokolu výsledků při dokončeníGet log results upon completion

Trénování modelu a monitorování probíhají na pozadí.Model training and monitoring happen in the background. Počkejte, dokud model nedokončí školení, než spustíte více kódu.Wait until the model has finished training before you run more code. Použijte wait_for_completion k zobrazení po dokončení školení modelu: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

Zobrazení výsledků spuštěníDisplay run results

Teď je model vytrénovaný na vzdáleném clusteru.You now have a model trained on a remote cluster. Načtěte přesnost modelu:Retrieve the accuracy of the model:

print(run.get_metrics())

Výstup ukazuje, že vzdálený model má přesnost 0,9204:The output shows the remote model has accuracy of 0.9204:

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

V dalším kurzu si tento model podrobněji prozkoumáte podrobněji.In the next tutorial, you explore this model in more detail.

Registrace modeluRegister model

Poslední krok v školicím skriptu vypsal soubor outputs/sklearn_mnist_model.pkl v adresáři s názvem outputs ve virtuálním počítači clusteru, ve kterém je úloha spuštěná.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. outputsje speciální adresář v tom, že se veškerý obsah v tomto adresáři automaticky nahraje do vašeho pracovního prostoru.outputs is a special directory in that all content in this directory is automatically uploaded to your workspace. Tento obsah se objeví v záznamu spuštění v experimentu pod vaším pracovním prostorem.This content appears in the run record in the experiment under your workspace. Proto je soubor modelu teď dostupný i ve vašem pracovním prostoru.So the model file is now also available in your workspace.

Můžete zobrazit soubory spojené s tímto spuštěním:You can see files associated with that run:

print(run.get_file_names())

Zaregistrujte model v pracovním prostoru, abyste vy nebo jiní spolupracovníci mohli později dotazovat, prozkoumávat a nasazovat tento model: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')

Vyčištění prostředkůClean up resources

Důležité

Prostředky, které jste vytvořili, je možné použít i ke splnění požadavků v dalších kurzech a článcích s návody pro službu Azure Machine Learning.The resources you created can be used as prerequisites to other Azure Machine Learning tutorials and how-to articles.

Pokud neplánujete použít prostředky, které jste vytvořili, odstraňte je, takže se vám neúčtují žádné poplatky:If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. Úplně nalevo na webu Azure Portal vyberte Skupiny prostředků.In the Azure portal, select Resource groups on the far left.

    Odstranit v Azure PortalDelete in the Azure portal

  2. V seznamu vyberte skupinu prostředků, kterou jste vytvořili.From the list, select the resource group you created.

  3. Vyberte Odstranit skupinu prostředků.Select Delete resource group.

  4. Zadejte název skupiny prostředků.Enter the resource group name. Vyberte Odstranit.Then select Delete.

Můžete také odstranit pouze výpočetní cluster Azure Machine Learning.You can also delete just the Azure Machine Learning Compute cluster. Automatické škálování je ale zapnuté a minimum clusteru je nula.However, autoscale is turned on, and the cluster minimum is zero. Takže se tomuto konkrétnímu prostředku neúčtují další poplatky za výpočetní prostředky, pokud se nepoužívá: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()

Další krokyNext steps

V tomto Azure Machine Learning kurzu jste použili Python pro následující úlohy:In this Azure Machine Learning tutorial, you used Python for the following tasks:

  • Nastavte vývojové prostředí.Set up your development environment.
  • Přístup k datům a jejich kontrolaAccess and examine the data.
  • Výuka více modelů na vzdáleném clusteru s využitím oblíbené knihovny Machine Learningu v scikitTrain multiple models on a remote cluster using the popular scikit-learn machine learning library
  • Zkontrolujte podrobnosti školení a zaregistrujte nejlepší model.Review training details and register the best model.

Jste připraveni nasadit tento registrovaný model pomocí pokynů v další části série kurzů:You're ready to deploy this registered model by using the instructions in the next part of the tutorial series: