Comment rendre opérationnel un pipeline de formation avec des points de terminaison par lots

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

Dans cet article, vous allez apprendre à rendre opérationnel un pipeline d’entraînement sous un point de terminaison par lots. Le pipeline utilise plusieurs composants (ou étapes) comprenant l’entraînement du modèle, le prétraitement des données et l’évaluation du modèle.

Vous allez apprendre à :

• Créer et tester un pipeline d’entraînement
• Déployer le pipeline sur un point de terminaison par lots
• Modifier le pipeline et créer un déploiement dans le même point de terminaison
• Tester le nouveau déploiement et le définir en tant que déploiement par défaut

À propos de cet exemple

Cet exemple montre comment déployer un pipeline d’entraînement qui prend les données d’entraînement d’entrée (étiquetées) et produit un modèle prédictif, ainsi que les résultats de l’évaluation et les transformations appliquées pendant le prétraitement. Le pipeline utilisera des données tabulaires de l’ensemble de données UCI sur les maladies cardiaques pour entraîner un modèle XGBoost. Nous utilisons un composant de prétraitement des données pour prétraiter les données avant qu’elles ne soient envoyées au composant d’entraînement afin qu’elles s’adaptent au modèle et l’évaluent.

Voici une visualisation du pipeline :

L’exemple de cet article est basé sur des extraits de code contenus dans le référentiel azureml-examples. Pour exécuter les commandes localement sans avoir à copier/coller le fichier YAML et d’autres fichiers, clonez d’abord le référentiel, puis modifiez les répertoires dans le dossier :

Azure CLI

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

Python

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

Les fichiers de cet exemple se situent dans :

cd endpoints/batch/deploy-pipelines/training-with-components

Suivre avec les notebooks Jupyter

Vous pouvez suivre la version du Kit de développement logiciel (SDK) Python de cet exemple en ouvrant le notebook sdk-deploy-and-test.ipynb dans le référentiel cloné.

Prérequis

Avant de suivre les étapes décrites dans cet article, vérifiez que vous disposez des composants requis suivants :

• Un abonnement Azure. 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.

• Un espace de travail Azure Machine Learning. Si vous n’en avez pas, suivez les étapes décrites dans l’article Gérer des espaces de travail Azure Machine Learning pour en créer un.

• Vérifiez que vous disposez des autorisations suivantes dans l’espace de travail :

  • Créez ou gérez des points de terminaison et des déploiements par lots : utilisez un rôle propriétaire, contributeur ou personnalisé autorisant Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.

  • Créez des déploiements ARM dans le groupe de ressources de l’espace de travail : utilisez un rôle propriétaire, contributeur ou personnalisé autorisant Microsoft.Resources/deployments/write dans le groupe de ressources où l’espace de travail est déployé.

• Vous devez installer le logiciel suivant pour utiliser Azure Machine Learning :

  Azure CLI

  L’interface Azure CLI et l’mlextension pour Azure Machine Learning.

  az extension add -n ml
  

  Notes

  Les déploiements de composants de pipeline pour des points de terminaison Batch ont été introduits dans la version 2.7 de l’extension ml pour Azure CLI. Utilisez az extension update --name ml pour en obtenir la dernière version.

  Python

  Le kit de développement logiciel (SDK) Azure Machine Learning pour Python.

  pip install azure-ai-ml
  

  Notes

  Les classes ModelBatchDeployment et PipelineComponentBatchDeployment ont été introduites dans la version 1.7.0 du kit de développement logiciel (SDK). Utilisez pip install -U azure-ai-ml pour en obtenir la dernière version.

Se connecter à un espace de travail

L’espace de travail est la ressource de niveau supérieur pour Azure Machine Learning. Il fournit un emplacement centralisé dans lequel exploiter tous les artefacts que vous créez lorsque vous utilisez Azure Machine Learning. Dans cette section, nous allons nous connecter à l’espace de travail dans lequel vous allez effectuer des tâches de déploiement.

Azure CLI

Transmettez les valeurs de votre ID d’abonnement, de votre espace de travail, de votre emplacement et de votre groupe de ressources dans le code suivant :

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Python

