Tutoriel : Effectuer l’apprentissage d’un modèle dans Azure Machine Learning

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

Découvrez comment un scientifique des données utilise Azure Machine Learning pour entraîner un modèle. Dans cet exemple, vous utilisez un jeu de données de cartes de crédit pour comprendre comment utiliser Azure Machine Learning afin de résoudre un problème de classification. L’objectif est de prédire si un client a une forte probabilité d’utiliser par défaut un paiement par carte de crédit. Le script d’apprentissage gère la préparation des données. Le script effectue ensuite l’apprentissage et l’inscription d’un modèle.

Ce tutoriel vous guide tout au long des étapes permettant d’envoyer un travail d’apprentissage basé sur le cloud (travail de commande).

Si vous souhaitez en savoir plus sur le chargement de vos données dans Azure, consultez Tutoriel : Charger, accéder à et explorer vos données dans Azure Machine Learning.

Cette vidéo montre comment bien démarrer dans Azure Machine Learning studio pour pouvoir suivre les étapes du tutoriel. La vidéo montre comment créer un notebook, créer une instance de calcul et cloner le notebook. Les étapes sont également décrites dans les sections suivantes.

Prérequis

• Vous avez besoin d’un espace de travail pour utiliser Azure Machine Learning. Si vous n’en avez pas, suivez la procédure Créer les ressources nécessaires pour commencer pour créer un espace de travail et en savoir plus sur son utilisation.

  Important

  Si votre espace de travail Azure Machine Learning est configuré avec un réseau virtuel managé, il peut être nécessaire d’ajouter des règles de trafic sortant pour autoriser l’accès aux référentiels de packages Python publics. Pour plus d’informations, consultez Scénario : Accéder à des packages Machine Learning publics.

• Connectez-vous au studio et sélectionnez votre espace de travail s’il n’est pas déjà ouvert.

• Ouvrez ou créez un notebook dans votre espace de travail :

  • Si vous souhaitez copier et coller du code dans des cellules, créez un notebook.
  • Sinon, ouvrez tutorials/get-started-notebooks/train-model.ipynb dans la section Exemples de Studio. Sélectionnez ensuite Cloner pour ajouter le notebook à vos fichiers. Pour trouver des exemples de notebooks, consultez Apprendre à partir d’exemples de notebooks.

Définir votre noyau et ouvrir dans Visual Studio Code (VS Code)

1. Dans la barre supérieure au-dessus de votre notebook ouvert, créez une instance de calcul si vous n’en avez pas déjà une.

   

2. Si l’instance de calcul est arrêtée, sélectionnez Démarrer le calcul et attendez qu’elle s’exécute.

   

3. Attendez que l’instance de calcul soit en cours d’exécution. Vérifiez ensuite que le noyau, situé en haut à droite, est Python 3.10 - SDK v2. Si ce n’est pas le cas, utilisez la liste déroulante pour sélectionner ce noyau.

   

   Si vous ne voyez pas ce noyau, vérifiez que votre instance de calcul est en cours d’exécution. S’il est présent, sélectionnez le bouton Actualiser en haut à droite du notebook.

4. Si une bannière vous indique que vous devez être authentifié, sélectionnez Authentifier.

5. Vous pouvez exécuter le notebook ici, ou l’ouvrir dans VS Code pour un environnement de développement intégré (IDE) complet avec la puissance des ressources Azure Machine Learning. Sélectionnez Ouvrir dans VS Code, puis l’option web ou de bureau. Lors d’un tel lancement, VS Code est attaché à votre instance de calcul, au noyau et au système de fichiers de l’espace de travail.

   

Utiliser un travail de commande pour effectuer l’apprentissage d’un modèle dans Azure Machine Learning

Pour effectuer l’apprentissage d’un modèle, vous devez envoyer un travail. Azure Machine Learning propose différents types de travaux pour effectuer l’apprentissage des modèles. Vous pouvez sélectionner votre méthode d’apprentissage en fonction de la complexité du modèle, de la taille des données et des exigences de vitesse d’apprentissage. Dans ce tutoriel, vous découvrez comment soumettre un travail de commande pour exécuter un script d’apprentissage.

