Tutoriel : Azure Machine Learning en un jour

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

Découvrez comment un scientifique des données utilise Azure Machine Learning pour entraîner un modèle, puis utilise le modèle pour la prédiction. Ce tutoriel vous aidera à vous familiariser avec les concepts fondamentaux d’Azure Machine Learning et leur utilisation la plus courante.

Vous allez apprendre à envoyer un travail de commande pour exécuter votre script d’entraînement sur une ressource de calcul spécifiée, configurée avec l’environnement de travail nécessaire pour exécuter le script.

Le script d’entraînement gère la préparation des données, puis entraîne et inscrit un modèle. Une fois que vous avez le modèle, vous allez le déployer en tant que point de terminaison, puis appeler le point de terminaison pour inférence.

Les étapes à suivre sont les suivantes :

• Connectez-vous à votre espace de travail Azure Machine Learning
• Créer votre ressource de calcul et votre environnement de travail
• Créer votre script d’entraînement
• Créez et exécutez votre travail de commande pour exécuter le script d’entraînement sur la ressource de calcul, configuré avec l’environnement de travail approprié
• Afficher la sortie de votre script d’entraînement
• Déployer le modèle nouvellement entraîné en tant que point de terminaison.
• Appeler le point de terminaison Azure Machine Learning pour l’inférence

Prérequis

• Suivez le guide Démarrage rapide : Bien démarrer avec Azure Machine Learning pour :

  • Créez un espace de travail.
  • Créer une instance de calcul basée sur le cloud à utiliser pour votre environnement de développement.

• Créez un notebook ou copiez-le.

  • Suivez les étapes du Guide de démarrage rapide : Exécuter le notebook Jupiter dans Azure Machine Learning studio pour créer un nouveau notebook.
  • Vous pouvez également utiliser les étapes du guide de démarrage rapide pour cloner le dossier tutoriels v2, puis ouvrir le notebook à partir du dossier tutoriels/azureml-in-a-day/azureml-in-a-day.ipynb dans votre section Fichier.

Exécuter votre notebook

1. Dans la barre supérieure, sélectionnez l’instance de calcul que vous avez créée lors du Démarrage rapide : Bien démarrer avec Azure Machine Learning à utiliser pour l’exécution du notebook.

2. Assurez-vous 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.

Important

Le reste de ce tutoriel contient des cellules du notebook du tutoriel. Copiez/collez-les dans votre nouveau notebook ou basculez vers le notebook maintenant si vous l’avez cloné.

Pour exécuter une seule cellule de code dans un notebook, cliquez sur celle-ci et appuyez sur Maj + Entrée. Sinon, exécutez l’intégralité du notebook en choisissant Run all (Tout exécuter) dans la barre d’outils supérieure.

Se connecter à l’espace de travail

Avant de plonger dans le code, vous devez vous connecter à votre espace de travail Azure Machine Learning. 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.

Nous allons utiliser DefaultAzureCredential pour accéder à l’espace de travail. DefaultAzureCredential est utilisé pour gérer la plupart des scénarios d’authentification du Kit de développement logiciel (SDK) Azure.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

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.
3. Vous devez copier une valeur, fermer la zone et coller, puis revenir pour la suivante.

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

Le résultat est un gestionnaire de l’espace de travail que vous utiliserez pour gérer d’autres ressources et travaux.

Important

La création de MLClient n’établit pas de connexion à l’espace de travail. L’initialisation du client est différée. Elle attend la première fois qu’elle doit effectuer un appel (dans le notebook ci-dessous, cela se produit lors de la création du calcul).

Créer une ressource de calcul pour exécuter votre travail

Vous aurez besoin d’une ressource de calcul pour exécuter un travail. Il peut s’agir de machines à nœud unique ou à plusieurs nœuds avec un système d’exploitation Linux ou Windows, ou d’une structure fabric de calcul spécifique comme Spark.

Vous allez provisionner un cluster de calcul Linux. Consultez la liste complète des tailles et des prix des machines virtuelles.

Pour cet exemple, vous avez seulement besoin d’un cluster de base : vous allez donc utiliser un modèle Standard_DS3_v2 avec 2 cœurs de processeurs virtuels et 7 Go de RAM, et créer un calcul Azure Machine Learning.

from azure.ai.ml.entities import AmlCompute

# Name assigned to the compute cluster
cpu_compute_target = "cpu-cluster"

try:
    # let's see if the compute target already exists
    cpu_cluster = ml_client.compute.get(cpu_compute_target)
    print(
        f"You already have a cluster named {cpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new cpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    cpu_cluster = AmlCompute(
        name=cpu_compute_target,
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_DS3_V2",
        # Minimum running nodes when there is no job running
        min_instances=0,
        # Nodes in cluster
        max_instances=4,
        # How many seconds will the node running after the job termination
        idle_time_before_scale_down=180,
        # Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
        tier="Dedicated",
    )
    print(
        f"AMLCompute with name {cpu_cluster.name} will be created, with compute size {cpu_cluster.size}"
    )
    # Now, we pass the object to MLClient's create_or_update method
    cpu_cluster = ml_client.compute.begin_create_or_update(cpu_cluster)

Créer un environnement de travail

Pour exécuter votre travail Azure Machine Learning sur votre ressource de calcul, vous aurez besoin d’un environnement. Un environnement répertorie le runtime logiciel et les bibliothèques que vous souhaitez installer sur le calcul où vous allez former. Il est similaire à votre environnement Python sur votre ordinateur local.

Azure Machine Learning fournit de nombreux environnements organisés ou prêts à l’utilisation, qui sont utiles pour les scénarios courants d’apprentissage et d’inférence. Vous pouvez également créer vos propres environnements personnalisés à l’aide d’une image Docker ou d’une configuration conda.

Dans cet exemple, vous allez créer un environnement conda pour vos travaux à l’aide d’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)

À présent, créez le fichier dans le répertoire des dépendances. La cellule ci-dessous utilise IPython magic pour écrire le fichier dans le répertoire que vous venez de créer.

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

La spécification contient certains packages habituels que vous utiliserez dans votre travail (numpy, 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"

pipeline_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults pipeline",
    tags={"scikit-learn": "0.24.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yml"),
    image="mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest",
)
pipeline_job_env = ml_client.environments.create_or_update(pipeline_job_env)

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

Qu’est-ce qu’un travail de commande ?

Vous allez créer un travail de commande Azure Machine Learning pour entraîner un modèle à des fins de prédiction de défaillance de crédit. Le travail de commande est utilisé pour exécuter un script d’entraînement dans un environnement spécifié sur une ressource de calcul spécifiée. Vous avez déjà créé l’environnement et la ressource de calcul. Ensuite, vous allez créer le script d’entraînement.

Le script d’entraînement gère la préparation des données, l’entraînement et l’inscription du modèle entraîné. Dans ce tutoriel, vous allez créer un script d’entraînement Python.

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

Après avoir exécuté le travail d’entraînement, vous allez déployer le modèle, puis l’utiliser pour produire une prédiction.

Créer un script d’entraînement

Commençons par créer le script d’entraînement : 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 gère le prétraitement des données, le fractionnant en données de test et d’apprentissage. Il consomme ensuite ces données pour entraîner un modèle basé sur une arborescence et retourner le modèle de sortie.

MLFlow sera utilisé pour consigner les paramètres et les métriques pendant l’exécution de notre pipeline.

La cellule ci-dessous utilise IPython magic pour écrire le script d’entraînement dans le répertoire que vous venez de créer.

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

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

Comme vous pouvez le voir 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. Vous pouvez maintenant utiliser le modèle inscrit dans les points de terminaison d’inférence.

Configurer la commande

Maintenant que vous disposez d’un script qui peut effectuer les tâches souhaitées, vous allez utiliser 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.

Ici, vous allez créer 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 effectue les actions suivantes :

• Utilisez le calcul créé précédemment pour exécuter cette commande.
• Utilisez l’environnement créé précédemment. Vous pouvez utiliser la notation @latest pour indiquer la dernière version de l’environnement lors de l’exécution de la commande.
• Configurez certaines métadonnées telles que le nom d’affichage, le nom de l’expérience, etc. Une expérience est un conteneur pour toutes les itérations que vous effectuez sur un certain projet. Tous les travaux soumis sous le même nom d’expérience sont listés les uns à côtés des autres dans Azure Machine Learning Studio.
• Configurez l’action de ligne de commande elle-même. python main.py, dans ce cas. Les entrées/sorties sont accessibles sur la commande au moyen de la notation ${{ ... }}.

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://archive.ics.uci.edu/ml/machine-learning-databases/00350/default%20of%20credit%20card%20clients.xls",
        ),
        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",
    compute="cpu-cluster",
    experiment_name="train_model_credit_default_prediction",
    display_name="credit_default_prediction",
)

Envoi du travail

Il est maintenant temps de soumettre le travail à exécuter dans Azure Machine Learning. Cette fois, vous allez utiliser create_or_update sur ml_client.jobs.

ml_client.create_or_update(job)

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

Affichez le travail dans Azure Machine Learning Studio en sélectionnant le lien dans la sortie de la cellule précédente.

La sortie de ce travail ressemblera à ceci dans Azure Machine Learning Studio. Explorez les onglets pour obtenir différents détails tels que les métriques, les sorties, etc. Une fois terminé, le travail inscrit un modèle dans votre espace de travail suite à l’entraînement.

Important

Attendez que l’état du travail soit terminé avant de revenir à ce notebook pour continuer. Le travail prend 2 à 3 minutes. Cela peut prendre plus de temps (jusqu’à 10 minutes) si le cluster de calcul a été mis à l’échelle jusqu’à zéro nœuds et que l’environnement personnalisé est toujours généré.

Déployer le modèle en tant que point de terminaison en ligne

Déployez maintenant votre modèle Machine Learning en tant que service web dans le cloud Azure, un online endpoint.

Pour déployer un service Machine Learning, vous avez généralement besoin des éléments suivants :

• Les ressources de modèle (fichiers, métadonnées) que vous souhaitez déployer. Vous avez déjà inscrit ces ressources dans votre travail d’entraînement.
• Du code à exécuter en tant que service. Le code exécute le modèle lors d’une requête d’entrée donnée. Ce script d’entrée reçoit les données envoyées à un service web déployé et les transmet au modèle, puis retourne la réponse du modèle au client. Le script est propre à votre modèle. Le script d'entrée doit comprendre les données que le modèle attend et renvoie. Avec un modèle MLFlow, comme dans ce tutoriel, ce script est créé automatiquement pour vous Vous trouverez ici des exemples de scripts de scoring.

Créer un point de terminaison en ligne

Maintenant que vous avez un modèle inscrit et un script d’inférence, il est temps de créer votre point de terminaison en ligne. Le nom du point de terminaison doit être unique dans toute la région Azure. Pour ce tutoriel, vous allez créer un nom unique à l’aide de UUID.

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "credit-endpoint-" + str(uuid.uuid4())[:8]

Notes

Attendez-vous à ce que la création du point de terminaison prenne environ six à huit minutes.

from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
        "model_type": "sklearn.GradientBoostingClassifier",
    },
)

endpoint = ml_client.online_endpoints.begin_create_or_update(endpoint).result()

print(f"Endpoint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Une fois que vous avez créé un point de terminaison, vous pouvez le récupérer comme suit :

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpoint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Déployer le modèle sur le point de terminaison

Une fois le point de terminaison créé, déployez le modèle avec le script d’entrée. Chaque point de terminaison peut avoir plusieurs déploiements. Le trafic direct vers ces déploiements peut être spécifié à l’aide des règles. Ici, vous allez créer un déploiement unique qui gère 100 % du trafic entrant. Nous avons choisi un nom de couleur pour le déploiement, par exemple, déploiements bleu, vert, rouge, qui est arbitraire.

Vous pouvez consulter la page Modèles dans Azure Machine Learning Studio pour identifier la dernière version de votre modèle inscrit. En guise d’alternative, le code ci-dessous récupère le numéro de la version la plus récente à utiliser.

# Let's pick the latest version of the model
latest_model_version = max(
    [int(m.version) for m in ml_client.models.list(name=registered_model_name)]
)

Déployez la dernière version du modèle.

Notes

Attendez-vous à ce que ce déploiement prenne environ six à huit minutes.

# picking the model to deploy. Here we use the latest version of our registered model
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)


# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

blue_deployment = ml_client.begin_create_or_update(blue_deployment).result()

Tester avec un exemple de requête

Maintenant que le modèle est déployé sur le point de terminaison, vous pouvez exécuter l’inférence avec celui-ci.

Créez un exemple de fichier de requête suivant la conception attendue dans la méthode d’exécution dans le script de score.

deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)

%%writefile {deploy_dir}/sample-request.json
{
  "input_data": {
    "columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
    "index": [0, 1],
    "data": [
            [20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8]
        ]
  }
}

# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./deploy/sample-request.json",
    deployment_name="blue",
)

Nettoyer les ressources

Si vous ne souhaitez pas utiliser le point de terminaison, supprimez-le pour cesser d’utiliser la ressource. Vérifiez qu’aucun autre déploiement n’utilise un point de terminaison avant de le supprimer.

Notes

Attendez-vous à ce que cette étape prenne environ six à huit minutes.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Tout supprimer

Utilisez ces étapes pour supprimer votre espace de travail Azure Machine Learning et toutes les ressources de calcul.

Important

Les ressources que vous avez créées peuvent être utilisées comme prérequis pour d’autres tutoriels d’Azure Machine Learning et des articles de procédure.

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

1. Dans le portail Azure, sélectionnez Groupes de ressources tout à gauche.

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

3. Sélectionnez Supprimer le groupe de ressources.

   

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

Étapes suivantes

• Convertissez ce tutoriel en pipeline prêt pour la production avec des composants réutilisables.
• Découvrez toutes les options de déploiement d’Azure Machine Learning.
• Découvrez comment s’authentifier auprès du modèle déployé.