Creare ed eseguire pipeline di Machine Learning usando componenti con Machine Learning SDK v2

SI APPLICA A: Python SDK azure-ai-ml v2 (corrente)

Questo articolo illustra come creare una pipeline di Azure Machine Learning usando Azure Machine Learning Python SDK v2 per completare un'attività di classificazione delle immagini contenente tre passaggi: preparare i dati, eseguire il training di un modello di classificazione delle immagini e assegnare un punteggio al modello. Le pipeline di Machine Learning ottimizzano il flusso di lavoro con velocità, portabilità e riutilizzo, in modo da potersi concentrare sull'apprendimento automatico anziché sull'infrastruttura e sull'automazione.

La pipeline di esempio addestra una piccola rete neurale convoluzionale Keras per classificare le immagini nel dataset Fashion MNIST. La pipeline è simile alla seguente:

In questo articolo vengono completate le attività seguenti:

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare. Provare la versione gratuita o a pagamento di Azure Machine Learning.

Prerequisiti

• Un'area di lavoro di Azure Machine Learning. Se non ne hai uno, completa l'esercitazione Creare risorse.

• Un ambiente Python in cui è stato installato Azure Machine Learning Python SDK v2. Per istruzioni sull'installazione, vedere Introduzione. Questo ambiente è per definire e controllare le risorse di Azure Machine Learning ed è separato dall'ambiente usato in fase di esecuzione per il training.

• Un clone del repository di esempi.

  Per eseguire gli esempi di training, clonare prima di tutto il repository di esempi e passare alla sdk directory :

  git clone --depth 1 https://github.com/Azure/azureml-examples
  cd azureml-examples/sdk
  

Avviare una sessione Interattiva di Python

Questo articolo usa Azure Machine Learning Python SDK per creare e controllare una pipeline di Azure Machine Learning. L'articolo è scritto in base al presupposto che i frammenti di codice vengano eseguiti in modo interattivo in un ambiente Python REPL o in un notebook jupyter.

Questo articolo si basa sul notebook image_classification_keras_minist_convnet.ipynb, che puoi trovare nella sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet directory del repository degli esempi di Azure Machine Learning.

Importare le librerie obbligatorie

Importare tutte le librerie di Azure Machine Learning necessarie per questo articolo:

# import required libraries
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

from azure.ai.ml import MLClient
from azure.ai.ml.dsl import pipeline
from azure.ai.ml import load_component

Preparare i dati di input per il processo della pipeline

È necessario preparare i dati di input per la pipeline di classificazione delle immagini.

Fashion MNIST è un set di dati di immagini di moda suddivise in 10 classi. Ogni immagine è un'immagine 28 x 28 in tonalità di grigio. Sono disponibili 60.000 immagini di training e 10.000 immagini di test. Come problema di classificazione delle immagini, Fashion MNIST è più complesso rispetto al database classico delle cifre scritte a mano MNIST. È distribuito nella stessa forma binaria compressa del database di cifre scritto a mano originale.

Definendo un Input, si crea un riferimento al percorso dell'origine dati. I dati rimangono nell'attuale posizione, quindi non si incorre in costi aggiuntivi di archiviazione.

Creare componenti per la compilazione della pipeline

L'attività di classificazione delle immagini può essere suddivisa in tre passaggi: preparare i dati, eseguire il training del modello e assegnare un punteggio al modello.

Un componente di Azure Machine Learning è un frammento di codice autonomo che completa un passaggio in una pipeline di Machine Learning. In questo articolo vengono creati tre componenti per l'attività di classificazione delle immagini:

• Preparare i dati per il training e testarli.
• Addestrare una rete neurale per la classificazione delle immagini utilizzando dati di addestramento.
• Assegnare un punteggio al modello usando i dati di test.

Per ogni componente, è necessario completare questi passaggi:

1. Preparare lo script Python che contiene la logica di esecuzione.

2. Definire l'interfaccia del componente.

3. Aggiungere altri metadati del componente, inclusi l'ambiente di runtime e il comando per eseguire il componente.

La sezione successiva illustra come creare i componenti in due modi. Per i primi due componenti, si usa una funzione Python. Per il terzo componente si usa la definizione YAML.

