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

Article
09/03/2024

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

Les points de terminaison de traitement par lots offrent un moyen pratique de déployer des modèles qui exécutent l’inférence sur de grands volumes de données. Ces points de terminaison simplifient le processus d’hébergement de vos modèles pour le scoring par lots. Ainsi, vous pouvez vous concentrer sur le Machine Learning plutôt que sur l’infrastructure.

Utilisez des points de terminaison de traitement par lots pour le déploiement de 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 utilisez un point de terminaison de traitement par lots pour déployer un modèle Machine Learning qui résout le problème classique de reconnaissance des chiffres du MNIST (Modified National Institute of Standards and Technology). Votre modèle déployé effectue ensuite une inférence par lots sur de grandes quantités de données, dans le cas présent, des fichiers image. Vous commencez par créer un déploiement par lots d’un modèle conçu à l’aide de Torch. Ce déploiement devient le déploiement par défaut du point de terminaison. Plus tard, vous allez créer un deuxième déploiement d’un modèle conçu avec TensorFlow (Keras), tester le deuxième déploiement, puis le définir en tant que déploiement par défaut du point de terminaison.

Pour accéder aux exemples de code et aux fichiers nécessaires à l’exécution locale des commandes de cet article, consultez la section Cloner le référentiel d’exemples. Les exemples de code et les fichiers sont contenus dans le référentiel azureml-examples.

Prérequis

Pour pouvoir suivre les étapes décrites dans cet article, vérifiez que vous disposez des pré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.
Pour effectuer les tâches suivantes, vérifiez que vous disposez des autorisations suivantes dans l’espace de travail :
- Pour créer/gérer des points de terminaison et des déploiements par lots : utilisez un rôle de propriétaire, un rôle de contributeur ou un rôle personnalisé autorisant Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
- Pour créer des déploiements ARM dans le groupe de ressources de l’espace de travail : utilisez un rôle de propriétaire, un rôle de 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 :
- Azure CLI
- Python
- Studio
S’APPLIQUE À : Extension ml Azure CLI v2 (actuelle)

Azure CLI et l’extension ml pour Azure Machine Learning.
```
az extension add -n ml
```
S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

Installez le kit de développement logiciel (SDK) Azure Machine Learning pour Python.
```
pip install azure-ai-ml
```
Il n’y a pas d’autres exigences si vous envisagez d’utiliser Azure Machine Learning studio.

Cloner le référentiel d’exemples

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

!git clone https://github.com/Azure/azureml-examples --depth 1
!cd azureml-examples/sdk/python/endpoints/batch/deploy-models/mnist-classifier

Pour accéder à cet exemple dans un notebook Jupyter Notebook, dans le référentiel cloné, ouvrez le notebook : mnist-batch.ipynb.

Préparer votre système

Se connecter à un espace de travail

Connectez-vous d'abord à l'espace de travail Azure Machine Learning dans lequel vous allez travailler.

Si vous n’avez pas encore défini les paramètres par défaut pour l’interface CLI Azure, enregistrez vos paramètres par défaut. Pour éviter de passer les valeurs liées à votre abonnement, votre espace de travail, votre groupe de ressources et votre emplacement, exécutez ce code :

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

L’espace de travail est la ressource de niveau supérieur pour Azure Machine Learning. Il fournit un emplacement centralisé dans lequel exploiter tous les artefacts que vous créez lorsque vous utilisez Azure Machine Learning. Dans cette section, vous vous connectez à l’espace de travail dans lequel vous allez effectuer les tâches de déploiement.

Importez les bibliothèques nécessaires :

from azure.ai.ml import MLClient, Input, load_component
from azure.ai.ml.entities import BatchEndpoint, ModelBatchDeployment, ModelBatchDeploymentSettings, PipelineComponentBatchDeployment, Model, AmlCompute, Data, BatchRetrySettings, CodeConfiguration, Environment, Data
from azure.ai.ml.constants import AssetTypes, BatchDeploymentOutputAction
from azure.ai.ml.dsl import pipeline
from azure.identity import DefaultAzureCredential

Notes

Les classes ModelBatchDeployment et PipelineComponentBatchDeployment ont été introduites dans la version 1.7.0 du SDK.

Configurez les détails de l’espace de travail et obtenez un handle pour l’espace de travail :

subscription_id = "<subscription>"
resource_group = "<resource-group>"
workspace = "<workspace>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

Créer une capacité de calcul

