Démarrage rapide : Bien démarrer avec Azure Machine Learning

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

Ce tutoriel présente certaines des fonctionnalités les plus utilisées du service Azure Machine Learning. Vous créez, inscrivez et déployez un modèle. Ce tutoriel va vous aider à vous familiariser avec les concepts fondamentaux d’Azure Machine Learning et leur utilisation la plus courante.

Vous allez apprendre à exécuter un travail d’entraînement sur une ressource de calcul évolutive, à le déployer, puis à tester le déploiement.

Vous allez créer un script d’entraînement pour gérer la préparation des données, l’entraînement et l’inscription d’un modèle. Après avoir entraîné le modèle, vous le déployez en tant que point de terminaison, puis appelez le point de terminaison pour l’inférence.

Voici les étapes à suivre :

Pour obtenir une vue d’ensemble des étapes décrites dans ce guide de démarrage rapide, regardez cette vidéo.

Prérequis

1. 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é, vous devrez peut-être ajouter des règles de trafic sortant pour autoriser l’accès aux référentiels publics de packages Python. Pour plus d’informations, consulter Scénario : accéder aux packages Machine Learning publics.

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

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

   • Si vous souhaitez copier et coller du code dans les cellules, créez un notebook.
   • Ou ouvrez tutorials/get-started-notebooks/pipeline.ipynb à partir de 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.

   

Créer un descripteur vers l’espace de travail

Avant de vous plonger dans le code, vous avez besoin d’un moyen de référencer votre 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.

Créez ml_client en tant que handle dans l’espace de travail. Utilisez 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.
3. Vous devez copier une valeur, fermer la zone et la coller. Revenez ensuite pour la valeur 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 script d’entraînement

Créez le script d’entraînement, qui est le fichier main.py Python.

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 prétraite les données et les fractionne en jeux de données de test et d’apprentissage. Il entraîne un modèle basé sur une arborescence à l’aide de ces données et retourne le modèle de sortie.

Pendant l’exécution du pipeline, utilisez MLFlow pour consigner les paramètres et les métriques.

La cellule suivante utilise la magie IPython 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_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)

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

    # pin numpy
    conda_env = {
        'name': 'mlflow-env',
        'channels': ['conda-forge'],
        'dependencies': [
            'python=3.10.15',
            'pip<=21.3.1',
            {
                'pip': [
                    'mlflow==2.17.0',
                    'cloudpickle==2.2.1',
                    'pandas==1.5.3',
                    'psutil==5.8.0',
                    'scikit-learn==1.5.2',
                    'numpy==1.26.4',
                ]
            }
        ],
    }

    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
        conda_env=conda_env,
    )

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

Lorsque le modèle est entraîné, le script enregistre et inscrit le fichier de modèle dans l’espace de travail. Vous pouvez utiliser le modèle inscrit dans des points de terminaison d’inférence.

Vous devrez peut-être sélectionner Actualiser pour afficher le nouveau dossier et le nouveau script dans vos fichiers.

Configurer la commande

Vous disposez maintenant d’un script qui peut effectuer les tâches souhaitées et un cluster de calcul pour exécuter le script. Utilisez une 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 fractionné, le taux d’apprentissage et le nom du modèle inscrit. Le script de commande :

• Utilise un environnement qui définit les bibliothèques de logiciels et d’exécution nécessaires pour le script d’entraînement. 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 allez utiliser l’un de ces environnements ici. Dans Tutoriel : Entraîner un modèle dans Azure Machine Learning, vous apprenez à créer un environnement personnalisé.
• Configure l’action de ligne de commande elle-même , python main.py dans ce cas. Les entrées et sorties sont accessibles dans la commande via la ${{ ... }} notation.
• Accède aux données à partir d’un fichier sur Internet.
• Comme vous n’avez pas spécifié de ressource de calcul, le script s’exécute sur un cluster de calcul serverless 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="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
    display_name="credit_default_prediction",
)

Envoi du travail

Envoyez le travail à exécuter dans Azure Machine Learning. Cette fois, utilisez create_or_update sur ml_client.

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 ressemble à 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 que le processus est terminé, le travail enregistre un modèle dans votre espace de travail résultant de la formation.

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

Déployez votre modèle Machine Learning en tant que service web dans le cloud Azure à l’aide d’un online endpoint.

Pour déployer un service Machine Learning, utilisez le modèle que vous avez inscrit.

Créer un point de terminaison en ligne

Maintenant que vous avez inscrit un modèle, créez votre point de terminaison en ligne. Le nom du point de terminaison doit être unique dans toute la région Azure. Pour ce tutoriel, créez 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]

Créez le point de terminaison.

# Expect the endpoint creation to take a few 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}")

Après avoir créé le point de terminaison, récupérez-le comme indiqué dans le code suivant :

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

Après avoir créé le point de terminaison, déployez le modèle à l’aide du script d’entrée. Chaque point de terminaison peut avoir plusieurs déploiements. Vous pouvez spécifier des règles pour diriger le trafic vers ces déploiements. Dans cet exemple, vous créez un déploiement unique qui gère 100% du trafic entrant. Choisissez un nom de couleur pour le déploiement, tel que bleu, vert ou rouge. Le choix est arbitraire.

Pour trouver la dernière version de votre modèle inscrit, consultez la page Modèles dans Azure Machine Learning Studio. Vous pouvez également utiliser le code suivant pour récupérer le numéro de version le plus récent.

# 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)]
)
print(f'Latest model is version "{latest_model_version}" ')

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

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

# Expect this deployment to take approximately 6 to 8 minutes.
# create an online deployment.
# if you run into an out of quota error, change the instance_type to a comparable VM that is available.
# Learn more on https://azure.microsoft.com/pricing/details/machine-learning/.
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()

Une fois le déploiement terminé, vous êtes prêt à le tester.

Tester avec un exemple de requête

Après avoir déployé le modèle sur le point de terminaison, exécutez l’inférence à l’aide du modèle.

Créez un fichier de requête d'exemple qui suit la conception attendue dans la méthode run du 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 n’avez pas besoin du point de terminaison, supprimez-le pour arrêter d’utiliser la ressource. Vérifiez qu’aucun autre déploiement n’utilise un point de terminaison avant de le supprimer.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Arrêter l’instance de calcul

Si vous n’en avez pas besoin maintenant, arrêtez l’instance de calcul :

1. Dans le studio, dans le volet gauche, sélectionnez Calcul.
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.

Étapes suivantes

Maintenant que vous avez une idée des éléments impliqués dans l’apprentissage et le déploiement d’un modèle, apprenez-en davantage sur le processus dans les tutoriels ci-dessous :