Didacticiel : entraîner des modèles de classification d’images avec des données MNIST et scikit-learn à l’aide d’Azure Machine LearningTutorial: Train image classification models with MNIST data and scikit-learn using Azure Machine Learning

S’APPLIQUE À : ouiÉdition de base ouiÉdition Entreprise                    (Mise à niveau vers l’édition Entreprise)APPLIES TO: yesBasic edition yesEnterprise edition                    (Upgrade to Enterprise edition)

Dans ce tutoriel, vous allez entraîner un modèle Machine Learning sur des ressources de calcul distantes.In this tutorial, you train a machine learning model on remote compute resources. Vous allez utiliser le workflow d’entraînement et de déploiement pour Azure Machine Learning dans un notebook Jupyter Python.You'll use the training and deployment workflow for Azure Machine Learning in a Python Jupyter notebook. Vous pourrez ensuite utiliser le bloc-notes en tant que modèle pour entraîner votre propre modèle Machine Learning avec vos propres données.You can then use the notebook as a template to train your own machine learning model with your own data. Ce tutoriel est le premier d’une série de deux.This tutorial is part one of a two-part tutorial series.

Ce tutoriel montre comment effectuer l’entraînement d’une régression logistique simple à l’aide du jeu de données MNIST et de scikit-learn avec Azure Machine Learning.This tutorial trains a simple logistic regression by using the MNIST dataset and scikit-learn with Azure Machine Learning. MNIST est un jeu de données populaire composé de 70 000 images en nuances de gris.MNIST is a popular dataset consisting of 70,000 grayscale images. Chaque image est un chiffre manuscrit de 28 x 28 pixels, représentant un nombre de zéro à neuf.Each image is a handwritten digit of 28 x 28 pixels, representing a number from zero to nine. L’objectif est de créer un classifieur multiclasse pour identifier le chiffre représenté par une image donnée.The goal is to create a multi-class classifier to identify the digit a given image represents.

Découvrez comment effectuer les actions suivantes :Learn how to take the following actions:

  • Configurer l’environnement de développementSet up your development environment.
  • Accéder aux données et les examinerAccess and examine the data.
  • Effectuez l’apprentissage d’un modèle de régression logistique simple sur un cluster distant.Train a simple logistic regression model on a remote cluster.
  • Examiner les résultats de l’entraînement et inscrire le meilleur modèleReview training results and register the best model.

Vous découvrirez comment sélectionner un modèle et le déployer dans la deuxième partie de ce tutoriel.You learn how to select a model and deploy it in part two of this tutorial.

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.If you don’t have an Azure subscription, create a free account before you begin. Essayez la version gratuite ou payante d’Azure Machine Learning dès aujourd’hui.Try the free or paid version of Azure Machine Learning today.

Notes

Le code présenté dans cet article a été testé avec le Kit de développement logiciel (SDK) Azure Machine Learning version 1.0.65.Code in this article was tested with Azure Machine Learning SDK version 1.0.65.

PrérequisPrerequisites

  • Suivre le Tutoriel : Commencez à créer votre première expérience ML pour :Complete the Tutorial: Get started creating your first ML experiment to:

    • Créer un espace de travailCreate a workspace
    • Clonez le notebook des tutoriels dans votre dossier au sein de l’espace de travail.Clone the tutorials notebook to your folder in the workspace.
    • Créez une machine virtuelle Notebook basée sur le cloud.Create a cloud-based Notebook VM.
  • Dans votre dossier de didacticiels clonés, ouvrez le notebook img-classification-part1-deploy.ipynb.In your cloned tutorials folder, open the img-classification-part1-training.ipynb notebook.

Vous trouverez également le tutoriel et le fichier utils.py correspondant sur GitHub si vous souhaitez les utiliser dans votre propre environnement local.The tutorial and accompanying utils.py file is also available on GitHub if you wish to use it on your own local environment. Exécutez pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib pour installer les dépendances de ce didacticiel.Run pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib to install dependencies for this tutorial.

Important

Le reste de cet article contient le même contenu que ce que vous voyez dans le notebook.The rest of this article contains the same content as you see in the notebook.

Basculez maintenant vers le notebook Jupyter si vous voulez lire le code à mesure que vous l’exécutez.Switch to the Jupyter notebook now if you want to read along as you run the code. Pour exécuter une seule cellule de code dans un notebook, cliquez sur celle-ci et appuyez sur Maj + Entrée.To run a single code cell in a notebook, click the code cell and hit Shift+Enter. Sinon, exécutez l’intégralité du notebook en choisissant Run all (Tout exécuter) dans la barre d’outils supérieure.Or, run the entire notebook by choosing Run all from the top toolbar.

