SI APPLICA A:
Estensione ML dell'interfaccia della riga di comando di Azure v2 (corrente)
SDK Python azure-ai-ml v2 (corrente)
Azure Machine Learning offre diversi modi per inviare job di training di ML. Questo articolo illustra come inviare processi usando i metodi seguenti:
- L'estensione interfaccia della riga di comando di Azure per il machine learning: l'estensione
ml, nota anche come CLI v2.
- Python SDK v2 per Azure Machine Learning.
- API REST: API su cui si basano l'interfaccia della riga di comando e l'SDK.
Prerequisiti
Per usare le informazioni sull'API REST , sono necessari gli elementi seguenti:
Un'entità servizio nell'area di lavoro. Usare l'autenticazione dell'entità servizio per richieste REST a fini amministrativi.
Un token di autenticazione dell'entità servizio. Per ottenere questo token, seguire la procedura descritta in Recuperare un token di autenticazione dell'entità servizio .
L'utilità curl. Il programma curl è disponibile nel sottosistema Windows per Linux o in qualsiasi distribuzione UNIX.
Suggerimento
In PowerShell curl è un alias per Invoke-WebRequest. Il comando curl -d "key=val" -X POST uri diventa Invoke-WebRequest -Body "key=val" -Method POST -Uri uri.
Anche se è possibile chiamare l'API REST da PowerShell, gli esempi in questo articolo presuppongono l'uso di Bash.
Utilità jq per l'elaborazione di JSON. Usare questa utilità per estrarre i valori dai documenti JSON restituiti dalle chiamate API REST.
Clonare il repository di esempi
I frammenti di codice in questo articolo sono basati su esempi nell'Azure Machine Learning esempi GitHub repository. Per clonare il repository nell'ambiente di sviluppo, usare il comando seguente:
git clone --depth 1 https://github.com/Azure/azureml-examples
Suggerimento
Usare --depth 1 per clonare solo il commit più recente nel repository, riducendo il tempo necessario per completare l'operazione.
Esempio di lavoro
Gli esempi in questo articolo usano il set di dati dei fiori iris per addestrare un modello MLFlow.
Eseguire il training nel cloud
Quando si esegue il training nel cloud, è necessario connettersi all'area di lavoro Azure Machine Learning e selezionare una risorsa di calcolo per eseguire il processo di training.
1. Connettersi all'area di lavoro
Suggerimento
Usare le schede seguenti per selezionare il metodo da usare per eseguire il training di un modello. Se si seleziona una scheda, tutte le schede di questo articolo vengono automaticamente selezionate nella stessa scheda. È possibile selezionare un'altra scheda in qualsiasi momento.
Per connettersi all'area di lavoro, sono necessari parametri di identificatore, ovvero una sottoscrizione, un gruppo di risorse e un nome dell'area di lavoro. Usare questi dettagli nel MLClient dallo spazio dei nomi azure.ai.ml per ottenere un punto di controllo sull'area di lavoro di Azure Machine Learning necessaria. Per eseguire l'autenticazione, usare l'autenticazione Azure predefinita >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)
Quando si usa il interfaccia della riga di comando di Azure, sono necessari parametri di identificatore, ovvero una sottoscrizione, un gruppo di risorse e un nome dell'area di lavoro. Sebbene sia possibile specificare questi parametri per ogni comando, è anche possibile impostare le impostazioni predefinite usate da tutti i comandi. Usare i comandi seguenti per impostare i valori predefiniti. Sostituire <subscription ID>, <Azure Machine Learning workspace name> e <resource group> con i valori per la configurazione:
az account set --subscription <subscription ID>
az configure --defaults workspace=<Azure Machine Learning workspace name> group=<resource group>
Gli esempi di API REST in questo articolo usano i segnaposti $SUBSCRIPTION_ID, $RESOURCE_GROUP, $LOCATION e $WORKSPACE. Sostituire i segnaposto con i propri valori come indicato di seguito:
-
$SUBSCRIPTION_ID: ID della sottoscrizione Azure.
-
$RESOURCE_GROUP: gruppo di risorse Azure che contiene l'area di lavoro.
-
$LOCATION: area Azure in cui si trova l'area di lavoro.
-
$WORKSPACE: nome dell'area di lavoro Azure Machine Learning.
-
$COMPUTE_NAME: nome del cluster di calcolo Azure Machine Learning.
Le richieste REST amministrative richiedono un token di autenticazione dell'entità servizio. È possibile recuperare un token con il comando seguente. Il token viene archiviato nella $TOKEN variabile di ambiente:
TOKEN=$(az account get-access-token --query accessToken -o tsv)
Il provider di servizi usa l'argomento api-version per garantire la compatibilità. L'argomento api-version varia da servizio a servizio.
Questo articolo usa endpoint Azure Resource Manager (management.azure.com). Impostare API_VERSION sulla versione Azure Machine Learning Resource Manager corrente:
API_VERSION="2025-09-01"
Se si utilizzano le API del piano dati di Azure Machine Learning, esse possono utilizzare una versione diversa. Ad esempio, il riferimento al piano dati di Azure AI Assets utilizza 2024-04-01-preview. Per altre informazioni, vedere i gruppi di operazioni REST per Azure Machine Learning (Resource Manager) e Azure asset di intelligenza artificiale (piano dati).
Quando si esegue il training usando l'API REST, è necessario caricare i dati e gli script di training in un account di archiviazione a cui l'area di lavoro può accedere. L'esempio seguente ottiene le informazioni di archiviazione per l'area di lavoro e la salva in variabili in modo da poterla usare in un secondo momento:
# 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. Creare una risorsa di calcolo per il training
Un cluster di calcolo Azure Machine Learning è una risorsa di calcolo completamente gestita che è possibile usare per eseguire il processo di training. Negli esempi seguenti viene creato un cluster di calcolo denominato 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"
}
}
}
}'
Suggerimento
Mentre l'operazione restituisce una risposta dopo alcuni secondi, questa risposta indica solo che la richiesta di creazione è accettata. Il completamento della creazione del cluster può richiedere alcuni minuti.
3. Inviare il processo di training
Per eseguire questo script, usare un command che esegue lo script main.py Python che si trova in ./sdk/python/jobs/single-step/lightgbm/iris/src/. Inviare il comando come job a Azure Machine Learning.
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
Nei precedenti esempi, hai configurato:
-
code : percorso in cui si trova il codice per eseguire il comando.
-
command : comando che deve essere eseguito.
-
environment : l'ambiente necessario per eseguire lo script di training. In questo esempio usare un ambiente curato o pronto fornito da Azure Machine Learning denominato AzureML-lightgbm-3.3@latest. È anche possibile usare ambienti personalizzati specificando un'immagine Docker di base e specificando un yaml conda al suo posto.
-
inputs: dizionario di input con coppie nome-valore per il comando. La chiave è un nome per l'input nel contesto del processo e il valore è il valore dell'input. Fare riferimento agli input in command utilizzando l'espressione ${{inputs.<input_name>}} . Per usare file o cartelle come input, usare la Input classe . Per altre informazioni, vedere Espressioni SDK e dell'interfaccia della riga di comando v2.
Per altre informazioni, vedere la documentazione di riferimento.
Quando si invia il job, il servizio restituisce un URL allo stato del job nell'Azure Machine Learning Studio. Usare l'interfaccia utente di Studio per visualizzare lo stato del processo. È anche possibile usare returned_job.status per controllare lo stato corrente del processo.
Il az ml job create comando in questo esempio richiede un file di definizione del processo YAML. Il file usato in questo esempio contiene il contenuto seguente:
$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.
Nel file YAML precedente, hai configurato:
-
code : percorso in cui si trova il codice per eseguire il comando.
-
command : comando che deve essere eseguito.
-
inputs: dizionario di input con coppie nome-valore per il comando. La chiave è un nome per l'input nel contesto del lavoro e il valore rappresenta l'input stesso. Viene fatto riferimento agli input in command utilizzando l'espressione ${{inputs.<input_name>}} . Per altre informazioni, vedere Espressioni SDK e dell'interfaccia della riga di comando v2.
-
environment : l'ambiente necessario per eseguire lo script di training. In questo esempio usare un ambiente curato o pronto fornito da Azure Machine Learning denominato AzureML-lightgbm-3.3@latest. È anche possibile usare ambienti personalizzati specificando un'immagine Docker di base e specificando un yaml conda al suo posto.
Per inviare il job, usare il comando seguente. L'ID di esecuzione (nome) del processo di training viene archiviato nella $run_id variabile :
run_id=$(az ml job create -f jobs/single-step/lightgbm/iris/job.yml --query name -o tsv)
Usare l'ID esecuzione archiviato per restituire informazioni sul processo. Il parametro --web apre l'interfaccia utente Web studio di Azure Machine Learning in cui è possibile esaminare i dettagli del processo:
az ml job show -n $run_id --web
Quando si invia un processo, è necessario caricare gli script e i dati di training in un percorso di archiviazione cloud a cui l'area di lavoro di Azure Machine Learning possa accedere.
Usare il comando interfaccia della riga di comando di Azure seguente per caricare lo script di training. Il comando specifica la directory che contiene i file necessari per il training, non un singolo file. Se invece si desidera utilizzare REST per caricare i dati, consultare la documentazione del 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
Creare un riferimento con controllo delle versioni ai dati di training. In questo esempio i dati sono già presenti nel cloud e si trovano in https://azuremlexamples.blob.core.windows.net/datasets/iris.csv. Per altre informazioni sul riferimento ai dati, vedere Data in 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\"
}
}"
Registrare un riferimento con controllo delle versioni allo script di training da usare con un processo. In questo esempio il percorso dello script è l'account di archiviazione predefinito e il contenitore caricati nel passaggio 1. L'ID del codice di training con controllo delle versioni viene restituito e archiviato nella variabile $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')
Creare l'ambiente usato dal cluster per eseguire lo script di training. In questo esempio usare un ambiente curato o pronto fornito da Azure Machine Learning denominato AzureML-lightgbm-3.3.
Azure Resource Manager non supporta una scorciatoia @latest per gli ID dell'ambiente. Il comando seguente elenca le versioni dell'ambiente e seleziona l'ID versione modificato più di recente, che viene quindi archiviato nella $ENVIRONMENT variabile .
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')
Infine, inviare il lavoro. L'esempio seguente mostra come inviare il lavoro, riferirsi all'ID del codice di addestramento, all'ID dell'ambiente, all'URL per i dati di input e all'ID del cluster di calcolo. Il percorso di output del processo viene archiviato nella variabile $JOB_OUTPUT:
Suggerimento
Il nome del processo deve essere univoco. In questo esempio viene uuidgen usato per generare un valore univoco per il nome.
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\"
}
}"
Importante
I processi di training e comando di Azure Machine Learning non supportano Registri Azure Container (ACR) che usano etichette di dominio personalizzate. Le attività che fanno riferimento a un registro di questo tipo potrebbero fallire durante l'avvio a causa di errori di pull dell'immagine o di risoluzione dell'ambiente. Per evitare questo problema:
- Usare il formato predefinito del server di login (
<registry-name>.azurecr.io) per il Registro Azure Container.
- Quando si crea il registro, impostare Ambito etichetta nome di dominio su Insicuro.
Registra il modello addestrato
Gli esempi seguenti illustrano come registrare un modello nell'area di lavoro Azure Machine Learning.
Suggerimento
Il processo di addestramento restituisce una proprietà name. Usare questo nome come parte del percorso del modello.
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)
Suggerimento
Usare il nome archiviato nella $run_id variabile come parte del percorso del modello.
az ml model create -n sklearn-iris-example -v 1 -p runs:/$run_id/model --type mlflow_model
Suggerimento
Usare il nome archiviato nella $run_id variabile come parte del percorso del modello.
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\"
}
}"
Passaggi successivi
Ora che hai un modello addestrato, scopri come distribuirlo usando un endpoint online.
Per altri esempi, vedere il repository GitHub esempi di Azure Machine Learning.
Per altre informazioni sui comandi interfaccia della riga di comando di Azure, sulle classi SDK Python o sulle API REST usate in questo articolo, vedere la documentazione di riferimento seguente: