Déployer des modèles MLflow sur des points de terminaison en ligne

APPLIES TO :Extension Azure ML CLI v2 (actuelle)

Dans cet article, vous découvrez comment déployer votre modèle MLflow sur un point de terminaison en ligne pour une inférence en temps réel. Lorsque vous déployez votre modèle MLflow sur un point de terminaison en ligne, vous n’avez plus besoin de spécifier un script de scoring ou un environnement. Cette fonctionnalité est appelée déploiement sans code.

Pour un déploiement sans code, Azure Machine Learning :

Installe dynamiquement les paquets Python que vous listez dans un fichier conda.yaml. Par conséquent, les dépendances sont installées pendant le runtime du conteneur.
Fournit une image de base MLflow ou un environnement organisé qui contient les éléments suivants :
- Le package azureml-inference-server-http
- Le package mlflow-skinny
- Script de scoring pour l’inférence

Prerequisites

Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
Un compte d’utilisateur qui a au moins l’un des rôles de contrôle d’accès en fonction du rôle Azure (Azure RBAC) suivants :
- Rôle propriétaire de l’espace de travail Azure Machine Learning
- Rôle Contributeur pour l’espace de travail Azure Machine Learning
- Rôle personnalisé disposant d’autorisations Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*
Pour plus d’informations, consultez Gérer l’accès aux espaces de travail Azure Machine Learning.
Accès à Azure Machine Learning :
Installer l’interface Azure CLI et l’extension ml pour l’interface Azure CLI. Pour connaître les étapes d’installation, consultez Installer et configurer l’interface CLI (v2).
Installer le kit de développement logiciel (SDK) Azure Machine Learning pour Python
```
pip install azure-ai-ml azure-identity
```
- Installez le package mlflowsdk MLflow et le package d’intégration Azure Machine Learning pour MLflow. azureml-mlflow
```
pip install mlflow azureml-mlflow
```
- Si vous n’exécutez pas de code dans une instance de calcul Azure Machine Learning, configurez l’URI de suivi MLflow ou l’URI de Registre MLflow pour pointer vers l’espace de travail Azure Machine Learning sur lequel vous travaillez. Pour plus d’informations sur la connexion de MLflow à votre espace de travail, consultez Configurer MLflow pour Azure Machine Learning.
Il n’existe aucun autre prérequis lorsque vous travaillez dans Azure Machine Learning Studio.

À propos de l’exemple

L’exemple de cet article vous montre comment déployer un modèle MLflow sur un point de terminaison en ligne pour effectuer des prédictions. L’exemple utilise un modèle MLflow basé sur le jeu de données Diabetes. Ce jeu de données contient 10 variables de base : âge, sexe, index de masse corporelle, pression artérielle moyenne et 6 mesures de sérum sanguin obtenues à partir de 442 patients diabétiques. Il contient également la réponse pertinente, une mesure quantitative de la progression de la maladie un an après la date des données de base.

Le modèle a été entraîné à l’aide d’un scikit-learn régresseur. Tout le prétraitement requis est empaqueté en tant que pipeline. Ce modèle est donc un pipeline de bout en bout qui passe des données brutes aux prédictions.

Les informations contenues dans cet article sont basées sur des exemples de code provenant du référentiel azureml-examples. Si vous clonez le référentiel, vous pouvez exécuter les commandes de cet article localement sans avoir à copier ou coller des fichiers YAML et d’autres fichiers. Utilisez les commandes suivantes pour cloner le référentiel et accéder au dossier de votre langage de codage :

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

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/sdk/python/endpoints/online/mlflow

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/sdk/python/endpoints/online/mlflow

Suivre dans Notebook Jupyter

Pour suivre les étapes décrites dans cet article, consultez le bloc-notes Déployer MLflow sur des points de terminaison en ligne dans le référentiel d’exemples.

Se connecter à un espace de travail

Connectez-vous à votre espace de travail Azure Machine Learning :

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

Importez les bibliothèques nécessaires :

from azure.ai.ml import MLClient, Input
from azure.ai.ml.entities import (
ManagedOnlineEndpoint,
ManagedOnlineDeployment,
Model,
Environment,
CodeConfiguration,
)
from azure.identity import DefaultAzureCredential
from azure.ai.ml.constants import AssetTypes

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

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

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

Importez les bibliothèques nécessaires :

import json
import mlflow
import requests
import pandas as pd
from mlflow.deployments import get_deploy_client
from mlflow.tracking import MlflowClient

Initialisez le client MLflow :
```
mlflow_client = MlflowClient()
```

Configurez le client de déploiement :

deployment_client = get_deploy_client(mlflow.get_tracking_uri())

Inscrire le modèle

Vous pouvez déployer uniquement des modèles inscrits sur des points de terminaison en ligne. Les étapes de cet article utilisent un modèle formé pour l’ensemble de données sur le diabète. Dans ce cas, vous disposez déjà d’une copie locale du modèle dans votre référentiel cloné. Vous devez donc uniquement publier le modèle dans le Registre dans l’espace de travail. Vous pouvez ignorer cette étape si le modèle à déployer est déjà inscrit.

MODEL_NAME='sklearn-diabetes'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "endpoints/online/ncd/sklearn-diabetes/model"

model_name = 'sklearn-diabetes'
model_local_path = "sklearn-diabetes/model"
model = ml_client.models.create_or_update(
        Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)

model_name = 'sklearn-diabetes'
model_local_path = "sklearn-diabetes/model"

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"file://{model_local_path}"
)
version = registered_model.version

Que se passe-t-il si votre modèle est journalisé à l’intérieur d’une exécution ?

Si votre modèle a été journalisé à l’intérieur d’une exécution, vous pouvez également l’inscrire directement.

Pour inscrire le modèle, vous devez connaître son emplacement de stockage :

Si vous utilisez la fonctionnalité MLflow autolog , le chemin d’accès au modèle dépend du type de modèle et de l’infrastructure. Vérifiez la sortie de la tâche pour identifier le nom du dossier du modèle. Ce dossier contient un fichier nommé MLModel.
Si vous utilisez la log_model méthode pour journaliser manuellement vos modèles, vous passez le chemin d’accès au modèle en tant qu’argument à cette méthode. Par exemple, si vous utilisez mlflow.sklearn.log_model(my_model, "classifier") pour enregistrer le modèle, classifier est le chemin d’accès sur lequel le modèle est stocké.

Vous pouvez utiliser Azure Machine Learning CLI v2 pour créer un modèle à partir de la sortie du travail d’apprentissage. Le code suivant utilise les artefacts d'un travail avec l'ID $RUN_ID pour enregistrer un modèle nommé $MODEL_NAME. $MODEL_PATH est le chemin d’accès que la tâche utilise pour stocker le modèle.

az ml model create --name $MODEL_NAME --path azureml://jobs/$RUN_ID/outputs/artifacts/$MODEL_PATH

Vous pouvez utiliser le Kit de développement logiciel (SDK) Python pour créer un modèle à partir de la sortie du travail d’apprentissage. Le code suivant utilise les artefacts d'un travail avec l'ID RUN_ID pour enregistrer un modèle nommé sklearn-diabetes. MODEL_PATH est le chemin d’accès que la tâche utilise pour stocker le modèle.

model_name = 'sklearn-diabetes'

ml_client.models.create_or_update(
    Model(
        path=f"azureml://jobs/{RUN_ID}/outputs/artifacts/{MODEL_PATH}",
        name=model_name,
        type=AssetTypes.MLFLOW_MODEL
    )
)

Vous pouvez utiliser le Kit de développement logiciel (SDK) Python MLflow pour créer un modèle à partir de la sortie du travail d’apprentissage. Le code suivant utilise les artefacts d'un travail avec l'ID RUN_ID pour enregistrer un modèle nommé sklearn-diabetes. MODEL_PATH est le chemin d’accès que la tâche utilise pour stocker le modèle.

model_name = 'sklearn-diabetes'

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"runs://{RUN_ID}/{MODEL_PATH}"
)
version = registered_model.version

Déployer des modèles MLflow sur un point de terminaison en ligne

Utilisez le code suivant pour configurer le nom et le mode d’authentification du point de terminaison sur lequel vous souhaitez déployer le modèle :

Définissez un nom de point de terminaison en exécutant la commande suivante. Remplacez d'abord YOUR_ENDPOINT_NAME par un nom unique.

export ENDPOINT_NAME="<YOUR_ENDPOINT_NAME>"

Pour configurer votre point de terminaison, créez un fichier YAML nommé create-endpoint.yaml qui contient les lignes suivantes :

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: my-endpoint
auth_mode: key

# To create a unique endpoint name, use a time stamp of the current date and time.
import datetime

endpoint_name = "sklearn-diabetes-" + datetime.datetime.now().strftime("%m%d%H%M%f")

endpoint = ManagedOnlineEndpoint(
    name=endpoint_name,
    description="An online endpoint to generate predictions for the diabetes dataset",
    auth_mode="key",
    tags={"env": "dev"},
)

Vous pouvez utiliser un fichier de configuration pour configurer les propriétés du point de terminaison. Dans ce cas, vous configurez le mode d’authentification du point de terminaison comme étant key.


# To create a unique endpoint name, use a time stamp of the current date and time.
import datetime

endpoint_name = "sklearn-diabetes-" + datetime.datetime.now().strftime("%m%d%H%M%f")

endpoint_config = {
    "auth_mode": "key",
    "identity": {
        "type": "system_assigned"
    }
}

Utilisez le code suivant pour écrire ces informations de configuration dans un fichier JSON :

endpoint_config_path = "endpoint_config.json"
with open(endpoint_config_path, "w") as outfile:
    outfile.write(json.dumps(endpoint_config))

Créez le point de terminaison :

az ml online-endpoint create --name $ENDPOINT_NAME -f endpoints/online/ncd/create-endpoint.yaml

ml_client.begin_create_or_update(endpoint)

endpoint = deployment_client.create_endpoint(
    name=endpoint_name,
    config={"endpoint-config-file": endpoint_config_path},
)

Configurez le déploiement. Un déploiement est un ensemble de ressources nécessaires pour héberger le modèle qui effectue l’inférence réelle.
Créez un fichier YAML nommé sklearn-deployment.yaml qui contient les lignes suivantes :
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: sklearn-deployment
endpoint_name: my-endpoint
model:
  name: mir-sample-sklearn-ncd-model
  version: 2
  path: sklearn-diabetes/model
  type: mlflow_model
instance_type: Standard_DS3_v2
instance_count: 1
```
```
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1
)
```
```
blue_deployment_name = "blue"
```
Pour configurer les exigences matérielles de votre déploiement, créez un fichier JSON avec la configuration souhaitée :
```
deploy_config = {
    "instance_type": "Standard_F4s_v2",
    "instance_count": 1,
}
```
Note

Pour plus d’informations sur la spécification complète de cette configuration, consultez le schéma YAML de déploiement en ligne managé CLI (v2).

Utilisez le code suivant pour écrire la configuration dans un fichier :
```
deployment_config_path = "deployment_config.json"
with open(deployment_config_path, "w") as outfile:
    outfile.write(json.dumps(deploy_config))
```
Vous effectuez cette étape dans la phase de déploiement.
Note

La génération automatique des scoring_script et environment n'est prise en charge que pour la version PyFunc du modèle. Pour utiliser une autre saveur de modèle, consultez Personnaliser les déploiements de modèles MLflow.
Créez le déploiement :
```
az ml online-deployment create --name sklearn-deployment --endpoint $ENDPOINT_NAME -f endpoints/online/ncd/sklearn-deployment.yaml --all-traffic
```
```
az ml online-deployment create --name sklearn-deployment --endpoint $ENDPOINT_NAME -f endpoints/online/ncd/sklearn-deployment.yaml --all-traffic
```
```
ml_client.online_deployments.begin_create_or_update(blue_deployment)
```
```
blue_deployment = deployment_client.create_deployment(
    name=blue_deployment_name,
    endpoint=endpoint_name,
    model_uri=f"models:/{model_name}/{version}",
    config={"deploy-config-file": deployment_config_path},
)    
```
1. Sélectionnez Points de terminaison. Accédez à l’onglet Points de terminaison en temps réel, puis sélectionnez Créer.
2. Sélectionnez le modèle MLflow que vous avez enregistré précédemment, puis sélectionnez Sélectionner.
  
  Note
  
  La page de configuration inclut une note pour vous informer que le script de scoring et l’environnement sont générés automatiquement pour votre modèle MLflow sélectionné.
3. Sous Point de terminaison, sélectionnez Nouveau pour déployer sur un nouveau point de terminaison.
4. Sous Nom du point de terminaison, entrez un nom pour le point de terminaison ou conservez le nom par défaut.
5. Sous Nom du déploiement, entrez un nom pour le déploiement ou conservez le nom par défaut.
6. Sélectionnez Déployer pour déployer le modèle sur le point de terminaison.
Attribuez tout le trafic au déploiement. Jusqu’à présent, le point de terminaison a un déploiement, mais aucun trafic ne lui est attribué.
Cette étape n’est pas requise dans le Azure CLI si vous utilisez le paramètre --all-traffic pendant la création. Si vous devez modifier le trafic, vous pouvez utiliser la az ml online-endpoint update --traffic commande. Pour plus d’informations sur la mise à jour du trafic, consultez Mise à jour progressive du trafic.
```
endpoint.traffic = {"blue": 100}
```
```
traffic_config = {"traffic": {blue_deployment_name: 100}}
```
Écrivez la configuration dans un fichier :
```
traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))
```
Cette étape n’est pas obligatoire dans le studio.
Mettez à jour la configuration du point de terminaison :
Cette étape n’est pas requise dans le Azure CLI si vous utilisez le paramètre --all-traffic pendant la création. Si vous avez besoin de modifier le trafic, vous pouvez utiliser la az ml online-endpoint update --traffic commande. Pour plus d’informations sur la mise à jour du trafic, consultez Mise à jour progressive du trafic.
```
ml_client.begin_create_or_update(endpoint).result()
```
```
deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)
```
Cette étape n’est pas obligatoire dans le studio.

Appeler le point de terminaison

Lorsque votre déploiement est prêt, vous pouvez l’utiliser pour traiter les demandes. Une façon de tester le déploiement consiste à utiliser la fonctionnalité d’appel intégrée dans votre client de déploiement. Dans le référentiel d’exemples, le fichier sample-request-sklearn.json contient le code JSON suivant. Vous pouvez l’utiliser comme exemple de fichier de requête pour le déploiement.

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

{
  "input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ]
    ],
    "index": [0]
  }
}

{
  "input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ]
    ],
    "index": [0]
  }
}

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

Note

Ce fichier utilise la input_data clé au lieu de inputs, que le service MLflow utilise. Azure Machine Learning nécessite un format d’entrée différent pour pouvoir générer automatiquement les contrats Swagger pour les points de terminaison. Pour plus d’informations sur les formats d’entrée attendus, consultez Déploiement dans le serveur intégré MLflow et le déploiement dans le serveur d’inférence Azure Machine Learning.

Envoyez une demande au point de terminaison :

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/ncd/sample-request-sklearn.json

response = ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    request_file="sample-request-sklearn.json",
)

# Read the sample request that's in the JSON file, and then construct a pandas data frame.
with open("sample-request-sklearn.json", "r") as f:
    sample_request = json.loads(f.read())
    samples = pd.DataFrame(**sample_request["input_data"])

deployment_client.predict(endpoint=endpoint_name, df=samples)

La réponse doit être similaire au texte suivant :

[ 
  11633.100167144921,
  8522.117402884991
]

[ 
  11633.100167144921
]

[ 
  11633.100167144921
]

[ 
  11633.100167144921,
  8522.117402884991
]

Important

Pour le déploiement sans code MLflow, le test via des points de terminaison locaux n’est actuellement pas pris en charge.

Personnalisez les déploiements de modèles MLflow

Il n'est pas nécessaire de spécifier un script de scoring dans la définition du déploiement d'un modèle MLflow vers un point de terminaison en ligne. Toutefois, vous pouvez spécifier un script de scoring si vous souhaitez personnaliser votre processus d’inférence.

Vous souhaitez généralement personnaliser votre déploiement de modèle MLflow dans les cas suivants :

Le modèle n’a pas de saveur PyFunc.
Vous devez personnaliser la façon dont vous exécutez le modèle. Par exemple, vous devez utiliser une saveur mlflow.<flavor>.load_model() spécifique pour charger le modèle.
Vous devez effectuer un prétraitement ou un post-traitement dans votre routine de scoring, car le modèle ne fait pas ce traitement.
La sortie du modèle ne peut pas être correctement représentée dans les données tabulaires. Par exemple, la sortie est un tenseur représentant une image.

Important

Si vous spécifiez 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écute.

Déployer un script de scoring personnalisé

Pour déployer un modèle MLflow qui utilise un script de scoring personnalisé, procédez comme suit.

Identifier le dossier du modèle

Identifiez le dossier qui contient votre modèle MLflow en effectuant les étapes suivantes :

Accédez à Azure Machine Learning Studio.
Accédez à la section Modèles.
Sélectionnez le modèle que vous souhaitez déployer et accédez à son onglet Artefacts.
Notez le dossier affiché. Lorsque vous inscrivez un modèle, vous spécifiez ce dossier.

Créer un script de scoring.

Le script de scoring suivant, score.py, fournit un exemple d’inférence avec un modèle MLflow. Vous pouvez adapter ce script à vos besoins ou modifier l’une de ses parties pour refléter votre scénario. Notez que le nom du dossier que vous avez identifié précédemment est modelinclus dans la init() fonction.

import logging
import os
import json
import mlflow
from io import StringIO
from mlflow.pyfunc.scoring_server import infer_and_parse_json_input, predictions_to_json


def init():
    global model
    global input_schema
    # "model" is the path of the mlflow artifacts when the model was registered. For automl
    # models, this is generally "mlflow-model".
    model_path = os.path.join(os.getenv("AZUREML_MODEL_DIR"), "model")
    model = mlflow.pyfunc.load_model(model_path)
    input_schema = model.metadata.get_input_schema()


def run(raw_data):
    json_data = json.loads(raw_data)
    if "input_data" not in json_data.keys():
        raise Exception("Request must contain a top level key named 'input_data'")

    serving_input = json.dumps(json_data["input_data"])
    data = infer_and_parse_json_input(serving_input, input_schema)
    predictions = model.predict(data)

    result = StringIO()
    predictions_to_json(predictions, result)
    return result.getvalue()

Warning

Avis MLflow 2.0 : L’exemple de script de scoring fonctionne avec MLflow 1.X et MLflow 2.X. Toutefois, les formats d’entrée et de sortie attendus sur ces versions peuvent varier. Vérifiez la définition de votre environnement pour voir la version MLflow que vous utilisez. MLflow 2.0 est pris en charge uniquement dans Python 3.8 et versions ultérieures.

Créer un environnement

L’étape suivante consiste à créer un environnement dans lequel vous pouvez exécuter le script de scoring. Étant donné que le modèle est un modèle MLflow, les exigences conda sont également spécifiées dans le package de modèle. Pour plus d’informations sur les fichiers inclus dans un modèle MLflow, consultez le format MLmodel. Vous générez l’environnement à l’aide des dépendances conda à partir du fichier. Toutefois, vous devez également inclure le azureml-inference-server-http package, qui est requis pour les déploiements en ligne dans Azure Machine Learning.

Vous pouvez créer un fichier de définition conda nommé conda.yaml qui contient les lignes suivantes :

channels:
- conda-forge
dependencies:
- python=3.12
- pip
- pip:
  - mlflow
  - scikit-learn==1.7.0
  - cloudpickle==3.1.1
  - psutil==7.0.0
  - pandas==2.3.0
  - azureml-inference-server-http
name: mlflow-env

Note

La dependencies section de ce fichier conda inclut le azureml-inference-server-http package.

Utilisez ce fichier de dépendances conda pour créer l’environnement :

L’environnement est créé en ligne dans la configuration du déploiement.

environment = Environment(
    conda_file="sklearn-diabetes/environment/conda.yaml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest",
)

Créer le déploiement

Dans le dossier endpoints/online/ncd, créez un fichier de configuration de déploiement, deployment.yml, qui contient les lignes suivantes :

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: sklearn-diabetes-custom
endpoint_name: my-endpoint
model: azureml:sklearn-diabetes@latest
environment: 
    image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04
    conda_file: sklearn-diabetes/environment/conda.yaml
code_configuration:
    code: sklearn-diabetes/src
    scoring_script: score.py
instance_type: Standard_F2s_v2
instance_count: 1

Créez le déploiement :

az ml online-deployment create -f endpoints/online/ncd/deployment.yml

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    environment=environment,
    code_configuration=CodeConfiguration(
        code="sklearn-diabetes/src",
        scoring_script="score.py"
    ),
    instance_type="Standard_F4s_v2",
    instance_count=1,
)

ml_client.online_deployments.begin_create_or_update(blue_deployment)

Traiter les demandes

Une fois votre déploiement terminé, il est prêt à traiter les demandes. Une façon de tester le déploiement consiste à utiliser la invoke méthode avec un exemple de fichier de requête tel que le fichier suivant, sample-request-sklearn.json:

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

{
  "input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ]
    ],
    "index": [0]
  }
}

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

Envoyez une demande au point de terminaison :

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/ncd/sample-request-sklearn.json

response = ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment.name,
    request_file="sample-request-sklearn.json",
)

La réponse doit être similaire au texte suivant :

{
    "predictions": [ 
    1095.2797413413252,
    1134.585328803727
    ]
}

{
    "predictions": [ 
    1095.2797413413252
    ]
}

{
    "predictions": [ 
    1095.2797413413252,
    1134.585328803727
    ]
}

Warning

Avis MLflow 2.0 : dans MLflow 1.X, la réponse ne contient pas la predictions clé.

Nettoyer les ressources

Si vous n’avez plus besoin du point de terminaison, supprimez ses ressources associées :

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

ml_client.online_endpoints.begin_delete(endpoint_name)

deployment_client.delete_endpoint(endpoint_name)

Commentaires

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

Last updated on 2025-10-09

Partager via

Configurer les paramètres initiaux

Configurer des paramètres personnalisés