Samouczek: uczenie modeli klasyfikacji obrazów przy użyciu MNIST ręcznie danych i scikit — uczenie sięTutorial: Train image classification models with MNIST data and scikit-learn

W tym samouczku przeprowadzisz szkolenie modelu uczenia maszynowego na zdalnych zasobach obliczeniowych.In this tutorial, you train a machine learning model on remote compute resources. Możesz użyć przepływu pracy szkolenia i wdrażania Azure Machine Learning w Jupyter Notebook języka Python.You'll use the training and deployment workflow for Azure Machine Learning in a Python Jupyter Notebook. Następnie możesz użyć notesu jako szablonu do uczenia własnego modelu uczenia maszynowego z użyciem własnych danych.You can then use the notebook as a template to train your own machine learning model with your own data. Ten samouczek jest częścią jednej z serii samouczków z dwiema częściami.This tutorial is part one of a two-part tutorial series.

Ten samouczek pociąga za niego prostą regresję logistyczną za pomocą zestawu danych mnist ręcznie i scikit — uczenie się z Azure Machine Learning.This tutorial trains a simple logistic regression by using the MNIST dataset and scikit-learn with Azure Machine Learning. MNIST jest popularnym zestawem danych składającym się z 70 000 obrazów w skali szarości.MNIST is a popular dataset consisting of 70,000 grayscale images. Każdy obraz ma rozmiar 28 x 28 pikseli i przedstawia odręcznie napisaną cyfrę z zakresu od 0 do 9.Each image is a handwritten digit of 28 x 28 pixels, representing a number from zero to nine. Celem jest utworzenie klasyfikatora wieloklasowego do identyfikacji cyfry reprezentowanej przez dany obraz.The goal is to create a multi-class classifier to identify the digit a given image represents.

Dowiedz się, jak wykonać następujące czynności:Learn how to take the following actions:

  • Konfigurowanie środowiska projektowego.Set up your development environment.
  • Uzyskiwanie dostępu do danych i badanie ich.Access and examine the data.
  • Uczenie prostego modelu regresji logistycznej w klastrze zdalnym.Train a simple logistic regression model on a remote cluster.
  • Przeglądanie wyników uczenia i rejestrowanie najlepszego modelu.Review training results and register the best model.

Tego, jak wybrać i wdrożyć model, dowiesz się z drugiej części tego samouczka.You learn how to select a model and deploy it in part two of this tutorial.

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.If you don't have an Azure subscription, create a free account before you begin. Wypróbuj bezpłatną lub płatną wersję Azure Machine Learning dzisiaj.Try the free or paid version of Azure Machine Learning today.

Uwaga

Kod w tym artykule został przetestowany przy użyciu zestawu SDK Azure Machine Learning 1.13.0.Code in this article was tested with Azure Machine Learning SDK version 1.13.0.

Wymagania wstępnePrerequisites

Samouczek i towarzyszący plik utils.py są również dostępne w usłudze GitHub , jeśli chcesz korzystać z niego w środowisku lokalnym.The tutorial and accompanying utils.py file is also available on GitHub if you wish to use it on your own local environment. Uruchom pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib , aby zainstalować zależności dla tego samouczka.Run pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib to install dependencies for this tutorial.

Ważne

Pozostała część tego artykułu zawiera tę samą zawartość, która jest wyświetlana w notesie.The rest of this article contains the same content as you see in the notebook.

Przełącz się do Jupyter Notebook teraz, jeśli chcesz czytać wraz z uruchamianiem kodu.Switch to the Jupyter Notebook now if you want to read along as you run the code. Aby uruchomić pojedynczą komórkę kodu w notesie, kliknij komórkę kod i naciśnij klawisze SHIFT + ENTER.To run a single code cell in a notebook, click the code cell and hit Shift+Enter. Lub Uruchom cały Notes, wybierając pozycję Uruchom wszystkie z górnego paska narzędzi.Or, run the entire notebook by choosing Run all from the top toolbar.

Konfigurowanie środowiska projektowegoSet up your development environment