Configurer votre environnement de développementSet up your development environment

Toute la configuration pour votre travail de développement peut être effectuée dans un bloc-notes Python.All the setup for your development work can be accomplished in a Python notebook. La configuration comprend les actions suivantes :Setup includes the following actions:

  • Importer des packages PythonImport Python packages.
  • Se connecter à un espace de travail, afin que votre ordinateur local puisse communiquer avec des ressources distantesConnect to a workspace, so that your local computer can communicate with remote resources.
  • Créer une expérience pour effectuer le suivi de toutes vos exécutionsCreate an experiment to track all your runs.
  • Créer une cible de calcul distante à utiliser pour l’entraînementCreate a remote compute target to use for training.

Importer des packagesImport packages

Importez les packages Python dont vous avez besoin dans cette session.Import Python packages you need in this session. Affichez également la version du SDK Azure Machine Learning :Also display the Azure Machine Learning SDK version:

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

import azureml.core
from azureml.core import Workspace

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

Se connecter à un espace de travailConnect to a workspace

Créez un objet d’espace de travail à partir de l’espace de travail existant.Create a workspace object from the existing workspace. Workspace.from_config() lit le fichier config.json et charge les détails dans un objet nommé 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')

Création d'une expérienceCreate an experiment

Créez une expérience pour effectuer le suivi des exécutions dans votre espace de travail.Create an experiment to track the runs in your workspace. Un espace de travail peut avoir plusieurs expériences :A workspace can have multiple experiments:

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

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

Créer ou attacher une cible de calcul existanteCreate or attach an existing compute target

En utilisant le service managé Capacité de calcul Azure Machine Learning, les scientifiques des données peuvent entraîner des modèles Machine Learning sur des clusters de machines virtuelles Azure.By using Azure Machine Learning Compute, a managed service, data scientists can train machine learning models on clusters of Azure virtual machines. Il peut s’agir notamment de machines virtuelles prenant en charge les GPU.Examples include VMs with GPU support. Dans ce tutoriel, vous allez créer la Capacité de calcul Azure Machine Learning qui vous servira d’environnement d’entraînement.In this tutorial, you create Azure Machine Learning Compute as your training environment. Le code ci-dessous crée automatiquement les clusters de calcul s’ils n’existent pas encore dans votre espace de travail.The code below creates the compute clusters for you if they don't already exist in your workspace.

La création de la cible de calcul prend environ cinq minutes.Creation of the compute target takes about five minutes. Si la ressource de calcul se trouve déjà dans l’espace de travail, le code l’utilise et ignore le processus de création.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())

Vous disposez désormais des packages et des ressources de calcul nécessaires pour entraîner un modèle dans le cloud.You now have the necessary packages and compute resources to train a model in the cloud.

Explorer les donnéesExplore data

Avant d’entraîner un modèle, vous devez comprendre les données que vous utilisez pour l’entraîner.Before you train a model, you need to understand the data that you use to train it. Dans cette section, vous allez découvrir comment :In this section you learn how to:

  • Télécharger le jeu de données MNISTDownload the MNIST dataset.
  • Afficher des exemples d’imagesDisplay some sample images.

Télécharger le jeu de données MNISTDownload the MNIST dataset

Utilisez Azure Open Datasets pour récupérer les fichiers de données MNIST bruts.Use Azure Open Datasets to get the raw MNIST data files. Les jeux de données Azure Open Datasets sont des jeux de données publics organisés que vous pouvez utiliser pour ajouter des fonctionnalités spécifiques à des scénarios à des solutions de Machine Learning afin d'obtenir des modèles plus précis.Azure Open Datasets are curated public datasets that you can use to add scenario-specific features to machine learning solutions for more accurate models. Chaque jeu de données a une classe correspondante, MNIST dans ce cas, pour récupérer les données de différentes façons.Each dataset has a corresponding class, MNIST in this case, to retrieve the data in different ways.

Ce code récupère les données sous la forme d’un objet FileDataset, qui est une sous-classe de Dataset.This code retrieves the data as a FileDataset object, which is a subclass of Dataset. Un FileDataset fait référence à des fichiers uniques ou multiples de différents formats dans vos magasins de fichiers ou vos URL publiques.A FileDataset references single or multiple files of any format in your datastores or public urls. La classe vous permet de télécharger ou de monter les fichiers dans votre calcul en créant une référence à l’emplacement de la source de données.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. En outre, vous inscrivez le jeu de données dans votre espace de travail pour faciliter la récupération pendant la formation.Additionally, you register the Dataset to your workspace for easy retrieval during training.

