Kurz: výukový model klasifikace obrázků s příkladem Jupyter Notebook

V tomto kurzu se naučíte model strojového učení ve vzdálených výpočetních prostředcích. pracovní postup školení a nasazení budete používat pro Azure Machine Learning v Jupyter Notebook pythonu. 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. Tento kurz je první částí z dvoudílné série kurzů.

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. MNIST je oblíbená datová sada obsahující 70 000 obrázků ve stupních šedi. Každý obrázek je ručně psaná číslice o 28 × 28 pixelech, která představuje číslo od 0 do 9. Cílem je vytvoření klasifikátoru s více třídami pro identifikaci číslice, kterou představuje daný obrázek.

Přečtěte si, jak provést následující akce:

Naučíte se, jak vybrat model a nasadit ho v části 2 tohoto kurzu.

Pokud ještě nemáte předplatné Azure, vytvořte si napřed bezplatný účet. vyzkoušení bezplatné nebo placené verze Azure Machine Learning dnes

Požadavky

• dokončete rychlý start: začínáme s Azure Machine Learning :
  • Vytvoření pracovního prostoru.
  • Vytvořte cloudovou instanci COMPUTE pro použití ve vývojovém prostředí.
  • Vytvořte cloudový výpočetní cluster, který se použije pro školení modelu.

Spuštění poznámkového bloku z pracovního prostoru

Azure Machine Learning v pracovním prostoru obsahuje cloudový notebook pro instalaci bez předkonfigurovaného a předem nakonfigurovaného prostředí. Použijte vlastní prostředí , pokud dáváte přednost kontrole prostředí, balíčků a závislostí.

Sledujte spolu s tímto videem nebo použijte podrobný postup k klonování a spuštění poznámkového bloku kurzu z pracovního prostoru.

Naklonování složky poznámkového bloku

dokončili jste následující postup nastavení experimentu a spustíte kroky v Azure Machine Learning studiu. Toto konsolidované rozhraní zahrnuje nástroje strojového učení, které slouží k provádění scénářů pro datové vědy u všech úrovní dovedností.

1. přihlaste se k Azure Machine Learning studiu.

2. Vyberte své předplatné a pracovní prostor, který jste vytvořili.

3. Na levé straně vyberte poznámkové bloky.

4. V horní části vyberte kartu ukázky .

5. Otevřete složku Python .

6. Otevřete složku s číslem verze. Toto číslo představuje aktuální vydání sady Python SDK.

7. Klikněte na tlačítko ... napravo od složky kurzy a pak vyberte klonovat.

   

8. Seznam složek zobrazuje každého uživatele, který přistupuje k pracovnímu prostoru. Vyberte složku, do které se má naklonovat složka s kurzy .

Otevřít Klonovaný Poznámkový blok

1. Otevřete složku kurzy , která byla naklonována do části uživatelské soubory .

   Důležité

   Poznámkové bloky můžete zobrazit ve složce Samples , ale nemůžete z nich spustit Poznámkový blok. Pokud chcete spustit Poznámkový blok, ujistěte se, že jste v části soubory uživatelů otevřeli naklonované verze poznámkového bloku.

2. Vyberte soubor img-Classification-part1-Training. ipynb ve složce kurzy/image-klasifikace-mnist ručně zapsaných-data .

   

3. Na horním panelu vyberte svou výpočetní instanci, kterou chcete použít ke spuštění poznámkového bloku.

kurz a doprovodný soubor utils.py je také k dispozici na GitHub , pokud ho chcete použít ve svém vlastním místním prostředí. Pokud nepoužíváte výpočetní instanci, spusťte příkaz pip install azureml-sdk[notebooks] azureml-opendatasets matplotlib k instalaci závislostí pro tento kurz.

Nastavíte vývojové prostředí

Veškeré nastavení pro vaši vývojovou práci se dá provést v poznámkovém bloku Pythonu. Instalační program zahrnuje následující akce:

• Importujte balíčky Pythonu.
• Připojení k pracovnímu prostoru, aby váš místní počítač mohl komunikovat se vzdálenými prostředky.
• Vytvořte experiment pro sledování všech vašich spuštění.
• Vytvořte vzdálený výpočetní cíl, který se bude používat pro školení.

Import balíčků

Naimportujte balíčky Pythonu, které potřebujete v této relaci. zobrazit také Azure Machine Learning verzi sady SDK:

%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 prostoru

Vytvořte objekt pracovního prostoru z existujícího pracovního prostoru. Workspace.from_config() přečte soubor config.json a načte podrobnosti do objektu s názvem ws. Instance COMPUTE obsahuje kopii tohoto souboru uloženou v kořenovém adresáři. Pokud kód spustíte jinde, budete ho muset vytvořit.

# 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í experimentu

Vytvořte experiment pro sledování spuštění ve vašem pracovním prostoru. Pracovní prostor může mít více experimentů:

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

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

