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 :

A screenshot of the pipeline showing the preprocessing and training components.

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 :

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

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 Comment gérer des espaces de travail pour en créer un.

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

    • Créer et gérer des points de terminaison par lots et des déploiements : utilisez le rôle Propriétaire, Contributeur ou un rôle personnalisé autorisant Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.

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

  • Vous devez installer les logiciels suivants pour utiliser Azure Machine Learning :

    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.

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.

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>

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==2.30.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 :

    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.
    
  2. Créez l’environnement :

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

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.

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

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.

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

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.

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.

Voici une visualisation du pipeline :

An image of the pipeline showing the job input, pipeline components, and the outputs at each step of the 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.

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

Créez le travail de test :

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

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.

    ENDPOINT_NAME="uci-classifier-train"
    
  2. Configurer le point de terminaison :

    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
    
  3. Créez le point de terminaison :

    az ml batch-endpoint create --name $ENDPOINT_NAME -f endpoint.yml
    
  4. Interrogez l’URI du point de terminaison :

    az ml batch-endpoint show --name $ENDPOINT_NAME
    

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 :

    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
    
  2. Créez le déploiement :

    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.

  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.

    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
    

    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 :

    JOB_NAME=$(az ml batch-endpoint invoke -n $ENDPOINT_NAME --f inputs.yml --query name -o tsv)
    
  3. Vous pouvez surveiller la progression de l’affichage et diffuser les journaux en continu à l’aide de :

    az ml job stream -n $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 :

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

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 :

    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}}
    
  2. Configurez le déploiement :

    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
    
  3. Créez le déploiement :

    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é.

  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 :

    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)
    
  2. Vous pouvez surveiller la progression de l’affichage et diffuser les journaux en continu à l’aide de :

    az ml job stream -n $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 :

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

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 :

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

Nettoyer les ressources

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

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

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

az ml compute delete -n batch-cluster

Étapes suivantes