Pour en savoir plus sur les jeux de données et leur utilisation dans le kit de développement logiciel, suivez le guide pratique.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)

Afficher des exemples d’imagesDisplay some sample images

Chargez les fichiers compressés dans des tableaux numpy.Load the compressed files into numpy arrays. Utilisez ensuite matplotlib pour tracer 30 images aléatoires du jeu de données avec leurs étiquettes au-dessus.Then use matplotlib to plot 30 random images from the dataset with their labels above them. Cette étape nécessite une fonction load_data qui est incluse dans un fichier util.py.This step requires a load_data function that's included in an util.py file. Ce fichier est inclus dans l’exemple de dossier.This file is included in the sample folder. Vérifiez qu’il se trouve dans le même dossier que ce bloc-notes.Make sure it's placed in the same folder as this notebook. La fonction load_data analyse les fichiers compressés dans des tableaux Numpy.The load_data function simply parses the compressed files into numpy arrays.

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

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

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

Un échantillon aléatoire d’images affiche :A random sample of images displays:

Échantillon aléatoire d’images

Vous avez maintenant une idée de l’aspect de ces images et du résultat de prédiction attendu.Now you have an idea of what these images look like and the expected prediction outcome.

Effectuer l’entraînement sur un cluster distantTrain on a remote cluster

Pour cette tâche, envoyez le travail au cluster d’entraînement distant défini précédemment.For this task, submit the job to the remote training cluster you set up earlier. Pour envoyer un travail, vous devez :To submit a job you:

  • Créer un répertoireCreate a directory
  • Créer un script d’entraînementCreate a training script
  • Créer un objet EstimatorCreate an estimator object
  • Envoi du travailSubmit the job

Créer un répertoireCreate a directory

Créez un répertoire pour fournir le code nécessaire à partir de votre ordinateur à la ressource distante.Create a directory to deliver the necessary code from your computer to the remote resource.

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

Créer un script d’entraînementCreate a training script

Pour envoyer le travail au cluster, vous devez d’abord créer un script d’entraînement.To submit the job to the cluster, first create a training script. Exécutez le code suivant pour créer le script d’entraînement nommé train.py dans le répertoire que vous venez de créer.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
from sklearn.externals 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')

Notez comment le script obtient les données et enregistre les modèles :Notice how the script gets data and saves models:

  • Le script d’entraînement lit un argument pour rechercher le répertoire qui contient les données.The training script reads an argument to find the directory that contains the data. Quand vous envoyez le travail ultérieurement, vous pointez vers la banque de données pour cet 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')

  • Le script d’entraînement enregistre votre modèle dans un répertoire nommé outputs.The training script saves your model into a directory named outputs. Tout ce qui est écrit dans ce répertoire est chargé automatiquement dans votre espace de travail.Anything written in this directory is automatically uploaded into your workspace. Vous accédez à votre modèle à partir de ce répertoire plus loin dans le tutoriel.You access your model from this directory later in the tutorial. joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

  • Le script d’entraînement nécessite le fichier utils.py pour charger correctement le jeu de données.The training script requires the file utils.py to load the dataset correctly. Le code suivant copie utils.py dans script_folder, afin que le fichier soit accessible en plus du script d’entraînement sur la ressource distante.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)
    

Créer un estimateurCreate an estimator

Un objet estimateur SKLearn est utilisé pour soumettre l’exécution.An SKLearn estimator object is used to submit the run. Créez votre estimateur en exécutant le code suivant pour définir ces éléments :Create your estimator by running the following code to define these items:

  • Le nom de l’objet estimateur, est.The name of the estimator object, est.
  • Le répertoire qui contient vos scripts.The directory that contains your scripts. Tous les fichiers dans ce répertoire sont chargés dans les nœuds de cluster pour l’exécution.All the files in this directory are uploaded into the cluster nodes for execution.
  • La cible de calcul.The compute target. Dans le cas présent, vous utilisez le cluster de calcul Azure Machine Learning que vous avez créé.In this case, you use the Azure Machine Learning compute cluster you created.
  • Le nom du script d’entraînement, train.py.The training script name, train.py.
  • Les paramètres requis à partir du script d’entraînement.Parameters required from the training script.

