Utiliser un conteneur personnalisé pour déployer un modèle sur un point de terminaison en ligne

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

Découvrez comment utiliser un conteneur personnalisé pour déployer un modèle sur un point de terminaison en ligne dans Azure Machine Learning.

Les déploiements de conteneurs personnalisés peuvent utiliser des serveurs web autres que le serveur Flask Python par défaut utilisé par Azure Machine Learning. Les utilisateurs de ces déploiements peuvent toujours tirer parti de la surveillance, de la mise à l’échelle, des alertes et de l’authentification intégrées d’Azure Machine Learning.

Le tableau suivant répertorie différents exemples de déploiement qui utilisent des conteneurs personnalisés tels que TensorFlow Serving, TorchServe, Triton Inference Server, le package Plumber R et l’image Minimale d’inférence Azure Machine Learning.

Exemple	Script (CLI)	Description
minimal/multimodel	deploy-custom-container-minimal-multimodel	Déployez plusieurs modèles sur un déploiement unique en étendant l’image Minimale d’inférence Azure Machine Learning.
minimal/single-model	deploy-custom-container-minimal-single-model	Déployez un modèle unique en étendant l’image Minimale d’inférence Azure Machine Learning.
mlflow/multideployment-scikit	deploy-custom-container-mlflow-multideployment-scikit	Déployez deux modèles MLFlow avec des exigences Python différentes sur deux déploiements distincts derrière un point de terminaison unique à l’aide de l’image minimale d’inférence Azure Machine Learning.
r/multimodel-plumber	deploy-custom-container-r-multimodel-plumber	Déployer trois modèles de régression sur un point de terminaison à l’aide du package Plumber R
tfserving/half-plus-two	deploy-custom-container-tfserving-half-plus-two	Déployez un modèle Half Plus Two à l’aide d’un conteneur personnalisé TensorFlow Serving avec le processus d’inscription de modèle standard.
tfserving/half-plus-two-integrated	deploy-custom-container-tfserving-half-plus-two-integrated	Déployez un modèle Half Plus Two à l’aide d’un conteneur personnalisé TensorFlow Serving avec le modèle intégré à l’image.
torchserve/densenet	deploy-custom-container-torchserve-densenet	Déployez un modèle unique à l’aide d’un conteneur personnalisé TorchServe.
torchserve/huggingface-textgen	deploy-custom-container-torchserve-huggingface-textgen	Déployez des modèles Hugging Face sur un point de terminaison en ligne et suivez l’exemple Hugging Face Transformers TorchServe.
triton/single-model	deploy-custom-container-triton-single-model	Déployer un modèle Triton à l’aide d’un conteneur personnalisé

Cet article se concentre sur la mise en service d’un modèle TensorFlow (TF) avec TensorFlow Serving.

Avertissement

Microsoft risque de ne pas pouvoir vous aider à résoudre les problèmes dus à une image personnalisée. Si vous rencontrez des problèmes, vous devrez sans doute utiliser l’image par défaut ou l’une des images fournies par Microsoft pour voir si le problème est spécifique à votre image.

Prérequis

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

• Un espace de travail Azure Machine Learning. Si vous n’en avez pas, procédez comme suit dans le Guide de démarrage rapide : Créer des ressources d’espace de travail pour en créer un.

• Azure CLI et l’extension mlou le Kit de développement logiciel (SDK) Python Azure Machine Learning v2 :

  • Pour installer Azure CLI et l’extension, consultez Installer, configurer et utiliser l’interface CLI (v2).

    Important

    Les exemples CLI de cet article supposent que vous utilisez l’interpréteur de commandes Bash (ou compatible). Par exemple, à partir d’un système Linux ou d’un sous-système Windows pour Linux.

  • Pour installer le kit SDK Python v2, 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 Installer le kit SDK Python v2 pour Azure Machine Learning.

• Vous ou le principal de service que vous utilisez devez avoir l’accès Contributeur au groupe de ressources Azure qui contient votre espace de travail. Vous disposez d’un tel groupe de ressources si vous avez configuré votre espace de travail à l’aide de l’article de démarrage rapide.

• Pour déployer localement, vous devez exécuté le moteur Docker localement. Cette étape est fortement recommandée. Cela vous aide à déboguer des problèmes.

Téléchargement du code source

Pour suivre ce tutoriel, clonez le code source depuis GitHub.

Azure CLI

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

Kit de développement logiciel (SDK) Python

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

Consultez également l’exemple de notebook, mais notez que la section 3. Test locally du notebook suppose qu’il s’exécute sous le répertoire azureml-examples/sdk.

Initialiser des variables d’environnement

Définissez des variables d’environnement :

BASE_PATH=endpoints/online/custom-container/tfserving/half-plus-two
AML_MODEL_NAME=tfserving-mounted
MODEL_NAME=half_plus_two
MODEL_BASE_PATH=/var/azureml-app/azureml-models/$AML_MODEL_NAME/1

Télécharger un modèle TensorFlow

Téléchargez et décompressez un modèle qui divise une entrée en deux et ajoute « 2 » au résultat :

wget https://aka.ms/half_plus_two-model -O $BASE_PATH/half_plus_two.tar.gz
tar -xvf $BASE_PATH/half_plus_two.tar.gz -C $BASE_PATH

Exécuter une image TF Serving localement pour tester son fonctionnement

Utilisez Docker pour exécuter votre image localement à des fins de test :

docker run --rm -d -v $PWD/$BASE_PATH:$MODEL_BASE_PATH -p 8501:8501 \
 -e MODEL_BASE_PATH=$MODEL_BASE_PATH -e MODEL_NAME=$MODEL_NAME \
 --name="tfserving-test" docker.io/tensorflow/serving:latest
sleep 10

Vérifier que vous pouvez envoyer des requêtes liveness et scoring à l’image

Tout d’abord, vérifiez que le conteneur est vivant, c’est-à-dire que le processus à l’intérieur du conteneur est toujours en cours d’exécution. Vous devez obtenir une réponse 200 (OK).

curl -v http://localhost:8501/v1/models/$MODEL_NAME

Ensuite, vérifiez que vous pouvez obtenir des prédictions sur les données sans étiquette :

curl --header "Content-Type: application/json" \
  --request POST \
  --data @$BASE_PATH/sample_request.json \
  http://localhost:8501/v1/models/$MODEL_NAME:predict

Arrêter l’image

Maintenant que vous avez effectué un test local, arrêtez l’image :

docker stop tfserving-test

Déployer votre point de terminaison en ligne dans Azure

Ensuite, déployez votre point de terminaison en ligne dans Azure.

Azure CLI

Créer un fichier YAML pour votre point de terminaison et votre déploiement

Vous pouvez configurer votre déploiement cloud à l’aide de YAML. Jetez un coup d’œil à l’échantillon YAML pour cet exemple :

tfserving-endpoint.yml

$schema: https://azuremlsdk2.blob.core.windows.net/latest/managedOnlineEndpoint.schema.json
name: tfserving-endpoint
auth_mode: aml_token

tfserving-deployment.yml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: {{MODEL_VERSION}}
  path: ./half_plus_two
environment_variables:
  MODEL_BASE_PATH: /var/azureml-app/azureml-models/tfserving-mounted/{{MODEL_VERSION}}
  MODEL_NAME: half_plus_two
environment:
  #name: tfserving
  #version: 1
  image: docker.io/tensorflow/serving:latest
  inference_config:
    liveness_route:
      port: 8501
      path: /v1/models/half_plus_two
    readiness_route:
      port: 8501
      path: /v1/models/half_plus_two
    scoring_route:
      port: 8501
      path: /v1/models/half_plus_two:predict
instance_type: Standard_DS3_v2
instance_count: 1

Kit de développement logiciel (SDK) Python

Se connecter à un espace de travail Azure Machine Learning

Connectez-vous à votre espace de travail Azure Machine Learning, configurez les détails de l’espace de travail, puis obtenez un descripteur pour l’espace de travail comme suit :

1. 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

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

# enter details of your Azure Machine Learning workspace
subscription_id = "<SUBSCRIPTION_ID>"
resource_group = "<RESOURCE_GROUP>"
workspace = "<AZUREML_WORKSPACE_NAME>"

# get a handle to the workspace
ml_client = MLClient(
   DefaultAzureCredential(), subscription_id, resource_group, workspace
)

Pour plus d’informations, consultez Déployez des modèles Machine Learning sur un point de terminaison en ligne managé à l’aide du kit SDK Python v2.

Configurer le point de terminaison en ligne

Conseil

• name : Nom du point de terminaison. Il doit être unique au sein de la région Azure. Le nom d’un point de terminaison doit commencer par une lettre majuscule ou minuscule et contenir uniquement des caractères « - » et alphanumériques. Pour plus d’informations sur les règles de nommage, consultez limites de point de terminaison.
• auth_mode : utilisez key pour l’authentification basée sur une clé. Utilisez aml_token pour l’authentification Azure Machine Learning basée sur les jetons. key n’expire pas, mais aml_token expire. Pour plus d’informations sur l’authentification, consultez S’authentifier auprès d’un point de terminaison en ligne.

Vous pouvez éventuellement ajouter une description, des étiquettes à votre point de terminaison.

# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

online_endpoint_name = "endpoint-" + datetime.datetime.now().strftime("%m%d%H%M%f")

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is a sample online endpoint",
    auth_mode="key",
    tags={"foo": "bar"},
)

Configurer le déploiement en ligne

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 déploiement pour notre point de terminaison avec la classe ManagedOnlineDeployment.

Conseil

• name - Nom du déploiement.
• endpoint_name - Nom du point de terminaison sous lequel créer le déploiement.
• model - Modèle à utiliser pour le déploiement. Cette valeur peut être une référence à un modèle versionné > existant dans l’espace de travail ou une spécification de modèle inline.
• environment - Environnement à utiliser pour le déploiement. Cette valeur peut être une référence à un environnement versionné > existant dans l’espace de travail ou une spécification d’environnement inline.
• code_configuration - Configuration du code source et du script de scoring
  • path - Chemin au répertoire de code source pour le scoring du modèle
  • scoring_script - Chemin relatif au fichier de scoring dans le répertoire de code source
• instance_type - Taille de machine virtuelle à utiliser pour le déploiement. Pour obtenir la liste des tailles prises en charge, consultez la liste des références SKU des points de terminaison.
• instance_count - Nombre d’instances à utiliser pour le déploiement

# create a blue deployment
model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

env = Environment(
    image="docker.io/tensorflow/serving:latest",
    inference_config={
        "liveness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "readiness_route": {"port": 8501, "path": "/v1/models/half_plus_two"},
        "scoring_route": {"port": 8501, "path": "/v1/models/half_plus_two:predict"},
    },
)

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    environment_variables={
        "MODEL_BASE_PATH": "/var/azureml-app/azureml-models/tfserving-mounted/1",
        "MODEL_NAME": "half_plus_two",
    },
    instance_type="Standard_DS2_v2",
    instance_count=1,
)

Voici quelques concepts importants à noter dans ce paramètre YAML/Python :

Itinéraire readiness et itinéraire liveness

Un serveur HTTP définit des chemins d’accès pour liveness et readiness. Un itinéraire liveness est utilisé pour vérifier si le serveur est en cours d’exécution. Un itinéraire readiness est utilisé pour vérifier si le serveur est prêt à effectuer le travail. Dans l’inférence d’apprentissage automatique, un serveur peut répondre 200 (OK) à une requête liveness avant de charger un modèle. Le serveur peut répondre 200 OK à une requête readiness uniquement après le chargement du modèle en mémoire.

Si vous souhaitez en savoir plus sur les probes liveness et readiness, veuillez consulter la documentation de Kubernetes.

Notez que ce déploiement utilise le même chemin d’accès pour liveness et readiness, car TF Serving définit uniquement un itinéraire liveness.

Localisation du modèle monté

Lorsque vous déployez un modèle en tant que point de terminaison en ligne, Azure Machine Learning monte votre modèle sur votre point de terminaison. Le montage du modèle vous permet de déployer de nouvelles versions du modèle sans avoir à créer de nouvelle image Docker. Par défaut, un modèle inscrit avec le nom foo et la version 1 se trouve sous le chemin suivant à l’intérieur de votre conteneur déployé : /var/azureml-app/azureml-models/foo/1

Par exemple, si vous avez une structure de répertoires /azureml-examples/cli/endpoints/online/custom-container sur votre ordinateur local, où le modèle est nommé half_plus_two :

Azure CLI

Et tfserving-deployment.yml contient :

model:
    name: tfserving-mounted
    version: 1
    path: ./half_plus_two

Kit de développement logiciel (SDK) Python

Et la classe Model contient :

model = Model(name="tfserving-mounted", version="1", path="half_plus_two")

Alors, votre modèle se trouvera sous /var/azureml-app/azureml-models/tfserving-deployment/1 dans votre déploiement :

Vous pouvez éventuellement configurer votre model_mount_path. Cela vous permet de modifier le chemin d’accès où le modèle est monté.

Important

Le model_mount_path doit être un chemin d’accès absolu valide dans Linux (le système d’exploitation de l’image conteneur).

Azure CLI

Par exemple, vous pouvez avoir le paramètre model_mount_path dans votre tfserving-deployment.yml :

name: tfserving-deployment
endpoint_name: tfserving-endpoint
model:
  name: tfserving-mounted
  version: 1
  path: ./half_plus_two
model_mount_path: /var/tfserving-model-mount
.....

Kit de développement logiciel (SDK) Python

Vous pouvez par exemple avoir le paramètre model_mount_path dans votre classe ManagedOnlineDeployment :

blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    environment=env,
    model_mount_path="/var/tfserving-model-mount",
    ...
)

Alors, votre modèle se trouve à l’emplacement /var/tfserving-model-mount/tfserving-deployment/1 dans votre déploiement. Notez qu’il ne figure plus dans le chemin d’accès azureml-app/azureml-models, mais dans le chemin de montage que vous avez spécifié :

Créer votre point de terminaison et votre déploiement

Azure CLI

Maintenant que vous comprenez comment le YAML a été construit, créez votre point de terminaison.

az ml online-endpoint create --name tfserving-endpoint -f endpoints/online/custom-container/tfserving-endpoint.yml

La création d’un déploiement peut prendre quelques minutes.

az ml online-deployment create --name tfserving-deployment -f endpoints/online/custom-container/tfserving-deployment.yml --all-traffic

Kit de développement logiciel (SDK) Python

En utilisant le MLClient créé précédemment, créez 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.begin_create_or_update(endpoint)

Créez le déploiement en exécutant :

ml_client.begin_create_or_update(blue_deployment)

Appeler le point de terminaison

Une fois votre déploiement terminé, vérifiez si vous pouvez effectuer une requête scoring sur le point de terminaison déployé.

Azure CLI

RESPONSE=$(az ml online-endpoint invoke -n $ENDPOINT_NAME --request-file $BASE_PATH/sample_request.json)

Kit de développement logiciel (SDK) Python

En utilisant le MLClient créé précédemment, vous obtenez un descripteur pour le point de terminaison. Le point de terminaison peut être appelé à l’aide de la commande invokeavec 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

Nous allons envoyer un échantillon de requête à l’aide d’un fichier JSON. L’échantillon de JSON se trouve dans le référentiel d’exemples.

# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    deployment_name="blue",
    request_file="sample-request.json",
)

Supprimer le point de terminaison

Maintenant que vous avez réussi à établir un score de votre point de terminaison, vous pouvez le supprimer :

Azure CLI

az ml online-endpoint delete --name tfserving-endpoint

Kit de développement logiciel (SDK) Python

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Contenu connexe

• Déploiement sécurisé pour les points de terminaison en ligne
• Résolution des problèmes de déploiement de points de terminaison en ligne
• Exemple de Torch serve