Les points de terminaison de traitement par lots s’exécutent sur des clusters de calcul, et prennent en charge à la fois les clusters de calcul Azure Machine Learning (AmlCompute) et les clusters Kubernetes. Les clusters sont une ressource partagée. Un même cluster peut donc héberger un ou plusieurs déploiements par lots (avec d’autres charges de travail, le cas échéant).

Créez un calcul nommé batch-cluster, comme indiqué dans le code suivant. Vous pouvez effectuer des ajustements selon les besoins, et référencer votre calcul en utilisant azureml:<your-compute-name>.

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

compute_name = "batch-cluster"
if not any(filter(lambda m: m.name == compute_name, ml_client.compute.list())):
    compute_cluster = AmlCompute(
        name=compute_name,
        description="CPU cluster compute",
        min_instances=0,
        max_instances=2,
    )
    ml_client.compute.begin_create_or_update(compute_cluster).result()

Remarque

Le calcul ne vous est pas facturé à ce stade, car le cluster reste à 0 nœud jusqu’à ce qu’un point de terminaison de traitement par lots soit appelé, et qu’un travail de scoring par lots soit envoyé. Pour plus d’informations sur les coûts de calcul, consultez Gérer et optimiser les coûts pour AmlCompute.

Créer un point de terminaison de traitement de lots

Un point de terminaison de traitement par lots 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 effectue le scoring de plusieurs entrées. Un déploiement par lots est un ensemble de ressources de calcul hébergeant le modèle qui effectue le scoring par lots (ou l’inférence par lots). Un point de terminaison de traitement de lots peut avoir plusieurs déploiements de lot. Pour plus d’informations sur les points de terminaison de traitement par lots, consultez Que sont les points de terminaison de traitement de lots ?.

Conseil

L’un des déploiements par lots sert de déploiement par défaut pour le point de terminaison. Quand le point de terminaison est appelé, le déploiement par défaut effectue le scoring par lots. Pour plus d’informations sur les points de terminaison de traitement par lots et les déploiements par lots, consultez Points de terminaison de traitement par lots et déploiement par lots.

Nommez le point de terminaison. Le nom du point de terminaison doit être unique au sein d’une région Azure, car le nom est inclus dans l’URI du point de terminaison. Par exemple, il ne peut y avoir qu’un seul point de terminaison de traitement par lots avec le nom mybatchendpoint dans westus2.
- Azure CLI
- Python
- Studio
Placez le nom du point de terminaison dans une variable pour pouvoir le référencer facilement plus tard.
```
ENDPOINT_NAME="mnist-batch"
```
Placez le nom du point de terminaison dans une variable pour pouvoir le référencer facilement plus tard.
```
endpoint_name = "mnist-batch"
```
Vous fournissez le nom du point de terminaison plus tard, au moment de la création du déploiement.

Configurer le point de terminaison de traitement par lots

Le fichier YAML suivant définit un point de terminaison de lot. Vous pouvez utiliser ce fichier avec la commande CLI pour la création du point de terminaison de traitement par lots.

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.

endpoint = BatchEndpoint(
    name=endpoint_name,
    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 plus d’informations sur la définition du point de terminaison de traitement par lots, consultez BatchEndpoint, classe.

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.

Créez le point de terminaison :
- Azure CLI
- Python
- Studio
Exécutez le code suivant pour créer un point de terminaison de traitement par lots.
```
az ml batch-endpoint create --file endpoint.yml  --name $ENDPOINT_NAME
```
```
ml_client.begin_create_or_update(endpoint).result()
```
Vous créez le point de terminaison plus tard, au moment où vous créez le déploiement.

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 des éléments suivants :

Un modèle inscrit dans l’espace de travail
Le code permettant d’effectuer un scoring du modèle
Un environnement dans lequel les dépendances du modèle sont installées
Le calcul créé au préalable et les paramètres de ressource

Commencez par inscrire le modèle à déployer : un modèle Torch pour le célèbre problème de reconnaissance de chiffres (MNIST). 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 à déployer est déjà inscrit.

Conseil

Les modèles sont associés au déploiement plutôt qu’au point de terminaison. Cela signifie qu’un même point de terminaison peut mettre à disposition différents modèles (ou différentes versions de modèle), à condition que les différents modèles (ou différentes versions de modèle) soient déployés dans des déploiements distincts.
- Azure CLI
- Python
- Studio
```
MODEL_NAME='mnist-classifier-torch'
az ml model create --name $MODEL_NAME --type "custom_model" --path "deployment-torch/model"
```
```
model_name = "mnist-classifier-torch"
model_local_path = "deployment-torch/model/"

model = ml_client.models.create_or_update(
    Model(
        name=model_name,
        path=model_local_path,
        type=AssetTypes.CUSTOM_MODEL,
        tags={"task": "classification", "framework": "torch"},
    )
)
```
1. Accédez à l’onglet Modèles dans le menu latéral.
2. Sélectionnez Inscrire>À partir de fichiers locaux.
3. Dans l’Assistant, pour l’option Type de modèle, conservez la valeur Type non spécifié.
4. Sélectionnez Parcourir>Parcourir le dossier> sélectionnez le dossier deployment-torch/model>Suivant.
5. Configurez le nom du modèle : mnist-classifier-torch. Vous pouvez laisser le reste des champs tels qu’ils sont.
6. Sélectionnez Inscription.

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 de traitement par lots prennent en charge les scripts créés en Python. Dans le cas présent, vous déployez un modèle qui lit des fichiers image représentant des chiffres, et génère 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 l’article Utilisation de modèles MLflow dans les déploiements par lots.

Avertissement

Si vous déployez un modèle AutoML (Machine Learning automatisé) sous un point de terminaison de traitement par lots, notez que le script de scoring fourni par AutoML fonctionne uniquement pour les points de terminaison en ligne, et qu’il n’est pas conçu pour l’exécution par lots. Pour plus d’informations sur la création d’un script de scoring pour votre déploiement par lots, consultez Créer des scripts de scoring pour les déploiements par lots.

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)

Créez un environnement dans lequel votre déploiement par lots s’exécutera. L’environnement doit inclure les packages azureml-core et azureml-dataset-runtime[fuse], nécessaires aux points de terminaison de traitement par lots ainsi que les dépendances nécessaires à l’exécution de votre code. Dans le cas présent, les dépendances ont été capturées dans un fichier 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.

Spécifiez l’environnement de la façon suivante :
- Azure CLI
- Python
- Studio
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
```
Obtenez une référence à l’environnement :
```
env = Environment(
    name="batch-torch-py38",
    conda_file="deployment-torch/environment/conda.yaml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
```
Dans Azure Machine Learning studio, suivez ces étapes :
1. Accédez à l’onglet Environnements dans le menu latéral.
2. Sélectionnez l’onglet Créer des environnements>Créer.
3. Entrez le nom de l’environnement, en l’occurrence torch-batch-env.
4. Pour Sélectionner une source d’environnement, sélectionnez Utiliser une image Docker existante avec un fichier Conda facultatif.
5. Pour Chemin de l’image de registre de conteneurs, entrez mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.
6. Sélectionnez Suivant pour accéder à la section « Personnaliser ».
7. Copiez le contenu du fichier deployment-torch/environment/conda.yaml du dépôt GitHub vers le portail.
8. Sélectionnez Suivant jusqu’à ce que vous arriviez à la « page Vérifier ».
9. Sélectionnez Créer, puis attendez que l’environnement soit prêt à être utilisé.
Avertissement

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

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

deployment-torch/deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.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

Le tableau suivant décrit les propriétés clés du déploiement par lots. 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`. Cette définition permet de charger et d’inscrire automatiquement les fichiers de modèles avec un nom et une version générés automatiquement. Pour plus d’options, consultez 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 `code_configuration.code`. 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()` n’est appelé qu’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 d’un 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, consultez le Schéma d’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 à l’aide de la syntaxe`azureml:<compute-name>`.
`resources.instance_count`	Nombre d’instances à utiliser pour chaque travail de scoring par lots.
`settings.max_concurrency_per_instance`	Nombre maximal d’exécutions `scoring_script` parallèles par instance.
`settings.mini_batch_size`	Nombre de fichiers qu’un `scoring_script` peut traiter en un appel `run()`.
`settings.output_action`	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`	Nom du fichier de sortie de scoring par lots pour `append_row` `output_action`.
`settings.retry_settings.max_retries`	Nombre maximal de tentatives pour un échec d’un `scoring_script` `run()`.
`settings.retry_settings.timeout`	Délai d’attente, en secondes, pour un `scoring_script` `run()` pour le scoring d’un mini-lot.
`settings.error_threshold`	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`	Verbosité du journal. Les valeurs permettant d’augmenter le niveau de détail sont : WARNING, INFO et DEBUG.
`settings.environment_variables`	Dictionnaire de paires nom-valeur de variable d’environnement à définir pour chaque travail de scoring par lots.

deployment = ModelBatchDeployment(
    name="mnist-torch-dpl",
    description="A deployment using Torch to solve the MNIST classification dataset.",
    endpoint_name=endpoint_name,
    model=model,
    code_configuration=CodeConfiguration(
        code="deployment-torch/code/", scoring_script="batch_driver.py"
    ),
    environment=env,
    compute=compute_name,
    settings=ModelBatchDeploymentSettings(
        max_concurrency_per_instance=2,
        mini_batch_size=10,
        instance_count=2,
        output_action=BatchDeploymentOutputAction.APPEND_ROW,
        output_file_name="predictions.csv",
        retry_settings=BatchRetrySettings(max_retries=3, timeout=30),
        logging_level="info",
    ),
)

La classe BatchDeployment vous permet de configurer les propriétés clés suivantes d’un déploiement par lots :

Clé	Description
`name`	Nom du déploiement.
`endpoint_name`	Nom du point de terminaison sous lequel créer le déploiement.
`model`	Modèle à utiliser pour le déploiement. Cette valeur peut être une référence à un modèle versionné existant dans l’espace de travail ou une spécification de modèle inline.
`environment`	Environnement à utiliser pour le déploiement. Cette valeur peut être une référence à un environnement versionné existant dans l’espace de travail ou une spécification d’environnement inline (facultatif pour les modèles MLflow).
`code_configuration`	Configuration de l’exécution de l’inférence pour le modèle (facultatif pour les modèles MLflow).
`code_configuration.code`	Chemin d’accès du répertoire du code source pour le scoring du modèle.
`code_configuration.scoring_script`	Chemin relatif au fichier de scoring dans le répertoire de code source.
`compute`	Nom de la cible de calcul sur laquelle exécuter les travaux de scoring par lots.
`instance_count`	Nombre de nœuds à utiliser pour chaque travail de scoring par lots.
`settings`	Configuration de l’inférence du déploiement de modèle.
`settings.max_concurrency_per_instance`	Nombre maximal d’exécutions `scoring_script` parallèles par instance.
`settings.mini_batch_size`	Nombre de fichiers que `code_configuration.scoring_script` peut traiter en un seul appel de `run`().
`settings.retry_settings`	Paramètres de nouvelle tentative pour le scoring de chaque mini-lot.
`settings.retry_settingsmax_retries`	Nombre maximal de nouvelles tentatives pour un mini-lot ayant échoué ou dépassé le délai d’expiration (3 nouvelles tentatives par défaut).
`settings.retry_settingstimeout`	Délai d’expiration en secondes pour le scoring d’un mini-lot (30 secondes par défaut).
`settings.output_action`	Mode d’organisation de la sortie dans le fichier de sortie. Valeurs autorisées : `append_row` ou `summary_only`. La valeur par défaut est `append_row`.
`settings.logging_level`	Niveau de verbosité du journal. Les valeurs autorisées sont `warning`, `info` et `debug`. La valeur par défaut est `info`.
`settings.environment_variables`	Dictionnaire de paires nom-valeur de variable d’environnement à définir pour chaque travail de scoring par lots.

Dans le studio, suivez ces étapes :

Accédez à l’onglet Points de terminaison dans le menu latéral.
Sélectionnez l’onglet Points de terminaison de traitement par lots>Créer.
Donnez un nom au point de terminaison, en l’occurrence mnist-batch. Vous pouvez configurer le reste des champs ou les laisser vides.
Sélectionnez Suivant pour accéder à la section « Modèle ».
Sélectionnez le modèle mnist-classifier-torch.
Sélectionnez Suivant pour accéder à la page « Déploiement ».
Donnez un nom au déploiement.
Pour Action de sortie, vérifiez que l’option Ajouter une ligne est sélectionnée.
Pour Nom du fichier de sortie, vérifiez que le fichier de sortie de scoring par lots est celui dont vous avez besoin. La valeur par défaut est predictions.csv.
Pour Taille minimale de lot, ajustez la taille des fichiers à inclure dans chaque mini-lot. Cette taille contrôle la quantité de données que votre script de scoring reçoit par lot.
Pour Délai d’expiration du scoring (en secondes), vérifiez que vous laissez suffisamment de temps à votre déploiement pour effectuer le scoring d’un lot de fichiers donné. Si vous augmentez le nombre de fichiers, vous devez généralement augmenter la valeur du délai d’expiration. Les modèles plus coûteux (comme ceux basés sur le deep learning) peuvent nécessiter des valeurs élevées dans ce champ.
Pour Concurrence maximale par instance, configurez le nombre d’exécuteurs à avoir pour chaque instance de calcul que vous obtenez dans le déploiement. Un nombre plus élevé garantit un degré de parallélisation plus élevé, mais il augmente également la sollicitation de la mémoire sur l’instance de calcul. Ajustez cette valeur conjointement avec Taille minimale de lot.
Une fois l’opération effectuée, sélectionnez Suivant pour accéder à la page « Code + environnement ».
Pour « Sélectionner un script de scoring pour l’inférence », recherchez et sélectionnez le fichier de script de scoring deployment-torch/code/batch_driver.py.
Dans la section « Sélectionner un environnement », sélectionnez l’environnement que vous avez créé torch-batch-env.
Sélectionnez Suivant pour passer à la page « Calcul ».
Sélectionnez le cluster de calcul que vous avez créé à une étape précédente.

Avertissement

Les clusters Azure Kubernetes sont pris en charge dans les déploiements par lots, mais uniquement quand ils sont créés avec Azure Machine Learning CLI ou le SDK Python.
Pour Nombre d’instances, entrez le nombre d’instances de calcul souhaitées pour le déploiement. Dans le cas présent, utilisez 2.
Cliquez sur Suivant.

Créez le déploiement :
- Azure CLI
- Python
- Studio
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 en tant que 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. Conformément aux meilleures pratiques dans les scénarios de production, vous pouvez être amené à créer un déploiement sans le définir en tant que déploiement par défaut. Vérifiez que le déploiement fonctionne comme prévu, puis mettez-le à jour plus tard en tant que déploiement par défaut. Pour plus d’informations sur l’implémentation de ce processus, consultez la section Déployer un nouveau modèle.
En utilisant le MLClient créé plus tôt, créez le déploiement dans l’espace de travail. Cette commande lance la création du déploiement et retourne une réponse de confirmation pendant que la création du déploiement se poursuit.
```
ml_client.begin_create_or_update(deployment).result()
```
Une fois le déploiement effectué, définissez le nouveau déploiement en tant que déploiement par défaut dans le point de terminaison :
```
endpoint = ml_client.batch_endpoints.get(endpoint_name)
endpoint.defaults.deployment_name = deployment.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()
```
Dans l’Assistant, cliquez sur Créer pour démarrer le processus de déploiement.
Vérifiez les détails du point de terminaison de traitement par lots et du déploiement.
- Azure CLI
- Python
- Studio
Utilisez show pour vérifier les détails relatifs au point de terminaison et au 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
```
Pour vérifier un déploiement par lots, exécutez le code suivant :
```
ml_client.batch_deployments.get(name=deployment.name, endpoint_name=endpoint.name)
```
Une fois le point de terminaison de traitement par lots créé, la page des détails du point de terminaison s’ouvre. Vous pouvez également trouver cette page en suivant ces étapes :
1. Accédez à l’onglet Points de terminaison dans le menu latéral.
2. Sélectionnez l’onglet Points de terminaison de traitement par lots.
3. Sélectionnez le point de terminaison de traitement par lots à visualiser.
4. La page Détails du point de terminaison affiche les détails du point de terminaison ainsi que tous les déploiements disponibles dans le point de terminaison.

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. Le travail name est retourné à partir de la réponse à l’appel, et peut être utilisé pour suivre la progression du scoring par lots. Quand vous exécutez des modèles à des fins de scoring dans les points de terminaison de traitement par lots, vous devez spécifier le chemin d’accès des données d’entrée pour permettre aux points de terminaison de trouver les données devant faire l’objet d’un scoring. 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 ces options, consultez Créer des travaux et des données d’entrée pour les points de terminaison de lot.

Remarque

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 que cela se produit 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 les fractionner en fichiers plus petits pour atteindre un niveau de parallélisme plus élevé, ou de réduire le nombre de fichiers par mini-lot. Pour le moment, les déploiements par lots ne peuvent pas gérer les asymétries dans la distribution des tailles de 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)

