Tutorial: Creación de una canalización de Azure Machine Learning para la clasificación de imágenes

SE APLICA A:SDK de Azure Machine Learning v1 para Python

En este tutorial, aprenderá a crear una canalización de Azure Machine Learning para preparar los datos y entrenar un modelo de Machine Learning. Las canalizaciones de Machine Learning optimizan el flujo de trabajo con velocidad, portabilidad y reutilización, con el fin de que pueda centrarse en el aprendizaje automático, en lugar de en la infraestructura y la automatización.

En el ejemplo se entrena una pequeña red neuronal convolucional de Keras para clasificar las imágenes del conjunto de datos de MNIST Fashion.

En este tutorial, va a completar las siguientes tareas:

Si no tiene una suscripción de Azure, cree una cuenta gratuita antes de empezar. Pruebe hoy mismo la versión gratuita o de pago de Azure Machine Learning.

Requisitos previos

• Completa la Creación de recursos para empezar si aún no tienes un área de trabajo de Azure Machine Learning.
• Un entorno de Python en el que se instalan tanto los paquetes azureml-core como azureml-pipeline. Use este entorno para definir y controlar los recursos de Azure Machine Learning. Es independiente del entorno utilizado en tiempo de ejecución para el entrenamiento.

Inicio de una sesión interactiva de Python

En este tutorial se usa el SDK de Python para Azure Machine Learning para crear y controlar una canalización de Azure Machine Learning. En el tutorial se supone que ejecuta los fragmentos de código de forma interactiva en un entorno de REPL de Python o en un cuaderno de Jupyter Notebook.

• Este tutorial se basa en el cuaderno image-classification.ipynb que se encuentra en el v1/python-sdk/tutorials/using-pipelines directorio de la rama Ejemplos de Azure Machine Learning v1-archive. El código fuente de los propios pasos está en el subdirectorio keras-mnist-fashion.

Tipos de importación

Importe todos los tipos de Azure Machine Learning que necesita para este tutorial:

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)

La versión del SDK de Azure Machine Learning debe ser la 1.61 o la versión más reciente disponible. Si no es así, actualice mediante pip install --upgrade azureml-core.

Configuración del área de trabajo

Cree un objeto de área de trabajo a partir del área de trabajo de Azure Machine Learning existente.

workspace = Workspace.from_config()

Creación de la infraestructura para la canalización

Cree un objeto Experiment que contenga los resultados de las ejecuciones de canalización:

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

Cree un ComputeTarget que represente el recurso de máquina en el que se ejecuta el pipeline. La red neuronal simple que se usa en este tutorial se entrena en tan solo unos minutos incluso en una máquina basada en CPU. Si desea usar una GPU para el entrenamiento, establezca use_gpu en True. El aprovisionamiento de un destino de proceso normalmente tarda unos cinco minutos.

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

Creación de un conjunto de datos para los datos almacenados en Azure

Fashion-MNIST es un conjunto de datos de imágenes de moda dividido en 10 clases. Cada imagen es una imagen en escala de grises de 28 x 28 y hay 60 000 imágenes de entrenamiento y 10 000 de prueba. Como problema de clasificación de imágenes, Fashion-MNIST es más compleja que la base de datos de dígitos manuscritos de MNIST clásica. Se distribuye en el mismo formato binario comprimido que la base de datos de dígitos manuscritos original.

Para crear un objeto Dataset que haga referencia a los datos basados en web, ejecute:

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

Este código se completa rápidamente. Los datos subyacentes permanecen en el recurso de almacenamiento de Azure especificado en la matriz data_urls.

Creación del paso de canalización de preparación de datos

El primer paso de esta canalización convierte los archivos de datos comprimidos de fashion_ds en un conjunto de datos en su propia área de trabajo que consta de archivos CSV listos para usar en el entrenamiento. Una vez registrado en el área de trabajo, los colaboradores pueden acceder a estos datos para su propio análisis, aprendizaje, etc.

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

El código anterior especifica un conjunto de datos basado en la salida de un paso de canalización. Los archivos procesados subyacentes se colocan en el almacenamiento de blobs predeterminado del almacén de datos del área de trabajo en la ruta especificada en destination. El conjunto de datos se registra en el área de trabajo con el nombre prepared_fashion_ds.

Creación del origen del paso de canalización

El código que ejecutó hasta ahora crea y controla los recursos de Azure. Ahora es el momento de escribir código que realice el primer paso en el dominio.

Si sigue el ejemplo del repositorio de ejemplos de Azure Machine Learning, el archivo de código fuente ya está disponible como keras-mnist-fashion/prepare.py.

Si va a trabajar desde cero, cree un subdirectorio denominado keras-mnist-fashion/. Cree un archivo, agréguele el siguiente código y asigne al archivo el nombre 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,
)

El código de prepare.py toma dos argumentos de línea de comandos: el primero se asigna a mounted_input_path y el segundo a mounted_output_path. Si ese subdirectorio no existe, la llamada a os.makedirs lo crea. A continuación, el programa convierte los datos de entrenamiento y prueba, y genera los archivos separados por comas en mounted_output_path.

Especificación del paso de canalización

De nuevo en el entorno de Python que va a usar para especificar la canalización, ejecute este código para crear un PythonScriptStep para el código de preparación:

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

La llamada a PythonScriptStep especifica que, cuando se ejecuta el paso de canalización:

• Todos los archivos del directorio script_folder se cargan en el compute_target.
• Entre los archivos de origen cargados, el archivo prepare.py se ejecuta
• Los conjuntos de datos fashion_ds y prepared_fashion_ds se montan en compute_target y aparecen como directorios.
• La ruta de acceso a los fashion_ds archivos es el primer argumento de prepare.py. En prepare.py, este argumento se asigna a mounted_input_path.
• La ruta de acceso a prepared_fashion_ds es el segundo argumento de prepare.py. En prepare.py, este argumento se asigna a mounted_output_path.
• Dado que allow_reuse es True, no se vuelve a ejecutar hasta que cambian sus archivos de origen o entradas.
• Esto PythonScriptStep se denomina prepare step

La modularidad y la reutilización son ventajas clave de las canalizaciones. Azure Machine Learning puede determinar automáticamente el código fuente o los cambios en el conjunto de datos. Si allow_reuse es True, la canalización reutiliza la salida de un paso que no se ve afectado sin volver a ejecutar los pasos de nuevo. Si un paso se basa en un origen de datos externo a Azure Machine Learning que podría cambiar (por ejemplo, una dirección URL que contiene datos de ventas), establezca allow_reuseFalse en y el paso de canalización se ejecute cada vez que se ejecute la canalización.

Creación del paso de entrenamiento

Después de convertir los datos del formato comprimido en archivos CSV, puede usarlo para entrenar una red neuronal convolucional.

Creación del origen del paso de entrenamiento

Para canalizaciones más grandes, coloque el código fuente de cada paso en un directorio independiente, como src/prepare/ o src/train/. Para este tutorial, use o cree el archivo train.py en el directorio keras-mnist-fashion/ de origen.

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

La mayoría de los desarrolladores de Machine Learning debería estar familiarizado con este código:

• Los datos se dividen en conjuntos de entrenamiento y validación para el entrenamiento y un subconjunto de pruebas independiente para la puntuación final.
• La forma de entrada es 28x28x1 (solo 1 porque la entrada es de escala de grises), hay 256 entradas en un lote y hay 10 clases.
• El número de épocas de entrenamiento es 10.
• El modelo tiene tres capas convolucionales, con agrupación y deserción máximas, seguidas de una capa densa y una capa de salida (softmax head).
• El modelo se ajusta para 10 épocas y, a continuación, se evalúa.
• La arquitectura del modelo se escribe en outputs/model/model.json y las ponderaciones en outputs/model/model.h5.

Sin embargo, parte del código es específico de Azure Machine Learning. run = Run.get_context() recupera un objeto Run, que contiene el contexto del servicio actual. La fuente train.py utiliza este objeto run para recuperar el conjunto de datos de entrada por su nombre. Este enfoque es una alternativa al código en prepare.py, que recupera el conjunto de datos a través del array argv de argumentos de script.

El run objeto también registra el progreso del entrenamiento al final de cada época y, al final del entrenamiento, registra el gráfico de pérdida y precisión a lo largo del tiempo.

Creación del paso de canalización de entrenamiento

El paso de entrenamiento tiene una configuración ligeramente más compleja que el paso de preparación. El paso de preparación solo usa bibliotecas estándar de Python. Con más frecuencia, debe modificar el entorno en tiempo de ejecución en el que se ejecuta el código fuente.

Cree un nuevo archivo denominado conda_dependencies.yml con el contenido siguiente:

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

La clase Environment representa el entorno en tiempo de ejecución en el que se ejecuta una tarea de aprendizaje automático. Asocie la especificación anterior al código de entrenamiento mediante:

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

El código para crear el paso de entrenamiento es similar al código que crea el paso de preparación:

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

Creación y ejecución de la canalización

Después de especificar las entradas y salidas de datos y crear los pasos de la canalización, compongalas en una canalización y ejecútela:

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

El Pipeline objeto que usted crea se ejecuta dentro de su workspace y está compuesto por los pasos de preparación y entrenamiento que especifique.

La llamada para submit el Experiment se completa rápidamente y produce una salida parecida a:

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

Para supervisar la ejecución de la canalización, abra el vínculo o puede bloquearlo hasta que se complete mediante la ejecución de:

run.wait_for_completion(show_output=True)

Una vez completada la canalización, puede recuperar las métricas que registró en el paso de entrenamiento:

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

Si está satisfecho con las métricas, registre el modelo en el área de trabajo:

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

Limpieza de recursos

No complete esta sección si planea ejecutar otros tutoriales de Azure Machine Learning.

Detención de la instancia de proceso

Si usó una instancia de proceso, detenga la máquina virtual cuando no la esté usando a fin de reducir el costo.

1. En el área de trabajo, seleccione Compute.

2. En la lista, seleccione el nombre de la instancia de proceso.

3. Seleccione Detener.

4. Cuando esté listo para volver a usar el servidor, seleccione Iniciar.

Eliminar todo el contenido

Si no tiene previsto usar los recursos que ha creado, elimínelos para no incurrir en cargos:

1. En Azure Portal, seleccione Grupos de recursos en el menú de la izquierda.
2. En la lista de grupos de recursos, seleccione el que ha creado.
3. Seleccione Eliminar grupo de recursos.
4. Escriba el nombre del grupo de recursos. A continuación, seleccione Eliminar.

También puede mantener el grupo de recursos pero eliminar una sola área de trabajo. Muestre las propiedades del área de trabajo y seleccione Eliminar.

Pasos siguientes

En este tutorial, ha usado los siguientes tipos:

• El Workspace tipo representa el área de trabajo de Azure Machine Learning. Contiene:
  • El Experiment que incluye los resultados de las ejecuciones de entrenamiento de la canalización.
  • El Dataset que carga lentamente los datos contenidos en el almacén de datos Fashion-MNIST.
  • ComputeTarget que representa las máquinas en las que se ejecutan los pasos de canalización.
  • El Environment que es el entorno de ejecución en el que se ejecutan los pasos de canalización.
  • La Pipeline que reúne los pasos de PythonScriptStep en un solo conjunto.
  • El Model que se registra después de validar el proceso de entrenamiento.

El Workspace objeto contiene referencias a otros recursos, como cuadernos y puntos de conexión, que no se usaron en este tutorial. Para más información, consulte ¿Qué es un área de trabajo de Azure Machine Learning?

OutputFileDatasetConfig promueve la salida de una ejecución a un conjunto de datos basado en archivos. Para más información sobre los conjuntos de datos y cómo trabajar con datos, consulte Acceso a los datos.

Para más información sobre los destinos de proceso y los entornos, consulte ¿Qué son los destinos de proceso en Azure Machine Learning? y ¿Qué son los entornos de Azure Machine Learning?

ScriptRunConfig asocia un ComputeTarget y un Environment a los archivos de código fuente de Python. "Un PythonScriptStep toma ese ScriptRunConfig y define sus entradas y salidas." En esta canalización, el resultado era el conjunto de datos de archivo creado por el OutputFileDatasetConfig.

Para más ejemplos de cómo crear canalizaciones mediante el SDK de Machine Learning, consulte el repositorio de ejemplos.