Créer et exécuter des pipelines Machine Learning à l’aide de composants avec le Kit de développement logiciel (SDK) Azure 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. Ce pipeline 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éparer les données d’entrée pour le travail de pipeline
• Créer trois composants pour préparer les données, entraîner un modèle et évaluer le modèle
• Générer un pipeline à partir des composants
• Accédez à un espace de travail disposant de ressources de calcul
• Envoyer le travail du pipeline
• Passez en revue la sortie des composants et du réseau neuronal entraîné
• (Facultatif) Inscrire 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.
• Un environnement Python avec le Kit de développement logiciel (SDK) Python Azure Machine Learning v2 installé. Pour obtenir des instructions d’installation, consultez Bien démarrer. Cet environnement est destiné à la définition et au contrôle de vos ressources Azure Machine Learning et est séparé 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’apprentissage, 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 part du principe que vous exécutez 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_mnist_convnet.ipynb dans le répertoire sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet 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.

import urllib3
import shutil
import gzip
import os
from pathlib import Path
from azure.ai.ml import Input

base_url = "https://azureopendatastorage.blob.core.windows.net/mnist/"
base_dir = Path("mnist")
if not base_dir.exists():
    base_dir.mkdir(parents=True)

c = urllib3.PoolManager()
for target_file in [
    "train-images-idx3-ubyte.gz",
    "train-labels-idx1-ubyte.gz",
    "t10k-images-idx3-ubyte.gz",
    "t10k-labels-idx1-ubyte.gz",
]:
    if (base_dir / target_file[:-3]).exists():
        continue
    with c.request("GET", base_url + target_file, preload_content=False) as resp, open(
        base_dir / target_file, "wb"
    ) as out_file:
        shutil.copyfileobj(resp, out_file)
        resp.release_conn()
    with gzip.open(base_dir / target_file, "rb") as f_in, open(
        base_dir / target_file[:-3], "wb"
    ) as f_out:
        shutil.copyfileobj(f_in, f_out)
    os.unlink(base_dir / target_file)

mnist_ds = Input(path=base_dir.as_posix())

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éparer des données pour l’entraînement et le test
• Entraîner un réseau neuronal pour la classification d’images à l’aide de données d’apprentissage
• Scorer le modèle avec des données de test

Pour chaque composant, procédez comme suit :

1. Préparer le script Python qui contient la logique d’exécution
2. Définir l’interface du composant
3. Ajouter d’autres métadonnées du composant, notamment l’environnement d’exécution et la commande pour exécuter le composant

Les sections suivantes montrent comment créer les composants de deux façons. 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 une seule spécification statique (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 le nom d'affichage Prep Data en utilisant le décorateur @command_component.

• name est l’identificateur 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 graphique.

• description décrit la tâche que le composant peut terminer

• environment spécifie l’environnement d’exécution du composant à l’aide d’un fichier conda.yaml

  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 prepare_data_component fonction 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’apprentissage et les données de test

• Le composant convertit les données input_data en fichier training_data .csv pour les données d’apprentissage et un test_data fichier .csv pour les données de test

Dans l’interface utilisateur studio, un composant apparaît comme suit :

• Bloc dans un graphique de pipeline
• input_data, training_dataet test_data sont des ports du composant, qui se connectent à d’autres composants pour le streaming 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 à l’aide d’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 placez 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 à partir de 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 à utiliser 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 avec un nom d'affichage Train Image Classification Keras à l'aide de @command_component.

La keras_train_component fonction définit :

• Une entrée, input_data, pour les données d’apprentissage source
• Une entrée, epochsqui spécifie le nombre d’époques à utiliser pendant l’entraînement
• Une sortie, output_modelqui spécifie le chemin de sortie du fichier de 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 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é en utilisant la spécification et le 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 de scoring du modèle :

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 de données d’entrée, puis génère le résultat.

Définir le composant à l’aide de 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 complet, 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 s’exécute dans le cloud, tous les fichiers de ce chemin sont 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 l’exemple de référentiel

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

Charger les composants enregistrés depuis l’espace de travail

Remarque

Pour charger des composants inscrits à partir de votre espace de travail, vous devez d’abord configurer votre connexion d’espace de travail comme décrit dans la section Obtenir l’accès à votre espace de travail . L’objet ml_client est requis pour les opérations suivantes.

Si vous avez des composants déjà inscrits dans votre espace de travail, vous pouvez les charger directement à l’aide de la ml_client.components.get() méthode. Cette approche est utile lorsque vous souhaitez réutiliser des composants qui ont été précédemment inscrits par vous ou partagés par d’autres membres de l’équipe.

# Load a registered component by name and version
registered_component = ml_client.components.get(
    name="my_registered_component", 
    version="1.0.0"
)

# Load the latest version of a registered component
latest_component = ml_client.components.get(
    name="my_registered_component"
)

Vous pouvez répertorier tous les composants disponibles dans votre espace de travail pour trouver ceux dont vous avez besoin :

# List all components in the workspace
components = ml_client.components.list()
for component in components:
    print(f"Name: {component.name}, Version: {component.version}")

Une fois chargé, vous pouvez utiliser des composants inscrits dans votre pipeline exactement comme les composants chargés à partir de fichiers locaux ou de fonctions Python.

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:

• L'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.
• Puisque train_node entraîne un modèle CNN, vous pouvez spécifier ses ressources de calcul comme gpu_compute_target pour 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 utilisez 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 à soumettre l’expérience se termine rapidement et produit une sortie similaire à celle-ci :

Expérience	Nom	Type	Statut	Page de détails
pipeline_samples	sharp_pipe_4gvqx6h1fb	pipeline	Préparation	Lien vers Azure Machine Learning Studio

Vous pouvez surveiller l’exécution du pipeline en sélectionnant le lien. Vous pouvez également attendre qu’elle 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 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 voyez le graphique du flux :

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 les sections précédentes, 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 plus d’exemples de création de pipelines à l’aide du Kit de développement logiciel (SDK) Machine Learning, consultez l’exemple de référentiel
• 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 batch, consultez Guide pratique pour déployer des pipelines avec des points de terminaison de lot