S’APPLIQUE À :
Extension Azure ML CLI v2 (actuelle)
Kit de développement logiciel (SDK) Python azure-ai-ml v2 (préversion)
Azure Machine Learning fournit plusieurs façons d’envoyer des travaux d’apprentissage ML. Dans cet article, vous allez apprendre à envoyer des travaux à l’aide des méthodes suivantes :
- Extension Azure CLI pour Machine Learning : l’extension
ml, également appelée CLI v2.
- Kit de développement logiciel (SDK) Python v2 pour Azure Machine Learning.
- API REST : API sur laquelle l’interface CLI et le kit de développement logiciel (SDK) sont basés.
Prérequis
Pour utiliser les informations sur l’API REST, vous avez besoin des éléments suivants :
Un principal de service dans votre espace de travail. Utilisez l’authentification du principal de service pour les requêtes REST administratives.
Un jeton d’authentification du principal de service. Suivez les étapes décrites dans Récupérer un jeton d’authentification de principal de service pour obtenir ce jeton.
L’utilitaire curl. Le programme curl est disponible dans le Sous-système Windows pour Linux ou dans toute distribution UNIX.
Conseil
Dans PowerShell, curl est un alias pour Invoke-WebRequest. La commande curl -d "key=val" -X POST uri devient Invoke-WebRequest -Body "key=val" -Method POST -Uri uri.
Bien qu’il soit possible d’appeler l’API REST à partir de PowerShell, les exemples de cet article supposent que vous utilisez Bash.
Utilitaire jq pour le traitement JSON. Utilisez cet utilitaire pour extraire des valeurs des documents JSON retournés par l’API REST.
Cloner le référentiel d’exemples
Les extraits de code de cet article sont basés sur des exemples dans le référentiel GitHub d’exemples Azure Machine Learning. Pour cloner le référentiel dans votre environnement de développement, utilisez la commande suivante :
git clone --depth 1 https://github.com/Azure/azureml-examples
Conseil
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.
Exemple de travail
Les exemples de cet article utilisent le jeu de données d’iris pour effectuer l’apprentissage d’un modèle MLFlow.
Effectuer l’apprentissage dans le cloud
Lorsque vous effectuez l’apprentissage dans le cloud, vous devez vous connecter à votre espace de travail Azure Machine Learning et sélectionner une ressource de calcul pour exécuter le travail d’entraînement.
1. Connexion à l’espace de travail
Conseil
Utilisez les onglets suivants pour sélectionner la méthode que vous souhaitez utiliser pour entraîner un modèle. La sélection d’un onglet bascule automatiquement tous les onglets de cet article vers le même onglet. Vous pouvez sélectionner un autre onglet à tout moment.
Pour vous connecter à l’espace de travail, vous avez besoin de paramètres d’identificateur : un abonnement, un groupe de ressources et un nom d’espace de travail. Utilisez ces informations dans le MLClient à partir de l'espace de noms azure.ai.ml pour obtenir un handle vers l’espace de travail Azure Machine Learning requis. Pour vous authentifier, utilisez l’authentification Azure par défaut. Pour plus d’informations sur la configuration des informations d’identification et la connexion à un espace de travail, consultez cet exemple.
#import required libraries
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
#Enter details of your Azure Machine Learning workspace
subscription_id = '<SUBSCRIPTION_ID>'
resource_group = '<RESOURCE_GROUP>'
workspace = '<AZUREML_WORKSPACE_NAME>'
#connect to the workspace
ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)
Lorsque vous utilisez Azure CLI, vous avez besoin de paramètres d’identificateur : un abonnement, un groupe de ressources et un nom d’espace de travail. Bien que vous puissiez spécifier ces paramètres pour chaque commande, vous pouvez également définir les valeurs par défaut utilisées par toutes les commandes. Utilisez les commandes suivantes pour définir les valeurs par défaut. Remplacez <subscription ID>, <Azure Machine Learning workspace name> et <resource group> par les valeurs de votre configuration :
az account set --subscription <subscription ID>
az configure --defaults workspace=<Azure Machine Learning workspace name> group=<resource group>
Les exemples d’API REST de cet article utilisent les espaces réservés $SUBSCRIPTION_ID, $RESOURCE_GROUP, $LOCATION et $WORKSPACE. Remplacez les espaces réservés par vos valeurs comme suit :
-
$SUBSCRIPTION_ID : ID de votre abonnement Azure.
-
$RESOURCE_GROUP : groupe de ressources Azure qui contient votre espace de travail.
-
$LOCATION : région Azure où se trouve votre espace de travail.
-
$WORKSPACE : nom de votre espace de travail Azure Machine Learning.
-
$COMPUTE_NAME : nom de votre cluster de calcul Azure Machine Learning.
Les requêtes REST administratives utilisent un jeton d’authentification de principal de service. Vous pouvez récupérer un jeton à l’aide de la commande suivante. Le jeton est stocké dans la variable d’environnement $TOKEN :
TOKEN=$(az account get-access-token --query accessToken -o tsv)
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 version de l’API en tant que variable pour prendre en charge les futures versions :
API_VERSION="2022-05-01"
Lorsque vous effectuez l’apprentissage à l’aide de l’API REST, vous devez charger des données et des scripts d’entraînement sur un compte de stockage auquel l’espace de travail peut accéder. L’exemple suivant obtient les informations de stockage de votre espace de travail et les enregistre dans des variables afin de pouvoir l’utiliser ultérieurement :
# 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')
2. Créer une ressource de calcul pour l’apprentissage
Un cluster de calcul Azure Machine Learning est une ressource de calcul entièrement managée que vous pouvez utiliser pour exécuter le travail d’entraînement. Dans les exemples suivants, vous créez un cluster de calcul nommé cpu-cluster.
from azure.ai.ml.entities import AmlCompute
# specify aml compute name.
cpu_compute_target = "cpu-cluster"
try:
ml_client.compute.get(cpu_compute_target)
except Exception:
print("Creating a new cpu compute target...")
compute = AmlCompute(
name=cpu_compute_target, size="STANDARD_D2_V2", min_instances=0, max_instances=4
)
ml_client.compute.begin_create_or_update(compute).result()
az ml compute create -n cpu-cluster --type amlcompute --min-instances 0 --max-instances 4
curl -X PUT \
"https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/computes/$COMPUTE_NAME?api-version=$API_VERSION" \
-H "Authorization:Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d '{
"location": "'$LOCATION'",
"properties": {
"computeType": "AmlCompute",
"properties": {
"vmSize": "Standard_D2_V2",
"vmPriority": "Dedicated",
"scaleSettings": {
"maxNodeCount": 4,
"minNodeCount": 0,
"nodeIdleTimeBeforeScaleDown": "PT30M"
}
}
}
}'
Conseil
Bien que l’opération retourne une réponse après quelques secondes, cette réponse indique uniquement que la demande de création est acceptée. La création du cluster peut prendre plusieurs minutes.
3. Soumettre le travail d’apprentissage
Pour exécuter ce script, utilisez un command pour exécuter le script Python main.py situé sous ./sdk/python/jobs/single-step/lightgbm/iris/src/. Vous envoyez la commande en tant que commande job à Azure Machine Learning.
Remarque
Pour utiliser le calcul serverless, supprimez compute="cpu-cluster" dans ce code.
from azure.ai.ml import command, Input
# define the command
command_job = command(
code="./src",
command="python main.py --iris-csv ${{inputs.iris_csv}} --learning-rate ${{inputs.learning_rate}} --boosting ${{inputs.boosting}}",
environment="AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu@latest",
inputs={
"iris_csv": Input(
type="uri_file",
path="https://azuremlexamples.blob.core.windows.net/datasets/iris.csv",
),
"learning_rate": 0.9,
"boosting": "gbdt",
},
compute="cpu-cluster",
)
# submit the command
returned_job = ml_client.jobs.create_or_update(command_job)
# get a URL for the status of the job
returned_job.studio_url
Dans les exemples précédents, vous avez configuré :
-
code - chemin d’accès où se trouve le code pour exécuter la commande.
-
command - commande qui doit s’exécuter.
-
environment : l’environnement nécessaire pour exécuter le script d’apprentissage. Dans cet exemple, utilisez un environnement organisé ou prêt à l’emploi fourni par Azure Machine Learning appelé AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu. Utilisez la dernière version de cet environnement à l’aide de la @latest directive. Vous pouvez également utiliser des environnements personnalisés en spécifiant une image docker de base et en spécifiant un fichier yaml conda par dessus celui-ci.
-
inputs : dictionnaire d’entrées de paires nom-valeur pour la commande. La clé est un nom pour l’entrée dans le contexte du travail et la valeur est la valeur d’entrée. Référencez les entrées dans l’expression command à l’aide de l’expression ${{inputs.<input_name>}} . Pour utiliser des fichiers ou des dossiers comme entrées, utilisez la Input classe. Pour plus d’informations, consultez Expressions SDK et CLI v2.
Pour plus d’informations, consultez la documentation de référence.
Lorsque vous soumettez la tâche, le service retourne une URL indiquant l'état de la tâche dans Azure Machine Learning Studio. Utilisez l’interface utilisateur Studio pour afficher la progression du travail. Vous pouvez également utiliser returned_job.status pour vérifier l’état actuel du travail.
La az ml job create commande de cet exemple nécessite un fichier de définition de travail YAML. Le fichier utilisé dans cet exemple contient le contenu suivant :
Remarque
Pour utiliser le calcul serverless, supprimez compute: azureml:cpu-cluster" dans ce code.
$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: src
command: >-
python main.py
--iris-csv ${{inputs.iris_csv}}
inputs:
iris_csv:
type: uri_file
path: https://azuremlexamples.blob.core.windows.net/datasets/iris.csv
environment: azureml:AzureML-lightgbm-3.3@latest
compute: azureml:cpu-cluster
display_name: lightgbm-iris-example
experiment_name: lightgbm-iris-example
description: Train a LightGBM model on the Iris dataset.
Dans le YAML précédent, vous avez configuré :
-
code - chemin d’accès où se trouve le code pour exécuter la commande.
-
command - commande qui doit être exécutée.
-
inputs : dictionnaire d’entrées de paires nom-valeur pour la commande. La clé est un nom pour l’entrée dans le contexte du travail et la valeur est la valeur d’entrée. Les entrées sont référencées dans le command en utilisant l'expression ${{inputs.<input_name>}}. Pour plus d’informations, consultez Expressions SDK et CLI v2.
-
environment : l’environnement nécessaire pour exécuter le script d’apprentissage. Dans cet exemple, utilisez un environnement organisé ou prêt à l’emploi fourni par Azure Machine Learning appelé AzureML-lightgbm-3.3. Utilisez la dernière version de cet environnement à l’aide de la @latest directive. Vous pouvez également utiliser des environnements personnalisés en spécifiant une image docker de base et en spécifiant un fichier yaml conda par dessus celui-ci.
Pour envoyer le travail, utilisez la commande suivante. L’ID d’exécution (nom) du travail d’apprentissage est stocké dans la variable $run_id :
run_id=$(az ml job create -f jobs/single-step/lightgbm/iris/job.yml --query name -o tsv)
Utilisez l'ID d'exécution stocké pour retourner des informations sur la tâche. Le paramètre --web ouvre l’interface utilisateur web d’Azure Machine Learning Studio dans laquelle vous pouvez explorer les détails du travail :
az ml job show -n $run_id --web
Lorsque vous soumettez un travail, vous devez charger les scripts d’apprentissage et les données dans un emplacement de stockage cloud auquel votre espace de travail Azure Machine Learning peut accéder.
Utilisez la commande Azure CLI suivante pour charger le script d’entraînement. La commande spécifie le répertoire contenant les fichiers nécessaires à l’entraînement et non un fichier individuel. Si vous souhaitez utiliser REST pour charger les données à la place, consultez la référence Put Blob :
az storage blob upload-batch -d $AZUREML_DEFAULT_CONTAINER/testjob -s cli/jobs/single-step/lightgbm/iris/src/ --account-name $AZURE_STORAGE_ACCOUNT
Créez une référence versionnée aux données d’apprentissage. Dans cet exemple, les données se trouvent déjà dans le cloud, à l’emplacement https://azuremlexamples.blob.core.windows.net/datasets/iris.csv. Pour plus d’informations sur le référencement des données, consultez Données dans Azure Machine Learning :
DATA_VERSION=$RANDOM
curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/data/iris-data/versions/$DATA_VERSION?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
\"properties\": {
\"description\": \"Iris dataset\",
\"dataType\": \"uri_file\",
\"dataUri\": \"https://azuremlexamples.blob.core.windows.net/datasets/iris.csv\"
}
}"
Inscrivez une référence versionnée au script d’apprentissage à utiliser avec un travail. Dans cet exemple, l’emplacement du script est le compte de stockage et le conteneur par défaut utilisés pour le chargement à l’étape 1. L’ID du code d’entraînement versionné est retourné et stocké dans la variable $TRAIN_CODE :
TRAIN_CODE=$(curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/codes/train-lightgbm/versions/1?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
\"properties\": {
\"description\": \"Train code\",
\"codeUri\": \"https://$AZURE_STORAGE_ACCOUNT.blob.core.windows.net/$AZUREML_DEFAULT_CONTAINER/testjob\"
}
}" | jq -r '.id')
Créez l’environnement que le cluster utilise pour exécuter le script d’entraînement. Dans cet exemple, utilisez un environnement organisé ou prêt à l’emploi fourni par Azure Machine Learning appelé AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu. La commande suivante récupère une liste des versions d’environnement, avec la plus récente en haut de la liste.
jq est utilisé pour récupérer l’ID de la dernière version ([0]), qui est ensuite stockée dans la $ENVIRONMENT variable.
ENVIRONMENT=$(curl --location --request GET "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/environments/AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu?api-version=$API_VERSION" --header "Authorization: Bearer $TOKEN" | jq -r .id)
Enfin, envoyez le travail. L’exemple suivant montre comment envoyer le travail, référencer l’ID du code d’apprentissage, l’ID d’environnement, l’URL des données d’entrée et l’ID du cluster de calcul. L’emplacement de sortie du travail est stocké dans la $JOB_OUTPUT variable :
Conseil
Le nom du travail doit être unique. Dans cet exemple, uuidgen est utilisé pour générer une valeur unique pour le nom.
Remarque
Pour utiliser le calcul serverless, supprimez la ligne \"computeId\": dans ce code.
run_id=$(uuidgen)
curl --location --request PUT "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/jobs/$run_id?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" \
--header "Content-Type: application/json" \
--data-raw "{
\"properties\": {
\"jobType\": \"Command\",
\"codeId\": \"$TRAIN_CODE\",
\"command\": \"python main.py --iris-csv \$AZURE_ML_INPUT_iris\",
\"environmentId\": \"$ENVIRONMENT\",
\"inputs\": {
\"iris\": {
\"jobInputType\": \"uri_file\",
\"uri\": \"https://azuremlexamples.blob.core.windows.net/datasets/iris.csv\"
}
},
\"experimentName\": \"lightgbm-iris\",
\"computeId\": \"/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/computes/$COMPUTE_NAME\"
}
}"
Inscrire le modèle entraîné
Les exemples suivants montrent comment inscrire un modèle dans votre espace de travail Azure Machine Learning.
Conseil
La tâche d'apprentissage renvoie une propriété name. Utilisez ce nom dans le cadre du chemin d’accès au modèle.
from azure.ai.ml.entities import Model
from azure.ai.ml.constants import AssetTypes
run_model = Model(
path="azureml://jobs/{}/outputs/artifacts/paths/model/".format(returned_job.name),
name="run-model-example",
description="Model created from run.",
type=AssetTypes.MLFLOW_MODEL
)
ml_client.models.create_or_update(run_model)
Conseil
Utilisez le nom stocké dans la $run_id variable dans le cadre du chemin d’accès au modèle.
az ml model create -n sklearn-iris-example -v 1 -p runs:/$run_id/model --type mlflow_model
Conseil
Utilisez le nom stocké dans la $run_id variable dans le cadre du chemin d’accès au 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\": {
\"modelType\": \"mlflow_model\",
\"modelUri\":\"runs:/$run_id/model\"
}
}"
Étapes suivantes
Maintenant que vous avez un modèle entraîné, découvrez comment le déployer à l’aide d’un point de terminaison en ligne.
Pour plus d’exemples, consultez le référentiel GitHub d’exemples Azure Machine Learning.
Pour plus d’informations sur les commandes Azure CLI, les classes du Kit de développement logiciel (SDK) Python ou les API REST utilisées dans cet article, consultez la documentation de référence suivante :