S'APPLIQUE À :
Azure CLI ml extension v2 (actuelle)
Python SDK azure-ai-ml v2 (actuelle)
Azure Machine Learning fournit plusieurs façons d’envoyer des travaux de formation ML. Dans cet article, vous allez apprendre à envoyer des travaux à l’aide des méthodes suivantes :
- Azure CLI extension pour le Machine Learning : l’extension
ml, également appelée CLI v2.
- Python SDK v2 pour Azure Machine Learning.
- API REST : API sur laquelle l’interface CLI et le SDK sont basés.
Conditions préalables
Pour utiliser les informations de l’API REST , vous avez besoin des éléments suivants :
A service principal dans votre espace de travail. Utilisez l’authentification du principal de service pour les requêtes REST administratives.
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.
Utilitaire curl . Le programme curl est disponible dans la Sous-système Windows pour Linux ou 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 de 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 du dépôt GitHub Azure Machine Learning examples. 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 de l'opération.
Exemple de travail
Les exemples de cet article utilisent le jeu de données de fleur d’iris pour entraîner un modèle MLFlow.
Entraîner des modèles en 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. Se connecter à 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 détails dans le MLClient à partir de l’espace de noms azure.ai.ml pour obtenir une référence à l’espace de travail Azure Machine Learning requis. Pour vous authentifier, utilisez l’authentification default Azure. Pour plus d’informations sur la configuration des informations d’identification et la connexion à un espace de travail, consultez cette example.
#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 le 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 propres valeurs comme suit :
-
$SUBSCRIPTION_ID : VOTRE ID d’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 demandes REST administratives nécessitent un jeton d’authentification du principal de service. Vous pouvez récupérer un jeton avec 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 pour garantir la api-version compatibilité. L’argument api-version varie du service au service.
Cet article utilise des points de terminaison Azure Resource Manager (management.azure.com). Définissez API_VERSION sur la version Azure Machine Learning Resource Manager actuelle :
API_VERSION="2025-09-01"
Si vous utilisez les API de plan de données d'Azure Machine Learning, elles peuvent utiliser une version différente. Par exemple, la référence de plan de données Azure AI Assets utilise 2024-04-01-preview. Pour plus d’informations, consultez les groupes d’opérations REST pour Azure Machine Learning (Resource Manager) et Azure AI Assets (plan de données).
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’entraînement
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'entraînement
Pour exécuter ce script, utilisez un command qui exécute le script main.py Python situé sous ./sdk/python/jobs/single-step/lightgbm/iris/src/. Vous envoyez la commande en tant que job à Azure Machine Learning.
Note
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’entraînement. Dans cet exemple, utilisez un environnement organisé ou prêt à l’emploi fourni par Azure Machine Learning appelé AzureML-lightgbm-3.3@latest. Vous pouvez également utiliser des environnements personnalisés en spécifiant une image Docker de base et en spécifiant un yaml conda au-dessus de celui-ci.
-
inputs - dictionnaire d’entrées utilisant des 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 les 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 vers 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 :
$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 utilisant des paires nom valeur à la commande. La clé désigne un nom pour l’entrée dans le cadre de la tâche, et la valeur correspond à 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 les expressions SDK et CLI v2.
-
environment - l’environnement nécessaire 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.3@latest. Vous pouvez également utiliser des environnements personnalisés en spécifiant une image Docker de base et en spécifiant un yaml conda au-dessus de celui-ci.
Pour envoyer le travail, utilisez la commande suivante. L’ID d’exécution (nom) du travail d’entraînement est stocké dans la $run_id variable :
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 obtenir des informations sur la tâche. Le paramètre --web ouvre l’interface utilisateur web Azure Machine Learning studio où vous pouvez explorer les détails du travail :
az ml job show -n $run_id --web
Lorsque vous envoyez un travail, vous devez charger les scripts d’entraînement 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 qui contient 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 et situées à l’adresse https://azuremlexamples.blob.core.windows.net/datasets/iris.csv. Pour plus d’informations sur le référencement des données, consultez Data 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’entraînement à utiliser avec une tâche. Dans cet exemple, l’emplacement du script est le compte de stockage et le conteneur par défaut que vous avez chargés à l’étape 1. L’ID du code d’entraînement versionné est retourné et stocké dans la $TRAIN_CODE variable :
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.3.
Azure Resource Manager ne prend pas en charge un raccourci @latest pour les ID d'environnement. La commande suivante répertorie les versions d’environnement et sélectionne l’ID de version le plus récemment modifié, qui est ensuite stocké dans la $ENVIRONMENT variable.
ENVIRONMENT_NAME="AzureML-lightgbm-3.3"
ENVIRONMENT=$(curl --location --request GET "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/environments/$ENVIRONMENT_NAME/versions?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN" | jq -r '.value | sort_by(.systemData.lastModifiedAt) | last | .id')
Enfin, envoyez le travail. L’exemple suivant montre comment envoyer le travail, référencer l’ID de code d’entraînement, 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.
Note
Pour utiliser le calcul sans serveur, supprimez la ligne \"computeId\": de 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\"
}
}"
Important
Les travaux de formation et de commande Azure Machine Learning ne prennent pas en charge le Registre de conteneurs Azure (ACR) qui utilise des libellés de noms de domaine personnalisés. Les travaux qui font référence à un tel registre peuvent échouer au démarrage en raison d’erreurs de tirage d’image ou de résolution d’environnement. Pour éviter ce problème :
- Utilisez le format de serveur de connexion par défaut (
<registry-name>.azurecr.io) pour votre ACR.
- Lorsque vous créez le Registre, définissez l’étendue de l’étiquette de nom de domainesur Non sécurisé.
Inscrire le modèle entraîné
Les exemples suivants montrent comment inscrire un modèle dans votre espace de travail Azure Machine Learning.
Conseil
Le travail d’entraînement 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 Azure Machine Learning GitHub.
Pour plus d’informations sur les commandes Azure CLI, les classes de sdk Python ou les API REST utilisées dans cet article, consultez la documentation de référence suivante :