Conseil

Quelle est la différence entre les paramètres inputs et input lorsque vous appelez un point de terminaison ?

En général, vous pouvez utiliser un paramètre inputs = {} de dictionnaire avec la méthode invoke pour fournir un nombre arbitraire d’entrées nécessaires à un point de terminaison de lot qui contient un déploiement de modèle ou un déploiement de pipeline.

Pour un déploiement de modèle, vous pouvez utiliser le paramètre input comme moyen plus court pour spécifier l’emplacement des données d’entrée pour le déploiement. Cette approche fonctionne, car un déploiement de modèle ne prend toujours qu’une seule entrée de données.

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment.name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/",
        type=AssetTypes.URI_FOLDER,
    ),
)

Accédez à l’onglet Points de terminaison dans le menu latéral.
Sélectionnez l’onglet Points de terminaison de traitement par lots.
Sélectionnez le point de terminaison de traitement par lots que vous venez de créer.
Sélectionnez Créer un travail.
Pour Déploiement, sélectionnez le déploiement à exécuter.
Sélectionnez Suivant pour accéder à la page « Sélectionner la source de données ».
Pour « Type de source de données », sélectionnez Magasin de données.
Pour « Magasin de données », dans le menu déroulant, sélectionnez workspaceblobstore.
Pour « Chemin d’accès », entrez l’URL complète https://azuremlexampledata.blob.core.windows.net/data/mnist/sample.

Conseil

Ce chemin d’accès fonctionne uniquement dans la mesure où l’accès public est activé pour celui-ci. En règle générale, vous devez inscrire la source de données en tant que Magasin de données. Consultez Accès aux données à partir de travaux de points de terminaison de traitement par lots pour plus de détails.
Cliquez sur Suivant.
Sélectionnez Créer pour démarrer le travail.

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

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

ml_client.jobs.get(job.name)

Vérifier les résultats du scoring par lots

Les sorties du travail sont stockées dans le stockage cloud, soit dans l’instance par défaut du service Stockage Blob de l’espace de travail, soit dans le stockage que vous avez spécifié. Pour savoir comment changer les valeurs par défaut, consultez Configurer l’emplacement de sortie. Les étapes suivantes vous permettent de voir les résultats du scoring dans l’Explorateur Stockage Azure, une fois le travail effectué :

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
```
Dans le graphique du travail, sélectionnez l’étape batchscoring.
Sélectionnez l’onglet Sorties + journaux, puis sélectionnez Afficher les sorties de données.
À partir des Sorties de données, sélectionnez l’icône pour ouvrir l’Explorateur Stockage.

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

Configurer l’emplacement de sortie

Par défaut, les résultats de scoring par lots sont stockés dans le magasin d’objets blob par défaut de l’espace de travail, dans un dossier nommé en fonction du 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)

Utilisez params_override pour configurer n’importe quel dossier dans un magasin de données Azure Machine Learning inscrit. Seuls les magasins de données inscrits sont pris en charge en tant que chemins de sortie. Dans cet exemple, vous utilisez le magasin de données par défaut :

batch_ds = ml_client.datastores.get_default()

Une fois que vous avez identifié le magasin de données à utiliser, configurez la sortie comme suit :

filename = f"predictions-{random.randint(0,99999)}.csv"

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/",
        type=AssetTypes.URI_FOLDER,
    ),
    params_override=[
        {"output_dataset.datastore_id": f"azureml:{batch_ds.id}"},
        {"output_dataset.path": f"/{endpoint_name}/"},
        {"output_file_name": filename},
    ],
)

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, les sorties peuvent être stockées uniquement dans les magasins de données Azure Machine Learning qui s’exécutent sur des comptes Stockage Blob.

Remplacer la configuration de déploiement pour chaque travail

Quand vous appelez un point de terminaison de traitement par lots, vous pouvez remplacer certains paramètres pour optimiser l’utilisation des ressources de calcul et améliorer les performances. Les paramètres suivants peuvent être configurés en fonction du travail :

Nombre d’instances : utilisez ce paramètre 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.
Taille minimale de lot : utilisez ce paramètre pour remplacer le nombre de fichiers à inclure dans chaque mini-lot. Le nombre de mini-lots est déterminé en fonction du nombre total de fichiers d’entrée et de la taille du mini-lot. Une taille de mini-lot plus petite génère davantage 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.
Les autres paramètres, par exemple le nombre maximal de nouvelles tentatives, le délai d’expiration et le seuil d’erreur peuvent être remplacés. 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)

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/"
    ),
    params_override=[{"mini_batch_size": "20"}, {"compute.instance_count": "5"}],
)

Ajouter des 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 s’affectent pas les uns les autres.

Dans cet exemple, vous ajoutez un deuxième déploiement qui utilise un modèle créé avec Keras et TensorFlow pour résoudre le même problème MNIST.

Ajouter un deuxième déploiement

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 au 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.
- Azure CLI
- Python
- Studio
La définition d’environnement est incluse dans la définition de déploiement elle-même en tant qu’environnement anonyme.
```
environment:
  name: batch-tensorflow-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
