Déployer des modèles pour scoring dans des points de terminaison par lots

  • Article

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

Les points de terminaison par lots fournissent un moyen pratique de déployer des modèles pour exécuter l’inférence sur de grands volumes de données. Ils simplifient le processus d’hébergement de vos modèles pour le scoring par lots, ce qui vous permet de vous concentrer sur le machine learning, et non sur l’infrastructure. Nous appelons ce type de déploiement déploiement de modèle.

Utilisez des points de terminaison par lots pour déployer des modèles dans les cas suivants :

  • Vous disposez de modèles coûteux qui nécessitent plus de temps pour exécuter l’inférence.
  • Vous devez effectuer une inférence sur de grandes quantités de données, distribuées dans plusieurs fichiers.
  • Vous n’avez pas d’exigences de faible latence.
  • Vous pouvez tirer parti de la parallélisation.

Dans cet article, vous allez apprendre à utiliser des points de terminaison par lots pour déployer un modèle Machine Learning afin d’effectuer l’inférence.

À propos de cet exemple

Dans cet exemple, nous allons déployer un modèle afin de résoudre le problème classique de reconnaissance des chiffres du MNIST (« Modified National Institute of Standards and Technology ») pour effectuer l’inférence par lots sur de grandes quantités de données (des fichiers image). Dans la première section de ce tutoriel, nous allons créer un déploiement par lots avec un modèle créé en utilisant Torch. Ce déploiement deviendra notre déploiement par défaut dans le point de terminaison. Dans la seconde section, nous verrons comment créer un deuxième déploiement en utilisant modèle créé avec TensorFlow (Keras), le tester, puis changer le point de terminaison pour commencer à utiliser le nouveau déploiement comme déploiement défaut.

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-models/mnist-classifier

Suivre dans les notebooks Jupyter

Vous pouvez suivre cet exemple dans les notebooks suivants. Dans le dépôt cloné, ouvrez le notebook : mnist-batch.ipynb.

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 de lot 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

Se connecter à un espace de travail

Tout d’abord, nous allons nous connecter à l’espace de travail Azure Machine Learning où nous allons travailler.

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

Créer une capacité de calcul

Les points de terminaison de traitement par lots s’exécutent sur des clusters de calcul. Ils prennent en charge les clusters de calcul Azure Machine Learning (AmlCompute) ou les clusters Kubernetes. Les clusters étant une ressource partagée, un même cluster peut héberger un ou plusieurs déploiements par lots (ainsi que d’autres charges de travail si vous le souhaitez).

Cet article utilise un calcul créé ici nommé batch-cluster. Ajustez en fonction des besoins et référencez votre calcul à l’aide de azureml:<your-compute-name> ou créez-en un comme indiqué.

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

Notes

Vous n’êtes pas facturé pour le calcul à ce stade, car le cluster reste à 0 nœud jusqu’à ce qu’un point de terminaison de lot soit appelé et qu’un travail de scoring par lots soit envoyé. Apprenez-en davantage sur la gestion et l’optimisation des coûts pour AmlCompute.

Créer un point de terminaison de traitement de lots

Un point de terminaison de lot est un point de terminaison HTTPS que les clients peuvent appeler pour déclencher un travail de scoring par lots. Un travail de scoring par lots est un travail qui évalue plusieurs entrées (pour plus d’informations, consultez Que sont les points de terminaison de lot ?). Un déploiement de lot est un ensemble de ressources de calcul hébergeant le modèle qui effectue le scoring réel. Un point de terminaison de traitement de lots peut avoir plusieurs déploiements de lot.

Conseil

L’un des déploiements par lots servira de déploiement par défaut pour le point de terminaison. Le déploiement par défaut sera utilisé pour effectuer le scoring par lots réel lorsque le point de terminaison est appelé. En savoir plus sur les points de terminaison de lot et le déploiement par lots.

