S’APPLIQUE À :
Extension Azure CLI v2 (actuelle)
Kit de développement logiciel (SDK) Python azure-ai-ml v2 (version actuelle)
Dans cet article, vous allez apprendre à déployer votre modèle sur un point de terminaison en ligne pour une utilisation en temps réel de l’inférence. Vous commencez par déployer un modèle sur votre ordinateur local pour déboguer les erreurs. Ensuite, vous déployez et testez le modèle dans Azure, affichez les journaux de déploiement et surveillez le contrat de niveau de service (SLA). À la fin de cet article, vous disposez d’un point de terminaison HTTPS/REST évolutif que vous pouvez utiliser pour l’inférence en temps réel.
Les points de terminaison en ligne sont des points de terminaison utilisés pour l’inférence en temps réel. Il existe deux types de points de terminaison en ligne : les points de terminaison en ligne managés et les points de terminaison en ligne Kubernetes. Pour plus d’informations sur les différences, consultez Points de terminaison en ligne managés et points de terminaison en ligne Kubernetes.
Les points de terminaison en ligne managés vous aident à déployer vos modèles Machine Learning en un tournemain. Les points de terminaison en ligne managés fonctionnent avec des ordinateurs de processeur et GPU puissants dans Azure de manière évolutive et entièrement gérée. Les points de terminaison en ligne gérés s’occupent de servir, de mettre à l’échelle, de sécuriser et de surveiller vos modèles. Cette assistance vous libère de la surcharge liée à la configuration et à la gestion de l’infrastructure sous-jacente.
L’exemple principal de cet article utilise des points de terminaison en ligne managés pour le déploiement. Pour utiliser Kubernetes à la place, consultez les notes dans ce document qui sont incluses avec la discussion sur les points de terminaison en ligne managés.
Prérequis
S’APPLIQUE À :
Extension ml Azure CLI v2 (actuelle)
Azure CLI et l’extension ml
d’Azure CLI, installées et configurées. Pour plus d’informations, consultez Installer et configurer l’interface CLI (v2).
Un interpréteur de commandes Bash ou un interpréteur de commandes compatible, par exemple, un interpréteur de commandes sur un système Linux ou un sous-système Windows pour Linux. Les exemples Azure CLI de cet article supposent que vous utilisez ce type d’interpréteur de commandes.
Un espace de travail Azure Machine Learning. Pour obtenir des instructions sur la création d’un espace de travail, consultez Configurer.
Le contrôle d’accès en fonction du rôle Azure (Azure RBAC) est utilisé pour accorder l’accès aux opérations dans Azure Machine Learning. Pour effectuer les étapes décrites dans cet article, votre compte d’utilisateur doit être affecté au rôle Propriétaire ou Contributeur pour l’espace de travail Azure Machine Learning, ou un rôle personnalisé doit autoriser Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*
. Si vous utilisez Azure Machine Learning Studio pour créer et gérer des points de terminaison ou des déploiements en ligne, vous avez besoin de l’autorisation Microsoft.Resources/deployments/write
supplémentaire du propriétaire du groupe de ressources. Pour plus d’informations, consultez Gérer l’accès aux espaces de travail Azure Machine Learning.
(Facultatif) Pour déployer localement, vous devez installer Moteur Docker sur votre ordinateur local. Nous recommandons vivement cette option, ce qui facilite le débogage des problèmes.
S’APPLIQUE À :
Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)
Un espace de travail Azure Machine Learning. Pour connaître les étapes de création d’un espace de travail, consultez Créer l’espace de travail.
Kit de développement logiciel (SDK) Azure Machine Learning pour Python v2. Pour installer le Kit de développement logiciel (SDK), utilisez la commande suivante :
pip install azure-ai-ml azure-identity
Pour mettre à jour une installation existante du Kit de développement logiciel (SDK) vers la version la plus récente, utilisez la commande suivante :
pip install --upgrade azure-ai-ml azure-identity
Pour plus d’informations, consultez la bibliothèque de client du package Azure Machine Learning pour Python.
Azure RBAC est utilisé pour accorder l’accès aux opérations dans Azure Machine Learning. Pour effectuer les étapes décrites dans cet article, votre compte d’utilisateur doit être affecté au rôle Propriétaire ou Contributeur pour l’espace de travail Azure Machine Learning, ou un rôle personnalisé doit autoriser Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*
. Pour plus d’informations, consultez Gérer l’accès aux espaces de travail Azure Machine Learning.
(Facultatif) Pour déployer localement, vous devez installer Moteur Docker sur votre ordinateur local. Nous recommandons vivement cette option, ce qui facilite le débogage des problèmes.
Avant de suivre les étapes décrites dans cet article, vérifiez que vous disposez des conditions préalables suivantes :
L’interface de ligne de commande Azure et l’extension CLI pour Le Machine Learning sont utilisées dans ces étapes, mais elles ne sont pas le focus principal. Ils sont utilisés plus en tant qu’utilitaires pour passer des modèles à Azure et vérifier l’état des déploiements de modèles.
Azure CLI et l’extension ml
d’Azure CLI, installées et configurées. Pour plus d’informations, consultez Installer et configurer l’interface CLI (v2).
Un interpréteur de commandes Bash ou un interpréteur de commandes compatible, par exemple, un interpréteur de commandes sur un système Linux ou un sous-système Windows pour Linux. Les exemples Azure CLI de cet article supposent que vous utilisez ce type d’interpréteur de commandes.
Un espace de travail Azure Machine Learning. Pour obtenir des instructions sur la création d’un espace de travail, consultez Configurer.
- Azure RBAC est utilisé pour accorder l’accès aux opérations dans Azure Machine Learning. Pour effectuer les étapes décrites dans cet article, votre compte d’utilisateur doit être affecté au rôle Propriétaire ou Contributeur pour l’espace de travail Azure Machine Learning, ou un rôle personnalisé doit autoriser
Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*
. Pour plus d’informations, consultez Gérer l’accès à un espace de travail Azure Machine Learning.
Vérifiez que vous disposez d’un quota de machine virtuelle suffisant alloué pour le déploiement. Azure Machine Learning réserve 20% de vos ressources de calcul pour effectuer des mises à niveau sur certaines versions de machine virtuelle. Par exemple, si vous demandez 10 instances dans un déploiement, vous devez disposer d’un quota de 12 pour chaque nombre de cœurs pour la version de la machine virtuelle. L’échec du compte des ressources de calcul supplémentaires entraîne une erreur. Certaines versions de machine virtuelle sont exemptées de la réservation de quota supplémentaire. Pour plus d’informations sur l’allocation de quota, consultez Allocation de quota de machines virtuelles pour le déploiement.
Vous pouvez également utiliser le quota à partir du pool de quotas partagés Azure Machine Learning pendant une durée limitée. Azure Machine Learning fournit un pool de quotas partagé auquel les utilisateurs de diverses régions peuvent accéder pour effectuer des tests pendant une durée limitée, en fonction de la disponibilité.
Lorsque vous utilisez le studio pour déployer des modèles Llama-2, Phi, Nemotron, Mistral, Dolly et Deci-DeciLM à partir du catalogue de modèles vers un point de terminaison en ligne managé, Azure Machine Learning vous permet d’accéder à son pool de quotas partagés pendant une courte période afin de pouvoir effectuer des tests. Pour plus d’informations sur le pool de quotas partagés, consultez quota partagé Azure Machine Learning.
Préparer votre système
Définir des variables d’environnement
Si vous n’avez pas encore défini les paramètres par défaut pour l’interface CLI Azure, enregistrez vos paramètres par défaut. Pour éviter de transmettre plusieurs fois les valeurs de votre abonnement, de votre espace de travail et de votre groupe de ressources, exécutez le code suivant :
az account set --subscription <subscription ID>
az configure --defaults workspace=<Azure Machine Learning workspace name> group=<resource group>
Cloner le référentiel d’exemples
Pour suivre cet article, commencez par cloner le référentiel azureml-examples, puis passez au répertoire azureml-examples/cli du référentiel :
git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples/cli
Utilisez --depth 1
pour cloner uniquement le dernier commit dans le référentiel, ce qui réduit le temps nécessaire à l'opération.
Les commandes de ce didacticiel se trouvent dans les fichiers deploy-local-endpoint.sh et deploy-managed-online-endpoint.sh dans le répertoire cli . Les fichiers de configuration YAML se trouvent dans le sous-répertoire endpoints/online/managed/sample/.
Notes
Les fichiers de configuration YAML pour les points de terminaison en ligne Kubernetes se trouvent dans les points de terminaison/online/kubernetes/ sous-répertoire.
Cloner le référentiel d’exemples
Pour exécuter les exemples d’apprentissage, clonez d’abord le référentiel azureml-examples, puis passez au répertoire azureml-examples/sdk/python/endpoints/online/managed directory :
git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples/sdk/python/endpoints/online/managed
Utilisez --depth 1
pour cloner uniquement le dernier commit dans le dépôt, ce qui réduit le temps nécessaire pour effectuer l’opération.
Les informations contenues dans cet article sont basées sur le notebook online-endpoints-simple-deployment.ipynb. Il contient le même contenu que cet article, bien que l’ordre des codes soit légèrement différent.
Se connecter à un espace de travail Azure Machine Learning
L’espace de travail est la ressource de niveau supérieur du service Azure Machine Learning. Il fournit un emplacement centralisé pour travailler avec tous les artefacts que vous créez lorsque vous utilisez Azure Machine Learning. Dans cette section, vous vous connectez à l’espace de travail dans lequel vous effectuez des tâches de déploiement. Pour suivre cette procédure, ouvrez votre notebook online-endpoints-simple-deployment.ipynb .
Importez les bibliothèques nécessaires :
# import required libraries
from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
ManagedOnlineEndpoint,
ManagedOnlineDeployment,
Model,
Environment,
CodeConfiguration
)
from azure.identity import DefaultAzureCredential
Notes
Si vous utilisez le point de terminaison en ligne Kubernetes, importez les classes KubernetesOnlineEndpoint
et KubernetesOnlineDeployment
à partir de la bibliothèque azure.ai.ml.entities
.
Configurez les détails de l’espace de travail et obtenez un handle pour l’espace de travail.
Pour vous connecter à un espace de travail, vous avez besoin de ces paramètres d’identificateur : un abonnement, un groupe de ressources et un nom d’espace de travail. Vous utilisez ces détails MLClient
azure.ai.ml
pour obtenir un handle vers l’espace de travail Azure Machine Learning requis. Cet exemple utilise l’authentification Azure par défaut.
# enter details of your Azure Machine Learning workspace
subscription_id = "<subscription ID>"
resource_group = "<resource group>"
workspace = "<workspace name>"
# get a handle to the workspace
ml_client = MLClient(
DefaultAzureCredential(), subscription_id, resource_group, workspace
)
Si Git est installé sur votre ordinateur local, vous pouvez suivre les instructions pour cloner le référentiel d’exemples. Sinon, suivez les instructions pour télécharger des fichiers à partir du référentiel d’exemples.
Cloner le référentiel d’exemples
Pour suivre cet article, clonez d’abord le référentiel azureml-examples, puis passez au répertoire azureml-examples/cli/endpoints/online/model-1 .
git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples/cli/endpoints/online/model-1
Utilisez --depth 1
pour cloner uniquement le dernier commit dans le référentiel, ce qui réduit le temps d’exécution de l’opération.
Télécharger des fichiers à partir du référentiel d’exemples
Si vous avez cloné le référentiel d’exemples, votre ordinateur local dispose déjà de copies des fichiers pour cet exemple et vous pouvez passer à la section suivante. Si vous n’avez pas cloné le dépôt, téléchargez-le sur votre ordinateur local.
- Accédez au référentiel d’exemples (azureml-examples).
- Accédez au <> bouton Code de la page, puis sous l’onglet Local , sélectionnez Télécharger le fichier ZIP.
- Recherchez le dossier /cli/endpoints/online/model-1/model et le fichier /cli/endpoints/online/model-1/onlinescoring/score.py.
Définir des variables d’environnement
Définissez les variables d’environnement suivantes pour pouvoir les utiliser dans les exemples de cet article. Remplacez les valeurs par votre ID d’abonnement Azure, la région Azure où se trouve votre espace de travail, le groupe de ressources qui contient l’espace de travail et le nom de l’espace de travail :
export SUBSCRIPTION_ID="<subscription ID>"
export LOCATION="<your region>"
export RESOURCE_GROUP="<resource group>"
export WORKSPACE="<workspace name>"
Quelques exemples de modèles vous obligent à charger des fichiers dans Stockage Blob Azure pour votre espace de travail. Les étapes suivantes interrogent l’espace de travail et stockent ces informations dans les variables d’environnement utilisées dans les exemples :
Obtenez un jeton d’accès :
TOKEN=$(az account get-access-token --query accessToken -o tsv)
Définissez la version de l’API REST :
API_VERSION="2022-05-01"
Obtenez les informations de stockage :
# Get values for storage account
response=$(curl --location --request GET "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/datastores?api-version=$API_VERSION&isDefault=true" \
--header "Authorization: Bearer $TOKEN")
AZUREML_DEFAULT_DATASTORE=$(echo $response | jq -r '.value[0].name')
AZUREML_DEFAULT_CONTAINER=$(echo $response | jq -r '.value[0].properties.containerName')
export AZURE_STORAGE_ACCOUNT=$(echo $response | jq -r '.value[0].properties.accountName')
Cloner le référentiel d’exemples
Pour suivre cet article, commencez par cloner le référentiel azureml-examples, puis passez au répertoire azureml-examples :
git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples
Utilisez --depth 1
pour cloner uniquement le dernier commit vers le référentiel, ce qui réduit le temps nécessaire pour terminer l'opération.
Définir le point de terminaison
Pour définir un point de terminaison en ligne, spécifiez le nom du point de terminaison et le mode d’authentification. Pour plus d’informations sur les points de terminaison en ligne managés, consultez points de terminaison en ligne.
Définir un nom d’un point de terminaison
Pour définir le nom de votre point de terminaison, exécutez la commande suivante. Remplacez <YOUR_ENDPOINT_NAME>
par un nom unique dans la région Azure. Pour obtenir plus d’informations sur les règles d’affectation de noms, consultez Limites de point de terminaison.
export ENDPOINT_NAME="<YOUR_ENDPOINT_NAME>"
L’extrait de code suivant montre le fichier endpoints/online/managed/sample/endpoint.yml :
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: my-endpoint
auth_mode: key
La référence pour le format YAML du point de terminaison est décrite dans le tableau suivant. Pour savoir comment spécifier ces attributs, consultez la référence YAML du point de terminaison en ligne. Pour plus d’informations sur les limites liées aux points de terminaison managés, consultez les points de terminaison en ligne Azure Machine Learning et les points de terminaison par lots.
Clé |
Descriptif |
$schema |
(Facultatif) Schéma YAML. Pour voir toutes les options disponibles dans le fichier YAML, vous pouvez consulter le schéma dans l’extrait de code précédent avec un navigateur. |
name |
Nom du point de terminaison. |
auth_mode |
Utilisez key pour l’authentification basée sur les clés. Utilisez aml_token pour l’authentification Azure Machine Learning basée sur les jetons. Utilisez aad_token pour l’authentification basée sur le jeton Microsoft Entra (préversion). Pour plus d’informations sur l’authentification, consultez Authentifier les clients pour les points de terminaison en ligne. |
Définissez d’abord le nom du point de terminaison en ligne, puis configurez le point de terminaison.
Remplacez <YOUR_ENDPOINT_NAME>
par un nom unique dans la région Azure ou utilisez l’exemple de méthode pour définir un nom aléatoire. Veillez à supprimer la méthode que vous n’utilisez pas. Pour plus d’informations sur les règles d’affectation de noms, consultez Limites de point de terminaison.
# method 1: define an endpoint name
endpoint_name = "<YOUR_ENDPOINT_NAME>"
# method 2: example way to define a random name
import datetime
endpoint_name = "endpt-" + datetime.datetime.now().strftime("%m%d%H%M%f")
# create an online endpoint
endpoint = ManagedOnlineEndpoint(
name = endpoint_name,
description="this is a sample endpoint",
auth_mode="key"
)
Le code précédent utilise key
pour l’authentification par clé. Pour utiliser l’authentification basée sur un jeton Azure Machine Learning, utilisez aml_token
. Pour utiliser l’authentification basée sur les jetons Microsoft Entra (préversion), utilisez aad_token
. Pour plus d’informations sur l’authentification, consultez Authentifier les clients pour les points de terminaison en ligne.
Lorsque vous déployez sur Azure à partir du studio, vous créez un point de terminaison et un déploiement à y ajouter. À ce stade, vous êtes invité à fournir des noms pour le point de terminaison et le déploiement.
Définir un nom d’un point de terminaison
Pour définir le nom de votre point de terminaison, exécutez la commande suivante pour générer un nom aléatoire. Il doit être unique au sein de la région Azure. Pour plus d’informations sur les règles d’affectation de noms, consultez Limites de point de terminaison.
export ENDPOINT_NAME=endpoint-`echo $RANDOM`
Pour définir le point de terminaison et le déploiement, cet article utilise les modèles Azure Resource Manager (modèles ARM) online-endpoint.json et online-endpoint-deployment.json. Pour utiliser les modèles afin de définir un point de terminaison et un déploiement en ligne, consultez la section Déployer sur Azure.
Définir 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. Pour cet exemple, vous déployez un modèle qui effectue une scikit-learn
régression et utilisez un script de scoring score.py pour exécuter le modèle sur une demande d’entrée spécifique.
Pour en savoir plus sur les attributs clés d’un déploiement, consultez déploiements en ligne.
Votre configuration de déploiement utilise l’emplacement du modèle que vous souhaitez déployer.
L’extrait de code suivant montre le fichier endpoints/online/managed/sample/blue-deployment.yml avec toutes les entrées nécessaires pour configurer un déploiement :
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: blue
endpoint_name: my-endpoint
model:
path: ../../model-1/model/
code_configuration:
code: ../../model-1/onlinescoring/
scoring_script: score.py
environment:
conda_file: ../../model-1/environment/conda.yaml
image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest
instance_type: Standard_DS3_v2
instance_count: 1
Le fichier blue-deployment.yml spécifie les attributs de déploiement suivants :
model
: spécifie les propriétés du modèle inline à l’aide du path
paramètre (où charger des fichiers à partir de). L’interface CLI charge automatiquement les fichiers de modèle et inscrit le modèle avec un nom généré automatiquement.
environment
: utilise des définitions inline qui incluent l’emplacement à partir duquel charger des fichiers. L’interface CLI charge automatiquement le fichier conda.yaml et inscrit l’environnement. Plus tard, pour générer l’environnement, le déploiement utilise le image
paramètre pour l’image de base. Dans cet exemple, il est mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
. Les conda_file
dépendances sont installées sur l’image de base.
code_configuration
: charge les fichiers locaux, tels que la source Python pour le modèle de scoring, à partir de l’environnement de développement pendant le déploiement.
Pour plus d’informations sur le schéma YAML, consultez le document Référence YAML sur les points de terminaison en ligne.
Notes
Pour utiliser des points de terminaison Kubernetes au lieu de points de terminaison en ligne gérés comme cible de calcul :
- Créez et attachez votre cluster Kubernetes comme cible de calcul à votre espace de travail Azure Machine Learning avec Azure Machine Learning Studio.
- Utilisez le YAML du point de terminaison pour cibler Kubernetes au lieu du YAML du point de terminaison géré. Vous devez modifier le YAML pour modifier la valeur de
compute
en nom de votre cible de calcul inscrite. Vous pouvez utiliser ce deployment.yaml qui a d’autres propriétés qui s’appliquent à un déploiement Kubernetes.
Toutes les commandes utilisées dans cet article pour les points de terminaison en ligne managés s’appliquent également aux points de terminaison Kubernetes, à l’exception des fonctionnalités suivantes qui ne s’appliquent pas aux points de terminaison Kubernetes :
Utilisez le code suivant pour configurer un déploiement :
model = Model(path="../model-1/model/sklearn_regression_model.pkl")
env = Environment(
conda_file="../model-1/environment/conda.yaml",
image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
blue_deployment = ManagedOnlineDeployment(
name="blue",
endpoint_name=endpoint_name,
model=model,
environment=env,
code_configuration=CodeConfiguration(
code="../model-1/onlinescoring", scoring_script="score.py"
),
instance_type="Standard_DS3_v2",
instance_count=1,
)
Model
: spécifie les propriétés du modèle inline à l’aide du path
paramètre (où charger des fichiers à partir de). Le Kit de développement logiciel (SDK) charge automatiquement les fichiers de modèle et inscrit le modèle avec un nom généré automatiquement.
Environment
: utilise des définitions inline qui incluent l’emplacement à partir duquel charger des fichiers. Le Kit de développement logiciel (SDK) charge automatiquement le fichier conda.yaml et inscrit l’environnement. Plus tard, pour générer l’environnement, le déploiement utilise le image
paramètre pour l’image de base. Dans cet exemple, il est mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
. Les conda_file
dépendances sont installées sur l’image de base.
CodeConfiguration
: charge les fichiers locaux, tels que la source Python pour le modèle de scoring, à partir de l’environnement de développement pendant le déploiement.
Pour plus d’informations sur la définition de déploiement en ligne, consultez classe OnlineDeployment.
Lorsque vous effectuez un déploiement sur Azure, vous créez un point de terminaison et un déploiement à y ajouter. À ce stade, vous êtes invité à fournir des noms pour le point de terminaison et le déploiement.
Comprendre le script de scoring
Le format du script de scoring pour les points de terminaison en ligne est le même que celui utilisé dans la version précédente de l’interface CLI et dans le SDK Python.
Le script de scoring spécifié dans code_configuration.scoring_script
doit avoir une fonction init()
et une fonction run()
.
Le script de scoring doit avoir une fonction init()
et une fonction run()
.
Le script de scoring doit avoir une fonction init()
et une fonction run()
.
Le script de scoring doit avoir une fonction init()
et une fonction run()
. Cet article utilise le fichier score.py.
Lorsque vous utilisez un modèle pour le déploiement, vous devez d’abord charger le fichier d’évaluation dans le stockage Blob, puis l’inscrire :
Le code suivant utilise la commande az storage blob upload-batch
Azure CLI pour charger le fichier de scoring :
az storage blob upload-batch -d $AZUREML_DEFAULT_CONTAINER/score -s cli/endpoints/online/model-1/onlinescoring --account-name $AZURE_STORAGE_ACCOUNT
Le code suivant utilise un modèle pour inscrire le code :
az deployment group create -g $RESOURCE_GROUP \
--template-file arm-templates/code-version.json \
--parameters \
workspaceName=$WORKSPACE \
codeAssetName="score-sklearn" \
codeUri="https://$AZURE_STORAGE_ACCOUNT.blob.core.windows.net/$AZUREML_DEFAULT_CONTAINER/score"
Cet exemple utilise le fichier score.py à partir du dépôt que vous avez cloné ou téléchargé précédemment :
import os
import logging
import json
import numpy
import joblib
def init():
"""
This function is called when the container is initialized/started, typically after create/update of the deployment.
You can write the logic here to perform init operations like caching the model in memory
"""
global model
# AZUREML_MODEL_DIR is an environment variable created during deployment.
# It is the path to the model folder (./azureml-models/$MODEL_NAME/$VERSION)
# Please provide your model's folder name if there is one
model_path = os.path.join(
os.getenv("AZUREML_MODEL_DIR"), "model/sklearn_regression_model.pkl"
)
# deserialize the model file back into a sklearn model
model = joblib.load(model_path)
logging.info("Init complete")
def run(raw_data):
"""
This function is called for every invocation of the endpoint to perform the actual scoring/prediction.
In the example we extract the data from the json input and call the scikit-learn model's predict()
method and return the result back
"""
logging.info("model 1: request received")
data = json.loads(raw_data)["data"]
data = numpy.array(data)
result = model.predict(data)
logging.info("Request processed")
return result.tolist()
La fonction init()
est appelée lorsque le conteneur est initialisé ou démarré. Cette initialisation se produit généralement peu après la création ou la mise à jour du déploiement. La fonction init
est l’endroit où écrire une logique pour les opérations d’initialisation globales, telles que la mise en cache du modèle en mémoire (comme indiqué dans ce fichier score.py).
La run()
fonction est appelée chaque fois que le point de terminaison est appelé. Il effectue les véritables évaluations et prédictions. Dans ce fichier score.py, la fonction run()
extrait les données d’une entrée JSON, appelle la méthode predict()
du modèle scikit-learn, puis retourne le résultat de prédiction.
Déployer et déboguer localement à l’aide d’un point de terminaison local
Nous vous recommandons vivement de tester votre point de terminaison localement pour valider et déboguer votre code et votre configuration avant de déployer sur Azure. Azure CLI et le Kit de développement logiciel (SDK) Python prennent en charge les points de terminaison et les déploiements locaux, mais pas les modèles Azure Machine Learning Studio et ARM.
Pour effectuer un déploiement local, le moteur Docker doit être installé et en cours d’exécution. Le moteur Docker démarre généralement au démarrage de l’ordinateur. Si ce n’est pas le cas, vous pouvez dépanner le Moteur Docker.
Vous pouvez utiliser le package Python du serveur HTTP d’inférence Azure Machine Learning pour déboguer votre script de scoring localement sans le moteur Docker. Le débogage avec le serveur d’inférence vous permet de déboguer le script de scoring avant de déployer sur des points de terminaison locaux afin de pouvoir déboguer sans être affecté par les configurations de conteneur de déploiement.
Pour plus d’informations sur le débogage des points de terminaison en ligne localement avant de déployer sur Azure, consultez débogage de point de terminaison en ligne.
Déployer le modèle localement
Tout d’abord, créez un point de terminaison. Si vous le souhaitez, pour un point de terminaison local, vous pouvez ignorer cette étape. Vous pouvez créer le déploiement directement (étape suivante), ce qui crée à son tour les métadonnées requises. Le déploiement de modèles localement est utile à des fins de développement et de test.
az ml online-endpoint create --local -n $ENDPOINT_NAME -f endpoints/online/managed/sample/endpoint.yml
ml_client.online_endpoints.begin_create_or_update(endpoint, local=True)
Le studio ne prend pas en charge les points de terminaison locaux. Pour connaître les étapes de test du point de terminaison localement, consultez les onglets Azure CLI ou Python.
Le modèle ne prend pas en charge les points de terminaison locaux. Pour connaître les étapes de test du point de terminaison localement, consultez les onglets Azure CLI ou Python.
À présent, créez un déploiement nommé blue
sous le point de terminaison.
az ml online-deployment create --local -n blue --endpoint $ENDPOINT_NAME -f endpoints/online/managed/sample/blue-deployment.yml
L’indicateur --local
oriente l’interface CLI pour déployer le point de terminaison dans l’environnement Docker.
ml_client.online_deployments.begin_create_or_update(
deployment=blue_deployment, local=True
)
L’indicateur local=True
oriente le SDK pour déployer le point de terminaison dans l’environnement Docker.
Le studio ne prend pas en charge les points de terminaison locaux. Pour connaître les étapes de test du point de terminaison localement, consultez les onglets Azure CLI ou Python.
Le modèle ne prend pas en charge les points de terminaison locaux. Pour connaître les étapes de test du point de terminaison localement, consultez les onglets Azure CLI ou Python.
Vérifier que le déploiement local a réussi
Vérifiez l’état du déploiement pour déterminer si le modèle a été déployé sans erreur :
az ml online-endpoint show -n $ENDPOINT_NAME --local
Le résultat doit ressembler au JSON suivant. Le provisioning_state
paramètre est Succeeded
.
{
"auth_mode": "key",
"location": "local",
"name": "docs-endpoint",
"properties": {},
"provisioning_state": "Succeeded",
"scoring_uri": "http://localhost:49158/score",
"tags": {},
"traffic": {}
}
ml_client.online_endpoints.get(name=endpoint_name, local=True)
La méthode retourne une ManagedOnlineEndpoint
entité. Le provisioning_state
paramètre est Succeeded
.
ManagedOnlineEndpoint({'public_network_access': None, 'provisioning_state': 'Succeeded', 'scoring_uri': 'http://localhost:49158/score', 'swagger_uri': None, 'name': 'endpt-10061534497697', 'description': 'this is a sample endpoint', 'tags': {}, 'properties': {}, 'id': None, 'Resource__source_path': None, 'base_path': '/path/to/your/working/directory', 'creation_context': None, 'serialize': <msrest.serialization.Serializer object at 0x7ffb781bccd0>, 'auth_mode': 'key', 'location': 'local', 'identity': None, 'traffic': {}, 'mirror_traffic': {}, 'kind': None})
Le studio ne prend pas en charge les points de terminaison locaux. Pour connaître les étapes de test du point de terminaison localement, consultez les onglets Azure CLI ou Python.
Le modèle ne prend pas en charge les points de terminaison locaux. Pour connaître les étapes de test du point de terminaison localement, consultez les onglets Azure CLI ou Python.
Le tableau suivant contient les valeurs possibles de provisioning_state
:
Valeur |
Descriptif |
Creating |
La ressource est en cours de création. |
Updating |
La ressource est en cours de mise à jour. |
Deleting |
La ressource est en cours de suppression. |
Succeeded |
L’opération de création ou de mise à jour a réussi. |
Failed |
Échec de l’opération de création, de mise à jour ou de suppression. |
Appeler le point de terminaison local pour effectuer la notation des données avec votre modèle
Appelez le point de terminaison pour noter le modèle à l’aide de la commande invoke
et en passant des paramètres de requête stockés dans un fichier JSON :
az ml online-endpoint invoke --local --name $ENDPOINT_NAME --request-file endpoints/online/model-1/sample-request.json
Si vous souhaitez utiliser un client REST (par exemple, une boucle), vous devez disposer de l’URI de notation. Pour récupérer l’URI de notation, exécutez az ml online-endpoint show --local -n $ENDPOINT_NAME
. Dans les données retournées, recherchez l’attribut scoring_uri
.
Appelez le point de terminaison pour noter le modèle à l’aide de la commande invoke
et en passant des paramètres de requête stockés dans un fichier JSON.
ml_client.online_endpoints.invoke(
endpoint_name=endpoint_name,
request_file="../model-1/sample-request.json",
local=True,
)
Si vous souhaitez utiliser un client REST (par exemple, une boucle), vous devez disposer de l’URI de notation. Pour obtenir l’URI de scoring, exécutez le code suivant. Dans les données retournées, recherchez l’attribut scoring_uri
.
endpoint = ml_client.online_endpoints.get(endpoint_name, local=True)
scoring_uri = endpoint.scoring_uri
Le studio ne prend pas en charge les points de terminaison locaux. Pour connaître les étapes de test du point de terminaison localement, consultez les onglets Azure CLI ou Python.
Le modèle ne prend pas en charge les points de terminaison locaux. Pour connaître les étapes de test du point de terminaison localement, consultez les onglets Azure CLI ou Python.
Rechercher dans les journaux la sortie de l’opération d’appel
Dans l’exemple fichier score.py, la méthode run()
journalise une sortie dans la console.
Vous pouvez afficher cette sortie en utilisant la commande get-logs
:
az ml online-deployment get-logs --local -n blue --endpoint $ENDPOINT_NAME
Vous pouvez afficher cette sortie en utilisant la méthode get_logs
:
ml_client.online_deployments.get_logs(
name="blue", endpoint_name=endpoint_name, local=True, lines=50
)
Le studio ne prend pas en charge les points de terminaison locaux. Pour connaître les étapes de test du point de terminaison localement, consultez les onglets Azure CLI ou Python.
Le modèle ne prend pas en charge les points de terminaison locaux. Pour connaître les étapes de test du point de terminaison localement, consultez les onglets Azure CLI ou Python.
Déployer votre point de terminaison en ligne dans Azure
Ensuite, déployez votre point de terminaison en ligne dans Azure. Comme meilleure pratique pour la production, nous vous recommandons d’inscrire le modèle et l’environnement que vous utilisez dans votre déploiement.
Inscrire votre modèle et votre environnement
Nous vous recommandons d’inscrire votre modèle et votre environnement avant le déploiement sur Azure afin de pouvoir spécifier leurs noms et versions inscrits pendant le déploiement. Après avoir inscrit vos ressources, vous pouvez les réutiliser sans avoir à les charger chaque fois que vous créez des déploiements. Cette pratique augmente la reproductibilité et la traçabilité.
Contrairement au déploiement vers Azure, le déploiement local ne prend pas en charge l’utilisation de modèles et d’environnements inscrits. Au lieu de cela, le déploiement local utilise des fichiers de modèle local et utilise des environnements avec des fichiers locaux uniquement.
Pour le déploiement sur Azure, vous pouvez utiliser des ressources locales ou inscrites (modèles et environnements). Dans cette section de l’article, le déploiement sur Azure utilise des ressources inscrites, mais vous avez la possibilité d’utiliser des ressources locales à la place. Pour obtenir un exemple de configuration de déploiement qui charge les fichiers locaux à utiliser pour le déploiement local, consultez Configurer un déploiement.
Pour inscrire le modèle et l’environnement, utilisez le formulaire model: azureml:my-model:1
ou environment: azureml:my-env:1
.
Pour l'inscription, vous pouvez extraire les définitions YAML de model
et environment
vers des fichiers YAML distincts dans le dossier endpoints/online/managed/sample, et utiliser les commandes az ml model create
et az ml environment create
. Pour en savoir plus sur ces commandes, exécutez az ml model create -h
et az ml environment create -h
.
Créez une définition YAML pour le modèle. Nommez le fichier model.yml :
$schema: https://azuremlschemas.azureedge.net/latest/model.schema.json
name: my-model
path: ../../model-1/model/
Inscrivez le modèle :
az ml model create -n my-model -v 1 -f endpoints/online/managed/sample/model.yml
Créez une définition YAML pour l’environnement. Nommez le fichier environment.yml :
$schema: https://azuremlschemas.azureedge.net/latest/environment.schema.json
name: my-env
image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
conda_file: ../../model-1/environment/conda.yaml
Inscrivez l’environnement :
az ml environment create -n my-env -v 1 -f endpoints/online/managed/sample/environment.yml
Pour plus d’informations sur l’inscription de votre modèle en tant que ressource, consultez Inscrire un modèle à l’aide de l’interface de ligne de commande Azure ou du Kit de développement logiciel (SDK) Python. Pour plus d’informations sur la création d’un environnement, consultez Créer un environnement personnalisé.
Inscrire un modèle :
from azure.ai.ml.entities import Model
from azure.ai.ml.constants import AssetTypes
file_model = Model(
path="../model-1/model/",
type=AssetTypes.CUSTOM_MODEL,
name="my-model",
description="Model created from local file.",
)
ml_client.models.create_or_update(file_model)
Inscrivez l’environnement :
from azure.ai.ml.entities import Environment
env_docker_conda = Environment(
image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
conda_file="../model-1/environment/conda.yaml",
name="my-env",
description="Environment created from a Docker image plus Conda environment.",
)
ml_client.environments.create_or_update(env_docker_conda)
Pour savoir comment inscrire votre modèle en tant que ressource afin de pouvoir spécifier son nom et sa version inscrits pendant le déploiement, consultez Inscrire un modèle à l’aide de l’interface de ligne de commande Azure ou du Kit de développement logiciel (SDK) Python.
Pour plus d’informations sur la création d’un environnement, consultez Créer un environnement personnalisé.
Inscrire le modèle
Une inscription de modèle est une entité logique dans l’espace de travail qui peut contenir un fichier de modèle unique ou un répertoire comprenant plusieurs fichiers. En guise de meilleure pratique pour la production, inscrivez le modèle et l’environnement. Avant de créer le point de terminaison et le déploiement dans cet article, inscrivez le dossier de modèle qui contient le modèle.
Suivez ces étapes pour enregistrer l’exemple de modèle :
Accédez à Azure Machine Learning Studio.
Dans le volet gauche, sélectionnez la page Modèles .
Sélectionnez Enregistrer, puis choisissez À partir de fichiers locaux.
Sélectionnez Type non spécifié pour le Type de modèle.
Sélectionnez Parcourir, puis choisissez Parcourir le dossier.
Sélectionnez le dossier \azureml-examples\cli\endpoints\online\model-1\model à partir de la copie locale du dépôt que vous avez cloné ou téléchargé précédemment. Lorsque vous y êtes invité, sélectionnez Charger et attendre la fin du chargement.
Cliquez sur Suivant.
Entrez un nom convivial pour le modèle. Les étapes décrites dans cet article supposent que le modèle est nommé model-1
.
Sélectionnez Suivant, puis Inscrivez-vous pour terminer l’inscription.
Pour plus d’informations sur l’utilisation des modèles inscrits, consultez Utiliser des modèles inscrits.
Créer et inscrire l’environnement
Dans le volet gauche, sélectionnez la page Environnements .
Sélectionnez l’onglet Environnements personnalisés , puis choisissez Créer.
Dans la page Paramètres , entrez un nom, tel que my-env pour l’environnement.
Pour sélectionner une source d’environnement, choisissez Utiliser l’image Docker existante avec la source conda facultative.
Sélectionnez Suivant pour accéder à la page Personnaliser .
Copiez le contenu du fichier \azureml-examples\cli\endpoints\online\model-1\environment\conda.yaml à partir du dépôt que vous avez cloné ou téléchargé précédemment.
Collez le contenu dans la zone de texte.
Sélectionnez Suivant jusqu’à ce que vous accédiez à la page Créer , puis sélectionnez Créer.
Pour plus d’informations sur la création d’un environnement dans studio, consultez Créer un environnement.
Pour inscrire le modèle à l'aide d'un modèle prédéfini, vous devez d'abord charger le fichier du modèle dans Azure Blob Storage. L’exemple suivant utilise la commande az storage blob upload-batch
pour charger un fichier dans le stockage par défaut de votre espace de travail :
az storage blob upload-batch -d $AZUREML_DEFAULT_CONTAINER/model -s cli/endpoints/online/model-1/model --account-name $AZURE_STORAGE_ACCOUNT
Après avoir chargé le fichier, utilisez le modèle pour créer un enregistrement de modèle. Dans l’exemple suivant, le paramètre modelUri
contient le chemin d’accès au modèle :
az deployment group create -g $RESOURCE_GROUP \
--template-file arm-templates/model-version.json \
--parameters \
workspaceName=$WORKSPACE \
modelAssetName="sklearn" \
modelUri="azureml://subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/workspaces/$WORKSPACE/datastores/$AZUREML_DEFAULT_DATASTORE/paths/model/sklearn_regression_model.pkl"
Une partie de l’environnement est un fichier conda qui spécifie les dépendances de modèle nécessaires pour héberger le modèle. L’exemple suivant montre comment lire le contenu du fichier conda dans des variables d’environnement :
CONDA_FILE=$(cat cli/endpoints/online/model-1/environment/conda.yaml)
L’exemple suivant montre comment utiliser le modèle pour inscrire l’environnement. Le contenu du fichier conda de l’étape précédente est transmis au modèle à l’aide du condaFile
paramètre :
ENV_VERSION=$RANDOM
az deployment group create -g $RESOURCE_GROUP \
--template-file arm-templates/environment-version.json \
--parameters \
workspaceName=$WORKSPACE \
environmentAssetName=sklearn-env \
environmentAssetVersion=$ENV_VERSION \
dockerImage=mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:20210727.v1 \
condaFile="$CONDA_FILE"
Important
Lorsque vous définissez un environnement personnalisé pour votre déploiement, vérifiez que le azureml-inference-server-http
package est inclus dans le fichier conda. Ce package est essentiel pour que le serveur d’inférence fonctionne correctement. Si vous ne connaissez pas la création de votre propre environnement personnalisé, utilisez l’un de nos environnements organisés tels que minimal-py-inference
(pour les modèles personnalisés qui n’utilisent mlflow
pas) ou mlflow-py-inference
(pour les modèles qui utilisent mlflow
). Vous trouverez ces environnements organisés sous l’onglet Environnements de votre instance d’Azure Machine Learning Studio.
Votre configuration de déploiement utilise le modèle inscrit que vous souhaitez déployer et votre environnement inscrit.
Utilisez les ressources inscrites (modèle et environnement) dans votre définition de déploiement. L’extrait de code suivant montre le fichier endpoints/online/managed/sample/blue-deployment-with-registered-assets.yml, avec toutes les entrées requises pour configurer un déploiement :
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: blue
endpoint_name: my-endpoint
model: azureml:my-model:1
code_configuration:
code: ../../model-1/onlinescoring/
scoring_script: score.py
environment: azureml:my-env:1
instance_type: Standard_DS3_v2
instance_count: 1
Pour configurer un déploiement, utilisez le modèle et l’environnement inscrits :
model = "azureml:my-model:1"
env = "azureml:my-env:1"
blue_deployment_with_registered_assets = ManagedOnlineDeployment(
name="blue",
endpoint_name=endpoint_name,
model=model,
environment=env,
code_configuration=CodeConfiguration(
code="../model-1/onlinescoring", scoring_script="score.py"
),
instance_type="Standard_DS3_v2",
instance_count=1,
)
Lorsque vous déployez à partir du studio, vous créez un point de terminaison et un déploiement à y ajouter. À ce stade, vous êtes invité à entrer des noms pour le point de terminaison et le déploiement.
Utilisation de différents types d’images et d’instances de processeur et GPU
Vous pouvez spécifier les types et images d’instance processeur ou GPU dans votre définition de déploiement pour le déploiement local et le déploiement sur Azure.
Votre définition de déploiement dans le fichier blue-deployment-with-registered-assets.yml a utilisé une instance de type Standard_DS3_v2
usage général et l’image mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
Docker non GPU. Pour le calcul GPU, choisissez une version de type de calcul GPU et une image Docker GPU.
Pour connaître les types d’instances à usage général et GPU pris en charge, consultez la liste des références SKU des points de terminaison en ligne managés. Pour obtenir la liste des images de base de processeur et GPU d’Azure ML, consultez Images de base Azure Machine Learning.
Vous pouvez spécifier les types et images d’instance processeur ou GPU dans votre configuration de déploiement pour le déploiement local et le déploiement sur Azure.
Précédemment, vous avez configuré un déploiement qui a utilisé un type à usage général Standard_DS3_v2
instance et une image Docker non GPU mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
. Pour le calcul GPU, choisissez une version de type de calcul GPU et une image Docker GPU.
Pour connaître les types d’instances à usage général et GPU pris en charge, consultez la liste des références SKU des points de terminaison en ligne managés. Pour obtenir la liste des images de base de processeur et GPU d’Azure ML, consultez Images de base Azure Machine Learning.
L’enregistrement précédent de l’environnement spécifie une image mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04
Docker non-GPU en passant la valeur au modèle environment-version.json à l’aide du paramètre dockerImage
. Pour un calcul GPU, fournissez une valeur pour une image Docker GPU au modèle (utilisez le dockerImage
paramètre) et fournissez une version de type de calcul GPU au online-endpoint-deployment.json
modèle (utilisez le skuName
paramètre).
Pour connaître les types d’instances à usage général et GPU pris en charge, consultez la liste des références SKU des points de terminaison en ligne managés. Pour obtenir la liste des images de base de processeur et GPU d’Azure ML, consultez Images de base Azure Machine Learning.
Ensuite, déployez votre point de terminaison en ligne dans Azure.
Déployer sur Azure
Créez le point de terminaison dans le cloud Azure :
az ml online-endpoint create --name $ENDPOINT_NAME -f endpoints/online/managed/sample/endpoint.yml
Créez le déploiement nommé blue
au niveau du point de terminaison :
az ml online-deployment create --name blue --endpoint $ENDPOINT_NAME -f endpoints/online/managed/sample/blue-deployment-with-registered-assets.yml --all-traffic
La création du déploiement peut prendre jusqu’à 15 minutes, selon que l’environnement ou l’image sous-jacent est créé pour la première fois. Les déploiements suivants qui utilisent le même environnement sont traités plus rapidement.
Si vous préférez ne pas bloquer votre console CLI, vous pouvez ajouter l’indicateur --no-wait
à la commande. Toutefois, cette option arrête l’affichage interactif de l’état du déploiement.
L’indicateur --all-traffic
dans le code az ml online-deployment create
utilisé pour créer le déploiement alloue 100 % du trafic de point de terminaison au déploiement bleu nouvellement créé. L’utilisation de cet indicateur est utile à des fins de développement et de test, mais pour la production, vous pouvez router le trafic vers le nouveau déploiement via une commande explicite. Par exemple, utilisez az ml online-endpoint update -n $ENDPOINT_NAME --traffic "blue=100"
.
Créez le point de terminaison :
En utilisant le endpoint
paramètre que vous avez défini précédemment et le MLClient
paramètre que vous avez créé précédemment, vous pouvez maintenant créer le point de terminaison dans l’espace de travail. Cette commande lance la création du point de terminaison et retourne une réponse de confirmation, pendant que la création du point de terminaison se poursuit.
ml_client.online_endpoints.begin_create_or_update(endpoint)
Créez le déploiement :
En utilisant le blue_deployment_with_registered_assets
paramètre que vous avez défini précédemment et le MLClient
paramètre que vous avez créé précédemment, vous pouvez maintenant créer 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.online_deployments.begin_create_or_update(blue_deployment_with_registered_assets)
Si vous préférez ne pas bloquer votre console Python, vous pouvez ajouter l’indicateur no_wait=True
aux paramètres. Toutefois, cette option arrête l’affichage interactif de l’état du déploiement.
# blue deployment takes 100 traffic
endpoint.traffic = {"blue": 100}
ml_client.online_endpoints.begin_create_or_update(endpoint)
Créer un point de terminaison en ligne managé et un déploiement
Utilisez le studio pour créer un point de terminaison en ligne managé directement dans votre navigateur. Quand vous créez un point de terminaison en ligne managé dans le studio, vous devez définir un déploiement initial. Vous ne pouvez pas créer un point de terminaison managé en ligne vide.
Vous pouvez créer un point de terminaison en ligne managé dans le studio à partir de la page Modèles. Cette méthode permet aussi d’ajouter facilement un modèle à un déploiement en ligne managé existant. Pour déployer le modèle nommé model-1
que vous avez inscrit précédemment dans la section Inscrire votre modèle et votre environnement :
Accédez à Azure Machine Learning Studio.
Dans le volet gauche, sélectionnez la page Modèles .
Sélectionnez le modèle nommé model-1.
Sélectionnez Déployer>Point de terminaison en temps réel.
Cette action ouvre une fenêtre dans laquelle vous pouvez spécifier des détails sur votre point de terminaison.
Entrez un nom de point de terminaison unique dans la région Azure. Pour plus d’informations sur les règles de nommage, consultez Limites de Point de Terminaison.
Conservez la sélection par défaut : managé pour le type de calcul.
Conservez la sélection par défaut : l’authentification par clé pour le type d’authentification. Pour plus d’informations sur l’authentification, consultez Authentifier les clients pour les points de terminaison en ligne.
Sélectionnez Suivant jusqu’à accéder à la page Déploiement . Basculez les diagnostics Application Insights sur Activé pour que vous puissiez afficher les graphiques des activités de votre point de terminaison dans le studio ultérieurement et analyser les métriques et les journaux à l’aide d’Application Insights.
Sélectionnez Suivant pour passer à la page Code + environnement. Sélectionnez les options suivantes :
- Sélectionnez un script de scoring pour l’inférence : parcourez et sélectionnez le fichier \azureml-examples\cli\endpoints\online\model-1\onlinescoring\score.py à partir du dépôt que vous avez cloné ou téléchargé précédemment.
- section Sélectionner l’environnement : sélectionnez environnements personnalisés, puis sélectionnez l’environnement my-env:1 que vous avez créé précédemment.
Sélectionnez Suivant et acceptez les valeurs par défaut jusqu’à ce que vous soyez invité à créer le déploiement.
Passez en revue vos paramètres de déploiement, puis sélectionnez Créer.
Vous pouvez aussi créer un point de terminaison en ligne managé à partir de la page Points de terminaison dans le studio.
Accédez à Azure Machine Learning Studio.
Dans le volet gauche, sélectionnez la page Points de terminaison .
Sélectionnez + Créer.
Cette action ouvre une fenêtre pour vous permettre de sélectionner votre modèle et de spécifier des détails sur votre point de terminaison et votre déploiement. Entrez les paramètres de votre point de terminaison et de votre déploiement, comme décrit précédemment, puis sélectionnez Créer pour créer le déploiement.
Utilisez le modèle pour créer un point de terminaison en ligne :
az deployment group create -g $RESOURCE_GROUP \
--template-file arm-templates/online-endpoint.json \
--parameters \
workspaceName=$WORKSPACE \
onlineEndpointName=$ENDPOINT_NAME \
identityType=SystemAssigned \
authMode=AMLToken \
location=$LOCATION
Déployez le modèle sur le point de terminaison une fois le point de terminaison créé :
resourceScope="/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices"
az deployment group create -g $RESOURCE_GROUP \
--template-file arm-templates/online-endpoint-deployment.json \
--parameters \
workspaceName=$WORKSPACE \
location=$LOCATION \
onlineEndpointName=$ENDPOINT_NAME \
onlineDeploymentName=blue \
codeId="$resourceScope/workspaces/$WORKSPACE/codes/score-sklearn/versions/1" \
scoringScript=score.py \
environmentId="$resourceScope/workspaces/$WORKSPACE/environments/sklearn-env/versions/$ENV_VERSION" \
model="$resourceScope/workspaces/$WORKSPACE/models/sklearn/versions/1" \
endpointComputeType=Managed \
skuName=Standard_F2s_v2 \
skuCapacity=1
Pour déboguer des erreurs dans votre déploiement, consultez Résolution des problèmes de déploiements de points de terminaison en ligne.
Vérifier l’état du point de terminaison en ligne
Utilisez la commande show
pour afficher des informations dans le provisioning_state
pour le point de terminaison et le déploiement :
az ml online-endpoint show -n $ENDPOINT_NAME
Répertoriez tous les points de terminaison de l’espace de travail dans un format de tableau à l’aide de la commande list
:
az ml online-endpoint list --output table
Vérifiez l’état du point de terminaison pour déterminer si le modèle a été déployé sans erreur :
ml_client.online_endpoints.get(name=endpoint_name)
Répertoriez tous les points de terminaison de l’espace de travail dans un format de tableau à l’aide de la méthode list
:
for endpoint in ml_client.online_endpoints.list():
print(endpoint.name)
La méthode retourne une liste (itérateur) des entités ManagedOnlineEndpoint
.
Vous pouvez obtenir plus d’informations en spécifiant plus de paramètres. Par exemple, sortiez la liste des points de terminaison comme une table :
print("Kind\tLocation\tName")
print("-------\t----------\t------------------------")
for endpoint in ml_client.online_endpoints.list():
print(f"{endpoint.kind}\t{endpoint.location}\t{endpoint.name}")
Afficher des points de terminaison en ligne managés
Vous pouvez afficher tous vos points de terminaison en ligne managés sur la page Points de terminaison . Accédez à la page Détails du point de terminaison pour rechercher des informations critiques, telles que l’URI de point de terminaison, l’état, les outils de test, les moniteurs d’activité, les journaux de déploiement et l’exemple de code de consommation.
Dans le volet gauche, sélectionnez Points de terminaison pour afficher la liste de tous les points de terminaison de l’espace de travail.
(Facultatif) Créez un filtre sur le type de calcul pour afficher uniquement les types de calcul managés .
Sélectionnez le nom d’un point de terminaison pour voir la page Détails du point de terminaison.
Les modèles sont utiles pour déployer des ressources, mais vous ne pouvez pas les utiliser pour répertorier, afficher ou appeler des ressources. Utilisez Azure CLI, le SDK Python ou le studio pour effectuer ces opérations. Le code suivant utilise Azure CLI.
Utilisez la commande show
pour afficher des informations dans le paramètre provisioning_state
concernant le point de terminaison et le déploiement :
az ml online-endpoint show -n $ENDPOINT_NAME
Répertoriez tous les points de terminaison de l’espace de travail dans un format de tableau à l’aide de la commande list
:
az ml online-endpoint list --output table
Vérifier l’état du déploiement en ligne
Vérifiez les journaux pour voir si le modèle a été déployé sans erreur.
Pour voir la sortie de journal d’un conteneur, utilisez la commande CLI suivante :
az ml online-deployment get-logs --name blue --endpoint $ENDPOINT_NAME
Par défaut, les journaux sont extraits du conteneur du serveur d’inférence. Pour voir les journaux du conteneur de l’initialiseur de stockage, ajoutez l’indicateur --container storage-initializer
. Pour plus d’informations sur les journaux de déploiement, consultez Obtenir des journaux de conteneur.
Vous pouvez afficher la sortie du journal à l’aide de la méthode get_logs
:
ml_client.online_deployments.get_logs(
name="blue", endpoint_name=endpoint_name, lines=50
)
Par défaut, les journaux sont extraits du conteneur du serveur d’inférence. Pour voir les journaux du conteneur de l’initialiseur de stockage, ajoutez l’option container_type="storage-initializer"
. Pour plus d’informations sur les journaux de déploiement, consultez Obtenir des journaux de conteneur.
ml_client.online_deployments.get_logs(
name="blue", endpoint_name=endpoint_name, lines=50, container_type="storage-initializer"
)
Pour afficher la sortie du journal, sélectionnez l’onglet Journaux d’activité dans la page du point de terminaison. Si vous avez plusieurs déploiements dans votre interface, utilisez la liste déroulante pour sélectionner le déploiement dont vous souhaitez consulter le journal de bord.
Par défaut, les journaux sont extraits du serveur d’inférence. Pour voir les journaux du conteneur de l’initialiseur de stockage, utilisez Azure CLI ou le SDK Python (voir chaque onglet pour les détails). Les journaux du conteneur de l’initialiseur de stockage fournissent des informations indiquant si le code et les données de modèle ont été correctement téléchargés dans le conteneur. Pour plus d’informations sur les journaux de déploiement, consultez Obtenir des journaux de conteneur.
Les modèles sont utiles pour déployer des ressources, mais vous ne pouvez pas les utiliser pour répertorier, afficher ou appeler des ressources. Utilisez Azure CLI, le SDK Python ou le studio pour effectuer ces opérations. Le code suivant utilise Azure CLI.
Pour voir la sortie de journal d’un conteneur, utilisez la commande CLI suivante :
az ml online-deployment get-logs --name blue --endpoint $ENDPOINT_NAME
Par défaut, les journaux sont extraits du conteneur du serveur d’inférence. Pour voir les journaux du conteneur de l’initialiseur de stockage, ajoutez l’indicateur --container storage-initializer
. Pour plus d’informations sur les journaux de déploiement, consultez Obtenir des journaux de conteneur.
Appeler le point de terminaison pour effectuer la notation des données avec votre modèle
Utilisez la commande invoke
ou un client REST de votre choix pour appeler le point de terminaison et noter certaines données :
az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/model-1/sample-request.json
Obtenez la clé utilisée pour l’authentification auprès du point de terminaison :
Vous pouvez contrôler quels principaux de sécurité Microsoft Entra peuvent obtenir la clé d’authentification en leur attribuant un rôle personnalisé qui autorise Microsoft.MachineLearningServices/workspaces/onlineEndpoints/token/action
et Microsoft.MachineLearningServices/workspaces/onlineEndpoints/listkeys/action
. Pour plus d’informations sur la gestion de l’autorisation sur les espaces de travail, consultez Gérer l’accès à un espace de travail Azure Machine Learning.
ENDPOINT_KEY=$(az ml online-endpoint get-credentials -n $ENDPOINT_NAME -o tsv --query primaryKey)
Utilisez curl pour noter les données.
SCORING_URI=$(az ml online-endpoint show -n $ENDPOINT_NAME -o tsv --query scoring_uri)
curl --request POST "$SCORING_URI" --header "Authorization: Bearer $ENDPOINT_KEY" --header 'Content-Type: application/json' --data @endpoints/online/model-1/sample-request.json
Notez que vous utilisez show
et get-credentials
commandes pour obtenir les informations d’identification d’authentification. Notez également que vous utilisez l’indicateur --query
pour filtrer uniquement les attributs nécessaires. Pour en savoir plus sur l’indicateur de --query
, consultez requête de sortie de commande Azure CLI.
Pour visualiser les journaux d’appel, exécutez get-logs
de nouveau.
En utilisant le paramètre MLClient
que vous avez créé précédemment, vous obtenez une référence du point de terminaison. Vous pouvez ensuite appeler le point de terminaison à l’aide de la invoke
commande avec les paramètres suivants :
endpoint_name
: nom du point de terminaison.
request_file
: Fichier avec des données de requête.
deployment_name
: nom du déploiement spécifique à tester dans un point de terminaison.
Envoyez un exemple de requête à l’aide d’un fichier JSON .
# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
endpoint_name=endpoint_name,
deployment_name="blue",
request_file="../model-1/sample-request.json",
)
Utilisez l’onglet Test sur la page des détails du point de terminaison pour tester votre déploiement en ligne géré. Entrez l’exemple d’entrée et affichez les résultats.
Sélectionnez l’onglet Test dans la page de détails du point de terminaison.
Utilisez la liste déroulante pour sélectionner le déploiement que vous souhaitez tester.
Entrez l’exemple d’entrée .
Sélectionnez Test.
Les modèles sont utiles pour déployer des ressources, mais vous ne pouvez pas les utiliser pour répertorier, afficher ou appeler des ressources. Utilisez Azure CLI, le SDK Python ou le studio pour effectuer ces opérations. Le code suivant utilise Azure CLI.
Utilisez la commande invoke
ou un client REST de votre choix pour appeler le point de terminaison et noter certaines données :
az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file cli/endpoints/online/model-1/sample-request.json
(Facultatif) Mettre à jour le déploiement
Si vous souhaitez mettre à jour le code, le modèle ou l’environnement, mettez à jour le fichier YAML. Exécutez ensuite la commande az ml online-endpoint update
.
Si vous mettez à jour le nombre d’instances (pour mettre à l’échelle votre déploiement) ainsi que d’autres paramètres de modèle (tels que le code, le modèle ou l’environnement) dans une seule update
commande, l’opération de mise à l’échelle est effectuée en premier. Les autres mises à jour sont appliquées ensuite. Il est conseillé d’effectuer ces opérations séparément dans un environnement de production.
Pour comprendre comment update
fonctionne :
Ouvrez le fichier online/model-1/onlinescoring/score.py.
Modifiez la dernière ligne de la fonction init()
: après logging.info("Init complete")
, ajoutez logging.info("Updated successfully")
.
Enregistrez le fichier .
Exécutez cette commande :
az ml online-deployment update -n blue --endpoint $ENDPOINT_NAME -f endpoints/online/managed/sample/blue-deployment-with-registered-assets.yml
La mise à jour à l’aide de YAML est déclarative. Autrement dit, les modifications apportées au YAML sont reflétées dans les ressources Resource Manager sous-jacentes (points de terminaison et déploiements). Une approche déclarative facilite les GitOps : Toutes les modifications apportées aux points de terminaison et déploiements passent (même instance_count
) par le fichier YAML.
Vous pouvez utiliser des paramètres de mise à jour génériques, tels que le paramètre --set
, avec la commande CLI update
pour remplacer les attributs dans votre YAML ou pour définir des attributs spécifiques sans les passer dans le fichier YAML. L’utilisation de --set
pour les attributs uniques est particulièrement importante dans les scénarios de développement et de test. Par exemple, pour effectuer un scale-up de la valeur instance_count
pour le premier déploiement, vous pouvez utiliser l’indicateur --set instance_count=2
. Toutefois, étant donné que le code YAML n’est pas mis à jour, cette technique ne facilite pas les GitOps.
La spécification du fichier YAML n’est pas obligatoire. Par exemple, si vous souhaitez tester différents paramètres d’accès concurrentiel pour un déploiement spécifique, vous pouvez essayer quelque chose comme az ml online-deployment update -n blue -e my-endpoint --set request_settings.max_concurrent_requests_per_instance=4 environment_variables.WORKER_COUNT=4
. Cette approche conserve toutes les configurations existantes, mais met à jour uniquement les paramètres spécifiés.
Étant donné que vous avez modifié la init()
fonction, qui s’exécute lorsque le point de terminaison est créé ou mis à jour, le message Updated successfully
apparaît dans les journaux. Récupérez les journaux en exécutant :
az ml online-deployment get-logs --name blue --endpoint $ENDPOINT_NAME
La commande update
fonctionne également avec les déploiements locaux. Utilisez la même commande az ml online-deployment update
avec l’indicateur --local
.
Si vous souhaitez mettre à jour le code, le modèle ou l’environnement, mettez à jour la configuration, puis exécutez la MLClient
méthode « s online_deployments.begin_create_or_update
pour créer ou mettre à jour un déploiement.
Si vous mettez à jour le nombre d’instances (pour mettre à l’échelle votre déploiement) ainsi que d’autres paramètres de modèle (tels que le code, le modèle ou l’environnement) dans une seule begin_create_or_update
méthode, l’opération de mise à l’échelle est effectuée en premier. Ensuite, les autres mises à jour sont appliquées. Il est conseillé d’effectuer ces opérations séparément dans un environnement de production.
Pour comprendre comment begin_create_or_update
fonctionne :
Ouvrez le fichier online/model-1/onlinescoring/score.py.
Modifiez la dernière ligne de la fonction init()
: après logging.info("Init complete")
, ajoutez logging.info("Updated successfully")
.
Enregistrez le fichier .
Exécutez la méthode :
ml_client.online_deployments.begin_create_or_update(blue_deployment_with_registered_assets)
Étant donné que vous avez modifié la init()
fonction, qui s’exécute lorsque le point de terminaison est créé ou mis à jour, le message Updated successfully
apparaît dans les journaux. Récupérez les journaux en exécutant :
ml_client.online_deployments.get_logs(
name="blue", endpoint_name=endpoint_name, lines=50
)
La méthode begin_create_or_update
fonctionne également avec les déploiements locaux. Utilisez la même méthode avec l’indicateur local=True
.
Actuellement, vous pouvez effectuer des mises à jour uniquement pour le nombre d’instances d’un déploiement. Utilisez les instructions suivantes pour effectuer un scale-up ou un scale-down d’un déploiement individuel en ajustant le nombre d’instances :
- Ouvrez la page Détails du point de terminaison et recherchez la carte du déploiement que vous souhaitez mettre à jour.
- Sélectionnez l’icône de modification (en forme de crayon) en regard du nom du déploiement.
- Mettez à jour le nombre d’instances associées au déploiement. Choisissez entre par défaut ou utilisation cible pour le type d’échelle de déploiement.
- Si vous sélectionnez Par défaut, vous pouvez également spécifier une valeur numérique pour le nombre d’instances.
- Si vous sélectionnez Utilisation cible, vous pouvez spécifier des valeurs à utiliser pour les paramètres lorsque vous scalez automatiquement le déploiement.
- Sélectionnez Mettre à jour pour terminer la mise à jour du nombre d’instances pour votre déploiement.
Il n’existe actuellement aucune option permettant de mettre à jour le déploiement à l’aide d’un modèle ARM.
Notes
La mise à jour du déploiement dans cette section est un exemple de mise à jour propagée sur place.
- Pour un point de terminaison en ligne managé, le déploiement est mis à jour vers la nouvelle configuration avec 20 % des nœuds à la fois. Autrement dit, si le déploiement a 10 nœuds, 2 nœuds à la fois sont mis à jour.
- Pour un point de terminaison en ligne Kubernetes, le système crée de manière itérative une nouvelle instance de déploiement avec la nouvelle configuration et supprime l’ancienne.
- Pour l’utilisation de la production, envisagez un déploiement bleu-vert, qui offre une alternative plus sûre pour la mise à jour d’un service web.
La mise à l’échelle automatique exécute automatiquement la quantité appropriée de ressources pour gérer la charge sur votre application. Les points de terminaison en ligne managés prennent en charge la mise à l’échelle automatique via l’intégration à la fonctionnalité de mise à l’échelle automatique Azure Monitor. Pour configurer la mise à l’échelle automatique, consultez Mise à l’échelle automatique de points de terminaison en ligne.
(Facultatif) Surveiller le contrat SLA à l’aide d’Azure Monitor
Pour afficher les métriques et définir des alertes en fonction de votre contrat SLA, suivez les étapes décrites dans Surveiller les points de terminaison en ligne.
(Facultatif) Intégrer à Log Analytics
La get-logs
commande de l’interface CLI ou de la get_logs
méthode du Kit de développement logiciel (SDK) fournit uniquement les dernières centaines de lignes de journaux d’activité d’une instance sélectionnée automatiquement. Toutefois, Log Analytics offre un moyen de stocker et d’analyser durablement les journaux. Pour plus d’informations sur l’utilisation de la journalisation, consultez Utiliser les journaux d’activité.
Supprimez le point de terminaison et le déploiement
Utilisez la commande suivante pour supprimer le point de terminaison et tous ses déploiements sous-jacents :
az ml online-endpoint delete --name $ENDPOINT_NAME --yes --no-wait
Utilisez la commande suivante pour supprimer le point de terminaison et tous ses déploiements sous-jacents :
ml_client.online_endpoints.begin_delete(name=endpoint_name)
Si vous n’allez pas utiliser le point de terminaison et le déploiement, supprimez-les. En supprimant le point de terminaison, vous supprimez également tous ses déploiements sous-jacents.
- Accédez à Azure Machine Learning Studio.
- Dans le volet gauche, sélectionnez la page Points de terminaison .
- Sélectionnez un point de terminaison.
- Sélectionnez Supprimer.
Vous pouvez également supprimer un point de terminaison en ligne géré directement en sélectionnant l’icône Supprimer dans la page de détails du point de terminaison.
Utilisez la commande suivante pour supprimer le point de terminaison et tous ses déploiements sous-jacents :
az ml online-endpoint delete --name $ENDPOINT_NAME --yes --no-wait
Contenu connexe