Partage via

Déployer des modèles avec REST

  • Article

Cet article décrit comment utiliser l’API REST Azure Machine Learning pour déployer des modèles en utilisant des points de terminaison en ligne. Les points de terminaison en ligne vous permettent de déployer votre modèle sans avoir à créer ni à gérer l’infrastructure sous-jacente et les clusters Kubernetes. Les procédures suivantes démontrent comment créer un point de terminaison en ligne, le déployer et le valider en l’appelant.

Il existe plusieurs façons de créer un point de terminaison en ligne Azure Machine Learning. Vous pouvez utiliser l’interface Azure CLI, l’Azure Machine Learning studio ou l’API REST. L’API REST utilise des verbes HTTP standard pour créer, récupérer, mettre à jour et supprimer des ressources. Ils fonctionnent avec tout langage ou outil pouvant effectuer des requêtes HTTP. La structure simple de l’API REST en fait souvent un bon choix dans des environnements de script et pour l’automatisation des opérations d’apprentissage automatique.

Prérequis

Définir le nom du point de terminaison

Les noms de points de terminaison doivent être uniques au niveau de la région Azure. Un nom de point de terminaison comme my-point doit être le seul point de terminaison ayant ce nom au sein d’une région spécifiée.

Créez un nom de point de terminaison unique en appelant l’utilitaire RANDOM qui ajoute un nombre aléatoire comme suffixe à la valeur endpt-rest :

export ENDPOINT_NAME=endpt-rest-`echo $RANDOM`

Créer des ressources de machine learning

Pour préparer le déploiement, configurez vos ressources Azure Machine Learning, puis votre travail. Vous inscrivez les ressources nécessaires au déploiement, notamment le modèle, le code et l’environnement.

Conseil

Les appels de l’API REST dans les procédures suivantes utilisent $SUBSCRIPTION_ID, $RESOURCE_GROUP, $LOCATION (région) et Azure Machine Learning $WORKSPACE comme espace réservé pour certains arguments. Lorsque vous établissez le code de votre déploiement, remplacez les espaces réservés d’argument par les valeurs spécifiques à votre déploiement.

Les requêtes REST administratives utilisent un jeton d’authentification de principal de service. Lorsque vous établissez le code de votre déploiement, remplacez les instances de l’espace réservé $TOKEN par le jeton du principal de service de votre déploiement. Vous pouvez récupérer ce jeton à l’aide de la commande suivante :

response=$(curl -H "Content-Length: 0" --location --request POST "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME/token?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN")
accessToken=$(echo $response | jq -r '.accessToken')

Le fournisseur de services utilise l’argument api-version pour garantir la compatibilité. L’argument api-version varie d’un service à l’autre.

Définissez la variable API_version pour prendre en charge les futures versions :

API_VERSION="2022-05-01"

Obtenir les détails du compte de stockage

Pour inscrire le modèle et le code, vous devez d’abord charger ces éléments dans un compte Stockage Azure. Les informations du compte Stockage Azure sont disponibles dans le magasin de données. Dans cet exemple, vous obtenez le magasin de stockage par défaut et le compte Stockage Azure pour votre espace de travail. Interrogez votre espace de travail avec une requête GET pour obtenir ces informations dans un fichier JSON.

Vous pouvez utiliser l’outil jq pour analyser le résultat JSON et obtenir les valeurs nécessaires. Vous pouvez aussi utiliser le portail Azure pour rechercher les mêmes informations :

# 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')

Charger et inscrire le code

Maintenant que vous disposez du magasin de données, vous pouvez charger le script de scoring. Utilisez l’interface CLI Stockage Azure pour charger un objet blob dans votre conteneur par défaut :

az storage blob upload-batch -d $AZUREML_DEFAULT_CONTAINER/score -s endpoints/online/model-1/onlinescoring

Conseil

Vous pouvez utiliser d’autres méthodes pour effectuer le chargement, comme le Portail Azure ou l’Explorateur Stockage Azure.

Une fois le code chargé, vous pouvez le spécifier avec une requête PUT et faire référence au magasin de données avec l’identificateur datastoreId :

curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/codes/score-sklearn/versions/1?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
  \"properties\": {
    \"codeUri\": \"https://$AZURE_STORAGE_ACCOUNT.blob.core.windows.net/$AZUREML_DEFAULT_CONTAINER/score\"
  }
}"

Charger et inscrire le modèle

Chargez les fichiers de modèle avec un appel d’API REST similaire :

az storage blob upload-batch -d $AZUREML_DEFAULT_CONTAINER/model -s endpoints/online/model-1/model

Une fois le chargement terminé, inscrivez le modèle :

curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/models/sklearn/versions/1?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
    \"properties\": {
        \"modelUri\":\"azureml://subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/workspaces/$WORKSPACE/datastores/$AZUREML_DEFAULT_DATASTORE/paths/model\"
    }
}"

Créer un environnement

Le déploiement doit s’exécuter dans un environnement qui a les dépendances requises. Créez l’environnement avec une demande PUT. Utilisez une image Docker à partir de Microsoft Container Registry. Vous pouvez configurer l’image Docker avec la commande docker et ajouter des dépendances Conda avec la commande condaFile.

Le code suivant lit le contenu d’un environnement Conda (fichier YAML) dans une variable d’environnement :

ENV_VERSION=$RANDOM
curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/environments/sklearn-env/versions/$ENV_VERSION?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
    \"properties\":{
        \"condaFile\": \"$CONDA_FILE\",
        \"image\": \"mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:20210727.v1\"
    }
}"

Création d’un point de terminaison

Créez le point de terminaison en ligne :

response=$(curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME?api-version=$API_VERSION" \
--header "Content-Type: application/json" \
--header "Authorization: Bearer $TOKEN" \
--data-raw "{
    \"identity\": {
       \"type\": \"systemAssigned\"
    },
    \"properties\": {
        \"authMode\": \"AMLToken\"
    },
    \"location\": \"$LOCATION\"
}")

Créer un déploiement

Créez un déploiement sous le point de terminaison en ligne :

response=$(curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME/deployments/blue?api-version=$API_VERSION" \
--header "Content-Type: application/json" \
--header "Authorization: Bearer $TOKEN" \
--data-raw "{
    \"location\": \"$LOCATION\",
    \"sku\": {
        \"capacity\": 1,
        \"name\": \"Standard_DS2_v2\"
    },
    \"properties\": {
        \"endpointComputeType\": \"Managed\",
        \"scaleSettings\": {
            \"scaleType\": \"Default\"
        },
        \"model\": \"/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/models/sklearn/versions/1\",
        \"codeConfiguration\": {
            \"codeId\": \"/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/codes/score-sklearn/versions/1\",
            \"scoringScript\": \"score.py\"
        },
        \"environmentId\": \"/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/environments/sklearn-env/versions/$ENV_VERSION\"
    }
}")

Appeler le point de terminaison pour attribuer un score aux données avec un modèle

Vous avez besoin de l’URI de scoring et du jeton d’accès pour appeler le point de terminaison de déploiement.

Tout d’abord, récupérez l’URI de scoring :

response=$(curl --location --request GET "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME?api-version=$API_VERSION" \
--header "Content-Type: application/json" \
--header "Authorization: Bearer $TOKEN")

scoringUri=$(echo $response | jq -r '.properties.scoringUri')

Récupérez ensuite le jeton d’accès du point de terminaison :

response=$(curl -H "Content-Length: 0" --location --request POST "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME/token?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN")
accessToken=$(echo $response | jq -r '.accessToken')

Enfin, appelez le point de terminaison en utilisant l’utilitaire curl :

curl --location --request POST $scoringUri \
--header "Authorization: Bearer $accessToken" \
--header "Content-Type: application/json" \
--data-raw @endpoints/online/model-1/sample-request.json

Vérifier des journaux de déploiement

Vérifiez les journaux du déploiement :

curl --location --request POST "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME/deployments/blue/getLogs?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{ \"tail\": 100 }"

Supprimer le point de terminaison

Si vous n’allez pas utiliser de nouveau le déploiement, supprimez les ressources.

Exécutez la commande suivante qui supprime le point de terminaison et tous les déploiements sous-jacents :

curl --location --request DELETE "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/onlineEndpoints/$ENDPOINT_NAME?api-version=$API_VERSION" \
--header "Content-Type: application/json" \
--header "Authorization: Bearer $TOKEN" || true

Contenu connexe