```
Obtenez une référence à l’environnement :
```
env = Environment(
    name="batch-tensorflow-py38",
    conda_file="deployment-keras/environment/conda.yaml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
```
1. Accédez à l’onglet Environnements dans le menu latéral.
2. Sélectionnez l’onglet Créer des environnements>Créer.
3. Entrez le nom de l’environnement, en l’occurrence keras-batch-env.
4. Pour Sélectionner une source d’environnement, sélectionnez Utiliser une image Docker existante avec un fichier Conda facultatif.
5. Pour Chemin de l’image de registre de conteneurs, entrez mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.
6. Sélectionnez Suivant pour accéder à la section « Personnaliser ».
7. Copiez le contenu du fichier deployment-keras/environment/conda.yaml du dépôt GitHub vers le portail.
8. Sélectionnez Suivant jusqu’à ce que vous arriviez à la « page Vérifier ».
9. Sélectionnez Créer, puis attendez que l’environnement soit prêt à être utilisé.
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]
```

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)

Créer une nouvelle définition de déploiement
- Azure CLI
- Python
- Studio
deployment-keras/deployment.yml
```
$schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.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
```
```
deployment_keras = ModelBatchDeployment(
    name="mnist-keras-dpl",
    description="A deployment using Keras to solve the MNIST classification dataset.",
    endpoint_name=endpoint_name,
    model=model,
    code_configuration=CodeConfiguration(
        code="deployment-keras/code/", scoring_script="batch_driver.py"
    ),
    environment=env,
    compute=compute_name,
    settings=ModelBatchDeploymentSettings(
        instance_count=2,
        max_concurrency_per_instance=2,
        mini_batch_size=10,
        output_action=BatchDeploymentOutputAction.APPEND_ROW,
        output_file_name="predictions.csv",
        retry_settings=BatchRetrySettings(max_retries=3, timeout=30),
        logging_level="info",
    ),
)
```
1. Accédez à l’onglet Points de terminaison dans le menu latéral.
2. Sélectionnez l’onglet Points de terminaison de traitement par lots.
3. Sélectionnez le point de terminaison de traitement par lots existant dans lequel vous souhaitez ajouter le déploiement.
4. Sélectionnez Ajouter un déploiement.
5. Sélectionnez Suivant pour accéder à la page « Modèle ».
6. Dans la liste des modèles, sélectionnez le modèle mnist, puis sélectionnez Suivant.
7. Dans la page de configuration du déploiement, attribuez un nom au déploiement.
8. Annulez la sélection de l’option : Faites de ce nouveau déploiement le déploiement par défaut pour les tâches par lots.
9. Pour Action de sortie, vérifiez que l’option Ajouter une ligne est sélectionnée.
10. Pour Nom du fichier de sortie, vérifiez que le fichier de sortie de scoring par lots est celui dont vous avez besoin. La valeur par défaut est predictions.csv.
11. Pour Taille minimale de lot, ajustez la taille des fichiers à inclure dans chaque mini-lot. Ceci permet de contrôler la quantité de données que votre script de scoring reçoit pour chaque lot.
12. Pour Délai d’expiration du scoring (en secondes), vérifiez que vous laissez suffisamment de temps à votre déploiement pour effectuer le scoring d’un lot de fichiers donné. Si vous augmentez le nombre de fichiers, vous devez généralement augmenter la valeur du délai d’expiration. Les modèles plus coûteux (comme ceux basés sur le deep learning) peuvent nécessiter des valeurs élevées dans ce champ.
13. Pour Concurrence maximale par instance, configurez le nombre d’exécuteurs à avoir pour chaque instance de calcul que vous obtenez dans le déploiement. Un nombre plus élevé garantit un degré de parallélisation plus élevé, mais il augmente également la sollicitation de la mémoire sur l’instance de calcul. Ajustez cette valeur conjointement avec Taille minimale de lot.
14. Sélectionnez Suivant pour accéder à la page « Code + environnement ».
15. Pour Sélectionner un script de scoring pour l’inférence, recherchez et sélectionnez le fichier de script de scoring deployment-keras/code/batch_driver.py.
16. Pour Sélectionner un environnement, sélectionnez l’environnement que vous avez créé à une étape précédente.
17. Cliquez sur Suivant.
18. Dans la page Calcul, sélectionnez le cluster de calcul que vous avez créé à une étape précédente.
19. Pour Nombre d’instances, entrez le nombre d’instances de calcul souhaitées pour le déploiement. Dans le cas présent, utilisez 2.
20. Cliquez sur Suivant.
Créez le déploiement :
- Azure CLI
- Python
- Studio
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. Conformément aux meilleures pratiques dans les scénarios de production, créez un déploiement sans le définir en tant que déploiement par défaut. Vérifiez-le ensuite, puis mettez-le à jour plus tard en tant que déploiement par défaut.
En utilisant le MLClient créé plus tôt, créez le déploiement dans l’espace de travail. Cette commande lance la création du déploiement et retourne une réponse de confirmation pendant que la création du déploiement se poursuit.
```
ml_client.begin_create_or_update(deployment_keras).result()
```
Dans l’Assistant, cliquez sur Créer pour démarrer le processus de déploiement.

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 à 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 à exécuter. Avec ce paramètre, vous pouvez invoke un déploiement non défini par défaut sans mettre à jour le déploiement par défaut du point de terminaison de traitement par lots.

job = ml_client.batch_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment_keras.name,
    input=Input(
        path="https://azuremlexampledata.blob.core.windows.net/data/mnist/sample/",
        type=AssetTypes.URI_FOLDER,
    ),
)

Notez que deployment_name est utilisé pour spécifier le déploiement à exécuter. Avec ce paramètre, vous pouvez invoke un déploiement non défini par défaut sans mettre à jour le déploiement par défaut du point de terminaison de traitement par lots.

Accédez à l’onglet Points de terminaison dans le menu latéral.
Sélectionnez l’onglet Points de terminaison de traitement par lots.
Sélectionnez le point de terminaison de traitement par lots que vous venez de créer.
Sélectionnez Créer un travail.
Pour Déploiement, sélectionnez le déploiement à exécuter. Dans ce cas, mnist-keras.
Terminez l’Assistant Création de travaux pour commencer le travail.

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

Bien que vous puissiez appeler un déploiement spécifique dans un point de terminaison, vous appelez généralement le point de terminaison lui-même, et le laissez décider du déploiement à utiliser, à savoir le déploiement par défaut. Vous pouvez changer le déploiement par défaut (et, ainsi, changer le modèle prenant en charge le déploiement) sans changer votre contrat avec l’utilisateur qui appelle le point de terminaison. Utilisez le code suivant pour mettre à jour le déploiement par défaut :

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

endpoint = ml_client.batch_endpoints.get(endpoint_name)
endpoint.defaults.deployment_name = deployment_keras.name
ml_client.batch_endpoints.begin_create_or_update(endpoint).result()

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

Si vous n’utilisez pas l’ancien déploiement par lots, supprimez-le 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 traitement par lots et tous ses déploiements sous-jacents. Les travaux de scoring par lots ne seront pas supprimés.

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

Si vous n’utilisez pas l’ancien déploiement par lots, supprimez-le en exécutant le code suivant.

ml_client.batch_deployments.begin_delete(
    endpoint_name=endpoint_name, name=deployment.name
).result()

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

ml_client.batch_endpoints.begin_delete(name=endpoint_name)

Partager via

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

Prérequis

Cloner le référentiel d’exemples

Préparer votre système

Se connecter à un espace de travail

Créer une capacité de calcul

Créer un point de terminaison de traitement de lots

Créer un déploiement par lots

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

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

Vérifier les résultats du scoring par lots

Configurer l’emplacement de sortie

Remplacer la configuration de déploiement pour chaque travail

Ajouter des déploiements à un point de terminaison

Ajouter un deuxième déploiement

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

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

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

Commentaires

Ressources supplémentaires

Partager via

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

Prérequis

Cloner le référentiel d’exemples

Préparer votre système

Se connecter à un espace de travail

Créer une capacité de calcul

Créer un point de terminaison de traitement de lots

Créer un déploiement par lots

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

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

Vérifier les résultats du scoring par lots

Configurer l’emplacement de sortie

Remplacer la configuration de déploiement pour chaque travail

Ajouter des déploiements à un point de terminaison

Ajouter un deuxième déploiement

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

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

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

Contenu connexe

Commentaires

Ressources supplémentaires