Dans ce tutoriel, cette cible est AmlCompute.In this tutorial, this target is AmlCompute. Tous les fichiers du dossier de scripts sont chargés dans les nœuds de cluster pour l’exécution.All files in the script folder are uploaded into the cluster nodes for run. data_folder est configuré pour utiliser le jeu de données.The data_folder is set to use the dataset. Commencez par créer un objet d’environnement qui spécifie les dépendances nécessaires à l’entraînement.First create an environment object that specifies the dependencies required for training.

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

env = Environment('my_env')
cd = CondaDependencies.create(pip_packages=['azureml-sdk','scikit-learn','azureml-dataprep[pandas,fuse]>=1.1.14'])
env.python.conda_dependencies = cd

Créez ensuite l’estimateur avec le code suivant.Then create the estimator with the following code.

from azureml.train.sklearn import SKLearn

script_params = {
    '--data-folder': mnist_file_dataset.as_named_input('mnist_opendataset').as_mount(),
    '--regularization': 0.5
}

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

Envoyer le travail au clusterSubmit the job to the cluster

Exécutez l’expérience en soumettant l’objet estimateur :Run the experiment by submitting the estimator object:

run = exp.submit(config=est)
run

L’appel étant asynchrone, il retourne un état en cours de préparation ou en cours d’exécution dès le démarrage du travail.Because the call is asynchronous, it returns a Preparing or Running state as soon as the job is started.

Superviser une exécution à distanceMonitor a remote run

Au total, la première exécution prend environ 10 minutes.In total, the first run takes about 10 minutes. Mais pour les exécutions suivantes, tant que les dépendances de script ne changent pas, la même image est réutilisée.But for subsequent runs, as long as the script dependencies don't change, the same image is reused. La durée de démarrage du conteneur est donc beaucoup plus courte.So the container startup time is much faster.

Ce qui se passe pendant que vous attendez :What happens while you wait:

  • Création d’images : une image Docker qui correspond à l’environnement Python spécifié par l’estimateur est créée.Image creation: A Docker image is created that matches the Python environment specified by the estimator. L’image est chargée dans l’espace de travail.The image is uploaded to the workspace. La création et le chargement de l’image prennent environ cinq minutes.Image creation and uploading takes about five minutes.

    Cette étape se produit une fois pour chaque environnement Python, puisque le conteneur est mis en cache pour les exécutions suivantes.This stage happens once for each Python environment because the container is cached for subsequent runs. Lors de la création d’image, les journaux d’activité sont diffusés en continu vers l’historique d’exécutions.During image creation, logs are streamed to the run history. Vous pouvez superviser la progression de la création d’image à l’aide de ces journaux d’activité.You can monitor the image creation progress by using these logs.

  • Mise à l’échelle : si le cluster distant nécessite plus de nœuds pour l’exécution que la quantité disponible actuellement, des nœuds supplémentaires sont ajoutés automatiquement.Scaling: If the remote cluster requires more nodes to do the run than currently available, additional nodes are added automatically. En général, la mise à l’échelle prend environ cinq minutes.Scaling typically takes about five minutes.

  • Running : Lors de cette étape, les fichiers et les scripts nécessaires sont envoyés à la cible de calcul.Running: In this stage, the necessary scripts and files are sent to the compute target. Ensuite, les banques de données sont montées ou copiées.Then datastores are mounted or copied. Pour finir, entry_script est exécuté.And then the entry_script is run. Pendant que le travail s’exécute, stdout et le répertoire ./logs sont diffusés en continu vers l’historique d’exécutions.While the job is running, stdout and the ./logs directory are streamed to the run history. Vous pouvez superviser la progression de l’exécution à l’aide de ces journaux d’activité.You can monitor the run's progress by using these logs.

  • Post-traitement : le répertoire ./outputs de l’exécution est copié dans l’historique des exécutions de votre espace de travail, afin que vous puissiez accéder à ces résultats.Post-processing: The ./outputs directory of the run is copied over to the run history in your workspace, so you can access these results.

Vous pouvez vérifier la progression d’un travail en cours d’exécution de plusieurs façons.You can check the progress of a running job in several ways. Ce tutoriel utilise un widget Jupyter et une méthode wait_for_completion.This tutorial uses a Jupyter widget and a wait_for_completion method.

Widget JupyterJupyter widget

Surveillez la progression de l’exécution avec un widget Jupyter.Watch the progress of the run with a Jupyter widget. Comme l’envoi de l’exécution, le widget est asynchrone et fournit des mises à jour automatiques toutes les 10 à 15 secondes jusqu’à ce que la tâche soit terminée :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()