Cała konfiguracja dla prac programistycznych może zostać wykonana w notesie języka Python.All the setup for your development work can be accomplished in a Python notebook. Konfiguracja obejmuje następujące czynności:Setup includes the following actions:

  • Importowanie pakietów języka Python.Import Python packages.
  • Nawiązywanie połączenia z obszarem roboczym, aby komputer lokalny mógł komunikować się z zasobami zdalnymi.Connect to a workspace, so that your local computer can communicate with remote resources.
  • Tworzenie eksperymentu do śledzenia wszystkich przebiegów.Create an experiment to track all your runs.
  • Tworzenie zdalnego docelowego zasobu obliczeniowego na potrzeby uczenia.Create a remote compute target to use for training.

Importowanie pakietówImport packages

Zaimportuj pakiety języka Python, które są potrzebne w tej sesji.Import Python packages you need in this session. Wyświetl również wersję zestawu Azure Machine Learning 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)

Łączenie z obszarem roboczymConnect to a workspace

Utwórz obiekt obszaru roboczego na podstawie istniejącego obszaru roboczego.Create a workspace object from the existing workspace. Metoda Workspace.from_config() odczytuje plik config.json i ładuje szczegóły do obiektu o nazwie 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')

Uwaga

Może zostać wyświetlony monit o uwierzytelnienie w obszarze roboczym przy pierwszym uruchomieniu poniższego kodu.You may be asked to authenticate to your workspace the first time you run the following code. Wykonaj instrukcje wyświetlane na ekranie.Follow the on-screen instructions.

Tworzenie eksperymentuCreate an experiment

Utwórz eksperyment do śledzenia przebiegów w Twoim obszarze roboczym.Create an experiment to track the runs in your workspace. Obszar roboczy może zawierać wiele eksperymentów:A workspace can have multiple experiments:

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

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

Utwórz lub Dołącz istniejący obiekt docelowy obliczeńCreate or attach an existing compute target

Za pomocą usługi zarządzanej Azure Machine Learning Compute analitycy danych mogą szkolić modele uczenia maszynowego w klastrach maszyn wirtualnych platformy Azure.By using Azure Machine Learning Compute, a managed service, data scientists can train machine learning models on clusters of Azure virtual machines. Przykłady obejmują maszyny wirtualne z obsługą procesorów GPU.Examples include VMs with GPU support. W tym samouczku utworzysz usługę Azure Machine Learning Compute jako środowisko uczenia.In this tutorial, you create Azure Machine Learning Compute as your training environment. Kod języka Python do uruchomienia na tej maszynie wirtualnej zostanie przesłany później w samouczku.You will submit Python code to run on this VM later in the tutorial.

Poniższy kod utworzy za Ciebie klastry obliczeniowe, jeśli nie istnieją one jeszcze w Twoim obszarze roboczym.The code below creates the compute clusters for you if they don't already exist in your workspace. Konfiguruje klaster, który będzie skalowany w dół do 0, gdy nie jest używany, i może być skalowany w górę do maksymalnie 4 węzłów.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.

Tworzenie obiektu docelowego obliczeń trwa około 5 minut.Creation of the compute target takes about five minutes. Jeśli zasób obliczeniowy znajduje się już w obszarze roboczym, kod używa go i pomija proces tworzenia.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", "cpu-cluster")
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())

Teraz masz pakiety i zasoby obliczeniowe niezbędne do przeprowadzenia uczenia modelu w chmurze.You now have the necessary packages and compute resources to train a model in the cloud.

Eksplorowanie danychExplore data

Zanim nauczysz model, musisz zrozumieć dane używane na potrzeby uczenia.Before you train a model, you need to understand the data that you use to train it. W tej sekcji dowiesz się, jak wykonać następujące czynności:In this section you learn how to:

  • Pobieranie zestawu danych MNISTDownload the MNIST dataset.
  • Wyświetlanie przykładowych obrazówDisplay some sample images.

Pobieranie zestawu danych MNISTDownload the MNIST dataset