Vytvořit nebo připojit existující cíl služby COMPUTE

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. Mezi příklady patří virtuální počítače s podporou GPU. v tomto kurzu vytvoříte Azure Machine Learning compute jako školicí prostředí. Později v tomto kurzu odešlete kód Pythonu, který se bude spouštět na tomto virtuálním počítači.

Následující kód vytvoří výpočetní clustery za vás, pokud už ve vašem pracovním prostoru neexistují. Nastaví cluster, který se bude škálovat dolů na 0, pokud se nepoužívá, a může škálovat až na 4 uzly.

Vytvoření cíle výpočtů trvá asi pět minut. Pokud je výpočetní prostředek již v pracovním prostoru, kód ho použije a přeskočí proces vytváření.

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

Nyní máte k dispozici potřebné balíčky a výpočetní prostředky pro trénink modelu v cloudu.

Zkoumání dat

Než začnete pracovat s modelem, potřebujete pochopit data, která používáte k jeho učení. V této části získáte informace o následujících postupech:

• Stáhněte si datovou sadu MNIST ručně zapsaných.
• Zobrazí některé ukázkové obrázky.

Stáhnutí datové sady MNIST

K získání nezpracovaných datových souborů MNIST ručně zapsaných použijte Azure Open DataSets. 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. Každá datová sada má odpovídající třídu, MNIST v tomto případě pro načtení dat různými způsoby.

Tento kód načte data jako FileDataset objekt, který je podtřídou třídy Dataset . Odkazuje na jeden nebo více souborů libovolného formátu v FileDataset datových obchodech nebo veřejných adresách URL. Třída poskytuje možnost stáhnout nebo připojit soubory k výpočetním prostředkům vytvořením odkazu na umístění zdroje dat. Datovou sadu navíc zaregistrujete do svého pracovního prostoru, abyste ji během trénování snadno načítala.

Další informace o datových sadách a jejich použití v sadě SDK najdete v tomto návodu.

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ů

Načtěte komprimované soubory do pole numpy. Pak pomocí matplotlib vykreslete 30 náhodných obrázků z datové sady s jejich popisky nad nimi. Tento krok vyžaduje load_data funkci, která je součástí utils.py souboru . Tento soubor je umístěný ve složce s ukázkou. Ujistěte se, že je umístěný ve stejné složce jako tento poznámkový blok. Funkce load_data jednoduše parsuje komprimované soubory do polí numpy.

# 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ů:

Nyní máte představu o tom, jak tyto obrázky vypadají, a o očekávaném výstupu predikce.

Trénování na vzdáleném clusteru

Pro tento úkol odešlete úlohu ke spuštění na clusteru vzdáleného trénování, který jste nastavili dříve. K odeslání úlohy je potřeba provést:

• Vytvoření adresáře
• Vytvoření trénovacího skriptu
• Vytvoření konfigurace spuštění skriptu
• Odeslání úlohy

Vytvoření adresáře

Vytvořte adresář, ze kterého bude dodán potřebný kód z počítače do vzdáleného prostředku.

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

Vytvoření trénovacího skriptu

Pokud chcete odeslat úlohu do clusteru, vytvořte nejprve trénovací skript. 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.

%%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:

• Trénovací skript přečte argument pro vyhledání adresáře, který obsahuje 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')

• Trénovací skript uloží model do adresáře s názvem outputs. Vše, co je v tomto adresáři zapsáno, se automaticky nahraje do vašeho pracovního prostoru. K modelu se z tohoto adresáře přistupte později v tomto kurzu. joblib.dump(value=clf, filename='outputs/sklearn_mnist_model.pkl')

• Trénovací skript vyžaduje, aby utils.py soubor správně načítá datovou sadu. Následující kód se zkopíruje do souboru , aby byl k souboru přístupný spolu s trénovacím utils.py script_folder skriptem ve vzdáleném prostředku.

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

Konfigurace trénovací úlohy

Vytvořte objekt ScriptRunConfig, který určí podrobnosti konfigurace trénovací úlohy, včetně trénovacího skriptu, prostředí, které se má použít, a cílového výpočetního objektu, ve které se má spustit. Nakonfigurujte ScriptRunConfig zadáním:

• Adresář, který obsahuje vaše skripty. Všechny soubory v tomto adresáři se nahrají do uzlů clusteru ke spuštění.
• Cílové výpočetní prostředí. V tomto případě používáte cluster pro výpočty služby Azure Machine Learning, který jste vytvořili.
• Název trénovacího skriptu train.py.
• Prostředí obsahující knihovny potřebné ke spuštění skriptu.
• Argumenty vyžadované z trénovacího skriptu.

V tomto kurzu je cílem AmlCompute. Všechny soubory ve složce script se nahrají do uzlů clusteru ke spuštění. Vlastnost --data_folder je nastavená na použití datové sady.

Nejprve vytvořte prostředí, které obsahuje: knihovnu scikit-learn, azureml-dataset-runtime vyžadované pro přístup k datové sadě a azureml-defaults, která obsahuje závislosti pro metriky protokolování. Nastavení azureml-defaults obsahuje také závislosti vyžadované pro nasazení modelu jako webové služby dále ve 2. části kurzu.

Jakmile je prostředí definované, zaregistrujte ho v pracovním prostoru a znovu ho použijte ve 2. části kurzu.

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)

Pak vytvořte ScriptRunConfig zadáním trénovacího skriptu, cílového výpočetního prostředí a prostředí.

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)

Odeslání úlohy do clusteru

Spusťte experiment odesláním objektu ScriptRunConfig:

run = exp.submit(config=src)
run

Vzhledem k tomu, že volání je asynchronní, vrátí stav Příprava nebo Spuštěno ihned po spuštění úlohy.

Monitorování vzdáleného spuštění

První spuštění trvá celkem přibližně 10 minut. Pokud se ale u následných spuštění nezmění závislosti skriptů, znovu se použije stejná image. Proto je čas spuštění kontejneru mnohem rychlejší.

Co se stane, když čekáte:

• Vytvoření image: Vytvoří se image Dockeru, která odpovídá prostředí Pythonu určenému prostředím Azure ML. Image se nahraje do pracovního prostoru. Vytvoření a nahrání image trvá přibližně pět minut.

  Tato fáze se pro každé prostředí Pythonu stane jednou, protože kontejner se ukládá do mezipaměti pro následná spuštění. Při vytváření image se streamují protokoly do historie spuštění. Průběh vytváření image můžete monitorovat pomocí těchto protokolů.

• Škálování: Pokud vzdálený cluster vyžaduje ke spuštění více uzlů, než je aktuálně k dispozici, přidávají se další uzly automaticky. Škálování obvykle trvá přibližně pět minut.

• Spuštění: V této fázi se nezbytné skripty a soubory odesílaly do cílového výpočetního prostředí. Pak se úložiště dat připojí nebo zkopírují. Pak se entry_script spuštění. Když je úloha spuštěná, streamuje se stdout a adresář ./logs do historie spuštění. Průběh spuštění můžete monitorovat pomocí těchto protokolů.

• Po zpracování: Adresář ./outputs spuštění se zkopíruje do historie spuštění ve vašem pracovním prostoru, abyste k těmto výsledkům měli přístup.

Průběh spuštěné úlohy můžete zkontrolovat několika způsoby. V tomto kurzu se používá widget Jupyter a wait_for_completion metoda.

Widget Jupyter

Sledujte průběh spuštění pomocí widgetu Jupyter. Podobně jako odeslání spuštění je widget asynchronní a poskytuje živé aktualizace každých 10 až 15 sekund, dokud se úloha nedokončí:

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

Widget bude na konci trénování vypadat takto:

Pokud potřebujete zrušit spuštění, můžete postupovat podle těchto pokynů.

Získání protokolu výsledků při dokončení

Trénování modelu a monitorování probíhají na pozadí. Než spustíte další kód, počkejte na dokončení trénování modelu. Pomocí wait_for_completion zobrazíte, kdy se trénování modelu dokončí:

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

Zobrazení výsledků spuštění

Teď je model vytrénovaný na vzdáleném clusteru. Načtěte přesnost modelu:

print(run.get_metrics())

Výstup ukazuje, že vzdálený model má přesnost 0,9204:

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

V dalším kurzu prozkoumáte tento model podrobněji.

Registrace modelu

Poslední krok trénovacího skriptu zapsal soubor do adresáře s názvem ve virtuálním počítače clusteru, ve kterém outputs/sklearn_mnist_model.pkl outputs se úloha spouštěla. outputs je speciální adresář v tom, že se veškerý obsah v tomto adresáři automaticky nahraje do vašeho pracovního prostoru. Tento obsah se objeví v záznamu spuštění v experimentu pod vaším pracovním prostorem. Soubor modelu je teď k dispozici také ve vašem pracovním prostoru.

Zobrazí se soubory přidružené k tomuto spuštění:

print(run.get_file_names())

Zaregistrujte model v pracovním prostoru, abyste vy nebo jiní spolupracovníci mohli později dotazovat, zkoumat a nasazovat tento 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ů

Pokud neplánujete použít žádné prostředky, které jste vytvořili, odstraňte je, takže se vám neúčtují žádné poplatky:

1. Úplně nalevo na webu Azure Portal vyberte Skupiny prostředků.

2. V seznamu vyberte skupinu prostředků, kterou jste vytvořili.

3. Vyberte Odstranit skupinu prostředků.

   

4. Zadejte název skupiny prostředků. Vyberte Odstranit.

Můžete také odstranit pouze cluster Azure Machine Learning Compute. Automatické škálování je ale zapnuté a minimum clusteru je nulové. Za tento konkrétní prostředek se tedy nebudou v případě, že se tento prostředek nebude používat, účtovány další poplatky za výpočetní prostředky:

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

Další kroky

V tomto Azure Machine Learning kurzu jste použili Python pro následující úlohy:

Jste připraveni nasadit tento zaregistrovaný model podle pokynů v další části této série kurzů: