Kurz: Vytvoření kanálu Azure Machine Learning pro klasifikaci obrázků

PLATÍ PRO:Python SDK azureml v1

Poznámka:

Kurz, který k sestavení kanálu používá sadu SDK v2, najdete v tématu Kurz: Použití kanálů ML pro produkční pracovní postupy ML se sadou Python SDK v2 v poznámkovém bloku Jupyter.

V tomto kurzu se dozvíte, jak vytvořit kanál Azure Machine Learning pro přípravu dat a trénování modelu strojového učení. Kanály strojového učení optimalizují pracovní postup rychlostí, přenositelností a opětovným použitím, abyste se mohli soustředit na strojové učení místo infrastruktury a automatizace.

Příklad trénuje malou kerasovou konvoluční neurální síť, aby klasifikovala obrázky v datové sadě Fashion MNIST .

V tomto kurzu provedete následující úlohy:

• Konfigurace pracovního prostoru
• Vytvoření experimentu pro uložení práce
• Zřízení computeTargetu pro provedení práce
• Vytvoření datové sady, do které se mají ukládat komprimovaná data
• Vytvoření kroku kanálu pro přípravu dat na trénování
• Definování prostředí runtime, ve kterém se má trénování provádět
• Vytvoření kroku kanálu pro definování neurální sítě a provedení trénování
• Vytvoření kanálu z kroků kanálu
• Spuštění kanálu v experimentu
• Projděte si výstup kroků a natrénované neurální sítě.
• Registrace modelu pro další použití

Pokud ještě nemáte předplatné Azure, vytvořte si napřed bezplatný účet. Vyzkoušejte si bezplatnou nebo placenou verzi služby Azure Machine Learning ještě dnes.

Požadavky

• Dokončete vytváření prostředků, abyste mohli začít , pokud ještě nemáte pracovní prostor Služby Azure Machine Learning.
• Prostředí Pythonu, ve kterém jste nainstalovali balíčky azureml-core i azureml-pipeline balíčky. Toto prostředí slouží k definování a řízení prostředků azure Machine Learning a je oddělené od prostředí používaného za běhu pro trénování.

Důležité

Nejnovější verze Pythonu je v současné době kompatibilní s Pythonem azureml-pipeline 3.8. Pokud máte potíže s instalací azureml-pipeline balíčku, ujistěte se, že python --version je kompatibilní verze. Pokyny najdete v dokumentaci správce virtuálního prostředí Pythonu (venvcondaatd.).

Spuštění interaktivní relace Pythonu

Tento kurz používá sadu Python SDK pro Azure Machine Learning k vytvoření a řízení kanálu Azure Machine Learning. Tento kurz předpokládá, že fragmenty kódu budete spouštět interaktivně v prostředí Python REPL nebo v poznámkovém bloku Jupyter.

• Tento kurz je založený na image-classification.ipynb poznámkovém bloku v python-sdk/tutorial/using-pipelines adresáři úložiště Azure Machine Learning Examples . Zdrojový kód pro samotný postup je v keras-mnist-fashion podadresáři.

Typy importu

Naimportujte všechny typy služby Azure Machine Learning, které budete potřebovat pro tento kurz:

import os
import azureml.core
from azureml.core import (
    Workspace,
    Experiment,
    Dataset,
    Datastore,
    ComputeTarget,
    Environment,
    ScriptRunConfig
)
from azureml.data import OutputFileDatasetConfig
from azureml.core.compute import AmlCompute
from azureml.core.compute_target import ComputeTargetException
from azureml.pipeline.steps import PythonScriptStep
from azureml.pipeline.core import Pipeline

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

Verze sady Azure Machine Learning SDK by měla být 1.37 nebo vyšší. Pokud tomu tak není, upgradujte ho pomocí pip install --upgrade azureml-corenástroje .

Konfigurace pracovního prostoru

Vytvořte objekt pracovního prostoru z existujícího pracovního prostoru Služby Azure Machine Learning.

workspace = Workspace.from_config()

Důležité

Tento fragment kódu očekává, že se konfigurace pracovního prostoru uloží do aktuálního adresáře nebo nadřazeného adresáře. Další informace o vytvoření pracovního prostoru najdete v tématu Vytvoření prostředků pracovního prostoru. Další informace o uložení konfigurace do souboru naleznete v tématu Vytvoření konfiguračního souboru pracovního prostoru.

Vytvoření infrastruktury pro váš kanál

Experiment Vytvořte objekt pro uložení výsledků spuštění kanálu:

exp = Experiment(workspace=workspace, name="keras-mnist-fashion")

Vytvořte prostředek ComputeTarget počítače, na kterém se bude kanál spouštět. Jednoduchá neurální síť použitá v tomto kurzu se trénuje během několika minut i na počítači založeném na procesoru. Pokud chcete k trénování použít GPU, nastavte use_gpu na Truehodnotu . Zřízení cílového výpočetního objektu obvykle trvá přibližně pět minut.

use_gpu = False

# choose a name for your cluster
cluster_name = "gpu-cluster" if use_gpu else "cpu-cluster"

found = False
# Check if this compute target already exists in the workspace.
cts = workspace.compute_targets
if cluster_name in cts and cts[cluster_name].type == "AmlCompute":
    found = True
    print("Found existing compute target.")
    compute_target = cts[cluster_name]
if not found:
    print("Creating a new compute target...")
    compute_config = AmlCompute.provisioning_configuration(
        vm_size= "STANDARD_NC6" if use_gpu else "STANDARD_D2_V2"
        # vm_priority = 'lowpriority', # optional
        max_nodes=4,
    )

    # Create the cluster.
    compute_target = ComputeTarget.create(workspace, cluster_name, compute_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=10
    )
# For a more detailed view of current AmlCompute status, use get_status().print(compute_target.get_status().serialize())

Poznámka:

Dostupnost GPU závisí na kvótě předplatného Azure a na kapacitě Azure. Viz Správa a navýšení kvót pro prostředky s využitím služby Azure Machine Learning.

Vytvoření datové sady pro data uložená v Azure

Fashion-MNIST je datová sada módních obrázků rozdělených do 10 tříd. Každý obrázek je 28 × 28 stupňů šedé a existuje 60 000 trénovacích a 10 000 testovacích obrázků. Jako problém klasifikace obrázků je Fashion-MNIST těžší než klasická ručně psaná databáze MNIST. Distribuuje se ve stejném komprimovaném binárním formátu jako původní ručně psaná databáze číslic .

Pokud chcete vytvořit Dataset odkaz na webová data, spusťte:

data_urls = ["https://data4mldemo6150520719.blob.core.windows.net/demo/mnist-fashion"]
fashion_ds = Dataset.File.from_files(data_urls)

# list the files referenced by fashion_ds
print(fashion_ds.to_path())

Tento kód se rychle dokončí. Podkladová data zůstanou v prostředku úložiště Azure zadaném data_urls v poli.

Vytvoření kroku kanálu přípravy dat

První krok v tomto kanálu převede komprimované datové soubory fashion_ds do datové sady ve vašem vlastním pracovním prostoru, který se skládá ze souborů CSV připravených k použití při trénování. Po registraci v pracovním prostoru můžou vaši spolupracovníci přistupovat k datům pro vlastní analýzu, trénování atd.

datastore = workspace.get_default_datastore()
prepared_fashion_ds = OutputFileDatasetConfig(
    destination=(datastore, "outputdataset/{run-id}")
).register_on_complete(name="prepared_fashion_ds")

Výše uvedený kód určuje datovou sadu založenou na výstupu kroku kanálu. Podkladové zpracované soubory se umístí do výchozího úložiště objektů blob úložiště dat pracovního prostoru v cestě zadané v destination. Datová sada se zaregistruje v pracovním prostoru s názvem prepared_fashion_ds.

Vytvoření zdroje kroku kanálu

Kód, který jste zatím provedli, má vytvořené a řízené prostředky Azure. Teď je čas napsat kód, který provede první krok v doméně.

Pokud sledujete společně s příkladem v úložišti Azure Machine Learning Examples, zdrojový soubor je již k dispozici jako keras-mnist-fashion/prepare.py.

Pokud pracujete úplně od začátku, vytvořte podadresář s názvem keras-mnist-fashion/. Vytvořte nový soubor, přidejte do něj následující kód a pojmenujte ho prepare.py.

# prepare.py
# Converts MNIST-formatted files at the passed-in input path to a passed-in output path
import os
import sys

# Conversion routine for MNIST binary format
def convert(imgf, labelf, outf, n):
    f = open(imgf, "rb")
    l = open(labelf, "rb")
    o = open(outf, "w")

    f.read(16)
    l.read(8)
    images = []

    for i in range(n):
        image = [ord(l.read(1))]
        for j in range(28 * 28):
            image.append(ord(f.read(1)))
        images.append(image)

    for image in images:
        o.write(",".join(str(pix) for pix in image) + "\n")
    f.close()
    o.close()
    l.close()

# The MNIST-formatted source
mounted_input_path = sys.argv[1]
# The output directory at which the outputs will be written
mounted_output_path = sys.argv[2]

# Create the output directory
os.makedirs(mounted_output_path, exist_ok=True)

# Convert the training data
convert(
    os.path.join(mounted_input_path, "mnist-fashion/train-images-idx3-ubyte"),
    os.path.join(mounted_input_path, "mnist-fashion/train-labels-idx1-ubyte"),
    os.path.join(mounted_output_path, "mnist_train.csv"),
    60000,
)

# Convert the test data
convert(
    os.path.join(mounted_input_path, "mnist-fashion/t10k-images-idx3-ubyte"),
    os.path.join(mounted_input_path, "mnist-fashion/t10k-labels-idx1-ubyte"),
    os.path.join(mounted_output_path, "mnist_test.csv"),
    10000,
)

Kód má prepare.py dva argumenty příkazového řádku: první je přiřazen a mounted_input_path druhý k mounted_output_path. Pokud tento podadresář neexistuje, volání, které os.makedirs ho vytvoří. Program pak převede trénovací a testovací data a výstupy čárkami oddělené soubory na mounted_output_path.

Zadání kroku kanálu

Zpátky v prostředí Pythonu, které používáte k zadání kanálu, spusťte tento kód a vytvořte pro přípravný PythonScriptStep kód:

script_folder = "./keras-mnist-fashion"

prep_step = PythonScriptStep(
    name="prepare step",
    script_name="prepare.py",
    # On the compute target, mount fashion_ds dataset as input, prepared_fashion_ds as output
    arguments=[fashion_ds.as_named_input("fashion_ds").as_mount(), prepared_fashion_ds],
    source_directory=script_folder,
    compute_target=compute_target,
    allow_reuse=True,
)

PythonScriptStep Volání, které určuje, že při spuštění kroku kanálu:

• Všechny soubory v script_folder adresáři se nahrají do složky compute_target
• Mezi nahranými zdrojovými soubory se soubor prepare.py spustí.
• prepared_fashion_ds Datové fashion_ds sady a datové sady se připojí k compute_target adresářům a zobrazí se jako adresáře.
• Cesta k fashion_ds souborům bude prvním argumentem prepare.py. V prepare.pytomto argumentu je přiřazen mounted_input_path
• Cesta k sadě bude druhým argumentem prepared_fashion_dsprepare.py. V prepare.pytomto argumentu je přiřazen mounted_output_path
• Vzhledem k tomu allow_reuse , že se Truesoubor znovu nespustí, dokud se nezmění jeho zdrojové soubory nebo vstupy.
• Tento PythonScriptStep název bude pojmenován. prepare step

Modularita a opětovné použití jsou klíčovými výhodami kanálů. Azure Machine Learning dokáže automaticky určit zdrojový kód nebo změny datové sady. Výstup kroku, který není ovlivněn, se znovu použije bez opětovného opakování kroků, pokud allow_reuse je True. Pokud krok spoléhá na zdroj dat externí pro Azure Machine Learning, který se může změnit (například adresa URL obsahující prodejní data), nastaví allow_reuse se False a krok kanálu se spustí při každém spuštění kanálu.

Vytvoření kroku trénování

Po převodu dat z komprimovaného formátu na soubory CSV je možné je použít k trénování konvoluční neurální sítě.

Vytvoření zdroje kroku trénování

U větších kanálů je vhodné vložit zdrojový kód každého kroku do samostatného adresáře (src/prepare/src/train/atd.), ale v tomto kurzu stačí použít nebo vytvořit soubor train.py ve stejném keras-mnist-fashion/ zdrojovém adresáři.

import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.layers.normalization import BatchNormalization
from keras.utils import to_categorical
from keras.callbacks import Callback

import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from azureml.core import Run

# dataset object from the run
run = Run.get_context()
dataset = run.input_datasets["prepared_fashion_ds"]

# split dataset into train and test set
(train_dataset, test_dataset) = dataset.random_split(percentage=0.8, seed=111)

# load dataset into pandas dataframe
data_train = train_dataset.to_pandas_dataframe()
data_test = test_dataset.to_pandas_dataframe()

img_rows, img_cols = 28, 28
input_shape = (img_rows, img_cols, 1)

X = np.array(data_train.iloc[:, 1:])
y = to_categorical(np.array(data_train.iloc[:, 0]))

# here we split validation data to optimiza classifier during training
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=13)

# test data
X_test = np.array(data_test.iloc[:, 1:])
y_test = to_categorical(np.array(data_test.iloc[:, 0]))


X_train = (
    X_train.reshape(X_train.shape[0], img_rows, img_cols, 1).astype("float32") / 255
)
X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1).astype("float32") / 255
X_val = X_val.reshape(X_val.shape[0], img_rows, img_cols, 1).astype("float32") / 255

batch_size = 256
num_classes = 10
epochs = 10

# construct neuron network
model = Sequential()
model.add(
    Conv2D(
        32,
        kernel_size=(3, 3),
        activation="relu",
        kernel_initializer="he_normal",
        input_shape=input_shape,
    )
)
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(128, (3, 3), activation="relu"))
model.add(Dropout(0.4))
model.add(Flatten())
model.add(Dense(128, activation="relu"))
model.add(Dropout(0.3))
model.add(Dense(num_classes, activation="softmax"))

model.compile(
    loss=keras.losses.categorical_crossentropy,
    optimizer=keras.optimizers.Adam(),
    metrics=["accuracy"],
)

# start an Azure ML run
run = Run.get_context()


class LogRunMetrics(Callback):
    # callback at the end of every epoch
    def on_epoch_end(self, epoch, log):
        # log a value repeated which creates a list
        run.log("Loss", log["loss"])
        run.log("Accuracy", log["accuracy"])


history = model.fit(
    X_train,
    y_train,
    batch_size=batch_size,
    epochs=epochs,
    verbose=1,
    validation_data=(X_val, y_val),
    callbacks=[LogRunMetrics()],
)

score = model.evaluate(X_test, y_test, verbose=0)

# log a single value
run.log("Final test loss", score[0])
print("Test loss:", score[0])

run.log("Final test accuracy", score[1])
print("Test accuracy:", score[1])

plt.figure(figsize=(6, 3))
plt.title("Fashion MNIST with Keras ({} epochs)".format(epochs), fontsize=14)
plt.plot(history.history["accuracy"], "b-", label="Accuracy", lw=4, alpha=0.5)
plt.plot(history.history["loss"], "r--", label="Loss", lw=4, alpha=0.5)
plt.legend(fontsize=12)
plt.grid(True)

# log an image
run.log_image("Loss v.s. Accuracy", plot=plt)

# create a ./outputs/model folder in the compute target
# files saved in the "./outputs" folder are automatically uploaded into run history
os.makedirs("./outputs/model", exist_ok=True)

# serialize NN architecture to JSON
model_json = model.to_json()
# save model JSON
with open("./outputs/model/model.json", "w") as f:
    f.write(model_json)
# save model weights
model.save_weights("./outputs/model/model.h5")
print("model saved in ./outputs/model folder")

Většina tohoto kódu by měla být pro vývojáře STROJOVÉho učení známá:

• Data jsou rozdělena do trénovacích a ověřovacích sad pro trénování a samostatnou testovací podmnožinu pro konečné bodování.
• Vstupní obrazec je 28x28x1 (pouze 1, protože vstup je stupně šedé), v dávce bude 256 vstupů a existuje 10 tříd.
• Počet epoch trénování bude 10.
• Model má tři konvoluční vrstvy, s maximálním sdružováním a výpadkem, následovanými hustou vrstvou a softmax hlavou.
• Model je fitován pro 10 epoch a následně vyhodnocen
• Architektura modelu se zapisuje do outputs/model/model.json a závaží pro outputs/model/model.h5

Část kódu je ale specifická pro Azure Machine Learning. run = Run.get_context()Run načte objekt, který obsahuje aktuální kontext služby. Zdroj train.py pomocí tohoto run objektu načte vstupní datovou sadu prostřednictvím jejího názvu (alternativu ke kódu, který prepare.py datovou sadu načetl prostřednictvím argv pole argumentů skriptu).

Objekt run se také používá k protokolování průběhu trénování na konci každé epochy a na konci trénování k protokolování grafu ztráty a přesnosti v průběhu času.

Vytvoření kroku trénovacího kanálu

Krok trénování má o něco složitější konfiguraci než přípravný krok. Přípravný krok používal pouze standardní knihovny Pythonu. Častěji budete muset upravit běhové prostředí, ve kterém se spouští váš zdrojový kód.

Vytvořte soubor conda_dependencies.yml s následujícím obsahem:

dependencies:
- python=3.7
- pip:
  - azureml-core
  - azureml-dataset-runtime
  - keras==2.4.3
  - tensorflow==2.4.3
  - numpy
  - scikit-learn
  - pandas
  - matplotlib

Třída Environment představuje běhové prostředí, ve kterém běží úloha strojového učení. Přidružte výše uvedenou specifikaci k trénovacímu kódu:

keras_env = Environment.from_conda_specification(
    name="keras-env", file_path="./conda_dependencies.yml"
)

train_cfg = ScriptRunConfig(
    source_directory=script_folder,
    script="train.py",
    compute_target=compute_target,
    environment=keras_env,
)

Vytvoření samotného trénovacího kroku používá kód podobný kódu použitému k vytvoření přípravného kroku:

train_step = PythonScriptStep(
    name="train step",
    arguments=[
        prepared_fashion_ds.read_delimited_files().as_input(name="prepared_fashion_ds")
    ],
    source_directory=train_cfg.source_directory,
    script_name=train_cfg.script,
    runconfig=train_cfg.run_config,
)

Vytvoření a spuštění kanálu

Teď, když jste zadali vstupy a výstupy dat a vytvořili kroky kanálu, můžete je vytvořit do kanálu a spustit ho:

pipeline = Pipeline(workspace, steps=[prep_step, train_step])
run = exp.submit(pipeline)

Objekt Pipeline , který vytvoříte, workspace se bude skládat z vámi zadaných kroků přípravy a trénování.

Poznámka:

Tento kanál obsahuje jednoduchý graf závislostí: krok trénování spoléhá na přípravný krok a přípravný krok závisí na fashion_ds datové sadě. Produkční kanály mají často mnohem složitější závislosti. Kroky můžou záviset na několika upstreamových krocích, změna zdrojového kódu v raném kroku může mít dalekosáhlé důsledky atd. Azure Machine Learning sleduje tyto obavy za vás. Potřebujete předat pouze pole steps a Azure Machine Learning se postará o výpočet grafu provádění.

Volání dokončení submitExperiment se rychle dokončí a vytvoří výstup podobný následujícímu:

Submitted PipelineRun 5968530a-abcd-1234-9cc1-46168951b5eb
Link to Azure Machine Learning Portal: https://ml.azure.com/runs/abc-xyz...

Spuštění kanálu můžete monitorovat tak, že odkaz otevřete nebo ho můžete zablokovat, dokud se nespustí spuštěním příkazu:

run.wait_for_completion(show_output=True)

Důležité

První spuštění kanálu trvá přibližně 15 minut. Všechny závislosti se musí stáhnout, vytvoří se image Dockeru a prostředí Pythonu se zřídí a vytvoří. Opětovné spuštění kanálu trvá výrazně méně času, protože se tyto prostředky znovu používají místo vytvoření. Celková doba běhu kanálu ale závisí na úloze vašich skriptů a procesech spuštěných v jednotlivých krocích kanálu.

Po dokončení kanálu můžete načíst metriky, které jste protokolovali v kroku trénování:

run.find_step_run("train step")[0].get_metrics()

Pokud jste s metrikami spokojení, můžete model zaregistrovat ve svém pracovním prostoru:

run.find_step_run("train step")[0].register_model(
    model_name="keras-model",
    model_path="outputs/model/",
    datasets=[("train test data", fashion_ds)],
)

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

Pokud plánujete spouštět další kurzy služby Azure Machine Learning, nedokončíte tuto část.

Zastavení výpočetní instance

Pokud jste použili výpočetní instanci, zastavte virtuální počítač, když ho nepoužíváte, aby se snížily náklady.

1. V pracovním prostoru vyberte Compute.

2. V seznamu vyberte název výpočetní instance.

3. Vyberte Zastavit.

4. Až budete chtít server znovu použít, vyberte Spustit.

Odstranit vše

Pokud nemáte v úmyslu používat vytvořené prostředky, odstraňte je, takže se vám nebudou účtovat žádné poplatky:

1. Na webu Azure Portal v nabídce vlevo vyberte skupiny prostředků.
2. V seznamu skupin prostředků vyberte skupinu prostředků, kterou jste vytvořili.
3. Vyberte Odstranit skupinu prostředků.
4. Zadejte název skupiny prostředků. Pak vyberte Odstranit.

Můžete také zachovat skupinu prostředků, ale odstranit jeden pracovní prostor. Zobrazte vlastnosti pracovního prostoru a pak vyberte Odstranit.

Další kroky

V tomto kurzu jste použili následující typy:

• Představuje Workspace váš pracovní prostor Azure Machine Learning. Obsahuje:
  • Obsahuje Experiment výsledky trénovacích spuštění kanálu.
  • Ta Dataset , která líně načetla data uložená v úložišti dat Fashion-MNIST
  • Jedná se ComputeTarget o počítače, na kterých se spouští kroky kanálu.
  • Jedná Environment se o běhové prostředí, ve kterém se spouští kroky kanálu.
  • Tento Pipeline postup se skládá PythonScriptStep do celku.
  • Registrace Model , kterou jste zaregistrovali po splnění procesu trénování

Objekt Workspace obsahuje odkazy na jiné prostředky (poznámkové bloky, koncové body atd.), které se v tomto kurzu nepoužívaly. Další informace najdete v tématu Co je pracovní prostor Služby Azure Machine Learning?

Propaguje OutputFileDatasetConfig výstup spuštění na souborovou datovou sadu. Další informace o datovýchsadch

Další informace o cílových výpočetních prostředcích a prostředích najdete v tématu Co jsou cílové výpočetní objekty ve službě Azure Machine Learning? a co jsou prostředí Azure Machine Learning?

Přidruží ScriptRunConfig zdrojové soubory Pythonu ComputeTarget a Environment k němu. Vezme PythonScriptStep to ScriptRunConfig a definuje jeho vstupy a výstupy, které v tomto kanálu byly souborovou datovou sadou sestavenou OutputFileDatasetConfig.

Další příklady sestavení kanálů pomocí sady SDK strojového učení najdete v ukázkovém úložišti.