1. Importez les bibliothèques nécessaires :

   from azure.ai.ml import MLClient, Input, load_component
   from azure.ai.ml.entities import BatchEndpoint, ModelBatchDeployment, ModelBatchDeploymentSettings, PipelineComponentBatchDeployment, Model, AmlCompute, Data, BatchRetrySettings, CodeConfiguration, Environment, Data
   from azure.ai.ml.constants import AssetTypes, BatchDeploymentOutputAction
   from azure.ai.ml.dsl import pipeline
   from azure.identity import DefaultAzureCredential
   

2. Configurez les détails de l’espace de travail et obtenez un descripteur de l’espace de travail :

   Transmettez les valeurs de votre ID d’abonnement, de votre espace de travail et de votre groupe de ressources dans le code suivant :

   subscription_id = "<subscription>"
   resource_group = "<resource-group>"
   workspace = "<workspace>"
   
   ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
   

Créer le composant de pipeline d’entraînement

Dans cette section, nous allons créer toutes les ressources requises pour notre pipeline d’entraînement. Nous allons commencer par créer un environnement qui inclut les bibliothèques nécessaires pour entraîner le modèle. Nous allons ensuite créer un cluster de calcul sur lequel le déploiement par lots s’exécutera, et enfin, nous enregistrerons les données d’entrée en tant que ressource de données.

Créer l’environnement

Les composants de cet exemple utilisent un environnement avec les bibliothèques XGBoost et scikit-learn. Le fichier environment/conda.yml contient la configuration de l’environnement :

environment/conda.yml

channels:
- conda-forge
dependencies:
- python=3.8.5
- pip
- pip:
  - mlflow
  - azureml-mlflow
  - datasets
  - jobtools
  - cloudpickle==1.6.0
  - dask==2023.2.0
  - scikit-learn==1.1.2
  - xgboost==1.3.3
  - pandas==1.4
name: mlflow-env

Créez l’environnement ainsi :

1. Définissez l’environnement :

   Azure CLI

   environment/xgboost-sklearn-py38.yml

   $schema: https://azuremlschemas.azureedge.net/latest/environment.schema.json
   name: xgboost-sklearn-py38
   image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
   conda_file: conda.yml
   description: An environment for models built with XGBoost and Scikit-learn.
   

   Python

   environment = Environment(
       name="xgboost-sklearn-py38",
       description="An environment for models built with XGBoost and Scikit-learn.",
       image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
       conda_file="environment/conda.yml",
   )

2. Créez l’environnement :

   Azure CLI

   az ml environment create -f environment/xgboost-sklearn-py38.yml
   

   Python

   try:
       ml_client.environments.create_or_update(environment)
   except ResourceExistsError:
       pass

Créer un cluster de calcul

Les points de terminaison et les déploiements par lots s’exécutent sur des clusters de calcul. Ils peuvent s’exécuter sur n’importe quel cluster de calcul Azure Machine Learning qui existe déjà dans l’espace de travail. Par conséquent, plusieurs déploiements par lots peuvent partager la même infrastructure de calcul. Dans cet exemple, nous allons travailler sur un cluster de calcul Azure Machine Learning appelé batch-cluster. Nous allons vérifier que le calcul existe sur l’espace de travail ou le créer dans le cas contraire.

Azure CLI

az ml compute create -n batch-cluster --type amlcompute --min-instances 0 --max-instances 5

Python

compute_name = "batch-cluster"
if not any(filter(lambda m: m.name == compute_name, ml_client.compute.list())):
    compute_cluster = AmlCompute(
        name=compute_name,
        description="Batch endpoints compute cluster",
        min_instances=0,
        max_instances=5,
    )
    ml_client.begin_create_or_update(compute_cluster).result()

Inscrire les données d’entraînement en tant que ressource de données

Nos données d’entraînement sont représentées dans des fichiers CSV. Pour imiter une charge de travail au niveau de la production, nous allons inscrire les données d’entraînement dans le fichier heart.csv en tant que ressource de données dans l’espace de travail. Cette ressource de données sera indiquée ultérieurement en tant qu’entrée dans le point de terminaison.

Azure CLI

az ml data create --name heart-classifier-train --type uri_folder --path data/train

Python

data_path = "data/train"
dataset_name = "heart-dataset-train"

heart_dataset_train = Data(
    path=data_path,
    type=AssetTypes.URI_FOLDER,
    description="A training dataset for heart classification",
    name=dataset_name,
)

Créez la ressource de données :