Użyj otwartych zestawów danych platformy Azure, aby pobrać pierwotne pliki MNIST ręcznie.Use Azure Open Datasets to get the raw MNIST data files. Otwarte zestawy danych platformy Azure mają nadzorowane zestawy danych, których można użyć do dodawania funkcji specyficznych dla scenariusza do rozwiązań uczenia maszynowego w celu uzyskania dokładniejszych modeli.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żdy zestaw danych ma odpowiadającą klasę MNIST w tym przypadku, aby można było pobrać dane na różne sposoby.Each dataset has a corresponding class, MNIST in this case, to retrieve the data in different ways.

Ten kod pobiera dane jako FileDataset obiekt, który jest podklasą klasy Dataset .This code retrieves the data as a FileDataset object, which is a subclass of Dataset. Odwołuje się do FileDataset jednego lub wielu plików dowolnego formatu w magazynach danych lub publicznych adresach URL.A FileDataset references single or multiple files of any format in your datastores or public urls. Klasa umożliwia pobieranie lub Instalowanie plików w ramach obliczeń przez utworzenie odwołania do lokalizacji źródła danych.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. Ponadto możesz zarejestrować zestaw danych w obszarze roboczym, aby ułatwić jego pobieranie podczas uczenia się.Additionally, you register the Dataset to your workspace for easy retrieval during training.

Postępuj zgodnie z instrukcjami, aby dowiedzieć się więcej o zestawach danych i ich użyciu w zestawie 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)

Wyświetlanie przykładowych obrazówDisplay some sample images

Załaduj pliki skompresowane do tablic numpy.Load the compressed files into numpy arrays. Następnie użyj matplotlib do wykreślenia 30 losowych obrazów z zestawu danych wraz z ich etykietami nad nimi.Then use matplotlib to plot 30 random images from the dataset with their labels above them. Ten krok wymaga funkcji load_data uwzględnionej w pliku utils.py.This step requires a load_data function that's included in an utils.py file. Ten plik znajduje się w folderze przykładu.This file is included in the sample folder. Upewnij się, że znajduje się on w tym samym folderze co ten notes.Make sure it's placed in the same folder as this notebook. Funkcja load_data po prostu analizuje skompresowane pliki i przetwarza je w tablice 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()

Zostanie wyświetlona losowa próbka obrazów:A random sample of images displays:

Losowa próbka obrazów

Teraz wiesz już, jak wyglądają te obrazy i jakie są oczekiwane wyniki przewidywania.Now you have an idea of what these images look like and the expected prediction outcome.

Uczenie w klastrze zdalnymTrain on a remote cluster

W przypadku tego zadania można przesłać zadanie do uruchomienia na wcześniej skonfigurowanym klastrze szkoleniowym.For this task, you submit the job to run on the remote training cluster you set up earlier. W celu przesłania zadania wykonywane są następujące czynności:To submit a job you:

  • Tworzenie kataloguCreate a directory
  • Tworzenie skryptu uczeniaCreate a training script
  • Utwórz konfigurację uruchamiania skryptuCreate a script run configuration
  • Przesyłanie zadaniaSubmit the job

Tworzenie kataloguCreate a directory

Utwórz katalog w celu dostarczenia niezbędnego kodu ze swojego komputera do zasobu zdalnego.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)

Tworzenie skryptu uczeniaCreate a training script

Aby przesłać zadanie do klastra, najpierw utwórz skrypt uczenia.To submit the job to the cluster, first create a training script. Uruchom poniższy kod, aby utworzyć skrypt uczenia o nazwie train.py w katalogu, który został właśnie utworzony.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')

Zwróć uwagę, jak skrypt pobiera dane i zapisuje modele:Notice how the script gets data and saves models:

  • Skrypt uczenia odczytuje argument, aby znaleźć katalog zawierający dane.The training script reads an argument to find the directory that contains the data. Podczas późniejszego przesyłania zadania wskażesz magazyn danych dla tego argumentu: 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')

  • Skrypt szkoleniowy zapisuje model w katalogu o nazwie Outputs.The training script saves your model into a directory named outputs. Dowolne pliki zapisane w tym katalogu są automatycznie przekazywane do Twojego obszaru roboczego.Anything written in this directory is automatically uploaded into your workspace. W dalszej części samouczka z poziomu tego katalogu uzyskasz dostęp do swojego modelu.You access your model from this directory later in the tutorial. joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

  • Skrypt szkoleniowy wymaga pliku utils.py do poprawnego załadowania zestawu danych.The training script requires the file utils.py to load the dataset correctly. Poniższy kod kopiuje utils.py do script_folder programu, aby można było uzyskać dostęp do pliku wraz z skryptem szkoleniowym w zasobie zdalnym.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)
    