Un travail de commande est une fonction qui vous permet d’envoyer un script d’apprentissage personnalisé pour effectuer l’apprentissage de votre modèle. Ce travail peut aussi être défini en tant que travail d’apprentissage personnalisé. Un travail de commande dans Azure Machine Learning est un type de travail qui exécute un script ou une commande dans un environnement spécifique. Vous pouvez utiliser des travaux de commande pour effectuer l’apprentissage des modèles, traiter des données ou tout autre code personnalisé à exécuter dans le cloud.

Ce tutoriel met l’accent sur l’utilisation d’un travail de commande pour créer un travail d’apprentissage personnalisé que vous utilisez pour effectuer l’apprentissage d’un modèle. Un travail d’apprentissage personnalisé nécessite les éléments suivants :

• Environnement
• data
• Travail de commande
• script d’apprentissage

Ce tutoriel fournit ces éléments pour l’exemple de création d’un classifieur pour prédire les clients qui ont une forte probabilité de ne pas pouvoir couvrir leurs paiements par carte de crédit.

Créer un descripteur vers l’espace de travail

Avant de vous lancer dans la rédaction du code, il faut trouver un moyen de référencer l’espace de travail. Créez ml_client pour disposer d’un handle vers l’espace de travail. Utilisez ensuite ml_client pour gérer les ressources et les travaux.

Dans la cellule suivante, entrez votre ID d’abonnement, le nom du groupe de ressources et le nom de l’espace de travail. Pour rechercher ces valeurs :

1. Dans la barre d’outils supérieure droite d’Azure Machine Learning Studio, sélectionnez le nom de votre espace de travail.
2. Copiez la valeur de l’espace de travail, du groupe de ressources et de l’ID d’abonnement dans le code. Vous devez copier une valeur, fermer la zone et coller, puis revenir pour la suivante.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# authenticate
credential = DefaultAzureCredential()

SUBSCRIPTION="<SUBSCRIPTION_ID>"
RESOURCE_GROUP="<RESOURCE_GROUP>"
WS_NAME="<AML_WORKSPACE_NAME>"
# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id=SUBSCRIPTION,
    resource_group_name=RESOURCE_GROUP,
    workspace_name=WS_NAME,
)

# Verify that the handle works correctly.
# If you ge an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location,":", ws.resource_group)

Créer un environnement de travail

Pour exécuter votre travail Azure Machine Learning sur votre ressource de calcul, vous avez besoin d’un environnement. Un environnement liste le runtime logiciel et les bibliothèques que vous voulez installer sur la capacité de calcul où effectuer l’apprentissage. Il est similaire à l’environnement Python sur votre machine locale. Pour plus d’informations, consultez Présentation des environnements Azure Machine Learning.

Azure Machine Learning fournit de nombreux environnements organisés ou prêts à l’utilisation, qui sont utiles pour des scénarios courants d’apprentissage et d’inférence.

Dans cet exemple, vous créez un environnement conda pour vos travaux en utilisant un fichier yaml conda.

Tout d’abord, créez un répertoire dans lequel stocker le fichier.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

La cellule suivante utilise un commande magic IPython pour écrire le fichier conda dans le répertoire que vous avez créé.

%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=1.0.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - mlflow==2.8.0
    - mlflow-skinny==2.8.0
    - azureml-mlflow==1.51.0
    - psutil>=5.8,<5.9
    - tqdm>=4.59,<4.60
    - ipykernel~=6.0
    - matplotlib

La spécification contient quelques packages habituels que vous utilisez dans votre travail, comme numpy et pip.

Utilisez le fichier yaml pour créer et inscrire cet environnement personnalisé dans votre espace de travail :

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

custom_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults job",
    tags={"scikit-learn": "1.0.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
custom_job_env = ml_client.environments.create_or_update(custom_job_env)

print(
    f"Environment with name {custom_job_env.name} is registered to workspace, the environment version is {custom_job_env.version}"
)

Configurer un travail d’apprentissage à l’aide de la fonction de commande

Vous créez un travail de commande Azure Machine Learning pour effectuer l’apprentissage d’un modèle à des fins de prédiction de défaillance de crédit. Le travail de commande exécute un script d’apprentissage dans un environnement spécifié sur une ressource de calcul spécifique. Vous avez déjà créé l’environnement et le cluster de calcul. Ensuite, créez le script d’apprentissage. Dans le cas présent, nous effectuons l’apprentissage de notre jeu de données pour produire un classifieur en utilisant le modèle GradientBoostingClassifier.

Le script d’apprentissage gère la préparation des données, l’apprentissage et l’inscription du modèle entraîné. La méthode train_test_split fractionne le jeu de données en données de test et d’apprentissage. Dans ce tutoriel, vous créez un script d’apprentissage Python.

Les travaux de commande peuvent être exécutés à partir de l’interface CLI, du SDK Python ou de Studio. Dans ce tutoriel, utilisez le Kit de développement logiciel (SDK) Python Azure Machine Learning v2 pour créer et exécuter le travail de commande.

Créer un script d’entraînement

Commencez par créer le script d’apprentissage : le fichier Python main.py. Tout d’abord, créez un dossier source pour le script :

import os

train_src_dir = "./src"
os.makedirs(train_src_dir, exist_ok=True)

Ce script effectue un prétraitement des données, en les fractionnant en données de test et d’apprentissage. Il consomme ensuite ces données pour effectuer l’apprentissage d’un modèle basé sur une arborescence et retourner le modèle de sortie.

MLflow est utilisé pour consigner les paramètres et les métriques pendant le travail. Le package MLflow vous permet de faire le suivi des métriques et des résultats pour chaque modèle entraîné par Azure. Utilisez MLflow pour obtenir le meilleur modèle pour vos données. Visualisez ensuite les métriques du modèle sur le studio Azure. Pour plus d’informations, consultez MLflow et Azure Machine Learning.

%%writefile {train_src_dir}/main.py
import os
import argparse
import pandas as pd
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    args = parser.parse_args()
   
    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    ###################
    #<prepare the data>
    ###################
    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)
    
    credit_df = pd.read_csv(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    #Split train and test datasets
    train_df, test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )
    ####################
    #</prepare the data>
    ####################

    ##################
    #<train the model>
    ##################
    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))
    ###################
    #</train the model>
    ###################

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    
    # Stop Logging
    mlflow.end_run()

if __name__ == "__main__":
    main()

Dans ce script, une fois le modèle entraîné, le fichier de modèle est enregistré et inscrit auprès de l’espace de travail. L’inscription de votre modèle vous permet de stocker vos modèles dans le cloud Azure, au sein de votre espace de travail, et d’en gérer les versions. Une fois que vous avez inscrit un modèle, vous pouvez trouver tous les autres modèles inscrits à un même endroit du studio Azure, appelé registre de modèles. Le registre de modèles vous permet d’organiser et de suivre vos modèles entraînés.

Configurer la commande

Maintenant que vous disposez d’un script qui peut effectuer la tâche de classification, utilisez la commande à usage général qui peut exécuter des actions de ligne de commande. Cette action de ligne de commande peut appeler directement des commandes système ou exécuter un script.

Créez des variables d’entrée pour spécifier les données d’entrée, le ratio de fractionnement, le taux d’apprentissage et le nom du modèle inscrit. Le script de commande :

• Utilise l’environnement créé précédemment. Utilisez la notation @latest pour indiquer la dernière version de l’environnement lors de l’exécution de la commande.
• Configurez l’action de ligne de la commande elle-même, python main.py dans le cas présent. Vous pouvez accéder aux entrées et sorties de la commande en utilisant la notation ${{ ... }}.
• Comme aucune ressource de calcul n’a été spécifiée, le script est exécuté sur un cluster de calcul serverless qui est créé automatiquement.

from azure.ai.ml import command
from azure.ai.ml import Input

registered_model_name = "credit_defaults_model"

job = command(
    inputs=dict(
        data=Input(
            type="uri_file",
            path="https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
        ),
        test_train_ratio=0.2,
        learning_rate=0.25,
        registered_model_name=registered_model_name,
    ),
    code="./src/",  # location of source code
    command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
    environment="aml-scikit-learn@latest",
    display_name="credit_default_prediction",
)

Envoi du travail

Soumettez le travail à exécuter dans Azure Machine Learning studio. Cette fois, utilisez create_or_update sur ml_client. ml_client est une classe cliente qui vous permet de vous connecter à votre abonnement Azure à l’aide de Python et d’interagir avec les services Azure Machine Learning. ml_client vous permet d’envoyer vos travaux à l’aide de Python.

ml_client.create_or_update(job)

Afficher la sortie du travail et attendre l’achèvement du travail

Pour voir le travail dans Azure Machine Learning studio, sélectionnez le lien dans la sortie de la cellule précédente. La sortie de ce travail ressemble à ceci dans Azure Machine Learning studio. Explorez les onglets pour voir différents détails tels que les métriques, les sorties, etc. Une fois le travail terminé, il inscrit un modèle dans votre espace de travail comme résultat de l’apprentissage.

Quand vous exécutez la cellule, la sortie du notebook montre un lien vers la page de détails du travail dans Machine Learning studio. Vous pouvez également sélectionner Travaux dans le menu de navigation de gauche.

Une tâche est un regroupement d’un grand nombre d’exécutions d’un script ou d’un morceau de code spécifié. Les informations concernant l’exécution sont stockées sous cette tâche. La page de détails donne une vue d’ensemble du travail, la durée de son exécution, quand il a été créé et d’autres informations. La page contient également des onglets contenant d’autres informations sur le travail, comme les métriques, les sorties et les journaux et le code. Voici les onglets disponibles sur la page de détails du travail :

• Vue d’ensemble : des informations de base sur le travail, notamment son état, ses heures de début et de fin ainsi que le type de travail qui a été exécuté.
• Entrées : les données et le code qui ont été utilisés comme entrées pour le travail. Cette section peut inclure des jeux de données, des scripts, des configurations d’environnement et d’autres ressources utilisées pendant l’apprentissage.
• Sorties + journaux : les journaux générés pendant l’exécution du travail. Cet onglet vous aide à résoudre les problèmes liés à la création de votre script ou de votre modèle d’apprentissage.
• Métriques : des métriques de performances clés de votre modèle, comme le score d’apprentissage, le score f1 et le score d’exactitude.

Nettoyer les ressources

Si vous prévoyez de continuer maintenant avec d’autres tutoriels, passez à Contenu associé.

Arrêter l’instance de calcul

Si vous ne comptez pas l’utiliser maintenant, arrêtez l’instance de calcul :

1. Dans la zone de navigation gauche de Studio, sélectionnez Calculer.
2. Dans les onglets du haut, sélectionnez Instances de calcul.
3. Sélectionnez l’instance de calcul dans la liste.
4. Dans la barre d’outils supérieure, sélectionnez Arrêter.

Supprimer toutes les ressources

Si vous n’avez pas l’intention d’utiliser les ressources que vous avez créées, supprimez-les pour éviter des frais :

1. Dans la zone de recherche du Portail Azure, saisissez Groupes de ressources, puis sélectionnez-le dans les résultats.

2. Dans la liste, sélectionnez le groupe de ressources créé.

3. Dans la page Vue d’ensemble, sélectionnez Supprimer le groupe de ressources.

   

4. Entrez le nom du groupe de ressources. Puis sélectionnez Supprimer.

Contenu connexe

En savoir plus sur le déploiement d’un modèle :

Ce tutoriel utilisait un fichier de données en ligne. Pour plus d’informations sur les autres façons d’accéder aux données, consultez Tutoriel : Charger, accéder à et explorer vos données dans Azure Machine Learning.

Le ML automatisé est un outil supplémentaire qui permet de réduire le temps passé par un scientifique des données à trouver le modèle idéal pour ses données. Pour plus d’informations, consultez Présentation du Machine Learning automatisé.

Si vous souhaitez obtenir d’autres exemples similaires à ce tutoriel, consultez Apprendre avec des exemples de notebooks. Ces exemples sont disponibles dans la page des exemples de GitHub. Les exemples incluent des notebooks Python complets dont vous pouvez exécuter le code et qui vous montrent comment effectuer l’apprentissage d’un modèle. Vous pouvez modifier et exécuter des scripts existants à partir des exemples, qui contiennent des scénarios, notamment la classification, le traitement du langage naturel et la détection d’anomalie.