À la fin de l’entraînement, le widget ressemblera à ceci :The widget will look like the following at the end of training:

Widget de bloc-notes

Si vous devez annuler une exécution, vous pouvez suivre ces instructions.If you need to cancel a run, you can follow these instructions.

Obtenir des résultats du journal lors de l’achèvementGet log results upon completion

L’entraînement et la supervision du modèle se produisent en arrière-plan.Model training and monitoring happen in the background. Attendez que l’entraînement du modèle soit terminé avant d’exécuter davantage de code.Wait until the model has finished training before you run more code. Utilisez wait_for_completion pour indiquer quand l’entraînement du modèle est terminé :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

Afficher les résultats de l’exécutionDisplay run results

Vous disposez maintenant d’un modèle entraîné sur un cluster distant.You now have a model trained on a remote cluster. Récupérez la précision du modèle :Retrieve the accuracy of the model:

print(run.get_metrics())

La sortie montre que le modèle distant a une précision de 0.9204 :The output shows the remote model has accuracy of 0.9204:

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

Dans le tutoriel suivant, vous explorerez ce modèle plus en détail.In the next tutorial, you explore this model in more detail.

Inscrire le modèleRegister model

La dernière étape du script d’entraînement a écrit le fichier outputs/sklearn_mnist_model.pkl dans un répertoire nommé outputs sur la machine virtuelle du cluster où le travail est exécuté.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 est un répertoire spécial, dans la mesure où tout son contenu est chargé automatiquement dans votre espace de travail.outputs is a special directory in that all content in this directory is automatically uploaded to your workspace. Ce contenu apparaît dans l’enregistrement d’exécution dans l’expérience sous votre espace de travail.This content appears in the run record in the experiment under your workspace. Ainsi, le fichier de modèle est désormais disponible également dans votre espace de travail.So the model file is now also available in your workspace.

Vous pouvez voir les fichiers associés à cette exécution :You can see files associated with that run:

print(run.get_file_names())

Inscrivez le modèle dans l’espace de travail afin de pouvoir (vous-même ou d’autres collaborateurs) interroger, examiner et déployer ultérieurement ce modèle :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')

Supprimer des ressourcesClean up resources

Important

Les ressources que vous avez créées peuvent être utilisées comme conditions préalables pour d’autres didacticiels de Azure Machine Learning et des articles de procédure.The resources you created can be used as prerequisites to other Azure Machine Learning tutorials and how-to articles.

Si vous n’avez pas l’intention d’utiliser les ressources que vous avez créées, supprimez-les pour éviter des frais :If you don't plan to use the resources you created, delete them, so you don't incur any charges:

  1. Dans le portail Azure, sélectionnez Groupes de ressources tout à gauche.In the Azure portal, select Resource groups on the far left.

    Supprimer dans le portail AzureDelete in the Azure portal

  2. À partir de la liste, sélectionnez le groupe de ressources créé.From the list, select the resource group you created.

  3. Sélectionnez Supprimer le groupe de ressources.Select Delete resource group.

  4. Entrez le nom du groupe de ressources.Enter the resource group name. Puis sélectionnez Supprimer.Then select Delete.

Vous pouvez aussi supprimer uniquement le cluster de calcul Machine Learning.You can also delete just the Azure Machine Learning Compute cluster. Toutefois, la mise à l’échelle automatique est activée et le minimal de cluster est égal à zéro.However, autoscale is turned on, and the cluster minimum is zero. Par conséquent, cette ressource n’entraînera aucun frais de calcul supplémentaires quand elle ne sera pas en cours d’utilisation :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()

Étapes suivantesNext steps

Dans ce tutoriel sur Azure Machine Learning, vous avez utilisé Python pour les tâches suivantes :In this Azure Machine Learning tutorial, you used Python for the following tasks:

  • Configurer l’environnement de développementSet up your development environment.
  • Accéder aux données et les examinerAccess and examine the data.
  • Entraîner plusieurs modèles sur un cluster distant à l’aide de la bibliothèque de Machine Learning scikit-learn populaireTrain multiple models on a remote cluster using the popular scikit-learn machine learning library
  • Examiner les détails de l’entraînement et inscrire le meilleur modèleReview training details and register the best model.

Vous êtes prêt à déployer ce modèle inscrit en suivant les instructions fournies dans la deuxième partie de cette série de tutoriels :You're ready to deploy this registered model by using the instructions in the next part of the tutorial series: