Tutorial: Erstellen einer Azure Machine Learning-Pipeline für die Bildklassifizierung

GILT FÜR: Python SDK azureml v1

In diesem Tutorial erfahren Sie, wie Sie eine Azure Machine Learning-Pipeline erstellen, um Daten vorzubereiten und ein Machine Learning-Modell zu trainieren. Machine Learning-Pipelines optimieren Ihren Workflow durch eine Verbesserung in den Bereichen Geschwindigkeit, Portabilität und Wiederverwendung, sodass Sie sich auf Machine Learning konzentrieren können, anstatt sich um Infrastruktur und Automatisierung kümmern zu müssen.

Im Beispiel wird ein kleines Convolutional Neural Network von Keras trainiert, um Bilder im Fashion MNIST-Dataset zu klassifizieren.

In diesem Tutorial führen Sie die folgenden Aufgaben durch:

Wenn Sie nicht über ein Azure-Abonnement verfügen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen. Probieren Sie die kostenlose oder kostenpflichtige Version von Azure Machine Learning noch heute aus.

Voraussetzungen

• Schließen Sie Ressourcen erstellen, um zu beginnen ab, wenn Sie noch keinen Azure Machine Learning-Arbeitsbereich besitzen.
• Eine Python-Umgebung, in der Sie sowohl das azureml-core- als auch das azureml-pipeline-Paket installiert haben. Diese Umgebung dient zum Definieren und Steuern Ihrer Azure Machine Learning-Ressourcen und sie ist von der Umgebung getrennt, die zur Laufzeit für das Training verwendet wird.

Starten einer interaktiven Python-Sitzung

In diesem Tutorial wird das Python SDK für Azure Machine Learning zum Erstellen und Steuern einer Azure Machine Learning-Pipeline verwendet. In diesem Tutorial wird davon ausgegangen, dass Sie die Codeausschnitte interaktiv in einer Python-REPL-Umgebung oder in einem Jupyter Notebook ausführen.

• Dieses Tutorial basiert auf dem image-classification.ipynb-Notebook, das sich im python-sdk/tutorial/using-pipelines-Verzeichnis des Repositorys mit Azure Machine Learning-Beispielen befindet. Der Quellcode für die Schritte selbst befindet sich im Unterverzeichnis keras-mnist-fashion.

Importtypen

Importieren Sie alle Azure Machine Learning-Typen, die Sie für dieses Tutorial benötigen:

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)

Die Azure Machine Learning SDK-Version sollte 1.37 oder höher sein. Ist dies nicht der Fall, führen Sie ein Upgrade mit pip install --upgrade azureml-core durch.

Konfigurieren des Arbeitsbereichs

Erstellen Sie ein Arbeitsbereichsobjekt auf der Grundlage des vorhandenen Azure Machine Learning-Arbeitsbereichs.

workspace = Workspace.from_config()

Erstellen der Infrastruktur für Ihre Pipeline

Erstellen Sie ein Experiment-Objekt, das die Ergebnisse Ihrer Pipelineausführungen aufnimmt:

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

Erstellen Sie ein ComputeTarget, das die Computerressource darstellt, auf der Ihre Pipeline ausgeführt wird. Das in diesem Tutorial verwendete einfache neuronale Netz lässt sich selbst auf einem CPU-basierten Computer in wenigen Minuten trainieren. Wenn Sie eine GPU für das Training verwenden möchten, legen Sie use_gpu auf True fest. Die Bereitstellung eines Computeziels dauert in der Regel etwa fünf Minuten.

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

Erstellen eines Datasets für die in Azure gespeicherten Daten

Fashion-MNIST ist ein Dataset mit Modebildern, das in 10 Klassen unterteilt ist. Jedes Bild ist ein Graustufenbild im Format 28 x 28 und es gibt 60.000 Trainings- und 10.000 Testbilder. Als Bildklassifizierungsproblem ist Fashion-MNIST schwieriger als die klassische MNIST-Datenbank für handschriftliche Ziffern. Sie wird in der gleichen komprimierten binären Form wie die ursprüngliche Datenbank für handschriftliche Ziffern verteilt.

Führen Sie zum Erstellen einer Dataset-Instanz, die auf die webbasierten Daten verweist, Folgendes aus:

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

Dieser Code lässt sich schnell vervollständigen. Die zugrunde liegenden Daten verbleiben in der im data_urls-Array angegebenen Azure-Speicherressource.

Erstellen des Pipelineschritts zur Datenaufbereitung

Der erste Schritt in dieser Pipeline konvertiert die komprimierten Datendateien von fashion_ds in ein Dataset in Ihrem eigenen Arbeitsbereich, das aus CSV-Dateien besteht, die für das Training bereit sind. Nach der Registrierung beim Arbeitsbereich können Ihre Projektmitarbeiter für ihre eigenen Analysen, Trainings usw. auf diese Daten zugreifen.

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

Der obige Code gibt ein Dataset an, das auf der Ausgabe eines Pipelineschritts basiert. Die zugrunde liegenden verarbeiteten Dateien werden im Blobspeicher des Standarddatenspeichers des Arbeitsbereichs unter dem in destination angegebenen Pfad gespeichert. Das Dataset wird im Arbeitsbereich mit dem Namen prepared_fashion_ds registriert.

Erstellen der Quelle des Pipelineschritts

Der Code, den Sie bisher ausgeführt haben, hat Azure-Ressourcen erstellt und gesteuert. Jetzt ist es an der Zeit, einen Code zu schreiben, der den ersten Schritt in der Domäne ausführt.

Wenn Sie das Tutorial anhand des Beispiels im Repository mit Azure Machine Learning-Beispielen durcharbeiten, ist die Quelldatei bereits als keras-mnist-fashion/prepare.py verfügbar.

Wenn Sie das Beispiel von Grund auf neu erstellen, erstellen Sie ein Unterverzeichnis namens keras-mnist-fashion/. Erstellen Sie eine neue Datei, fügen Sie den folgenden Code hinzu, und weisen Sie der Datei den Namen prepare.py zu.

# 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,
)

Der Code in prepare.py verwendet zwei Befehlszeilenargumente: das erste wird mounted_input_path zugewiesen und das zweite mounted_output_path. Wenn dieses Unterverzeichnis nicht vorhanden ist, wird es durch den Aufruf von os.makedirs erstellt. Anschließend konvertiert das Programm die Trainings- und Testdaten und gibt die durch Komma getrennten Dateien im mounted_output_path aus.

Angeben des Pipelineschritts

Führen Sie in der Python-Umgebung, die Sie zum Angeben der Pipeline verwenden, den folgenden Code aus, um einen PythonScriptStep für Ihren Vorbereitungscode zu erstellen:

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

Der Aufruf von PythonScriptStep gibt Folgendes an, wenn der Pipelineschritt ausgeführt wird:

• Alle Dateien im Verzeichnis script_folder werden auf das compute_target hochgeladen.
• Unter diesen hochgeladenen Quelldateien wird die Datei prepare.py ausgeführt.
• Die Datasets fashion_ds und prepared_fashion_ds werden auf dem compute_target eingebunden und als Verzeichnisse angezeigt.
• Der Pfad zu den fashion_ds-Dateien ist das erste Argument für prepare.py. In prepare.py wird dieses Argument zu mounted_input_path zugewiesen.
• Der Pfad zu prepared_fashion_ds das zweite Argument für prepare.py. In prepare.py wird dieses Argument zu mounted_output_path zugewiesen.
• Da allow_reuse entsprechend True ist, wird es erst erneut ausgeführt, wenn sich die Quelldateien oder Eingaben ändern.
• Dieser PythonScriptStep wird der Name prepare step zugewiesen.

Modularität und Wiederverwendung sind wichtige Vorteile von Pipelines. Azure Machine Learning kann Änderungen am Quellcode oder Dataset automatisch ermitteln. Die Ausgabe eines Schritts, der nicht betroffen ist, wird wiederverwendet, ohne dass die Schritte erneut ausgeführt werden müssen, wenn allow_reuse entsprechend True ist. Wenn sich ein Schritt auf eine Datenquelle außerhalb von Azure Machine Learning stützt, die sich ändern kann (z. B. eine URL, die Umsatzdaten enthält), legen Sie allow_reuse auf False fest, und der Pipelineschritt wird jedes Mal ausgeführt, wenn die Pipeline ausgeführt wird.

Erstellen des Trainingsschritts

Sobald die Daten aus dem komprimierten Format in CSV-Dateien umgewandelt wurden, können sie für das Training eines Convolutional Neural Network verwendet werden.

Erstellen der Quelle des Trainingsschritts

Bei größeren Pipelines empfiehlt es sich, den Quellcode jedes Schritts in einem separaten Verzeichnis abzulegen (src/prepare/, src/train/ usw.), aber für dieses Tutorial verwenden oder erstellen Sie die Datei train.py einfach im selben keras-mnist-fashion/-Quellverzeichnis.

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

Der größte Teil dieses Codes sollte ML-Entwicklern vertraut sein:

• Die Daten werden für das Training in Trainings- und Validierungssätze sowie für die abschließende Bewertung in eine separate Testteilmenge unterteilt.
• Die Eingabeform ist 28 x 28 x 1 (nur 1, da die Eingabe in Graustufen erfolgt), es gibt 256 Eingaben in einem Batch und es gibt 10 Klassen.
• Die Anzahl der Trainingsepochen beträgt 10.
• Das Modell besteht aus drei Konvolutionsschichten mit maximalem Pooling und Dropout, gefolgt von einer dichten Schicht und einem Softmax-Kopf.
• Das Modell wird für 10 Epochen angepasst und dann ausgewertet.
• Die Modellarchitektur wird in outputs/model/model.json und die Gewichtungen in outputs/model/model.h5 geschrieben.

Ein Teil des Codes ist jedoch spezifisch für Azure Machine Learning. run = Run.get_context() ruft ein Run-Objekt ab, das den aktuellen Dienstkontext enthält. Die train.py-Quelle verwendet dieses run-Objekt, um das Eingabedataset über seinen Namen abzurufen (eine Alternative zum Code in prepare.py, der das Dataset über das argv-Array von Skriptargumenten abgerufen hat).

Das run-Objekt wird auch verwendet, um den Trainingsfortschritt am Ende jeder Epoche zu protokollieren und am Ende des Trainings den Graphen für Verlust und Genauigkeit im Laufe der Zeit zu protokollieren.

Erstellen des Trainingspipelineschritts

Der Trainingsschritt verfügt über eine etwas komplexere Konfiguration als der Vorbereitungsschritt. Im Vorbereitungsschritt wurden nur Python-Standardbibliotheken verwendet. In der Regel müssen Sie die Laufzeitumgebung ändern, in der Ihr Quellcode ausgeführt wird.

Erstellen Sie die Datei conda_dependencies.yml mit folgendem Inhalt:

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

Die Environment-Klasse stellt die Laufzeitumgebung dar, in der eine Machine Learning-Aufgabe ausgeführt wird. Ordnen Sie die obige Spezifikation dem Trainingscode zu:

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

Beim Erstellen des Trainingsschritts selbst wird Code verwendet, der dem Code ähnelt, der zum Erstellen des Vorbereitungsschritts verwendet wurde:

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

Erstellen und Ausführen der Pipeline

Jetzt, da Sie die Dateneingaben und -ausgaben festgelegt und die Schritte Ihrer Pipeline erstellt haben, können Sie diese zu einer Pipeline zusammenstellen und ausführen:

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

Das Pipeline-Objekt, das Sie erstellen, wird in Ihrem workspace ausgeführt und besteht aus den von Ihnen angegebenen Vorbereitungs- und Trainingsschritten.

Durch den Aufruf von submit wird Experiment schnell abgeschlossen und erzeugt eine Ausgabe ähnlich der folgenden:

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

Sie können die Pipelineausführung überwachen, indem Sie den Link öffnen, oder Sie können die Ausführung bis zum Abschluss blockieren, indem Sie Folgendes ausführen:

run.wait_for_completion(show_output=True)

Nach Abschluss der Pipeline können Sie die Metriken abrufen, die Sie im Trainingsschritt protokolliert haben:

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

Wenn Sie mit den Metriken zufrieden sind, können Sie das Modell in Ihrem Arbeitsbereich registrieren:

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

Bereinigen von Ressourcen

Überspringen Sie diesen Abschnitt, wenn Sie weitere Azure Machine Learning-Tutorials absolvieren möchten.

Beenden der Compute-Instanz

Sollten Sie eine Compute-Instanz verwendet haben, beenden Sie die VM, wenn Sie sie nicht verwenden, um Kosten zu sparen.

1. Wählen Sie in Ihrem Arbeitsbereich die Option Compute aus.

2. Wählen Sie in der Liste den Namen der Compute-Instanz aus.

3. Wählen Sie Stop (Beenden) aus.

4. Wenn Sie bereit sind, den Server erneut zu verwenden, wählen Sie Starten aus.

Alles löschen

Wenn Sie die erstellten Ressourcen nicht mehr benötigen, löschen Sie sie, damit Ihnen keine Kosten entstehen:

1. Wählen Sie im Azure-Portal im linken Menü die Option Ressourcengruppen aus.
2. Wählen Sie in der Liste der Ressourcengruppen die von Ihnen erstellte Ressourcengruppe aus.
3. Wählen Sie die Option Ressourcengruppe löschen.
4. Geben Sie den Ressourcengruppennamen ein. Wählen Sie dann Löschen aus.

Sie können die Ressourcengruppe auch behalten und einen einzelnen Arbeitsbereich löschen. Zeigen Sie die Eigenschaften des Arbeitsbereichs an, und wählen Sie Löschen aus.

Nächste Schritte

In diesem Tutorial haben Sie die folgenden Typen verwendet:

• Der Workspace stellt Ihren Azure Machine Learning-Arbeitsbereich dar. Er hat Folgendes enthalten:
  • Das Experiment, das die Ergebnisse der Trainingsausführungen Ihrer Pipeline enthält.
  • Das Dataset, das die im Fashion-MNIST-Datenspeicher gespeicherten Daten verzögert geladen hat.
  • Das ComputeTarget, das den/die Computer darstellt, auf denen die Pipelineschritte ausgeführt werden.
  • Die Environment, die die Laufzeitumgebung darstellt, in der die Pipelineschritte ausgeführt werden.
  • Die Pipeline, die die PythonScriptStep-Schritte zu einem Ganzen zusammenstellt.
  • Das Model, das Sie registriert haben, nachdem Sie mit dem Trainingsprozess zufrieden sind.

Das Workspace-Objekt enthält Verweise auf andere Ressourcen (Notebooks, Endpunkte usw.), die in diesem Tutorial nicht verwendet wurden. Weitere Informationen finden Sie unter Was ist ein Azure Machine Learning-Arbeitsbereich?.

Die OutputFileDatasetConfig stuft die Ausgabe einer Ausführung in ein dateibasiertes Dataset hoch. Weitere Informationen zu Datasets und zum Arbeiten mit Daten finden Sie unter Zugreifen auf Daten.

Weitere Informationen zu Computezielen und -umgebungen finden Sie unter Was sind Computeziele in Azure Machine Learning? und Was sind Azure Machine Learning-Umgebungen?.

Die ScriptRunConfig ordnet ein ComputeTarget und eine Environment den Python-Quelldateien zu. Ein PythonScriptStep verwendet diese ScriptRunConfig und definiert die Eingaben und Ausgaben, bei denen es sich in dieser Pipeline um das von der OutputFileDatasetConfig erstellte Dateidataset handelt.

Weitere Beispiele zum Erstellen von Pipelines mithilfe des Machine Learning SDK finden Sie im Beispielrepository.