Déployer des modèles MLflow dans les déploiements par lot

  • Article

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

Cet article explique comment déployer des modèles MLflow vers Azure Machine Learning pour une inférence en temps réel et par lots à l’aide de points de terminaison de lots. Lors du déploiement de modèles MLflow sur des points de terminaison de lot, Azure Machine Learning :

  • Fournit une image de base MLflow/un environnement organisé qui contient les dépendances requises pour exécuter un travail Azure Machine Learning Batch.
  • Crée un pipeline de programmes de traitement par lots avec un script de scoring pour vous permettant de traiter des données à l’aide de la parallélisation.

Remarque

Pour plus d’informations sur les types de fichiers d’entrée pris en charge et des détails sur le fonctionnement du modèle MLflow, consultez considérations relatives au déploiement sur l’inférence par lots.

À propos de cet exemple

Cet exemple montre comment déployer un modèle MLflow sur un point de terminaison de lot pour effectuer des prédictions par lots. Cet exemple utilise un modèle MLflow basé sur le jeu de données UCI Heart Disease Set. La base de données contient 76 attributs, mais nous utilisons un sous-ensemble de 14 d’entre eux. Le modèle tente de prédire la présence de maladie cardiaque chez un patient. Il est entier compris entre 0 (aucune présence de maladie) et 1 (présence de maladie).

Le modèle a été entraîné à l’aide d’un classifieur XGBBoost et tout le prétraitement requis a été empaqueté en tant que pipeline scikit-learn, ce qui fait de ce modèle un pipeline de bout en bout qui passe des données brutes aux prédictions.

L’exemple de cet article est basé sur des extraits de code contenus dans le référentiel azureml-examples. Pour exécuter les commandes localement sans avoir à copier/coller le fichier YAML et d’autres fichiers, clonez d’abord le référentiel, puis modifiez les répertoires dans le dossier :

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Les fichiers de cet exemple se situent dans :

cd endpoints/batch/deploy-models/heart-classifier-mlflow

Suivre dans les notebooks Jupyter

Vous pouvez suivre cet exemple dans les notebooks suivants. Dans le référentiel cloné, ouvrez le notebook : mlflow-for-batch-tabular.ipynb.

Prérequis

Avant de suivre les étapes décrites dans cet article, vérifiez que vous disposez des composants requis suivants :

  • Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer. Essayez la version gratuite ou payante d’Azure Machine Learning.

  • Un espace de travail Azure Machine Learning. Si vous n’en avez pas, suivez les étapes décrites dans l’article Gérer des espaces de travail Azure Machine Learning pour en créer un.

  • Vérifiez que vous disposez des autorisations suivantes dans l’espace de travail :

    • Créez ou gérez des points de terminaison et des déploiements par lots : utilisez un rôle propriétaire, contributeur ou personnalisé autorisant Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.

    • Créez des déploiements ARM dans le groupe de ressources de l’espace de travail : utilisez un rôle propriétaire, contributeur ou 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 :

    L’interface Azure CLI et l’mlextension pour Azure Machine Learning.

    az extension add -n ml

    Notes

    Les déploiements de composants de pipeline pour des points de terminaison Batch ont été introduits dans la version 2.7 de l’extension ml pour Azure CLI. Utilisez az extension update --name ml pour en obtenir la dernière version.

Se connecter à un espace de travail

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

Transmettez les valeurs de votre ID d’abonnement, de votre espace de travail, de votre emplacement et de votre groupe de ressources dans le code suivant :

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

Étapes

Procédez comme suit pour déployer un modèle MLflow sur un point de terminaison de lot pour l’exécution de l’inférence par lots sur de nouvelles données :

  1. Un point de terminaison par lots ne peut déployer que des modèles inscrits. Dans ce cas, nous avons déjà une copie locale du modèle dans le référentiel. Nous devons donc uniquement publier le modèle dans le Registre dans l’espace de travail. Vous pouvez ignorer cette étape si le modèle que vous essayez de déployer est déjà inscrit.

    MODEL_NAME='heart-classifier-mlflow'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "model"

  2. Avant cela, nous devons nous assurer que les déploiements par lots que nous sommes sur le point de créer peuvent s’exécuter sur une infrastructure (calcul). Les déploiements par lots peuvent s’exécuter sur n’importe quel calcul Azure Machine Learning qui existe déjà dans l’espace de travail. Cela signifie que plusieurs déploiements par lots peuvent partager la même infrastructure de calcul. Dans cet exemple, nous allons travailler sur un cluster de calcul Azure Machine Learning appelé cpu-cluster. Nous allons vérifier que le calcul existe sur l’espace de travail ou le créer dans le cas contraire.

    Créez un cluster de calcul comme suit :

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

  3. Il est maintenant temps de créer le point de terminaison de lot et le déploiement par lots. Commençons par le point de terminaison. Les points de terminaison ne nécessitent qu’un nom et une description pour être créés. Le nom du point de terminaison figurera dans l’URI associé à celui-ci. De ce fait, les noms de point de terminaison de traitement par lots doivent être uniques au sein d’une région Azure. Par exemple, il ne peut y avoir qu’un seul point de terminaison de traitement par lots avec le nom mybatchendpoint dans westus2.

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

    ENDPOINT_NAME="heart-classifier"

  4. Créez le point de terminaison :

    Pour créer un point de terminaison, créez une configuration YAML comme suit :

    endpoint.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: heart-classifier-batch
description: A heart condition classifier for batch inference
auth_mode: aad_token

    Ensuite, créez le déploiement avec la commande suivante :

    az ml batch-endpoint create -n $ENDPOINT_NAME -f endpoint.yml

  5. Maintenant, attendez la création du déploiement. Les modèles MLflow ne vous obligent pas à indiquer un environnement ou un script de scoring lors de la création des déploiements à mesure qu’ils sont créés pour vous. Toutefois, vous pouvez les spécifier si vous souhaitez personnaliser la façon dont le déploiement effectue l’inférence.

    Pour créer un nouveau déploiement sous le point de terminaison créé, créez une configuration YAML comme suit. Vous pouvez vérifier le schéma YAML du point de terminaison de lot complet pour obtenir des propriétés supplémentaires.

    deployment-simple/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
endpoint_name: heart-classifier-batch
name: classifier-xgboost-mlflow
description: A heart condition classifier based on XGBoost
type: model
model: azureml:heart-classifier-mlflow@latest
compute: azureml:batch-cluster
resources:
  instance_count: 2
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 2
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 300
  error_threshold: -1
  logging_level: info

    Ensuite, créez le déploiement avec la commande suivante :

    az ml batch-deployment create --file deployment-simple/deployment.yml --endpoint-name $ENDPOINT_NAME --set-default

    Important

    Configurez timeout dans votre déploiement en fonction du temps nécessaire à l’exécution de l’inférence sur un seul lot. Plus la taille du lot est grande, plus cette valeur doit être longue. Rappelez-vous que mini_batch_size indique le nombre de fichiers dans un lot, et non le nombre d’échantillons. Lorsque vous utilisez des données tabulaires, chaque fichier peut contenir plusieurs lignes, ce qui augmente le temps nécessaire pour que le point de terminaison de lot traite chaque fichier. Utilisez des valeurs élevées dans ces cas pour éviter les erreurs de délai d’attente.

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

    DEPLOYMENT_NAME="classifier-xgboost-mlflow"
az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

  7. À ce stade, notre point de terminaison batch est prêt à être utilisé.

Test du déploiement

Pour tester notre point de terminaison, nous allons utiliser un exemple de données non étiquetées situées dans ce référentiel et qui peuvent être utilisées avec le modèle. Les points de terminaison de lot peuvent uniquement traiter les données situées dans le cloud et accessibles à partir de l’espace de travail Azure Machine Learning. Dans cet exemple, nous allons les charger dans un magasin de données Azure Machine Learning. En particulier, nous allons créer une ressource de données qui peut être utilisée pour appeler le point de terminaison pour le scoring. Toutefois, notez que les points de terminaison de lots acceptent les données pouvant être placées à différents emplacements.

  1. Créons d’abord la ressource de données. Cette ressource de données se compose d’un dossier contenant plusieurs fichiers CSV que nous voulons traiter en parallèle à l’aide de points de terminaison de lots. Vous pouvez ignorer cette étape si vos données sont déjà inscrites en tant que ressource de données ou que vous souhaitez utiliser un autre type d’entrée.

    a. Créez une définition de ressource de données dans YAML :

    heart-dataset-unlabeled.yml

    $schema: https://azuremlschemas.azureedge.net/latest/data.schema.json
name: heart-dataset-unlabeled
description: An unlabeled dataset for heart classification.
type: uri_folder
path: data

    b. Créez la ressource de données :

    az ml data create -f heart-dataset-unlabeled.yml

  2. Maintenant que les données sont chargées et prêtes à être utilisées, appelons le point de terminaison :

    JOB_NAME = $(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input azureml:heart-dataset-unlabeled@latest --query name -o tsv)

    Notes

    L’utilitaire jq peut ne pas être installé sur chaque installation. Vous pouvez obtenir plus d’instructions d’installation sur ce lien.

    Conseil

    Notez que nous n’indiquons pas le nom de déploiement dans l’opération d’appel. Cela est dû au fait que le point de terminaison achemine automatiquement le travail vers le déploiement par défaut. Étant donné que notre point de terminaison n’a qu’un seul déploiement, il s’agit de celui par défaut. Vous pouvez cibler un déploiement spécifique en indiquant l’argument/le paramètre deployment_name.

  3. Une tâche de lot est démarrée dès que la commande retourne son résultat. Vous pouvez surveiller l’état du travail jusqu’à ce qu’il se termine :

    az ml job show -n $JOB_NAME --web

Analyse des sorties

Les prédictions de sortie sont générées dans le fichier predictions.csv, comme indiqué dans la configuration du déploiement. Le travail génère une sortie nommée appelée score où ce fichier est placé. Un seul fichier est généré par programme de traitement par lots.

Le fichier est structuré comme suit :

  • Il existe une ligne par point de données envoyé au modèle. Pour les données tabulaires, cela signifie que le fichier (predictions.csv) contient une ligne pour chaque ligne présente dans chacun des fichiers traités. Pour les autres types de données (par ex. : image, audio, texte), il y a une ligne par fichier traité.

  • Les colonnes suivantes se trouvent dans le fichier (dans l’ordre) :

    • row (facultatif), index de ligne correspondant dans le fichier de données d’entrée. Cela s’applique uniquement si les données d’entrée sont tabulaires. Les prédictions sont retournées dans le même ordre que dans le fichier d’entrée afin que vous puissiez vous appuyer sur le numéro de ligne pour avoir la prédiction correspondante.
    • prediction, prédiction associée aux données d’entrée. Cette valeur est retournée en l’état tel qu’elle a été fournie par la fonction du modèle predict()..
    • file_name, nom de fichier à partir duquel les données ont été lues. Dans les données tabulaires, utilisez ce champ pour savoir quelle prédiction appartient aux données d’entrée.

Vous pouvez télécharger les résultats du travail à l’aide du nom du travail :

Utilisez les commandes suivantes pour télécharger les prédictions :

az ml job download --name $JOB_NAME --output-name score --download-path ./

Une fois le fichier téléchargé, vous pouvez l’ouvrir à l’aide de votre outil favori. L’exemple suivant charge les prédictions à l’aide du dataframe Pandas.

import pandas as pd

score = pd.read_csv(
    "named-outputs/score/predictions.csv", names=["row", "prediction", "file"]
)

La sortie se présente comme suit :

row prediction file
0 0 heart-unlabeled-0.csv
1 1 heart-unlabeled-0.csv
2 0 heart-unlabeled-0.csv
... ... ...
307 0 heart-unlabeled-3.csv

Conseil

Notez que dans cet exemple, les données d’entrée étaient des données tabulaires au format CSV et qu’il y avait 4 fichiers d’entrée différents (heart-unlabeled-0.csv, heart-unlabeled-1.csv, heart-unlabeled-2.csv et heart-unlabeled-3.csv).

Considérations de déploiement avec inférence par lots

Azure Machine Learning prend en charge le déploiement de modèles MLflow sur des points de terminaison de traitement par lots sans indiquer de script de scoring. Cela constitue un moyen pratique de déployer de modèles impliquant le traitement d’importants volumes de données par lots. Azure Machine Learning utilise des informations dans la spécification du modèle MLflow pour orchestrer le processus d’inférence.

Distribution du travail aux Workers

Les points de terminaison Batch distribuent le travail au niveau du fichier, pour les données structurées et non structurées. Par conséquent, seuls les fichier URI et les dossiers d’URI sont pris en charge pour cette fonctionnalité. Chaque Worker traite les lots de Mini batch size fichiers à la fois. Pour les données tabulaires, les points de terminaison de lot ne tiennent pas compte du nombre de lignes à l’intérieur de chaque fichier lors de la distribution du travail.

Avertissement

Les structures de dossiers imbriquées ne sont pas explorées lors de l’inférence. Si vous partitionnez vos données à l’aide de dossiers, veillez à aplatir la structure au préalable.

Les déploiements par lots appellent la fonction predict du modèle MLflow une fois par fichier. Pour les fichiers CSV contenant plusieurs lignes, cela peut imposer une pression de mémoire dans le calcul sous-jacent et augmenter le temps nécessaire au modèle pour noter un seul fichier (spécialement pour les modèles coûteux comme les modèles de langage volumineux). Si vous rencontrez plusieurs exceptions hors mémoire ou entrées de délai d’attente dans les journaux, envisagez de fractionner les données dans des fichiers plus petits avec moins de lignes ou d’implémenter le traitement par lots au niveau des lignes à l’intérieur du script de modèle/scoring.

Prise en charge des types de fichiers

Les types de données suivants sont pris en charge pour l’inférence par lots lors du déploiement de modèles MLflow sans environnement et script de scoring. Si vous souhaitez traiter un autre type de fichier ou exécuter l’inférence d’une manière différente de celle utilisée par défaut par les points de terminaison de lots, vous pouvez toujours créer le déploiement avec un script de scoring, comme expliqué dans Utilisation de modèles MLflow avec un script de scoring.

Extension de fichier Type retourné en tant qu’entrée du modèle Exigence de signature
.csv, .parquet, .pqt pd.DataFrame ColSpec. S’il n’est pas fourni, la saisie de colonnes n’est pas appliquée.
.png, .jpg, .jpeg, .tiff, .bmp, .gif np.ndarray TensorSpec. L’entrée est remodelée pour correspondre à la forme des tenseurs, si disponible. Si aucune signature n’est disponible, les tenseurs de type np.uint8 sont déduits. Pour obtenir des conseils supplémentaires, lisez Considérations relatives au traitement des images de modèles MLflow.

Avertissement

Notez que tout fichier non pris en charge qui peut être présent dans les données d’entrée fera échouer le travail. Vous verrez une entrée d’erreur comme suit : « ERROR:azureml:Erreur de traitement du fichier d’entrée : ’/mnt/batch/tasks/.../a-given-file.avro’. Le type de fichier ’avro’ n’est pas pris en charge. ».

Application de signature pour les modèles MLflow

Les types de données d’entrée sont appliqués par des travaux de déploiement par lots lors de la lecture des données à l’aide de la signature de modèle MLflow disponible. Cela signifie que votre entrée de données doit se conformer aux types indiqués dans la signature du modèle. Si les données ne peuvent pas être analysées comme prévu, le travail échoue avec un message d’erreur similaire à celui-ci : « ERROR:azureml:Erreur de traitement du fichier d’entrée : « /mnt/batch/tasks/.../a-given-file.csv ». Exception : littéral non valide pour int() avec la base 10 : 'valeur' ».

Conseil

Les signatures dans les modèles MLflow sont facultatives, mais elles sont fortement encouragées, car elles offrent un moyen pratique de détecter rapidement les problèmes de compatibilité des données. Pour plus d’informations sur la façon de journaliser des modèles avec des signatures lisent les Modèles de journalisation avec une signature, un environnement ou des exemples personnalisés.

Vous pouvez inspecter la signature de modèle de votre modèle en ouvrant le fichier MLmodel associé à votre modèle MLflow. Pour plus d’informations sur le fonctionnement des signatures dans MLflow, consultez Signatures dans MLflow.

Prise en charge des saveurs

Les déploiements batch prennent uniquement en charge le déploiement de modèles MLflow avec une saveur pyfunc. Si vous devez déployer une autre saveur, consultez Utilisation de modèles MLflow avec un script de scoring.

Personnalisation de déploiements de modèles MLflow avec un script de scoring

Les modèles MLflow peuvent être déployés sur des points de terminaison de lots sans indiquer un script de scoring dans la définition de déploiement. Toutefois, vous pouvez choisir d’indiquer ce fichier (généralement appelé pilote par lots) pour personnaliser l’exécution de l’inférence.

Vous sélectionnez généralement ce workflow dans les cas suivants :

  • Vous devez traiter un type de fichier non pris en charge par les déploiements par lots MLflow.
  • Vous devez personnaliser la façon dont le modèle est exécuté, par exemple, utiliser une saveur spécifique pour la charger avec mlflow.<flavor>.load().
  • Vous devez effectuer le traitement prédéfini dans votre routine de scoring lorsqu’il n’est pas effectué par le modèle lui-même.
  • La sortie du modèle ne peut pas être correctement représentée dans les données tabulaires. Par exemple, il s’agit d’un capteur représentant une image.
  • Vous ne pouvez pas traiter chaque fichier à la fois en raison de contraintes de mémoire et il doit le lire par blocs.

Important

Si vous choisissez d’indiquer un script de scoring pour un déploiement de modèle MLflow, vous devez également spécifier l’environnement dans lequel le déploiement s’exécutera.

Étapes

Utilisez les étapes suivantes pour déployer un modèle MLflow avec un script de scoring personnalisé.

  1. Identifiez le dossier dans lequel votre modèle MLflow est placé.

    a. Accédez au portail Azure Machine Learning.

    b. Accédez à la section Modèles.

    c. Sélectionnez le modèle que vous essayez de déployer, puis cliquez sur l’onglet Artefacts.

    d. Notez le dossier affiché. Ce dossier a été indiqué lors de l’inscription du modèle.

    Capture d’écran montrant le dossier dans lequel les artefacts de modèle sont placés.

  2. Créer un script de scoring. Notez que le nom de dossier model que vous avez identifié précédemment a été inclus dans la fonction init().

    deployment-custom/code/batch_driver.py

    # Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license.

import os
import glob
import mlflow
import pandas as pd
import logging


def init():
    global model
    global model_input_types
    global model_output_names

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    # It is the path to the model folder
    # Please provide your model's folder name if there's one
    model_path = glob.glob(os.environ["AZUREML_MODEL_DIR"] + "/*/")[0]

    # Load the model, it's input types and output names
    model = mlflow.pyfunc.load(model_path)
    if model.metadata and model.metadata.signature:
        if model.metadata.signature.inputs:
            model_input_types = dict(
                zip(
                    model.metadata.signature.inputs.input_names(),
                    model.metadata.signature.inputs.pandas_types(),
                )
            )
        if model.metadata.signature.outputs:
            if model.metadata.signature.outputs.has_input_names():
                model_output_names = model.metadata.signature.outputs.input_names()
            elif len(model.metadata.signature.outputs.input_names()) == 1:
                model_output_names = ["prediction"]
    else:
        logging.warning(
            "Model doesn't contain a signature. Input data types won't be enforced."
        )


def run(mini_batch):
    print(f"run method start: {__file__}, run({len(mini_batch)} files)")

    data = pd.concat(
        map(
            lambda fp: pd.read_csv(fp).assign(filename=os.path.basename(fp)), mini_batch
        )
    )

    if model_input_types:
        data = data.astype(model_input_types)

    # Predict over the input data, minus the column filename which is not part of the model.
    pred = model.predict(data.drop("filename", axis=1))

    if pred is not pd.DataFrame:
        if not model_output_names:
            model_output_names = ["pred_col" + str(i) for i in range(pred.shape[1])]
        pred = pd.DataFrame(pred, columns=model_output_names)

    return pd.concat([data, pred], axis=1)

  3. Nous allons créer un environnement dans lequel le script de scoring peut être exécuté. Étant donné que notre modèle est MLflow, les exigences de conda sont également spécifiées dans le package de modèle (pour plus d’informations sur les modèles MLflow et les fichiers qui y sont inclus, consultez Le format MLmodel). Nous allons ensuite créer l’environnement à l’aide des dépendances conda du fichier. Toutefois, nous devons également inclure le package azureml-core requis pour les déploiements par lots.

    Conseil

    Si votre modèle est déjà inscrit dans le registre de modèles, vous pouvez télécharger/copier le conda.yml fichier associé à votre modèle en accédant à Modèles> Azure Machine Learning Studio > Sélectionnez votre modèle dans la liste > Artefacts. Ouvrez le dossier racine dans la navigation et sélectionnez le conda.yml fichier répertorié. Cliquez sur Télécharger ou copier son contenu.

    Important

    Cet exemple utilise un environnement conda spécifié dans /heart-classifier-mlflow/environment/conda.yaml. Ce fichier a été créé en combinant le fichier de dépendances conda MLflow d’origine et en ajoutant le package azureml-core. Vous ne pouvez pas utiliser le conda.yml fichier directement à partir du modèle.

    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-mlflow-xgboost
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml

  4. Configurez le déploiement :

    Pour créer un nouveau déploiement sous le point de terminaison créé, créez une configuration YAML comme suit. Vous pouvez vérifier le schéma YAML du point de terminaison de lot complet pour obtenir des propriétés supplémentaires.

    deployment-custom/deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
endpoint_name: heart-classifier-batch
name: classifier-xgboost-custom
description: A heart condition classifier based on XGBoost
type: model
model: azureml:heart-classifier-mlflow@latest
environment:
  name: batch-mlflow-xgboost
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
code_configuration:
  code: code
  scoring_script: batch_driver.py
compute: azureml:batch-cluster
resources:
  instance_count: 2
settings:
  max_concurrency_per_instance: 2
  mini_batch_size: 2
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 3
    timeout: 300
  error_threshold: -1
  logging_level: info

  5. Nous allons maintenant créer le déploiement :

    az ml batch-deployment create --file deployment-custom/deployment.yml --endpoint-name $ENDPOINT_NAME

  6. À ce stade, notre point de terminaison batch est prêt à être utilisé.

Nettoyer les ressources

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

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

Étapes suivantes