ml_client.data.create_or_update(heart_dataset_train)

Obtenons une référence pour la nouvelle ressource de données :

heart_dataset_train = ml_client.data.get(name=dataset_name, label="latest")

Créer le pipeline

Le pipeline que nous voulons opérationnaliser nécessite une entrée et les données d’entraînement, et produit trois sorties : le modèle entraîné, les résultats de l’évaluation et les transformations de données appliquées en tant que prétraitement. Le pipeline comprend deux composants :

• preprocess_job : cette étape lit les données d’entrée et retourne les données préparées et les transformations appliquées. L’étape reçoit trois entrées :
  • data : dossier contenant les données d’entrée à transformer et à évaluer
  • transformations : (facultatif) chemin des transformations qui seront appliquées, le cas échéant. Si le chemin d’accès n’est pas fourni, les transformations seront apprises à partir des données d’entrée. Étant donné que l’entrée transformations est facultative, le composant preprocess_job peut être utilisé pendant l’entraînement et l’évaluation.
  • categorical_encoding : stratégie d’encodage pour les fonctionnalités de catégorie (ordinal ou onehot).
• train_job : cette étape entraîne un modèle XGBoost basé sur les données préparées et retourne les résultats de l’évaluation et le modèle entraîné. L’étape reçoit trois entrées :
  • data : données prétraitées.
  • target_column : colonne que l’on souhaite prédire.
  • eval_size : indique la proportion des données d’entrée utilisées pour l’évaluation.

Azure CLI

La configuration du pipeline est définie dans le fichier deployment-ordinal/pipeline.yml :

deployment-ordinal/pipeline.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineComponent.schema.json
type: pipeline

name: uci-heart-train-pipeline
display_name: uci-heart-train
description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.

inputs:
  input_data:
    type: uri_folder

outputs: 
  model:
    type: mlflow_model
    mode: upload
  evaluation_results:
    type: uri_folder
    mode: upload
  prepare_transformations:
    type: uri_folder
    mode: upload

jobs:
  preprocess_job:
    type: command
    component: ../components/prepare/prepare.yml
    inputs:
      data: ${{parent.inputs.input_data}}
      categorical_encoding: ordinal
    outputs:
      prepared_data:
      transformations_output: ${{parent.outputs.prepare_transformations}}
  
  train_job:
    type: command
    component: ../components/train_xgb/train_xgb.yml
    inputs:
      data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
      target_column: target
      register_best_model: false
      eval_size: 0.3
    outputs:
      model: 
        mode: upload
        type: mlflow_model
        path: ${{parent.outputs.model}}
      evaluation_results:
        mode: upload
        type: uri_folder
        path: ${{parent.outputs.evaluation_results}}

Notes

Dans le fichier pipeline.yml, l’entrée transformations est manquante dans le preprocess_job. Par conséquent, le script apprend les paramètres de transformation à partir des données d’entrée.

Python

Les configurations des composants de pipeline se trouvent dans les fichiers prepare.yml et train_xgb.yml. Chargez les composants :

prepare_data = load_component(source="components/prepare/prepare.yml")
train_xgb = load_component(source="components/train_xgb/train_xgb.yml")

Construisez le pipeline :

@pipeline()
def uci_heart_classifier_trainer(input_data: Input(type=AssetTypes.URI_FOLDER)):
    prepared_data = prepare_data(data=input_data)
    trained_model = train_xgb(
        data=prepared_data.outputs.prepared_data,
        target_column="target",
        register_best_model=False,
        eval_size=0.3,
    )

    return {
        "model": trained_model.outputs.model,
        "evaluation_results": trained_model.outputs.evaluation_results,
        "transformations_output": prepared_data.outputs.transformations_output,
    }

Notes

Dans le pipeline, l’entrée transformations est manquante. Par conséquent, le script apprend les paramètres à partir des données d’entrée.

Voici une visualisation du pipeline :

Tester le pipeline

Testons le pipeline avec des exemples de données. Pour ce faire, nous allons créer un travail à l’aide du pipeline et du cluster de calcul batch-cluster créés précédemment.

Azure CLI

Le fichier pipeline-job.yml suivant contient la configuration du travail de pipeline :

deployment-ordinal/pipeline-job.yml

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

experiment_name: uci-heart-train-pipeline
display_name: uci-heart-train-job
description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.

compute: batch-cluster
component: pipeline.yml
inputs:
  input_data:
    type: uri_folder
outputs: 
  model:
    type: mlflow_model
    mode: upload
  evaluation_results:
    type: uri_folder
    mode: upload
  prepare_transformations:
    mode: upload

Python

pipeline_job = uci_heart_classifier_trainer(
    Input(type="uri_folder", path=heart_dataset_train.id)
)

À présent, nous allons configurer certains paramètres d’exécution pour exécuter le test :

pipeline_job.settings.default_datastore = "workspaceblobstore"
pipeline_job.settings.default_compute = "batch-cluster"

Créez le travail de test :

Azure CLI

az ml job create -f deployment-ordinal/pipeline-job.yml --set inputs.input_data.path=azureml:heart-classifier-train@latest

Python

pipeline_job_run = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="uci-heart-train-pipeline"
)
pipeline_job_run

Créer un point de terminaison de traitement de lots

1. Entrez un nom pour le point de terminaison. Le nom d’un point de terminaison de lot doit être unique dans chaque région, car le nom est utilisé pour construire l’URI d’appel. Pour garantir son originalité, ajoutez des caractères de fin au nom spécifié dans le code suivant.

   Azure CLI

   ENDPOINT_NAME="uci-classifier-train"
   

   Python

   endpoint_name = "uci-classifier-train"

2. Configurer le point de terminaison :

   Azure CLI

   Le fichier endpoint.yml contient la configuration du point de terminaison.

   endpoint.yml

   $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
   name: uci-classifier-train
   description: An endpoint to perform training of the Heart Disease Data Set prediction task.
   auth_mode: aad_token
   

   Python

   endpoint = BatchEndpoint(
       name=endpoint_name,
       description="An endpoint to perform training of the Heart Disease Data Set prediction task",
   )

3. Créez le point de terminaison :

   Azure CLI

   az ml batch-endpoint create --name $ENDPOINT_NAME -f endpoint.yml
   

   Python

   ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

4. Interrogez l’URI du point de terminaison :

   Azure CLI

   az ml batch-endpoint show --name $ENDPOINT_NAME
   

   Python

   endpoint = ml_client.batch_endpoints.get(name=endpoint_name)
   print(endpoint)

Déployer le composant de pipeline

Pour déployer le composant de pipeline, nous devons créer un déploiement par lots. Un déploiement est un ensemble de ressources nécessaires à l’hébergement de la ressource qui effectue le travail réel.

1. Configurez le déploiement :

   Azure CLI

   Le fichier deployment-ordinal/deployment.yml contient la configuration du déploiement. Pour obtenir des propriétés supplémentaires, vous pouvez vérifier le schéma YAML du point de terminaison de lot complet.

   deployment-ordinal/deployment.yml

   $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
   name: uci-classifier-train-xgb
   description: A sample deployment that trains an XGBoost model for the UCI dataset.
   endpoint_name: uci-classifier-train
   type: pipeline
   component: pipeline.yml
   settings:
       continue_on_step_failure: false
       default_compute: batch-cluster
   

   Python

   Notre pipeline est défini dans une fonction. Pour le transformer en composant, vous utiliserez sa propriété component. Les composants de pipeline sont des graphiques de calcul réutilisables qui peuvent être inclus dans des déploiements par lots ou utilisés pour composer des pipelines plus complexes.

   pipeline_component = ml_client.components.create_or_update(
       uci_heart_classifier_trainer().component
   )

   Nous pouvons maintenant définir le déploiement :

   deployment = PipelineComponentBatchDeployment(
       name="uci-classifier-train-xgb",
       description="A sample deployment that trains an XGBoost model for the UCI dataset.",
       endpoint_name=endpoint.name,
       component=pipeline_component,
       settings={"continue_on_step_failure": False, "default_compute": compute_name},
   )

2. Créez le déploiement :

   Azure CLI

   Exécutez le code suivant pour créer un déploiement par lots sous le point de terminaison de traitement par lots et le définir comme déploiement par défaut.

   az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-ordinal/deployment.yml --set-default
   

   Conseil

   Notez l’utilisation de l’indicateur --set-default pour indiquer que ce nouveau déploiement est désormais la valeur par défaut.

   Python

   Cette commande initie la création du déploiement et renvoie un réponse de confirmation tandis que la création du déploiement se poursuit.

   ml_client.batch_deployments.begin_create_or_update(deployment).result()

   Une fois créé, nous allons configurer ce nouveau déploiement comme déploiement par défaut :

   endpoint = ml_client.batch_endpoints.get(endpoint_name)
   endpoint.defaults.deployment_name = deployment.name
   ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

3. Votre déploiement est prêt à être utilisé.

test du déploiement

Une fois le déploiement créé, il est prêt à recevoir des travaux. Suivez ces étapes pour le tester :

1. Notre déploiement demande à ce que nous indiquions une entrée de données.

   Azure CLI

   Le fichier inputs.yml contient la définition de la ressource de données d’entrée :

   inputs.yml

   inputs:
     input_data:
       type: uri_folder
       path: azureml:heart-classifier-train@latest
   

   Python

   Définissez la ressource de données d’entrée :

   input_data = Input(type=AssetTypes.URI_FOLDER, path=heart_dataset_train.id)

   Conseil

   Pour en savoir plus sur la façon d’indiquer des entrées, consultez Créer des travaux et des données d’entrée pour les points de terminaison par lots.

2. Vous pouvez appeler le déploiement par défaut ainsi :

   Azure CLI

   JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)
   

   Python

   Conseil

   Quelle est la différence entre inputs et input lorsque vous appelez un point de terminaison ?

   En général, vous pouvez utiliser un dictionnaire inputs = {} avec la méthode invoke pour fournir un nombre arbitraire d’entrées nécessaires à un point de terminaison par lots contenant un modèle de déploiement ou un déploiement de pipelines.

   Pour un déploiement de modèle, vous pouvez utiliser input comme moyen plus court de spécifier l’emplacement des données d’entrée pour le déploiement, car un déploiement de modèle ne prend toujours qu’une seule entrée de données.

   job = ml_client.batch_endpoints.invoke(
       endpoint_name=endpoint.name, inputs={"input_data": input_data}
   )

3. Vous pouvez surveiller la progression de l’affichage et diffuser les journaux en continu à l’aide de :

   Azure CLI

   az ml job stream -n $JOB_NAME
   

   Python

   ml_client.jobs.get(job.name)

   Pour attendre la fin du travail, exécutez le code suivant :

   ml_client.jobs.stream(name=job.name)

Notez que seules les entrées du pipeline sont publiées en tant qu’entrées dans le point de terminaison par lots. Par exemple, categorical_encoding est une entrée d’une étape du pipeline, mais pas une entrée dans le pipeline lui-même. Servez-vous de cela pour contrôler les entrées que vous souhaitez exposer ou non à vos clients.

Accéder aux sorties du travail

Une fois le travail terminé, nous pouvons accéder à certaines de ses sorties. Ce pipeline produit les sorties suivantes pour ses composants :

• preprocess job : la sortie est transformations_output
• train job : les sorties sont model et evaluation_results

Vous pouvez télécharger les résultats associés à l’aide de :

Azure CLI

az ml job download --name $JOB_NAME --output-name transformations
az ml job download --name $JOB_NAME --output-name model
az ml job download --name $JOB_NAME --output-name evaluation_results

Python

ml_client.jobs.download(
    name=job.name, download_path=".", output_name="transformations_output"
)
ml_client.jobs.download(name=job.name, download_path=".", output_name="model")
ml_client.jobs.download(
    name=job.name, download_path=".", output_name="evaluation_results"
)

Créer un déploiement dans le point de terminaison

Les points de terminaison peuvent héberger plusieurs déploiements à la fois, tout en conservant un seul déploiement comme déploiement par défaut. Vous pouvez donc itérer sur vos différents modèles, déployer les différents modèles sur votre point de terminaison et les tester, et enfin, basculer le déploiement par défaut vers le déploiement de modèle qui vous convient le mieux.

Changeons la façon dont le prétraitement est effectué dans le pipeline pour voir si nous obtenons un modèle qui fonctionne mieux.

Modifier un paramètre dans le composant de prétraitement du pipeline

Le composant de prétraitement dispose d’une entrée appelée categorical_encoding, qui peut avoir des valeurs ordinal ou onehot. Ces valeurs correspondent à deux façons différentes d’encoder des caractéristiques catégorielles.

• ordinal : encode les valeurs de fonctionnalités avec des valeurs numériques (ordinales) depuis [1:n], où n est le nombre de catégories dans la fonctionnalité. L’encodage ordinal implique un ordre naturel de classement parmi les catégories de caractéristiques.
• onehot : n’implique pas de relation d’ordre naturel de classement, mais introduit un problème de dimensionnalité si le nombre de catégories est élevé.

Par défaut, nous avons précédemment utilisé ordinal. Nous allons maintenant modifier l’encodage catégoriel pour utiliser onehot et observer comment le modèle fonctionne.

Conseil

Nous aurions également pu exposer l’entrée categorial_encoding aux clients en tant qu’entrée dans le travail de pipeline lui-même. Toutefois, nous avons choisi de modifier la valeur du paramètre à l’étape de prétraitement afin de pouvoir masquer et contrôler le paramètre à l’intérieur du déploiement et tirer parti de la possibilité d’avoir plusieurs déploiements sous le même point de terminaison.

1. Modifiez le pipeline. Il se présente ainsi :

   Azure CLI

   La configuration du pipeline est définie dans le fichier deployment-onehot/pipeline.yml :

   deployment-onehot/pipeline.yml

   $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponent.schema.json
   type: pipeline
   
   name: uci-heart-train-pipeline
   display_name: uci-heart-train
   description: This pipeline demonstrates how to train a machine learning classifier over the UCI heart dataset.
   
   inputs:
     input_data:
       type: uri_folder
   
   outputs: 
     model:
       type: mlflow_model
       mode: upload
     evaluation_results:
       type: uri_folder
       mode: upload
     prepare_transformations:
       type: uri_folder
       mode: upload
   
   jobs:
     preprocess_job:
       type: command
       component: ../components/prepare/prepare.yml
       inputs:
         data: ${{parent.inputs.input_data}}
         categorical_encoding: onehot
       outputs:
         prepared_data:
         transformations_output: ${{parent.outputs.prepare_transformations}}
     
     train_job:
       type: command
       component: ../components/train_xgb/train_xgb.yml
       inputs:
         data: ${{parent.jobs.preprocess_job.outputs.prepared_data}}
         target_column: target
         eval_size: 0.3
       outputs:
         model: 
           type: mlflow_model
           path: ${{parent.outputs.model}}
         evaluation_results:
           type: uri_folder
           path: ${{parent.outputs.evaluation_results}}
   

   Python

   @pipeline()
   def uci_heart_classifier_onehot(input_data: Input(type=AssetTypes.URI_FOLDER)):
       prepared_data = prepare_data(data=input_data, categorical_encoding="onehot")
       trained_model = train_xgb(
           data=prepared_data.outputs.prepared_data,
           target_column="target",
           register_best_model=False,
           eval_size=0.3,
       )
   
       return {
           "model": trained_model.outputs.model,
           "evaluation_results": trained_model.outputs.evaluation_results,
           "transformations_output": prepared_data.outputs.transformations_output,
       }

2. Configurez le déploiement :

   Azure CLI

   Le fichier deployment-onehot/deployment.yml contient la configuration du déploiement. Pour obtenir des propriétés supplémentaires, vous pouvez vérifier le schéma YAML du point de terminaison de lot complet.

   deployment-onehot/deployment.yml

   $schema: https://azuremlschemas.azureedge.net/latest/pipelineComponentBatchDeployment.schema.json
   name: uci-classifier-train-onehot
   description: A sample deployment that trains an XGBoost model for the UCI dataset using onehot encoding for variables.
   endpoint_name: uci-classifier-train
   type: pipeline
   component: pipeline.yml
   settings:
       continue_on_step_failure: false
       default_compute: batch-cluster
   

   Python

   Notre pipeline est défini dans une fonction. Pour le transformer en composant, vous allez utiliser la méthode build(). Les composants de pipeline sont des graphiques de calcul réutilisables qui peuvent être inclus dans des déploiements par lots ou utilisés pour composer des pipelines plus complexes.

   pipeline_component = uci_heart_classifier_onehot._pipeline_builder.build()

   Nous pouvons maintenant définir le déploiement :

   deployment_onehot = PipelineComponentBatchDeployment(
       name="uci-classifier-train-onehot",
       description="A sample deployment that trains an XGBoost model for the UCI dataset with one hot encoding of categorical variables.",
       endpoint_name=endpoint.name,
       component=pipeline_component,
       settings={"continue_on_step_failure": False, "default_compute": compute_name},
   )

3. Créez le déploiement :

   Azure CLI

   Exécutez le code suivant pour créer un déploiement par lots sous le point de terminaison de traitement par lots et le définir comme déploiement par défaut.

   az ml batch-deployment create --endpoint $ENDPOINT_NAME -f deployment-onehot/deployment.yml
   

   Votre déploiement est prêt à être utilisé.

   Python

   Cette commande initie la création du déploiement et renvoie un réponse de confirmation tandis que la création du déploiement se poursuit.

   ml_client.batch_deployments.begin_create_or_update(deployment_onehot).result()

4. Votre déploiement est prêt à être utilisé.

Tester un déploiement non défini par défaut

Une fois le déploiement créé, il est prêt à recevoir des travaux. Nous pouvons le tester de la même manière qu’auparavant, mais nous allons maintenant appeler un déploiement spécifique :

1. Appelez le déploiement ainsi, en spécifiant le paramètre de déploiement pour déclencher le déploiement spécifique uci-classifier-train-onehot :

   Azure CLI

   DEPLOYMENT_NAME="uci-classifier-train-onehot"
   JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME -d $DEPLOYMENT_NAME --f inputs.yml --query name -o tsv)
   

   Python

   Conseil

   Quelle est la différence entre inputs et input lorsque vous appelez un point de terminaison ?

   En général, vous pouvez utiliser un dictionnaire inputs = {} avec la méthode invoke pour fournir un nombre arbitraire d’entrées nécessaires à un point de terminaison par lots contenant un modèle de déploiement ou un déploiement de pipelines.

   Pour un déploiement de modèle, vous pouvez utiliser input comme moyen plus court de spécifier l’emplacement des données d’entrée pour le déploiement, car un déploiement de modèle ne prend toujours qu’une seule entrée de données.

   job = ml_client.batch_endpoints.invoke(
       endpoint_name=endpoint.name,
       deployment_name=deployment_onehot.name,
       inputs={"input_data": input_data},
   )

2. Vous pouvez surveiller la progression de l’affichage et diffuser les journaux en continu à l’aide de :

   Azure CLI

   az ml job stream -n $JOB_NAME
   

   Python

   ml_client.jobs.get(name=job.name)

   Pour attendre la fin du travail, exécutez le code suivant :

   ml_client.jobs.stream(name=job.name)

Configurer le nouveau déploiement en tant que déploiement par défaut

Une fois que nous sommes satisfaits des performances du nouveau déploiement, nous pouvons définir celui-ci comme par défaut :

Azure CLI

az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

Python

endpoint = ml_client.batch_endpoints.get(endpoint_name)
endpoint.defaults.deployment_name = deployment.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

Supprimer l’ancien déploiement

Une fois que vous avez terminé, vous pouvez supprimer l’ancien déploiement si vous n’en avez plus besoin :

Azure CLI

az ml batch-deployment delete --name uci-classifier-train-xgb --endpoint-name $ENDPOINT_NAME --yes

Python

ml_client.batch_deployments.begin_delete(
    name=deployment.name, endpoint_name=endpoint.name
).result()

Nettoyer les ressources

Une fois que vous avez terminé, supprimez les ressources associées de l’espace de travail :

Azure CLI

Exécutez le code suivant pour supprimer le point de terminaison de lot et ses déploiements sous-jacents. Utilisez --yes pour confirmer la suppression.

az ml batch-endpoint delete -n $ENDPOINT_NAME --yes

Python

Supprimez le point de terminaison :

ml_client.batch_endpoints.begin_delete(endpoint_name).result()

(Facultatif) Supprimez le calcul, sauf si vous comptez réutiliser votre cluster de calcul dans des déploiements ultérieurs.

Azure CLI

az ml compute delete -n batch-cluster

Python

ml_client.compute.begin_delete(name="batch-cluster")

Étapes suivantes

• Comment déployer un pipeline pour effectuer une évaluation par lots avec prétraitement
• Créer des points de terminaison par lot à partir de travaux du pipeline
• Accès aux données à partir de travaux de points de terminaison de traitement par lots
• Résolution des problèmes de points de terminaison de traitement de lots