Creare il componente di preparazione dei dati

Il primo componente di questa pipeline converte i file di dati compressi di fashion_ds in due file .csv, uno per il training e l'altro per l'assegnazione dei punteggi. Usare una funzione Python per definire questo componente.

Se si segue l'esempio nel repository degli esempi di Azure Machine Learning, i file di origine sono già disponibili nella prep cartella . Questa cartella contiene due file per costruire il componente : prep_component.py, che definisce il componente e conda.yaml, che definisce l'ambiente di runtime del componente.

Definire il componente usando una funzione Python

Usando la command_component() funzione come decorator, è possibile definire facilmente l'interfaccia del componente, i relativi metadati e il codice da eseguire da una funzione Python. Ogni funzione Python decorata verrà trasformata in una singola specifica statica (YAML) che il servizio pipeline può elaborare.

# Converts MNIST-formatted files at the passed-in input path to training data output path and test data output path
import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="prep_data",
    version="1",
    display_name="Prep Data",
    description="Convert data to CSV file, and split to training and test data",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def prepare_data_component(
    input_data: Input(type="uri_folder"),
    training_data: Output(type="uri_folder"),
    test_data: Output(type="uri_folder"),
):
    convert(
        os.path.join(input_data, "train-images-idx3-ubyte"),
        os.path.join(input_data, "train-labels-idx1-ubyte"),
        os.path.join(training_data, "mnist_train.csv"),
        60000,
    )
    convert(
        os.path.join(input_data, "t10k-images-idx3-ubyte"),
        os.path.join(input_data, "t10k-labels-idx1-ubyte"),
        os.path.join(test_data, "mnist_test.csv"),
        10000,
    )


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

Il codice precedente definisce un componente con nome visualizzato Prep Data usando il decorator @command_component.

• name è l'identificatore univoco del componente.

• version è la versione corrente del componente. Un componente può avere più versioni.

• display_name è un nome visualizzato amichevole del componente per la UI. Non è univoco.

• description in genere descrive l'attività che il componente può completare.

• environment specifica l'ambiente di runtime per il componente. L'ambiente di questo componente specifica un'immagine Docker e fa riferimento al conda.yaml file.

  Il conda.yaml file contiene tutti i pacchetti usati per il componente:

  name: imagekeras_prep_conda_env
  channels:
    - defaults
  dependencies:
    - python=3.7.11
    - pip=20.0
    - pip:
      - mldesigner==0.1.0b4
  

• La funzione prepare_data_component definisce un input per input_data e due output per training_data e test_data. input_data è il percorso dei dati di input. training_data e test_data sono percorsi di dati di output per i dati di training e i dati di test.

• Il componente converte i dati da input_data in un training_data .csv per eseguire il training dei dati e un test_data .csv per testare i dati.

Questo è l'aspetto di un componente nell'interfaccia utente di Studio:

• Un componente è un blocco in un grafico della pipeline.
• input_data, training_datae test_data sono porte del componente, che si connettono ad altri componenti per il flusso di dati.

A questo punto sono stati preparati tutti i file di origine per il Prep Data componente.

Creare il componente di formazione del modello

In questa sezione si creerà un componente per il training del modello di classificazione delle immagini in una funzione Python, come è stato fatto con il Prep Data componente.

Poiché la logica di training è più complessa, il codice di training verrà inserito in un file Python separato.

I file di origine per questo componente si trovano nella train cartella nel repository degli esempi di Azure Machine Learning. Questa cartella contiene tre file per costruire il componente:

• train.py contiene la logica per eseguire il training del modello.
• train_component.py definisce l'interfaccia del componente e importa la funzione in train.py.
• conda.yaml definisce l'ambiente di runtime del componente.

Ottenere uno script contenente la logica

Il train.py file contiene una normale funzione Python che esegue la logica per il training di una rete neurale Keras per la classificazione delle immagini. Per visualizzare il codice, vedere il file train.py in GitHub.

Definire il componente usando una funzione Python

Dopo aver definito la funzione di training, è possibile usare @command_component in Azure Machine Learning SDK v2 per eseguire il wrapping della funzione come componente che può essere usato nelle pipeline di Azure Machine Learning:

import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="train_image_classification_keras",
    version="1",
    display_name="Train Image Classification Keras",
    description="train image classification with keras",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def keras_train_component(
    input_data: Input(type="uri_folder"),
    output_model: Output(type="uri_folder"),
    epochs=10,
):
    # avoid dependency issue, execution logic is in train() func in train.py file
    from train import train

    train(input_data, output_model, epochs)

Il codice precedente definisce un componente con nome Train Image Classification Keras visualizzato tramite @command_component.

• La keras_train_component funzione definisce un input, input_data, per i dati di training di origine, un input, epochs, che specifica il numero di periodi da usare durante il training e un output, output_model, che specifica il percorso di output per il file di modello. Il valore predefinito di epochs è 10. La logica di questo componente proviene dalla train() funzione in train.py.

Il componente del modello di training ha una configurazione leggermente più complessa rispetto al componente di preparazione dei dati. conda.yaml assomiglia a questo:

name: imagekeras_train_conda_env
channels:
  - defaults
dependencies:
  - python=3.8
  - pip=20.2
  - pip:
    - mldesigner==0.1.0b12
    - azureml-mlflow==1.50.0
    - tensorflow==2.7.0
    - numpy==1.21.4
    - scikit-learn==1.0.1
    - pandas==1.3.4
    - matplotlib==3.2.2
    - protobuf==3.20.0

A questo punto sono stati preparati tutti i file di origine per il Train Image Classification Keras componente.

Creare il componente di assegnazione dei punteggi del modello

In questa sezione, crei un componente per valutare il modello addestrato tramite la specifica YAML e lo script.

Se si segue l'esempio nel repository degli esempi di Azure Machine Learning, i file di origine sono già disponibili nella score cartella . Questa cartella contiene tre file per costruire il componente:

• score.py contiene il codice sorgente del componente.
• score.yaml definisce l'interfaccia e altri dettagli del componente.
• conda.yaml definisce l'ambiente di runtime del componente.

Ottenere uno script contenente la logica

Il score.py file contiene una normale funzione Python che esegue la logica del modello di training:

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

import argparse
from pathlib import Path
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import mlflow


def get_file(f):

    f = Path(f)
    if f.is_file():
        return f
    else:
        files = list(f.iterdir())
        if len(files) == 1:
            return files[0]
        else:
            raise Exception("********This path contains more than one file*******")


def parse_args():
    # setup argparse
    parser = argparse.ArgumentParser()

    # add arguments
    parser.add_argument(
        "--input_data", type=str, help="path containing data for scoring"
    )
    parser.add_argument(
        "--input_model", type=str, default="./", help="input path for model"
    )

    parser.add_argument(
        "--output_result", type=str, default="./", help="output path for model"
    )

    # parse args
    args = parser.parse_args()

    # return args
    return args


def score(input_data, input_model, output_result):

    test_file = get_file(input_data)
    data_test = pd.read_csv(test_file, header=None)

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

    # Read test data
    X_test = np.array(data_test.iloc[:, 1:])
    y_test = to_categorical(np.array(data_test.iloc[:, 0]))
    X_test = (
        X_test.reshape(X_test.shape[0], img_rows, img_cols, 1).astype("float32") / 255
    )

    # Load model
    files = [f for f in os.listdir(input_model) if f.endswith(".h5")]
    model = load_model(input_model + "/" + files[0])

    # Log metrics of the model
    eval = model.evaluate(X_test, y_test, verbose=0)

    mlflow.log_metric("Final test loss", eval[0])
    print("Test loss:", eval[0])

    mlflow.log_metric("Final test accuracy", eval[1])
    print("Test accuracy:", eval[1])

    # Score model using test data
    y_predict = model.predict(X_test)
    y_result = np.argmax(y_predict, axis=1)

    # Output result
    np.savetxt(output_result + "/predict_result.csv", y_result, delimiter=",")


def main(args):
    score(args.input_data, args.input_model, args.output_result)


# run script
if __name__ == "__main__":
    # parse args
    args = parse_args()

    # call main function
    main(args)

Il codice in score.py accetta tre argomenti della riga di comando: input_data, input_modele output_result. Il programma assegna un punteggio al modello di input usando i dati di input e quindi restituisce il risultato.

Definire il componente tramite YAML

In questa sezione si apprenderà come creare una specifica del componente nel formato di specifica del componente YAML valido. Questo file specifica le informazioni seguenti:

• Metadati. Nome, nome visualizzato, versione, tipo e così via.
• Interfaccia. Ingressi e uscite.
• Comando, codice e ambiente. Il comando, il codice e l'ambiente usati per eseguire il componente.

$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
type: command

name: score_image_classification_keras
display_name: Score Image Classification Keras
inputs:
  input_data: 
    type: uri_folder
  input_model:
    type: uri_folder
outputs:
  output_result:
    type: uri_folder
code: ./
command: python score.py --input_data ${{inputs.input_data}} --input_model ${{inputs.input_model}} --output_result ${{outputs.output_result}}
environment:
  conda_file: ./conda.yaml
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04

• name è l'identificatore univoco del componente. Il nome visualizzato è Score Image Classification Keras.
• Questo componente ha due input e un output.
• Il percorso del codice sorgente è definito nella code sezione . Quando il componente viene eseguito nel cloud, tutti i file di tale percorso verranno caricati come snapshot del componente.
• La command sezione specifica il comando da eseguire quando viene eseguito il componente.
• La environment sezione contiene un'immagine Docker e un file YAML conda. Il file di origine si trova nel repository di esempio.

Sono ora disponibili tutti i file di origine per il componente di assegnazione dei punteggi del modello.

Caricare i componenti per compilare una pipeline

È possibile importare il componente di preparazione dei dati e il componente di training del modello, definiti dalle funzioni Python, proprio come le normali funzioni Python.

Il codice seguente importa rispettivamente le prepare_data_component() funzioni e keras_train_component() dal prep_component.py file nella prep cartella e il train_component file nella train cartella .

%load_ext autoreload
%autoreload 2

# load component function from component python file
from prep.prep_component import prepare_data_component
from train.train_component import keras_train_component

# print hint of components
help(prepare_data_component)
help(keras_train_component)

È possibile usare la load_component() funzione per caricare il componente score, definito da YAML.

# load component function from yaml
keras_score_component = load_component(source="./score/score.yaml")

Creare la pipeline

Sono stati creati e caricati tutti i componenti e i dati di input per costruire la pipeline. È ora possibile componerli in una pipeline:

# define a pipeline containing 3 nodes: Prepare data node, train node, and score node
@pipeline(
    default_compute=cpu_compute_target,
)
def image_classification_keras_minist_convnet(pipeline_input_data):
    """E2E image classification pipeline with keras using python sdk."""
    prepare_data_node = prepare_data_component(input_data=pipeline_input_data)

    train_node = keras_train_component(
        input_data=prepare_data_node.outputs.training_data
    )
    train_node.compute = gpu_compute_target

    score_node = keras_score_component(
        input_data=prepare_data_node.outputs.test_data,
        input_model=train_node.outputs.output_model,
    )


# create a pipeline
pipeline_job = image_classification_keras_minist_convnet(pipeline_input_data=mnist_ds)

La pipeline ha un calcolo predefinito cpu_compute_target. Se non si specifica il calcolo per un nodo specifico, tale nodo verrà eseguito nel calcolo predefinito.

La pipeline ha un input a livello di pipeline, pipeline_input_data. È possibile assegnare un valore all'input della pipeline quando si invia un'operazione della pipeline.

La pipeline contiene tre nodi: prepare_data_node, train_nodee score_node.

• input_data di prepare_data_node usa il valore di pipeline_input_data.

• L'input_data di train_node è l'training_data output di prepare_data_node.

• l'oggetto input_data di score_node è l'output test_data di prepare_data_node, e input_model è l'oggetto output_model di train_node.

• Poiché train_node addestra un modello CNN, è possibile specificarne la potenza di calcolo usando gpu_compute_target. In questo modo è possibile migliorare le prestazioni di training.

Inviare il processo della pipeline

Dopo aver creato la pipeline, è possibile inviare il processo all'area di lavoro. Per inviare un'attività, è prima necessario connettersi a un'area di lavoro.

Ottenere l'accesso all'area di lavoro

Configurare le credenziali

Si userà DefaultAzureCredential per ottenere l'accesso all'area di lavoro. DefaultAzureCredential deve essere in grado di gestire la maggior parte degli scenari di autenticazione di Azure SDK.

Se DefaultAzureCredential non funziona, vedere questo esempio di configurazione delle credenziali e il pacchetto di identità.

try:
    credential = DefaultAzureCredential()
    # Check if given credential can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential not work
    credential = InteractiveBrowserCredential()

Ottieni un riferimento a un'area di lavoro con capacità di calcolo

Creare un MLClient oggetto per gestire i servizi di Azure Machine Learning. Se si usa il calcolo serverless, non è necessario creare questi calcoli.

# Get a handle to workspace
ml_client = MLClient.from_config(credential=credential)

# Retrieve an already attached Azure Machine Learning Compute.
cpu_compute_target = "cpu-cluster"
print(ml_client.compute.get(cpu_compute_target))
gpu_compute_target = "gpu-cluster"
print(ml_client.compute.get(gpu_compute_target))

Invia il compito della pipeline all'area di lavoro

Ora che si dispone di un accesso all'area di lavoro, è possibile inviare il job della pipeline:

pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="pipeline_samples"
)
pipeline_job

Il codice precedente invia un processo di pipeline per la classificazione delle immagini a un esperimento denominato pipeline_samples. Crea automaticamente l'esperimento se non esiste. pipeline_input_data usa fashion_ds.

La chiamata per inviare l'esperimento viene completata rapidamente. Produce un output simile al seguente:

È possibile monitorare l'esecuzione della pipeline selezionando il collegamento. In alternativa, è possibile bloccarlo fino al completamento eseguendo questo codice:

# wait until the job completes
ml_client.jobs.stream(pipeline_job.name)

Controllare gli output ed eseguire il debug della pipeline nell'interfaccia utente

È possibile selezionare la Link to Azure Machine Learning studiopagina dei dettagli del processo della pipeline. Verrà visualizzato il grafico della pipeline:

È possibile controllare i log e gli output di ogni componente facendo clic con il pulsante destro del mouse sul componente oppure selezionando il componente per aprire il relativo riquadro dei dettagli. Per altre informazioni su come eseguire il debug della pipeline nell'interfaccia utente, vedere Usare Azure Machine Learning Studio per eseguire il debug degli errori della pipeline.

(Facoltativo) Registrare i componenti nell'area di lavoro

Nella sezione precedente è stata creata una pipeline usando tre componenti per completare un'attività di classificazione delle immagini. È anche possibile registrare i componenti nell'area di lavoro in modo che possano essere condivisi e riutilizzati all'interno dell'area di lavoro. L'esempio seguente illustra come registrare il componente di preparazione dei dati:

try:
    # try get back the component
    prep = ml_client.components.get(name="prep_data", version="1")
except:
    # if not exists, register component using following code
    prep = ml_client.components.create_or_update(prepare_data_component)

# list all components registered in workspace
for c in ml_client.components.list():
    print(c)

È possibile usare ml_client.components.get() per ottenere un componente registrato in base al nome e alla versione. È possibile usare ml_client.components.create_or_update() per registrare un componente caricato in precedenza da una funzione Python o YAML.

Passaggi successivi

• Per altri esempi sulla creazione di pipeline tramite Machine Learning SDK, vedere il repository di esempi.
• Per informazioni sull'uso dell'interfaccia utente di Studio per inviare ed eseguire il debug di una pipeline, vedere Creare ed eseguire pipeline di Machine Learning usando componenti con Azure Machine Learning Studio.
• Per informazioni sull'uso dell'interfaccia della riga di comando di Azure Machine Learning per creare componenti e pipeline, vedere Creare ed eseguire pipeline di Machine Learning usando componenti con l'interfaccia della riga di comando di Azure Machine Learning.
• Per informazioni sulla distribuzione di pipeline nell'ambiente di produzione tramite endpoint batch, vedere Come distribuire pipeline con endpoint batch.