Étapes

  1. Choisissez le nom du point de terminaison. Le nom du point de terminaison figurera dans l’URI associé à celui-ci. De ce fait, les noms de point de terminaison de traitement par lots doivent être uniques au sein d’une région Azure. Par exemple, il ne peut y avoir qu’un seul point de terminaison de traitement par lots avec le nom mybatchendpoint dans westus2.

    En l’occurrence, nous allons placer le nom du point de terminaison dans une variable afin que nous puissions facilement le référencer ultérieurement.

    ENDPOINT_NAME="mnist-batch"

  2. Configurer votre point de terminaison de traitement par lots

    Le fichier YAML suivant définit un point de terminaison de lot, que vous pouvez inclure dans la commande CLI pour la création d’un point de terminaison de lot.

    endpoint.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: mnist-batch
description: A batch endpoint for scoring images from the MNIST dataset.
tags:
  type: deep-learning

    Le tableau suivant décrit les propriétés de clé du point de terminaison. Pour le schéma YAML du point de terminaison de lot complet, consultez la page Schéma YAML du point de terminaison de lot CLI (v2).

    Clé Description
    name Nom du point de terminaison de lot. Doit être unique au niveau de la région Azure.
    description Description du point de terminaison de traitement par lots. Cette propriété est facultative.
    tags Balises à inclure dans le point de terminaison. Cette propriété est facultative.

  3. Créez le point de terminaison :

    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-endpoint create --file endpoint.yml  --name $ENDPOINT_NAME

Créer un déploiement par lots

Un déploiement de modèle est un ensemble de ressources nécessaires pour héberger le modèle qui effectue l’inférence réelle. Pour créer un déploiement de modèle par lots, vous avez besoin de tous les éléments suivants :

  • Un modèle inscrit dans l’espace de travail.
  • Le code pour évaluer le modèle.
  • L’environnement sur lequel les dépendances du modèle sont installées.
  • Le calcul créé au préalable et les paramètres de ressource.

  1. Commençons par inscrire le modèle que nous voulons déployer. Les déploiements par lots peuvent uniquement déployer des modèles inscrits dans l’espace de travail. Vous pouvez ignorer cette étape si le modèle que vous essayez de déployer est déjà inscrit. Dans le cas présent, nous inscrivons un modèle Torch pour le problème classique de reconnaissance des chiffres (MNIST).

    Conseil

    Les modèles sont associés au déploiement plutôt qu’au point de terminaison. Cela signifie qu’un point de terminaison unique peut servir différents modèles ou différentes versions de modèle sous le même point de terminaison tant qu’ils sont déployés dans des déploiements différents.

    MODEL_NAME='mnist-classifier-torch'
az ml model create --name $MODEL_NAME --type "custom_model" --path "deployment-torch/model"

  2. Il est temps de créer un script de scoring. Les déploiements par lots nécessitent un script de scoring qui indique comment un modèle donné doit être exécuté et comment les données d’entrée doivent être traitées. Les points de terminaison Batch prennent en charge les scripts créés dans Python. Dans le cas présent, nous déployons un modèle qui lit des fichiers image représentant des chiffres et qui produit le chiffre correspondant. Le script de scoring se présente comme suit :

    Notes

    Pour les modèles MLflow, Azure Machine Learning génère automatiquement le script de scoring : vous n’êtes donc pas obligé d’en fournir un. Si votre modèle est un modèle MLflow, vous pouvez ignorer cette étape. Pour plus d’informations sur le fonctionnement des points de terminaison de traitement par lots avec les modèles MLflow, consultez le tutoriel dédié Utilisation de modèles MLflow dans les déploiements par lots.

    Avertissement

    Si vous déployez un modèle ML automatisé sous un point de terminaison par lots, notez que le script de scoring fourni par ML automatisé fonctionne seulement pour les points de terminaison en ligne et qu’il n’est pas conçu pour l’exécution par lots. Consultez Créer des scripts de scoring pour les déploiements par lots pour savoir comment en créer un en fonction de ce que fait votre modèle.

    deployment-torch/code/batch_driver.py

    import os
import pandas as pd
import torch
import torchvision
import glob
from os.path import basename
from mnist_classifier import MnistClassifier
from typing import List


def init():
    global model
    global device

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    # It is the path to the model folder
    model_path = os.environ["AZUREML_MODEL_DIR"]
    model_file = glob.glob(f"{model_path}/*/*.pt")[-1]

    model = MnistClassifier()
    model.load_state_dict(torch.load(model_file))
    model.eval()

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")


def run(mini_batch: List[str]) -> pd.DataFrame:
    print(f"Executing run method over batch of {len(mini_batch)} files.")

    results = []
    with torch.no_grad():
        for image_path in mini_batch:
            image_data = torchvision.io.read_image(image_path).float()
            batch_data = image_data.expand(1, -1, -1, -1)
            input = batch_data.to(device)

            # perform inference
            predict_logits = model(input)

            # Compute probabilities, classes and labels
            predictions = torch.nn.Softmax(dim=-1)(predict_logits)
            predicted_prob, predicted_class = torch.max(predictions, axis=-1)

            results.append(
                {
                    "file": basename(image_path),
                    "class": predicted_class.numpy()[0],
                    "probability": predicted_prob.numpy()[0],
                }
            )

    return pd.DataFrame(results)

  3. Créez un environnement dans lequel votre déploiement par lots s’exécutera. Un tel environnement doit inclure les packages azureml-core et azureml-dataset-runtime[fuse] nécessaires aux points de terminaison par lots, plus les dépendances nécessaires à l’exécution de votre code. Dans ce cas, les dépendances ont été capturées dans un conda.yaml :

    deployment-torch/environment/conda.yaml

    name: mnist-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip<22.0
  - pip:
    - torch==1.13.0
    - torchvision==0.14.0
    - pytorch-lightning
    - pandas
    - azureml-core
    - azureml-dataset-runtime[fuse]

    Important

    Les packages azureml-core et azureml-dataset-runtime[fuse] sont requis par les déploiements par lots et doivent être inclus dans les dépendances d’environnement.

    Indiquez l’environnement comme suit :

    La définition d’environnement sera incluse dans la définition de déploiement elle-même en tant qu’environnement anonyme. Vous verrez dans les lignes suivantes du déploiement :

    environment:
  name: batch-torch-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml

    Avertissement

    Les environnements organisés ne sont pas pris en charge dans les déploiements par lots. Vous devez indiquer votre propre environnement. Vous pouvez toujours utiliser l’image de base d’un environnement organisé comme la vôtre pour simplifier le processus.

  4. Créer une nouvelle définition de déploiement

    deployment-torch/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchDeployment.schema.json
name: mnist-torch-dpl
description: A deployment using Torch to solve the MNIST classification dataset.
endpoint_name: mnist-batch
type: model
model:
  name: mnist-classifier-torch
  path: model
code_configuration:
  code: code
  scoring_script: batch_driver.py
environment:
  name: batch-torch-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
compute: azureml:batch-cluster
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 10
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 30
  error_threshold: -1
  logging_level: info

    Pour le schéma YAML complet du déploiement par lots, consultez la page Schéma YAML de déploiement par lots CLI (v2).

    Clé Description
    name Le nom du déploiement.
    endpoint_name Nom du point de terminaison sous lequel créer le déploiement.
    model Modèle à utiliser pour le scoring par lots. L’exemple définit un modèle inclus à l’aide de path. Les fichiers de modèle seront automatiquement téléchargés et enregistrés avec un nom et une version générés automatiquement. Pour plus d’options, suivez le Schéma de modèle. En guise de meilleure pratique pour les scénarios de production, vous devez créer le modèle séparément et le référencer ici. Pour référencer un modèle existant, utilisez la syntaxe azureml:<model-name>:<model-version>.
    code_configuration.code Répertoire local qui contient tout le code source Python de scoring du modèle.
    code_configuration.scoring_script Fichier Python dans le répertoire ci-dessus. Ce fichier doit avoir une fonction init() et une fonction run(). Utilisez la fonction init() pour toute préparation coûteuse ou courante (par exemple, charger le modèle en mémoire). init() est appelé une seule fois au début du processus. Utilisez run(mini_batch) pour effectuer le scoring de chaque entrée. La valeur de mini_batch est une liste de chemins de fichiers. La fonction run() doit retourner un dataframe pandas ou un tableau. Chaque élément retourné indique une exécution réussie d’un élément d’entrée dans le mini_batch. Pour plus d’informations sur la création du script de scoring, consultez Compréhension du script de scoring.
    environment L’environnement pour évaluer le modèle. L’exemple définit un environnement inline à l’aide de conda_file et image. Les dépendances conda_file seront installées au-dessus de image. L’environnement sera automatiquement inscrit avec un nom et une version générés automatiquement. Pour plus d’options, suivez le schéma de l’environnement. En guise de meilleure pratique pour les scénarios de production, vous devez créer l’environnement séparément et le référencer ici. Pour référencer un environnement existant, utilisez la syntaxe azureml:<environment-name>:<environment-version>.
    compute Le calcul pour exécuter le scoring par lots. L’exemple utilise le batch-cluster créé au début et le référence en utilisant la syntaxe azureml:<compute-name>.
    resources.instance_count Nombre d’instances à utiliser pour chaque travail de scoring par lots.
    settings.max_concurrency_per_instance [Facultatif] Nombre maximal d’exécutions scoring_script parallèles par instance.
    settings.mini_batch_size [Facultatif] Nombre de fichiers qu’un scoring_script peut traiter en un appel run().
    settings.output_action [Facultatif] Mode d’organisation de la sortie dans le fichier de sortie. append_row fusionne tous les résultats de sortie run() retournés dans un seul fichier nommé output_file_name. summary_only ne fusionne pas les résultats de sortie et calcule uniquement error_threshold.
    settings.output_file_name [Facultatif] Nom du fichier de sortie de scoring par lots pour append_rowoutput_action.
    settings.retry_settings.max_retries [Facultatif] Nombre maximal de tentatives pour un échec d’un scoring_scriptrun().
    settings.retry_settings.timeout [Facultatif] Délai d’attente, en secondes, pour un scoring_scriptrun() de scoring d’un mini-lot.
    settings.error_threshold [Facultatif] Nombre d’échecs de scoring de fichier d’entrée qui doivent être ignorés. Si le nombre d’erreurs présentes dans la totalité de l’entrée dépasse cette valeur, le travail de scoring par lots va se terminer. L’exemple utilise -1, qui indique que tout nombre d’échecs est autorisé sans terminer le travail de scoring par lots.
    settings.logging_level [Facultatif] Niveau de détail des journaux. Les valeurs permettant d’augmenter le niveau de détail sont : WARNING, INFO et DEBUG.
    settings.environment_variables [Facultatif] Dictionnaire de paires nom-valeur de variable d’environnement à définir pour chaque tâche de scoring par lots.

  5. 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 --file deployment-torch/deployment.yml --endpoint-name $ENDPOINT_NAME --set-default

    Conseil

    Le paramètre --set-default définit le déploiement nouvellement créé comme déploiement par défaut du point de terminaison. C’est un moyen pratique de créer un nouveau déploiement de point de terminaison par défaut, en particulier pour la première création d’un déploiement. En guise de meilleure pratique pour les scénarios de production, vous pouvez créer un nouveau déploiement sans le définir comme valeur par défaut, puis le vérifier et mettre à jour le déploiement par défaut ultérieurement. Pour plus d’informations, consultez la section Déployer un nouveau modèle.

  6. Vérifiez les détails du point de terminaison de traitement par lots et du déploiement.

    Utilisez show pour vérifier les détails du point de terminaison et du déploiement. Pour vérifier un déploiement par lots, exécutez le code suivant :

    DEPLOYMENT_NAME="mnist-torch-dpl"
az ml batch-deployment show --name $DEPLOYMENT_NAME --endpoint-name $ENDPOINT_NAME

Exécuter des points de terminaison de lot et accéder aux résultats

L’appel d’un point de terminaison de lot déclenche un travail de scoring par lots. La tâche name est retournée à partir de la réponse à l’appel et peut être utilisée pour suivre la progression du scoring par lots. Quand vous exécutez des modèles pour le scoring dans des points de terminaison de lot, vous devez indiquer le chemin des données d’entrée où les points de terminaison doivent rechercher les données à scorer. L’exemple suivant montre comment démarrer une nouvelle tâche sur un exemple de données du jeu de données MNIST stocké dans un compte de stockage Azure.

Vous pouvez exécuter et appeler un point de terminaison de traitement par lots à l’aide d’Azure CLI, du KIT de développement logiciel (SDK) Azure Machine Learning ou de points de terminaison REST. Pour plus d’informations sur toutes les options, consultez Créer des tâches et entrer des données pour les points de terminaison de lot.

Notes

Comment fonctionne la parallélisation :

Les déploiements par lots distribuent le travail au niveau des fichiers, ce qui signifie qu’un dossier contenant 100 fichiers avec des mini-lots de 10 fichiers génère 10 lots de 10 fichiers chacun. Notez qu’il en est ainsi quelle que soit la taille des fichiers impliqués. Si vos fichiers sont trop volumineux pour être traités dans de grands mini-lots, nous vous suggérons de diviser les fichiers en fichiers plus petits pour atteindre un niveau de parallélisme plus élevé ou réduire le nombre de fichiers par mini-lot. À ce stade, le déploiement par lots ne peut pas tenir compte des asymétries dans la distribution de la taille du fichier.

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

Les points de terminaison de traitement par lots prennent en charge la lecture de fichiers ou de dossiers situés à différents emplacements. Pour en savoir plus sur les types pris en charge et sur la façon de les spécifier, consultez Accès aux données à partir de travaux de points de terminaison de traitement par lots.

Monitorer la progression de l’exécution du travail par lots

Les travaux de scoring par lots prennent généralement un certain temps pour traiter l’ensemble des entrées.

Le code suivant vérifie l’état du travail et génère un lien vers Azure Machine Learning Studio pour plus d’informations.

az ml job show -n $JOB_NAME --web

Vérifier les résultats du scoring par lots

Les sorties du travail sont stockées dans le stockage cloud : soit dans le stockage d’objets blob par défaut de l’espace de travail, soit dans le stockage que vous avez spécifié. Pour savoir comment modifier les valeurs par défaut, consultez Configurer l’emplacement de sortie. Suivez les étapes ci-dessous pour voir les résultats du scoring dans l’Explorateur Stockage Azure quand le travail est terminé :

  1. Exécutez le code suivant pour ouvrir le travail de scoring par lots dans Azure Machine Learning Studio. Le lien Studio du travail est également inclus dans la réponse de invoke, en tant que valeur de interactionEndpoints.Studio.endpoint.

    az ml job show -n $JOB_NAME --web

  2. Dans le graphique du travail, sélectionnez l’étape batchscoring.

  3. Sélectionnez l’onglet Sorties + journaux, puis sélectionnez Afficher les sorties de données.

  4. À partir des Sorties de données, sélectionnez l’icône pour ouvrir l’Explorateur Stockage.

    Capture d’écran de Studio montrant l’emplacement d’affichage des sorties de données.

    Les résultats du scoring dans l’Explorateur Stockage sont similaires à l’exemple de page suivant :

    Capture d’écran de la sortie de scoring.

Configurer l’emplacement de sortie

Les résultats de scoring par lots sont stockés par défaut dans le magasin d’objets blob par défaut de l’espace de travail, dans un dossier nommé par nom de travail (GUID généré par le système). Vous pouvez configurer l’emplacement où stocker les sorties de scoring lorsque vous appelez le point de terminaison de lot.

Utilisez output-path pour configurer n’importe quel dossier dans un magasin de données Azure Machine Learning inscrit. La syntaxe de --output-path est identique à celle de --input quand vous spécifiez un dossier, c’est-à-dire azureml://datastores/<datastore-name>/paths/<path-on-datastore>/. Utilisez --set output_file_name=<your-file-name> pour configurer un nouveau nom de fichier de sortie.

OUTPUT_FILE_NAME=predictions_`echo $RANDOM`.csv
OUTPUT_PATH="azureml://datastores/workspaceblobstore/paths/$ENDPOINT_NAME"

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --output-path $OUTPUT_PATH --set output_file_name=$OUTPUT_FILE_NAME --query name -o tsv)

Avertissement

Vous devez utiliser un emplacement de sortie unique. Si le fichier de sortie existe, le travail de scoring par lots échouera.

Important

Contrairement aux entrées, pour les sorties, seuls sont pris en charge les magasins de données Azure Machine Learning s’exécutant sur des comptes de stockage d’objets blob.

Remplacer la configuration de déploiement pour chaque travail

Certains paramètres peuvent être remplacés quand ils sont appelés pour tirer le meilleur parti des ressources de calcul et améliorer les performances. Les paramètres suivants peuvent être configurés par travail :

  • Utilisez le nombre d’instances pour remplacer le nombre d’instances à demander au cluster de calcul. Par exemple, pour un plus grand volume d’entrées de données, vous souhaiterez peut-être utiliser plus d’instances pour accélérer le scoring par lots de bout en bout.
  • Utilisez la taille de lot minimal pour remplacer le nombre de fichiers à inclure sur chaque mini-lot. Le nombre de mini-lots est déterminé par le nombre total de fichiers d’entrée et mini_batch_size. Une plus petite mini_batch_size génère plus de mini-lots. Les mini-lots peuvent être exécutés en parallèle, mais il peut y avoir des surcharges de planification et d’invocation supplémentaires.
  • D’autres paramètres peuvent être remplacés par d’autres paramètres, notamment le nombre maximal de nouvelles tentatives, le délai d’expiration et le seuil d’erreur. Ces paramètres peuvent avoir un impact sur la durée du scoring par lots de bout en bout pour différentes charges de travail.
JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --mini-batch-size 20 --instance-count 5 --query name -o tsv)

Ajout de déploiements à un point de terminaison

Une fois que vous avez un point de terminaison de traitement par lots avec un déploiement, vous pouvez continuer à affiner votre modèle et ajouter de nouveaux déploiements. Les points de terminaison de traitement par lots continuent de servir le déploiement par défaut pendant que vous développez et déployez de nouveaux modèles sous le même point de terminaison. Les déploiements ne peuvent pas s’affecter les uns les autres.

Dans cet exemple, vous allez découvrir comment ajouter un deuxième déploiement qui résout le même problème MNIST, mais en utilisant un modèle créé avec Keras et TensorFlow.

Ajout d’un deuxième déploiement

  1. Créez un environnement dans lequel votre déploiement par lots s’exécutera. Incluez dans l’environnement toute dépendance dont votre code a besoin pour s’exécuter. Vous devez également ajouter la bibliothèque azureml-core, car elle est nécessaire pour le bon fonctionnement des déploiements par lots. La définition d’environnement suivante contient les bibliothèques nécessaires pour exécuter un modèle avec TensorFlow.

    La définition d’environnement sera incluse dans la définition de déploiement elle-même en tant qu’environnement anonyme. Vous verrez dans les lignes suivantes du déploiement :

    environment:
  name: batch-tensorflow-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml

    Le fichier conda utilisé se présente comme suit :

    deployment-keras/environment/conda.yaml

    name: tensorflow-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip
  - pip:
    - pandas
    - tensorflow
    - pillow
    - azureml-core
    - azureml-dataset-runtime[fuse]

  2. Créez un script de scoring pour le modèle :

    deployment-keras/code/batch_driver.py

    import os
import numpy as np
import pandas as pd
import tensorflow as tf
from typing import List
from os.path import basename
from PIL import Image
from tensorflow.keras.models import load_model


def init():
    global model

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    model_path = os.path.join(os.environ["AZUREML_MODEL_DIR"], "model")

    # load the model
    model = load_model(model_path)


def run(mini_batch: List[str]) -> pd.DataFrame:
    print(f"Executing run method over batch of {len(mini_batch)} files.")

    results = []
    for image_path in mini_batch:
        data = Image.open(image_path)
        data = np.array(data)
        data_batch = tf.expand_dims(data, axis=0)

        # perform inference
        pred = model.predict(data_batch)

        # Compute probabilities, classes and labels
        pred_prob = tf.math.reduce_max(tf.math.softmax(pred, axis=-1)).numpy()
        pred_class = tf.math.argmax(pred, axis=-1).numpy()

        results.append(
            {
                "file": basename(image_path),
                "class": pred_class[0],
                "probability": pred_prob,
            }
        )

    return pd.DataFrame(results)

  3. Créer une nouvelle définition de déploiement

    deployment-keras/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchDeployment.schema.json
name: mnist-keras-dpl
description: A deployment using Keras with TensorFlow to solve the MNIST classification dataset.
endpoint_name: mnist-batch
type: model
model: 
  name: mnist-classifier-keras
  path: model
code_configuration:
  code: code
  scoring_script: batch_driver.py
environment:
  name: batch-tensorflow-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
compute: azureml:batch-cluster
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 10
  output_action: append_row
  output_file_name: predictions.csv

  4. 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 --file deployment-keras/deployment.yml --endpoint-name $ENDPOINT_NAME

    Conseil

    Le paramètre --set-default est manquant dans ce cas. En guise de meilleure pratique pour les scénarios de production, vous pouvez créer un nouveau déploiement sans le définir comme valeur par défaut, puis le vérifier et mettre à jour le déploiement par défaut ultérieurement.

Tester un déploiement par lots autre que celui par défaut

Pour tester le nouveau déploiement non défini par défaut, vous devez connaître le nom du déploiement que vous voulez exécuter.

DEPLOYMENT_NAME="mnist-keras-dpl"
JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --deployment-name $DEPLOYMENT_NAME --input https://azuremlexampledata.blob.core.windows.net/data/mnist/sample --input-type uri_folder --query name -o tsv)

Notez que --deployment-name est utilisé pour spécifier le déploiement que nous voulons exécuter. Ce paramètre vous permet d’effectuer invoke sur un déploiement autre que celui par défaut, et il ne met pas à jour le déploiement par défaut du point de terminaison de lot.

Mettre à jour le déploiement par lots par défaut

Bien que vous puissiez appeler un déploiement spécifique à l’intérieur d’un point de terminaison, vous voulez en général appeler le point de terminaison lui-même et le laisser décider du déploiement à utiliser. Ce déploiement s’appelle le déploiement « par défaut ». Cela vous donne la possibilité de modifier le déploiement par défaut et donc de modifier le modèle qui sert le déploiement sans modifier le contrat avec l’utilisateur appelant le point de terminaison. Utilisez l’instruction suivante pour mettre à jour le déploiement par défaut :

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

Supprimez le point de terminaison de lot et le déploiement

Si vous ne prévoyez pas d’utiliser l’ancien déploiement par lots, vous devez le supprimer en exécutant le code suivant. Utilisez --yes pour confirmer la suppression.

az ml batch-deployment delete --name mnist-torch-dpl --endpoint-name $ENDPOINT_NAME --yes

Exécutez le code suivant pour supprimer le point de terminaison de lot et tous les déploiements sous-jacents. Les travaux de scoring par lots ne seront pas supprimés.

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

Étapes suivantes