Konfigurowanie zadania szkoleniowegoConfigure the training job

Utwórz obiekt ScriptRunConfig , aby określić szczegóły konfiguracji zadania szkoleniowego, w tym skrypt szkoleniowy, środowisko, które ma być używane, oraz miejsce docelowe obliczeń do uruchomienia.Create a ScriptRunConfig object to specify the configuration details of your training job, including your training script, environment to use, and the compute target to run on. Skonfiguruj ScriptRunConfig, określając:Configure the ScriptRunConfig by specifying:

  • Katalog zawierający Twoje skrypty.The directory that contains your scripts. Wszystkie pliki w tym katalogu są przekazywane do węzłów klastra w celu wykonania.All the files in this directory are uploaded into the cluster nodes for execution.
  • Docelowy zasób obliczeniowy.The compute target. W tym przypadku użyjesz utworzonego klastra obliczeniowego usługi Azure Machine Learning.In this case, you use the Azure Machine Learning compute cluster you created.
  • Nazwa skryptu uczenia, train.py.The training script name, train.py.
  • Środowisko, które zawiera biblioteki, które są konieczne do uruchomienia skryptu.An environment that contains the libraries needed to run the script.
  • Argumenty wymagane ze skryptu szkoleniowego.Arguments required from the training script.

W tym samouczku elementem docelowym jest usługa AmlCompute.In this tutorial, this target is AmlCompute. Wszystkie pliki w folderze skryptów są przekazywane do węzłów klastra w celu uruchomienia.All files in the script folder are uploaded into the cluster nodes for run. Data_folder jest ustawiony do korzystania z zestawu danych.The --data_folder is set to use the dataset.

Najpierw Utwórz środowisko, które zawiera: Biblioteka scikit-Dowiedz się, która jest wymagana do uzyskania dostępu do zestawu danych, i wartość domyślna platformy Azure, która zawiera zależności dotyczące rejestrowania metryk.First, create the environment that contains: the scikit-learn library, azureml-dataset-runtime required for accessing the dataset, and azureml-defaults which contains the dependencies for logging metrics. Wartość domyślna platformy Azure zawiera również zależności wymagane do wdrożenia modelu jako usługi sieci Web w dalszej części tego samouczka.The azureml-defaults also contains the dependencies required for deploying the model as a web service later in the part 2 of the tutorial.

Po zdefiniowaniu środowiska zarejestruj je w obszarze roboczym, aby ponownie użyć go w części 2 samouczka.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-dataset-runtime[pandas,fuse]', 'azureml-defaults'], conda_packages=['scikit-learn==0.22.1'])

env.python.conda_dependencies = cd

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

Następnie utwórz ScriptRunConfig przez określenie skryptu szkoleniowego, celu i środowiska obliczeniowego.Then, create the ScriptRunConfig by specifying the training script, compute target and environment.

from azureml.core import ScriptRunConfig

args = ['--data-folder', mnist_file_dataset.as_mount(), '--regularization', 0.5]

src = ScriptRunConfig(source_directory=script_folder,
                      script='train.py', 
                      arguments=args,
                      compute_target=compute_target,
                      environment=env)

Przesyłanie zadania do klastraSubmit the job to the cluster

Uruchom eksperyment, przesyłając obiekt ScriptRunConfig:Run the experiment by submitting the ScriptRunConfig object:

run = exp.submit(config=src)
run

Ponieważ wywołanie jest asynchroniczne, zwraca ono stan Przygotowywanie lub Uruchomiono zaraz po uruchomieniu zadania.Because the call is asynchronous, it returns a Preparing or Running state as soon as the job is started.

Monitorowanie zdalnego przebieguMonitor a remote run

Łącznie pierwszy przebieg trwa około 10 minut.In total, the first run takes about 10 minutes. Jednak podczas kolejnych przebiegów, o ile zależności skryptu nie ulegną zmianie, jest ponownie używany ten sam obraz.But for subsequent runs, as long as the script dependencies don't change, the same image is reused. Dlatego czas uruchamiania kontenera jest znacznie krótszy.So the container startup time is much faster.

Co się dzieje podczas oczekiwania:What happens while you wait:

  • Tworzenie obrazu: tworzony jest obraz platformy Docker, który jest zgodny ze środowiskiem Python określonym w środowisku usługi Azure ml.Image creation: A Docker image is created that matches the Python environment specified by the Azure ML environment. Obraz jest przekazywany do obszaru roboczego.The image is uploaded to the workspace. Tworzenie obrazu i jego przekazywanie trwa około pięciu minut.Image creation and uploading takes about five minutes.

    Ten etap jest wykonywany tylko raz dla każdego środowiska Python, ponieważ kontener jest buforowany dla kolejnych przebiegów.This stage happens once for each Python environment because the container is cached for subsequent runs. Podczas tworzenia obrazu dzienniki są przesyłane strumieniowo do historii uruchamiania.During image creation, logs are streamed to the run history. Postęp tworzenia obrazu możesz monitorować przy użyciu tych dzienników.You can monitor the image creation progress by using these logs.

  • Skalowanie: Jeśli klaster zdalny wymaga większej liczby węzłów do uruchomienia, niż jest to obecnie dostępne, dodatkowe węzły są dodawane automatycznie.Scaling: If the remote cluster requires more nodes to do the run than currently available, additional nodes are added automatically. Skalowanie zazwyczaj trwa około pięciu minut.Scaling typically takes about five minutes.

  • Uruchomione: na tym etapie niezbędne skrypty i pliki są wysyłane do elementu docelowego obliczeń.Running: In this stage, the necessary scripts and files are sent to the compute target. Następnie magazyny danych są instalowane lub kopiowane.Then datastores are mounted or copied. Następnie uruchamiany jest skrypt entry_script.And then the entry_script is run. Podczas działania zadania dane z wyjścia stdout i katalogu ./logs są przesyłane strumieniowo do historii uruchamiania.While the job is running, stdout and the ./logs directory are streamed to the run history. Postęp przebiegu możesz monitorować przy użyciu tych dzienników.You can monitor the run's progress by using these logs.

  • Przetwarzanie końcowe: katalog ./Outputs przebiegu jest kopiowany do historii uruchamiania w obszarze roboczym, dzięki czemu możesz uzyskać dostęp do tych wyników.Post-processing: The ./outputs directory of the run is copied over to the run history in your workspace, so you can access these results.

Postęp działającego zadania możesz sprawdzić na kilka sposobów.You can check the progress of a running job in several ways. W tym samouczku jest używany widżet Jupyter oraz metoda wait_for_completion.This tutorial uses a Jupyter widget and a wait_for_completion method.

Widżet JupyterJupyter widget

Obejrzyj postęp przebiegu za pomocą widżetu Jupyter.Watch the progress of the run with a Jupyter widget. Podobnie jak przesyłanie przebiegu, widżet jest asynchroniczny i udostępnia aktualizacje na bieżąco co 10–15 sekund aż do zakończenia zadania: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()

Widżet będzie wyglądać podobnie do poniższego na końcu szkolenia:The widget will look like the following at the end of training:

Widżet notesu

Jeśli musisz anulować przebieg, możesz wykonać te instrukcje.If you need to cancel a run, you can follow these instructions.

Pobieranie wyników dziennika po zakończeniuGet log results upon completion

Uczenie i monitorowanie modelu odbywa się w tle.Model training and monitoring happen in the background. Poczekaj na zakończenie uczenia modelu przed uruchomieniem dalszego kodu.Wait until the model has finished training before you run more code. Za pomocą metody wait_for_completion można wyświetlić informację o zakończeniu trenowania 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

Wyświetlanie wyników przebieguDisplay run results

Teraz masz nauczony model w klastrze zdalnym.You now have a model trained on a remote cluster. Pobierz dokładność modelu:Retrieve the accuracy of the model:

print(run.get_metrics())

Dane wyjściowe pokazują, że model zdalny ma dokładność 0,9204:The output shows the remote model has accuracy of 0.9204:

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

W następnym samouczku bardziej szczegółowo poznasz ten model.In the next tutorial, you explore this model in more detail.

Rejestrowanie modeluRegister model

W ramach ostatniego kroku skryptu uczenia plik outputs/sklearn_mnist_model.pkl został zapisany w katalogu o nazwie outputs na maszynie wirtualnej klastra, gdzie zadanie jest uruchamiane.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. Katalog outputs jest katalogiem specjalnym, ponieważ cała jego zawartość jest automatycznie przekazywana do Twojego obszaru roboczego.outputs is a special directory in that all content in this directory is automatically uploaded to your workspace. Ta zawartość jest widoczna w rekordzie przebiegu eksperymentu w ramach Twojego obszaru roboczego.This content appears in the run record in the experiment under your workspace. W związku z tym plik modelu jest teraz również dostępny w Twoim obszarze roboczym.So the model file is now also available in your workspace.

Możesz zobaczyć pliki skojarzone z tym przebiegiem:You can see files associated with that run:

print(run.get_file_names())

Zarejestruj model w obszarze roboczym, aby umożliwić sobie (lub innym współpracownikom) późniejsze badanie i wdrażanie tego modelu oraz wykonywanie zapytań względem niego: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')

Czyszczenie zasobówClean up resources

Ważne

Utworzone zasoby mogą być używane jako wymagania wstępne dla innych samouczków Azure Machine Learning i artykułów z przewodnikiem.The resources that you created can be used as prerequisites to other Azure Machine Learning tutorials and how-to articles.

Jeśli nie planujesz używania utworzonych zasobów, usuń je, aby nie naliczane były opłaty:If you don't plan to use the resources that you created, delete them so you don't incur any charges:

  1. W witrynie Azure Portal na końcu z lewej strony wybierz pozycję Grupy zasobów.In the Azure portal, select Resource groups on the far left.

  2. Z listy wybierz utworzoną przez siebie grupę zasobów.From the list, select the resource group that you created.

  3. Wybierz pozycję Usuń grupę zasobów.Select Delete resource group.

    Zrzut ekranu przedstawiający opcje usuwania grupy zasobów w witrynie Azure Portal.

  4. Wpisz nazwę grupy zasobów.Enter the resource group name. Następnie wybierz pozycję Usuń.Then select Delete.

Usunąć możesz również sam klaster obliczeniowy usługi Azure Machine Learning.You can also delete just the Azure Machine Learning Compute cluster. Jednak ponieważ włączona jest funkcja skalowania automatycznego i minimalna wielkość klastra jest równa zero,However, autoscale is turned on, and the cluster minimum is zero. dla tego konkretnego zasobu nie będą naliczane dodatkowe opłaty za obliczenia, gdy nie jest on używany: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()

Następne krokiNext steps

W tym Azure Machine Learning samouczku użyto języka Python dla następujących zadań:In this Azure Machine Learning tutorial, you used Python for the following tasks:

  • Konfigurowanie środowiska projektowego.Set up your development environment.
  • Uzyskiwanie dostępu do danych i badanie ich.Access and examine the data.
  • Szkolenie wielu modeli w klastrze zdalnym przy użyciu popularnej biblioteki uczenia maszynowego scikit-learnTrain multiple models on a remote cluster using the popular scikit-learn machine learning library
  • Przeglądanie szczegółów uczenia i rejestrowanie najlepszego modelu.Review training details and register the best model.

Wszystko jest już gotowe do wdrożenia tego zarejestrowanego modelu zgodnie z instrukcjami w następnej części serii samouczków:You're ready to deploy this registered model by using the instructions in the next part of the tutorial series: