Créer et exécuter des pipelines Machine Learning à l’aide de composants avec le Kit de développement logiciel (SDK) Machine Learning v2

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-ml v2 (actuelle)

Dans cet article, vous allez apprendre à créer un pipeline Azure Machine Learning à l’aide du Kit de développement logiciel (SDK) Python Azure Machine Learning v2 pour effectuer une tâche de classification d’images qui contient trois étapes : préparer des données, entraîner un modèle de classification d’images et noter le modèle. Les pipelines Machine Learning optimisent votre flux de travail avec une vitesse, une portabilité et une réutilisation. Vous pouvez donc vous concentrer sur le Machine Learning au lieu de l’infrastructure et de l’automatisation.

L’exemple de pipeline entraîne une petit réseau neural convolutionnel Keras pour classifier des images dans le jeu de données Fashion MNIST. Le pipeline ressemble à ceci :

Dans cet article, vous allez effectuer les tâches suivantes :

• Préparez les données d’entrée pour le travail de pipeline.
• Créer trois composants pour préparer les données, entraîner une image et noter le modèle.
• Générez un pipeline à partir des composants.
• Obtenir l’accès à un espace de travail qui dispose de ressources de calcul.
• Envoyez le travail du pipeline.
• Passez en revue la sortie des composants et du réseau neuronal entraîné.
• (Facultatif) Inscrivez le composant pour une réutilisation et un partage supplémentaires dans l’espace de travail.

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer. Essayez la version gratuite ou payante d’Azure Machine Learning dès aujourd’hui.

Prérequis

• Un espace de travail Azure Machine Learning. Si vous n’en avez pas, suivez le didacticiel Créer des ressources.

• Environnement Python dans lequel vous avez installé le Kit de développement logiciel (SDK) Python Azure Machine Learning v2. Pour obtenir des instructions d’installation, consultez Bien démarrer. Cet environnement permet de définir et de contrôler vos ressources Azure Machine Learning et est distinct de l’environnement utilisé lors de l’exécution pour l’entraînement.

• Clone du référentiel d’exemples.

  Pour exécuter les exemples d’entraînement, commencez par cloner le référentiel d’exemples et accédez au sdk répertoire :

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

Démarrer une session Python interactive

Cet article utilise le Kit de développement logiciel (SDK) Python Azure Machine Learning pour créer et contrôler un pipeline Azure Machine Learning. L’article est écrit en fonction de l’hypothèse que vous exécuterez les extraits de code de manière interactive dans un environnement REPL Python ou un notebook Jupyter.

Cet article est basé sur le notebook image_classification_keras_minist_convnet.ipynb , que vous trouverez dans le sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet répertoire du référentiel d’exemples Azure Machine Learning .

Importer les bibliothèques nécessaires

Importez toutes les bibliothèques Azure Machine Learning dont vous avez besoin pour cet article :

# 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

Préparer les données d’entrée pour le travail du pipeline

Vous devez préparer les données d’entrée pour le pipeline de classification d’images.

Fashion MNIST est un jeu de données d’images de mode divisées en 10 classes. Chaque image est une image de 28 x 28 nuances de gris. Il existe 60 000 images d’entraînement et 10 000 images de test. En tant que problème de classification d’images, Fashion MNIST est plus difficile que la base de données de chiffres manuscrites MNIST classique. Elle est distribuée sous la même forme binaire compressée que la base de données de chiffres manuscrits.

En définissant Input, vous créez une référence à l’emplacement de la source de données. Les données restant à leur emplacement existant, aucun coût de stockage supplémentaire n’est encouru.

Créer des composants pour construire le pipeline

La tâche de classification d’images peut être divisée en trois étapes : préparer des données, entraîner le modèle et noter le modèle.

Un composant Azure Machine Learning est un élément de code autonome qui effectue une étape dans un pipeline Machine Learning. Dans cet article, vous allez créer trois composants pour la tâche de classification d’images :

• Préparez les données pour l’entraînement et testez-les.
• Entraîner un réseau neuronal pour la classification d’images à l’aide de données d’apprentissage.
• Évaluer le modèle à l’aide des données de test.

Pour chaque composant, vous devez effectuer les étapes suivantes :

1. Préparez le script Python qui contient la logique d’exécution.

2. Définissez l’interface du composant.

3. Ajoutez d’autres métadonnées du composant, notamment l’environnement d’exécution et la commande pour exécuter le composant.

La section suivante montre comment créer les composants de deux manières. Pour les deux premiers composants, vous utilisez une fonction Python. Pour le troisième composant, vous utilisez la définition YAML.

Créer le composant de préparation des données

Le premier composant de ce pipeline convertit les fichiers de données compressés de fashion_ds en deux fichiers .csv, l’un pour l’entraînement et l’autre pour l’évaluation. Vous utilisez une fonction Python pour définir ce composant.

Si vous suivez l’exemple dans le référentiel d’exemples Azure Machine Learning, les fichiers sources sont déjà disponibles dans le prep dossier. Ce dossier contient deux fichiers pour construire le composant : prep_component.py, qui définit le composant et conda.yaml, qui définit l’environnement d’exécution du composant.

Définir un composant à l’aide d’une fonction Python

En utilisant la command_component() fonction comme décorateur, vous pouvez facilement définir l’interface du composant, ses métadonnées et le code à exécuter à partir d’une fonction Python. Chaque fonction Python décorée est transformée en spécification statique unique au format YAML que le service de pipeline peut traiter.

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

Le code précédent définit un composant avec Prep Data comme nom d'affichage en utilisant le décorateur @command_component.

• name est l’identifiant unique du composant.

• version est la version actuelle du composant. Un composant peut avoir plusieurs versions.

• display_name est un nom d'affichage convivial du composant pour l'interface utilisateur. Ce n’est pas unique.

• description décrit généralement la tâche que le composant peut effectuer.

• environment spécifie l’environnement d’exécution du composant. L’environnement de ce composant spécifie une image Docker et fait référence au conda.yaml fichier.

  Le conda.yaml fichier contient tous les packages utilisés pour le composant :

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

• La fonction prepare_data_component définit une entrée pour input_data et deux sorties pour training_data et test_data. input_data est le chemin d’accès aux données d’entrée. training_data et test_data sont des chemins de données de sortie pour les données d’entraînement et de test.

• Le composant convertit les données de input_data en un training_data .csv pour les données d'entraînement et un test_data .csv pour les données de test.

Voici à quoi ressemble un composant dans l’interface utilisateur de Studio :

• Un composant est un bloc dans un graphe de pipeline.
• input_data, training_dataet test_data sont des ports du composant, qui se connectent à d’autres composants pour la diffusion en continu des données.

Vous avez maintenant préparé tous les fichiers sources pour le Prep Data composant.

Créer le composant d’entraînement du modèle

Dans cette section, vous allez créer un composant pour entraîner le modèle de classification d’images dans une fonction Python, comme vous l’avez fait avec le Prep Data composant.

Étant donné que la logique d’entraînement est plus complexe, vous allez placer le code d’entraînement dans un fichier Python distinct.

Les fichiers sources de ce composant se trouvent dans le train dossier du dépôt d’exemples Azure Machine Learning. Ce dossier contient trois fichiers pour construire le composant :

• train.py contient la logique d’apprentissage du modèle.
• train_component.py définit l’interface du composant et importe la fonction qui se trouve dans train.py.
• conda.yaml définit l’environnement d’exécution du composant.

Obtenir un script qui contient la logique

Le train.py fichier contient une fonction Python normale qui effectue la logique d’apprentissage d’un réseau neuronal Keras pour la classification d’images. Pour voir le code, consultez le fichier train.py sur GitHub.

Définir le composant à l’aide d’une fonction Python

Après avoir défini la fonction d’entraînement, vous pouvez utiliser @command_component dans le Kit de développement logiciel (SDK) Azure Machine Learning v2 pour encapsuler votre fonction en tant que composant pouvant être utilisé dans les pipelines 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)

Le code précédent définit un composant qui a un nom d'affichage Train Image Classification Keras à l’aide de @command_component.

• La keras_train_component fonction définit une entrée, input_datapour les données d’apprentissage sources, une entrée, epochsqui spécifie le nombre d’époques à utiliser pendant l’entraînement et une sortie, output_modelqui spécifie le chemin de sortie du fichier modèle. La valeur par défaut de epochs est 10. La logique de ce composant provient de la train() fonction dans train.py.

Le composant train-model présente une configuration légèrement plus complexe que le composant prep-data. conda.yaml ressemble à ceci :

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

Vous avez maintenant préparé tous les fichiers sources du Train Image Classification Keras composant.

Créer le composant de scoring de modèle

Dans cette section, vous allez créer un composant pour évaluer le modèle entraîné à l'aide de la spécification et du script YAML.

Si vous suivez l’exemple dans le référentiel d’exemples Azure Machine Learning, les fichiers sources sont déjà disponibles dans le score dossier. Ce dossier contient trois fichiers pour construire le composant :

• score.py contient le code source du composant.
• score.yaml définit l’interface et d’autres détails du composant.
• conda.yaml définit l’environnement d’exécution du composant.

Obtenir un script qui contient la logique

Le score.py fichier contient une fonction Python normale qui effectue la logique du modèle d’entraînement :

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)

Le code dans score.py prend trois arguments de ligne de commande : input_data, input_modelet output_result. Le programme note le modèle d’entrée à l’aide des données d’entrée, puis génère le résultat.

Définir le composant via YAML

Dans cette section, vous allez apprendre à créer une spécification de composant au format de spécification de composant YAML valide. Ce fichier spécifie les informations suivantes :

• Métadonnées. Nom, nom d'affichage, version, type, et ainsi de suite.
• Interface. Entrées et sorties.
• Commande, code et environnement. Commande, code et environnement utilisés pour exécuter le composant.

$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 est l’identifiant unique du composant. Son nom d’affichage est Score Image Classification Keras.
• Ce composant a deux entrées et une sortie.
• Le chemin du code source est défini dans la code section. Lorsque le composant est exécuté dans le cloud, tous les fichiers de ce chemin seront chargés en tant qu’instantané du composant.
• La command section spécifie la commande à exécuter lors de l’exécution du composant.
• La environment section contient une image Docker et un fichier YAML conda. Le fichier source se trouve dans le dépôt d’exemples.

Vous disposez maintenant de tous les fichiers sources pour le composant d'évaluation du modèle.

Charger les composants pour construire un pipeline

Vous pouvez importer le composant de préparation des données et le composant d’entraînement du modèle, qui sont définis par les fonctions Python, tout comme les fonctions Python normales.

Le code suivant importe les fonctions prepare_data_component() et keras_train_component() du fichier prep_component.py dans le dossier prep et du fichier train_component dans le dossier train, respectivement.

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

Vous pouvez utiliser la load_component() fonction pour charger le composant score, qui est défini par YAML.

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

Créer votre pipeline

Vous avez créé et chargé tous les composants et données d’entrée pour générer le pipeline. Vous pouvez les utiliser pour composer un pipeline :

Remarque

Pour utiliser le calcul serverless, ajoutez from azure.ai.ml.entities import ResourceConfiguration en haut du fichier. Remplacez ensuite :

• default_compute=cpu_compute_target avec default_compute="serverless".
• train_node.compute = gpu_compute_target avec train_node.resources = "ResourceConfiguration(instance_type="Standard_NC6s_v3",instance_count=2).

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

Le pipeline a un calcul cpu_compute_target par défaut. Si vous ne spécifiez pas de calcul pour un nœud spécifique, ce nœud s’exécute sur le calcul par défaut.

Le pipeline a une entrée de niveau pipeline, pipeline_input_data. Vous pouvez affecter une valeur à l’entrée du pipeline quand vous envoyez un travail de pipeline.

Le pipeline contient trois nœuds : prepare_data_node, train_nodeet score_node.

• input_data de prepare_data_node utilise la valeur de pipeline_input_data.

• Le input_data de train_node est la sortie training_data de prepare_data_node.

• Le input_data de score_node est la sortie test_data de prepare_data_node, et le input_model est le output_model de train_node.

• Comme train_node effectue l’apprentissage d’un modèle CNN, vous pouvez spécifier son calcul comme le gpu_compute_target. Cela peut améliorer les performances d’entraînement.

Envoyer votre travail de pipeline

Maintenant que vous avez construit le pipeline, vous pouvez envoyer le travail à votre espace de travail. Pour envoyer un travail, vous devez d’abord vous connecter à un espace de travail.

Accéder à votre espace de travail

Configurer les informations d’identification

Vous allez utiliser DefaultAzureCredential pour accéder à l’espace de travail. DefaultAzureCredential doit être capable de gérer la plupart des scénarios d’authentification du kit SDK Azure.

Si DefaultAzureCredential ne fonctionne pas pour vous, consultez cet exemple de configuration d’informations d’identification et Package d’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()

Obtenir un handle vers un espace de travail qui dispose de ressources de calcul

Créez un MLClient objet pour gérer les services Azure Machine Learning. Si vous utilisez le calcul serverless, vous n’avez pas besoin de créer ces calculs.

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

Important

Cet extrait de code s’attend à ce que le fichier JSON de configuration de l’espace de travail soit enregistré dans le répertoire actif ou son parent. Pour plus d’informations sur la création d’un espace de travail, consultez Créer des ressources d’espace de travail. Pour plus d’informations sur l’enregistrement de la configuration dans un fichier, consultez Créer un fichier de configuration d’espace de travail.

Envoyer le travail de pipeline à l’espace de travail

Maintenant que vous avez un handle vers votre espace de travail, vous pouvez envoyer votre travail de pipeline :

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

Le code précédent soumet ce travail de pipeline de classification d’images à une expérience appelée pipeline_samples. Le système crée automatiquement l'expérience si elle n'existe pas. pipeline_input_data utilise fashion_ds.

L’appel d’envoi de l’expérience se termine rapidement. Elle produit une sortie similaire à celle-ci :

Expérience	Nom	Catégorie	Statut	Page de détails
pipeline_samples	sharp_pipe_4gvqx6h1fb	canalisation	Préparation	Lien vers Azure Machine Learning studio.

Vous pouvez surveiller l’exécution du pipeline en sélectionnant le lien. Vous pouvez également le bloquer jusqu’à ce qu’il se termine en exécutant ce code :

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

Important

La première exécution du pipeline prend environ 15 minutes. Toutes les dépendances sont téléchargées, une image Docker est créée et l’environnement Python est provisionné et créé. La réexécution du pipeline prend beaucoup moins de temps, car ces ressources sont réutilisées au lieu d’être créées. Toutefois, le runtime total du pipeline dépend de la charge de travail de vos scripts et des processus qui s’exécutent à chaque étape du pipeline.

Vérifier les sorties et déboguer votre pipeline dans l’interface utilisateur

Vous pouvez ouvrir le lien Link to Azure Machine Learning studio, qui est la page détaillée du travail de votre pipeline. Vous verrez le graphique de pipeline :

Vous pouvez examiner les journaux et les résultats de chaque composant en cliquant avec le bouton droit sur le composant ou en sélectionnant le composant pour ouvrir sa fenêtre de détails. Pour en savoir plus sur la façon de déboguer votre pipeline dans l’interface utilisateur, consultez Utiliser Azure Machine Learning Studio pour déboguer des échecs de pipeline.

(Facultatif) Inscrire des composants dans l’espace de travail

Dans la section précédente, vous avez créé un pipeline à l’aide de trois composants pour effectuer une tâche de classification d’images. Vous pouvez également inscrire des composants dans votre espace de travail afin qu’ils puissent être partagés et réutilisés dans l’espace de travail. L’exemple suivant montre comment inscrire le composant de préparation des données :

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)

Vous pouvez utiliser ml_client.components.get() pour obtenir un composant inscrit par nom et version. Vous pouvez utiliser ml_client.components.create_or_update() pour inscrire un composant qui a été précédemment chargé à partir d’une fonction Python ou YAML.

Étapes suivantes

• Pour obtenir d’autres exemples de création de pipelines à l’aide du SDK Machine Learning, consultez le dépôt d’exemples.
• Pour plus d’informations sur l’utilisation de l’interface utilisateur studio pour envoyer et déboguer un pipeline, consultez Créer et exécuter des pipelines Machine Learning à l’aide de composants avec Azure Machine Learning Studio.
• Pour plus d’informations sur l’utilisation d’Azure Machine Learning CLI pour créer des composants et des pipelines, consultez Créer et exécuter des pipelines Machine Learning à l’aide de composants avec l’interface CLI Azure Machine Learning.
• Pour plus d’informations sur le déploiement de pipelines en production à l’aide de points de terminaison de traitement par lots, consultez Guide pratique pour déployer des pipelines avec des points de terminaison de lot.