Déployer des modèles pour le scoring dans des points de terminaison de lot

APPLIES TO :Extension Azure ML CLI v2 (actuelle)Kit de développement logiciel (SDK) Python azure-ai-ml v2 (préversion)

Les points de terminaison Batch vous permettent de déployer des modèles qui exécutent l’inférence sur de grands volumes de données. Ces points de terminaison simplifient l’hébergement de modèles pour le scoring par lots. Vous pouvez donc vous concentrer sur le Machine Learning au lieu de l’infrastructure.

Utilisez des points de terminaison par lot pour déployer des modèles lorsque :

Vous utilisez des modèles coûteux qui prennent plus de temps pour exécuter l’inférence.
Vous effectuez une inférence sur de grandes quantités de données distribuées dans plusieurs fichiers.
Vous n’avez pas besoin d’une faible latence.
Vous tirez parti de la parallélisation.

Cet article montre comment utiliser 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 numérique MNIST (Modified National Institute of Standards and Technology). Le modèle déployé effectue une inférence par lots sur de grandes quantités de données, telles que des fichiers image. Le processus commence par la création d’un déploiement par lots d’un modèle créé à l’aide de Torch. Ce déploiement devient la valeur par défaut dans le point de terminaison. Ensuite, créez un deuxième déploiement d’un modèle créé avec TensorFlow (Keras), testez le deuxième déploiement et définissez-le comme déploiement par défaut du point de terminaison.

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 le logiciel suivant pour utiliser Azure Machine Learning :
- Azure CLI
- Python
- Studio
APPLIES TO :Extension Azure ML CLI v2 (actuelle)

L’interface Azure CLI et l’mlextension pour Azure Machine Learning.
```
az extension add -n ml
```
APPLIES TO : 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 d’entrer les valeurs de votre abonnement, espace de travail, groupe de ressources et emplacement plusieurs fois, 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, qui fournit un emplacement centralisé pour gérer tous les artefacts que vous créez lors de l’utilisation d’Azure Machine Learning. Dans cette section, vous vous connectez à l’espace de travail dans lequel vous effectuez des 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
from azure.ai.ml.constants import AssetTypes, BatchDeploymentOutputAction
from azure.ai.ml.dsl import pipeline
from azure.identity import DefaultAzureCredential

Remarque

Les classes ModelBatchDeployment et PipelineComponentBatchDeployment ont été introduites dans la version 1.7.0 du kit de développement logiciel (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. Ajustez si nécessaire et consultez votre calcul à l’aide de 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 d'accès par lots est un point de terminaison HTTPS que les clients appellent pour déclencher une tâche d'évaluation par lots. Un processus de scoring par lots évalue 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 Qu’est-ce que les points de terminaison batch ?.

Conseil

L’un des déploiements par lots sert de déploiement par défaut pour le point de terminaison. Lorsque le point de terminaison est appelé, le déploiement par défaut effectue une évaluation par lots. Pour plus d’informations sur les points de terminaison et les déploiements par lots, consultez les points de terminaison de lot et le déploiement par lots.

Nommez le point de terminaison. Le nom du point de terminaison doit être unique dans 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 la référencer facilement ultérieurement.
```
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. Utilisez ce fichier avec la commande CLI pour la création du point de terminaison batch.

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é	Descriptif
`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é	Descriptif
`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 ce code 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 :

Remarque

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écute. 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 est incluse dans la définition de déploiement elle-même en tant qu’environnement anonyme. Vous voyez les lignes suivantes dans le déploiement :
```
environment:
  name: batch-torch-py38
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.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-ubuntu22.04:latest",
)
```
Dans Azure Machine Learning studio, suivez ces étapes :
Accédez à l’onglet Environnements dans le menu latéral.
Sélectionnez Environnements> personnalisésCréer.
1. Entrez le nom de l’environnement, en l’occurrence torch-batch-env.
2. Pour Sélectionner une source d’environnement, sélectionnez Utiliser une image Docker existante avec un fichier Conda facultatif.
3. Pour Chemin de l’image de registre de conteneurs, entrez mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04.
4. Sélectionnez Suivant pour accéder à la section « Personnaliser ».
5. Copiez le contenu du fichier deployment-torch/environment/conda.yaml du dépôt GitHub vers le portail.
Sélectionnez Suivant jusqu’à atteindre la page « Révision ».
Sélectionnez Créer et attendre que l’environnement soit prêt.

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-ubuntu22.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é	Descriptif
`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 bonne 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` sont installées au-dessus du `image`. L’environnement est 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 bonne 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_rowoutput_action`.
`settings.retry_settings.max_retries`	Nombre maximal de tentatives pour un échec d’un `scoring_scriptrun()`.
`settings.retry_settings.timeout`	Délai d’attente, en secondes, pour un `scoring_scriptrun()` 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 pour la totalité de l’entrée dépasse cette valeur, le travail de scoring par lots est interrompu. 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é	Descriptif
`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.

Accédez à l’onglet Points de terminaison dans le menu latéral.
1. Sélectionnez l’onglet Points de terminaison de traitement par lots>Créer.
2. Donnez un nom au point de terminaison, en l’occurrence mnist-batch. Vous pouvez configurer le reste des champs ou les laisser vides.
3. Sélectionnez Suivant pour accéder à la section « Modèle ».
4. Sélectionnez le modèle mnist-classifier-torch.
5. Sélectionnez Suivant pour accéder à la page « Déploiement ».
6. Donnez un nom au déploiement.
Pour l'action de sortie, vérifiez que Ajouter la ligne est sélectionné.
1. 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.
2. 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.
3. 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.
4. 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.
5. Une fois l’opération effectuée, sélectionnez Suivant pour accéder à la page « Code + environnement ».
6. 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.
7. Dans la section « Sélectionner un environnement », sélectionnez l’environnement que vous avez créé torch-batch-env.
8. Sélectionnez Suivant pour passer à la page « Calcul ».
9. 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.
10. Pour Nombre d’instances, entrez le nombre d’instances de calcul souhaitées pour le déploiement. Dans le cas présent, utilisez 2.
11. Sélectionnez 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.
Sélectionnez l’onglet Points de terminaison Batch .
1. Sélectionnez le point de terminaison de traitement par lots à visualiser.
2. 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

Vue d’ensemble des flux de données

Avant d’exécuter votre point de terminaison batch, comprenez comment les données transitent par le système :

Entrées : données à traiter (score). Cela inclut les éléments suivants :

Fichiers stockés dans stockage Azure (stockage d’objets blob, data lake)
Dossiers avec plusieurs fichiers
Jeux de données enregistrés dans Azure Machine Learning

Traitement : le modèle déployé traite les données d’entrée dans les lots (mini-lots) et génère des prédictions.

Sorties : résultats du modèle, stockés en tant que fichiers dans Stockage Azure. Par défaut, les sorties sont enregistrées dans le stockage dobjets blob par défaut de l’espace de travail, mais il est possible de spécifier un emplacement différent.

Appeler un point de terminaison de traitement par lots

L’appel d’un point de terminaison de lot déclenche un travail de scoring par lots. Le job name est retourné dans la réponse d'invocation et suit la progression du scoring par lots. Spécifiez le chemin des données d’entrée afin que les points de terminaison puissent localiser les données à noter. L’exemple suivant montre comment démarrer un nouveau travail 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 batch distribuent le travail au niveau du fichier. Par exemple, un dossier contenant 100 fichiers et mini-lots de 10 fichiers génère 10 lots de 10 fichiers chacun. Cela se produit indépendamment de la taille du fichier. Si les fichiers sont trop volumineux pour le traitement par mini-lots, fractionnez-les en fichiers plus petits pour augmenter le parallélisme ou réduire le nombre de fichiers par mini-lot. Actuellement, les déploiements batch ne comptent pas pour les asymétries dans la distribution de taille de fichier.

JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input $SAMPLE_INPUT_URI --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 modèle de déploiement ou un déploiement de pipeline.

Pour un modèle de déploiement, 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 modèle de déploiement 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=Path(temp_data_path) / "data",
        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.
Sélectionnez 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 processus de scoring par lots prennent du temps à traiter toutes les 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). Configurez l’emplacement de sortie lors de l’appel du point de terminaison batch.

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 $SAMPLE_INPUT_URI --output-path $OUTPUT_PATH --set output_file_name=$OUTPUT_FILE_NAME --query name -o tsv)

Le paramètre params_override vous permet de modifier les paramètres de déploiement d’un travail spécifique sans modifier définitivement la configuration du déploiement. Cela est utile pour ajuster les paramètres tels que l’emplacement de sortie, la taille de mini-lot ou le nombre d’instances pour des travaux individuels.

Les valeurs des paramètres params_override correspondent aux paramètres de configuration de déploiement qui peuvent être temporairement modifiés pour des travaux individuels. Ces paramètres proviennent des paramètres de schéma YAML de votre déploiement, des configurations de magasin de données (comme des chemins de sortie) et des variables d’exécution que vous définissez dans votre code.

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=Path(temp_data_path) / "data",
        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},
    ],
)

Conseil

Utilisez params_override quand vous avez besoin de paramètres différents pour différents travaux sans modifier votre déploiement. Cela est particulièrement utile pour gérer différentes tailles de données ou expérimenter des paramètres de performances.

Avertissement

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

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

Lorsque 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. Cette fonctionnalité est utile lorsque vous avez besoin de différents paramètres pour différents travaux sans modifier définitivement le déploiement.

Quels paramètres peuvent être substitués ?

Vous pouvez configurer les paramètres suivants par travail :

Réglage	Quand utiliser	Exemple de scénario
Nombre d’instances	Lorsque vous avez des volumes de données variables	Utilisez d’autres instances pour les jeux de données plus volumineux (10 instances pour 1 million de fichiers et 2 instances pour 100 000 fichiers).
Taille lini-batch	Quand vous devez équilibrer le débit et l’utilisation de la mémoire	Utilisez des lots plus petits (10 à 50 fichiers) pour les images volumineuses et les lots plus volumineux (100 à 500 fichiers) pour les petits fichiers texte.
Nombre total de tentatives	Lorsque la qualité des données varie	Nouvelles tentatives plus élevées (5 à 10) pour les données bruyantes ; nouvelles tentatives inférieures (1 à 3) pour les données propres
Délai d'expiration	Lorsque le temps de traitement varie selon le type de données	Délai d’expiration plus long (300s) pour les modèles complexes ; Délai d’expiration plus court (30s) pour les modèles simples
Seuil d’erreur	Quand vous avez besoin de différents niveaux de tolérance de défaillance	Seuil strict (-1) pour les travaux critiques ; seuil indulgent (10%) pour les travaux expérimentaux

Comment remplacer les paramètres

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="./data"),
    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 pour votre déploiement par lots. Incluez toutes les dépendances que votre code doit exécuter. Ajoutez la bibliothèque azureml-core, car elle est requise pour les déploiements par lots. La définition d’environnement suivante inclut les bibliothèques requises 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-ubuntu22.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-ubuntu22.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 ».
Copiez le contenu du fichier deployment-keras/environment/conda.yaml du dépôt GitHub vers le portail.
1. Sélectionnez Suivant jusqu’à ce que vous arriviez à la « page Vérifier ».
2. 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-ubuntu22.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.
Sélectionnez Suivant pour passer à la page « Code + environnement ».
1. 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.
2. Pour Sélectionner un environnement, sélectionnez l’environnement que vous avez créé à une étape précédente.
3. Sélectionnez Suivant.
4. Dans la page Calcul, sélectionnez le cluster de calcul que vous avez créé à une étape précédente.
5. Pour Nombre d’instances, entrez le nombre d’instances de calcul souhaitées pour le déploiement. Dans le cas présent, utilisez 2.
6. Sélectionnez 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 $SAMPLE_INPUT_URI --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=Path(temp_data_path) / "data",
        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()

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

Si vous n’avez pas besoin de l’ancien déploiement de lots, supprimez-le en exécutant le code suivant. L’indicateur --yes confirme 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 ses déploiements sous-jacents. Les travaux de scoring par lots ne sont 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)

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-08-04

Partager via

Déployer des modèles pour le scoring dans des points de terminaison de lot

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

Vue d’ensemble des flux de données

Appeler un point de terminaison de traitement par lots

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

Quels paramètres peuvent être substitués ?

Comment remplacer les paramètres

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

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

Contenu connexe

Commentaires

Ressources supplémentaires