Självstudie: Träna en bildklassificeringsmodell med ett Jupyter Notebook

I den här självstudien ska du träna en maskininlärningsmodell på fjärranslutna beräkningsresurser. Du använder tränings- och distributionsarbetsflödet för att Azure Machine Learning i ett Python-Jupyter Notebook. Du kan sedan använda anteckningsboken som en mall för att träna din egen maskininlärningsmodell med egna data. Den här självstudien är del ett i en självstudieserie i två delar.

Den här självstudien tränar en enkel logistisk regression med hjälp av MNIST-datauppsättningen och scikit-learn med Azure Machine Learning. MNIST är en populär datauppsättning som består av 70 000 gråskalebilder. Varje bild är en handskriven siffra på 28 × 28 pixlar, som representerar ett tal från noll till nio. Målet är att skapa en klassificerare för flera klasser som identifierar siffran som en viss bild representerar.

Läs hur du vidtar följande åtgärder:

Du lär dig hur du väljer en modell och distribuerar den i del två av den här självstudien.

Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen Azure Machine Learning idag.

Förutsättningar

• Slutför snabbstarten: Kom igång med Azure Machine Learning till:
  • Skapa en arbetsyta.
  • Skapa en molnbaserad beräkningsinstans som ska användas för din utvecklingsmiljö.
  • Skapa ett molnbaserat beräkningskluster som ska användas för att träna din modell.

Köra en notebook-dator från din arbetsyta

Azure Machine Learning innehåller en notebook-molnserver på din arbetsyta för en installationsfri och förkonfigurerad upplevelse. Använd din egen miljö om du föredrar att ha kontroll över din miljö, dina paket och dina beroenden.

Följ med i den här videon eller använd de detaljerade stegen för att klona och köra anteckningsboken för självstudien från din arbetsyta.

Klona en notebook-mapp

Du slutför följande experimentkonfiguration och kör stegen i Azure Machine Learning Studio. Det här konsoliderade gränssnittet innehåller maskininlärningsverktyg för att utföra datavetenskapsscenarier för data science-utövare på alla kunskapsnivåer.

1. Logga in på Azure Machine Learning studio.

2. Välj din prenumeration och den arbetsyta som du skapade.

3. Till vänster väljer du Notebooks.

4. Välj fliken Exempel längst upp.

5. Öppna Python-mappen.

6. Öppna mappen med ett versionsnummer. Det här numret representerar den aktuella versionen för Python SDK.

7. Välj knappen ... till höger om mappen tutorials och välj sedan Klona.

   

8. En lista över mappar visar varje användare som har åtkomst till arbetsytan. Välj din mapp för att klona mappen tutorials där.

Öppna den klonade notebook-datorn

1. Öppna mappen tutorials som klonade till avsnittet Användarfiler.

   Viktigt

   Du kan visa notebook-filer i exempelmappen, men du kan inte köra en notebook-fil därifrån. Om du vill köra en notebook-fil måste du öppna den klonade versionen av notebook-filen i avsnittet Användarfiler.

2. Välj filen img-classification-part1-training.ipynb i mappen tutorials/image-classification-mnist-data.

   

3. I det översta fältet väljer du den beräkningsinstans som ska användas för att köra anteckningsboken.

Självstudien och tillhörande utils.py finns också på GitHub om du vill använda den i din egen lokala miljö. Om du inte använder beräkningsinstansen kör du för pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib att installera beroenden för den här självstudien.

Ställt in din utvecklingsmiljö

All konfiguration under utvecklingsarbetet kan utföras i en Python-anteckningsbok. Konfigurationen inkluderar följande åtgärder:

• Importera Python-paket.
• Ansluta till en arbetsyta så att din lokala dator kan kommunicera med fjärranslutna resurser.
• Skapa ett experiment för att spåra alla dina körningar.
• Skapa ett fjärrberäkningsmål som ska användas för träning.

Importera paket

Importera Python-paket som du behöver i den här sessionen. Visa även Azure Machine Learning SDK-versionen:

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

import azureml.core
from azureml.core import Workspace

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

Anslut till en arbetsyta

Skapa ett arbetsyteobjekt från den befintliga arbetsytan. Workspace.from_config() läser filen config.json och läser in informationen i ett objekt med namnet ws. Beräkningsinstansen har en kopia av den här filen sparad i sin rotkatalog. Om du kör koden någon annanstans måste du skapa filen.

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

Skapa ett experiment

Skapa ett experiment för att spåra körningarna på arbetsytan. En arbetsyta kan ha flera experiment:

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

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

Skapa eller koppla ett befintligt beräkningsmål

Genom att använda Azure Machine Learning Compute, en hanterad tjänst så kan datavetare träna maskininlärningsmodeller i kluster med virtuella Azure-datorer. Exempel innefattar virtuella datorer med GPU-stöd. I den här självstudien ska du skapa Azure Machine Learning Compute som din träningsmiljö. Du skickar Python-kod som ska köras på den här virtuella datorn senare i självstudien.

Koden nedan skapar beräkningsklustren åt dig om de inte redan finns på din arbetsyta. Den uppsättningar ett kluster som skalar ned till 0 när det inte används och kan skala upp till högst 4 noder.

Det tar cirka fem minuter att skapa beräkningsmålet. Om beräkningsresursen redan finns på arbetsytan använder koden den och hoppar över skapandeprocessen.

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

Nu har du de nödvändiga paketen och beräkningsresurserna för att träna en modell i molnet.

Utforska data

Innan du tränar en modell så måste du förstå de data som du använder för att träna den. I det här avsnittet lär du dig att:

• Hämta MNIST-datauppsättningen.
• Visa några exempelbilder.

Ladda ned MNIST-datauppsättningen

Använd Azure Open Datasets för att hämta rådatafilerna för MNIST. Azure Open Datasets offentliga datauppsättningar som du kan använda för att lägga till scenariospecifika funktioner i maskininlärningslösningar för mer exakta modeller. Varje datauppsättning har en motsvarande klass, MNIST i det här fallet, för att hämta data på olika sätt.

Den här koden hämtar data som ett FileDataset -objekt, vilket är en underklass av Dataset . En FileDataset refererar till en eller flera filer i alla format i dina datalager eller offentliga URL:er. Klassen ger dig möjlighet att ladda ned eller montera filerna till din beräkning genom att skapa en referens till datakällans plats. Dessutom registrerar du datauppsättningen på din arbetsyta för enkel hämtning under träningen.

Följ nstruktionerna för att lära dig mer om datauppsättningar och deras användning i SDK.

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

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

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

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

Visa några exempelbilder

Läs in de komprimerade filerna i numpy-matriser. Använd därefter matplotlib till att rita 30 slumpmässiga bilder från datauppsättningen med sina etiketter ovanför dem. Det här steget kräver en load_data-funktion som ingår i en utils.py-fil. Den här filen finns med i exempelmappen. Kontrollera att den finns i samma mapp som den här anteckningsboken. Funktionen load_data parsar enkelt de komprimerade filerna till numpy-matriser.

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


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


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

Ett slumpmässigt urval av bilder visas:

Nu har du en uppfattning om hur dessa bilder ser ut och det förväntade förutsägelseresultatet.

Träna i ett fjärrkluster

För den här uppgiften skickar du jobbet som ska köras på det fjärrträningskluster som du konfigurerade tidigare. Du skickar ett jobb genom att:

• Skapa en katalog
• Skapa ett träningsskript
• Skapa en skriptkörningskonfiguration
• Skicka jobbet

Skapa en katalog

Skapa en katalog för att leverera den nödvändiga koden från din dator till fjärresursen.

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

Skapa ett träningsskript

Innan du skickar jobbet till klustret skapar du ett träningsskript. Kör följande kod för att skapa ett träningsskript med namnet train.py i katalogen som du nyss skapade.

%%writefile $script_folder/train.py

import argparse
import os
import numpy as np
import glob

from sklearn.linear_model import LogisticRegression
import joblib

from azureml.core import Run
from utils import load_data

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

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

# load train and test set into numpy arrays
# note we scale the pixel intensity values to 0-1 (by dividing it with 255.0) so the model can converge faster.
X_train = load_data(glob.glob(os.path.join(data_folder, '**/train-images-idx3-ubyte.gz'), recursive=True)[0], False) / 255.0
X_test = load_data(glob.glob(os.path.join(data_folder, '**/t10k-images-idx3-ubyte.gz'), recursive=True)[0], False) / 255.0
y_train = load_data(glob.glob(os.path.join(data_folder, '**/train-labels-idx1-ubyte.gz'), recursive=True)[0], True).reshape(-1)
y_test = load_data(glob.glob(os.path.join(data_folder, '**/t10k-labels-idx1-ubyte.gz'), recursive=True)[0], True).reshape(-1)

print(X_train.shape, y_train.shape, X_test.shape, y_test.shape, sep = '\n')

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

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

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

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

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

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

Observera hur skriptet hämtar data och sparar modeller:

• Träningsskriptet läser ett argument för att hitta katalogen som innehåller data. När du skickar jobbet senare pekar du på datalagret för det här argumentet:

  parser.add_argument('--data-folder', type=str, dest='data_folder', help='data directory mounting point')

• Träningsskriptet sparar din modell i en katalog med namnet outputs. Allt som skrivs i den här katalogen överförs automatiskt till din arbetsyta. Du kommer åt din modell från den här katalogen senare i självstudien. joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

• Träningsskriptet kräver att filen utils.py läser in datauppsättningen korrekt. Följande kod utils.py kopieras script_folder till så att filen kan nås tillsammans med träningsskriptet på fjärrresursen.

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

Konfigurera träningsjobbet

Skapa ett ScriptRunConfig-objekt för att ange konfigurationsinformationen för träningsjobbet, inklusive träningsskriptet, miljön som ska användas och beräkningsmålet som ska köras. Konfigurera ScriptRunConfig genom att ange:

• Katalogen som innehåller dina skript. Alla filer i den här katalogen laddas upp till klusternoderna för körning.
• Beräkningsmålet. I det här fallet använder du Azure Machine Learning-beräkningsklustret som du skapade.
• Namnet på träningsskriptet, train.py.
• En miljö som innehåller de bibliotek som behövs för att köra skriptet.
• Argument som krävs från träningsskriptet.

I den här självstudien är det här målet AmlCompute. Alla filer i skriptmappen laddas upp till klusternoderna för körning. --data_folder har angetts för att använda datauppsättningen.

Skapa först miljön som innehåller: scikit-learn-biblioteket, azureml-dataset-runtime som krävs för att komma åt datauppsättningen och azureml-defaults som innehåller beroenden för loggning av mått. Azureml-defaults innehåller också de beroenden som krävs för att distribuera modellen som en webbtjänst senare i del 2 av självstudien.

När miljön har definierats registrerar du den med arbetsytan för att använda den igen i del 2 av självstudien.

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)

Skapa sedan ScriptRunConfig genom att ange träningsskriptet, beräkningsmålet och miljön.

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)

Skicka jobbet till klustret

Kör experimentet genom att skicka ScriptRunConfig-objektet:

run = exp.submit(config=src)
run

Eftersom anropet är asynkront så returneras statusen Förbereder eller Körs så snart jobbet har startats.

Övervaka en fjärrkörning

Den första körningen tar totalt cirka 10 minuter. Men för efterföljande körningar så länge skriptberoendena inte ändras så återanvänds samma avbildning. Starttiden för containern är mycket snabbare.

Vad händer medan du väntar:

• Skapa avbildning: En Docker-avbildning skapas som matchar Den Python-miljö som anges av Azure ML miljön. Avbildningen laddas upp till arbetsytan. Det tar cirka fem minuter att skapa och överföra avbildningen.

  Den här fasen sker en gång för varje Python-miljö eftersom containern cachelagras för efterföljande körningar. När avbildningen skapas strömmas loggar till körningshistoriken. Du kan övervaka förloppet för avbildningsgenereringen med de här loggarna.

• Skalning: Om fjärrklustret kräver fler noder för att köra än vad som är tillgängligt för närvarande läggs ytterligare noder till automatiskt. Skalningen tar normalt cirka fem minuter.

• Körs: I det här steget skickas nödvändiga skript och filer till beräkningsmålet. Datalagren monteras eller kopieras därefter. Och sedan körs entry_script. Medan jobbet körs strömmas stdout och ./logs-katalogen till körningshistoriken. Du kan övervaka körningens förlopp med hjälp av de här loggarna.

• Efterbearbetning: Katalogen ./outputs för körningen kopieras till körningshistoriken på arbetsytan så att du kan komma åt dessa resultat.

Du kan kontrollera förloppet för ett jobb som körs på flera olika sätt. Den här självstudien använder en Jupyter-widget samt en wait_for_completion-metod.

Jupyter-widget

Titta på körningens förlopp med en Jupyter-widget. Precis som körningsöverföringen så är widgeten asynkron och tillhandahåller liveuppdateringar var 10:e till 15:e sekund tills jobbet slutförts:

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

Widgeten ser ut som följande i slutet av träningen:

Om du vill avbryta en körning kan du följa instruktionerna.

Hämta loggresultat när åtgärden har slutförts

Modellträningen och övervakningen sker i bakgrunden. Vänta tills modellen har slutfört träningen innan du kör mer kod. Använd wait_for_completion för att visa när modellträningen är klar:

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

Visa körningsresultat

Nu har du en modell som har tränats på ett fjärrkluster. Hämta modellens precision:

print(run.get_metrics())

Resultatet visar att fjärrmodellen har en riktighet på 0.9204:

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

I nästa självstudie får du analysera den här modellen i detalj.

Registrera modellen

Det sista steget i träningsskriptet skrev filen outputs/sklearn_mnist_model.pkl i en katalog med namnet outputs på den virtuella datorn i klustret där jobbet körs. outputs är en särskild katalog i det avseende att allt innehåll i den här katalogen överförs automatiskt till din arbetsyta. Det här innehållet visas i körningsposten i experimentet under din arbetsyta. Därför är modellfilen nu även tillgänglig på din arbetsyta.

Du kan se filer som hör till den körningen:

print(run.get_file_names())

Registrera modellen på arbetsytan så att du eller andra medarbetare senare kan fråga, utforska och distribuera modellen:

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

Rensa resurser

Om du inte planerar att använda någon av de resurser som du har skapat kan du ta bort dem så att du inte debiteras:

1. I Azure-portalen väljer du Resursgrupper längst till vänster.

2. Välj resursgruppen som du skapade från listan.

3. Välj Ta bort resursgrupp.

   

4. Ange resursgruppsnamnet. Välj sedan Ta bort.

Du kan också ta bort bara Azure Machine Learning-beräkningsklustret. Autoskalning är dock aktiverat och det minsta antalet kluster är noll. Så den här resursen debiteras inte ytterligare beräkningsavgifter när den inte används:

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

Nästa steg

I den Azure Machine Learning självstudien använde du Python för följande uppgifter:

Nu är du redo att distribuera den registrerade modellen genom att följa anvisningarna i nästa del av den här självstudieserien: