APLICA-SE A:
extensão CLI do Azure ml v2 (atual)
Python SDK azure-ai-ml v2 (atual)
O Azure Machine Learning oferece múltiplas formas de submeter trabalhos de formação em ML. Neste artigo, aprende como submeter ofertas de trabalho utilizando os seguintes métodos:
- CLI do Azure extensão para aprendizagem automática: A extensão
ml, também conhecida como CLI v2.
- Python SDK v2 para Azure Machine Learning.
- API REST: A API sobre a qual o CLI e o SDK são construídos.
Pré-requisitos
Para usar a informação da API REST , precisa dos seguintes itens:
Um principal de serviço no seu espaço de trabalho. Use autenticação principal de serviço para requisições REST administrativas.
Um token de autenticação de principal de serviço. Siga as etapas em Recuperar um token de autenticação do principal de serviço para obter este token.
A ferramenta curl. O programa curl está disponível no Subsistema Windows para Linux ou em qualquer distribuição UNIX.
Dica
No PowerShell, curl é um alias para Invoke-WebRequest. O comando curl -d "key=val" -X POST uri torna-se Invoke-WebRequest -Body "key=val" -Method POST -Uri uri.
Embora seja possível chamar a API REST a partir do PowerShell, os exemplos neste artigo assumem que estás a usar Bash.
A utilidade jq para processar JSON. Use esta utilidade para extrair valores dos documentos JSON que a API REST chama return.
Clonar o repositório de exemplos
Os excertos de código neste artigo baseiam-se em exemplos no Azure Machine Learning exemplos GitHub repo. Para clonar o repositório para o seu ambiente de desenvolvimento, use o seguinte comando:
git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples
Dica
Use --depth 1 para clonar apenas o commit mais recente do repositório, o que reduz o tempo para completar a operação.
Os comandos restantes neste artigo assumem que estás a correr a partir do azureml-examples diretório.
Exemplo de emprego
Os exemplos neste artigo utilizam o conjunto de dados de flores de íris para treinar um modelo MLFlow.
Treina na nuvem
Quando treina na cloud, deve ligar-se ao seu espaço de trabalho Azure Machine Learning e selecionar um recurso de computação para executar o trabalho de treino.
Conectar-se ao espaço de trabalho
Dica
Utilize as seguintes abas para selecionar o método que pretende usar para treinar um modelo. Selecionar um separador muda automaticamente todos os separadores deste artigo para o mesmo separador. Pode selecionar outro separador a qualquer momento.
Para se ligar ao espaço de trabalho, precisa de parâmetros identificadores – uma subscrição, grupo de recursos e nome do espaço de trabalho. Use estes detalhes no MLClient do espaço de nomes azure.ai.ml para obter um acesso ao espaço de trabalho do Azure Machine Learning requerido. Para autenticar, use a autenticação padrão do Azure. Para mais informações sobre como configurar credenciais e ligar-se a um espaço de trabalho, consulte este c0.
#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)
Verifique a ligação imprimindo o nome do espaço de trabalho:
print(ml_client.workspace_name)
Quando usa a CLI do Azure, precisa de parâmetros identificadores – uma subscrição, grupo de recursos e nome do espaço de trabalho. Embora possas especificar estes parâmetros para cada comando, também podes definir os padrões que todos os comandos usam. Use os seguintes comandos para definir os valores predefinidos. Substitua <subscription ID>, <Azure Machine Learning workspace name> e <resource group> pelos valores da sua configuração:
az account set --subscription <subscription ID>
az configure --defaults workspace=<Azure Machine Learning workspace name> group=<resource group>
Os exemplos da API REST neste artigo usam $SUBSCRIPTION_ID, $RESOURCE_GROUP, $LOCATION, e $WORKSPACE marcadores de posição. Substitua os marcadores de lugar pelos seus próprios valores da seguinte forma:
-
$SUBSCRIPTION_ID: O seu ID de subscrição Azure.
-
$RESOURCE_GROUP: O grupo de recursos Azure que contém o seu espaço de trabalho.
-
$LOCATION: A região Azure onde o seu espaço de trabalho está localizado.
-
$WORKSPACE: O nome do seu ambiente de trabalho do Azure Machine Learning.
-
$COMPUTE_NAME: O nome do seu cluster de computação Azure Machine Learning.
Os pedidos REST administrativos requerem um token de autenticação do principal de serviço. Pode recuperar um token com o seguinte comando. O token é armazenado na $TOKEN variável de ambiente:
TOKEN=$(az account get-access-token --query accessToken -o tsv)
O fornecedor de serviços usa o api-version argumento para garantir a compatibilidade. O argumento api-version varia de serviço para serviço.
Este artigo utiliza Azure Resource Manager endpoints (management.azure.com). Defina API_VERSION para a versão Azure Machine Learning Resource Manager atual:
API_VERSION="2025-09-01"
Se usares APIs do Azure Machine Learning data plane, podem usar uma versão diferente. Por exemplo, a referência do plano de dados Azure AI Assets usa 2024-04-01-preview. Para mais informações, consulte os grupos de operações REST para Azure Machine Learning (Resource Manager) e Azure AI Assets (plano de dados).
Quando treina usando a API REST, deve carregar dados e scripts de treino para uma conta de armazenamento à qual o espaço de trabalho possa aceder. O exemplo seguinte obtém a informação de armazenamento do seu espaço de trabalho e guarda-a em variáveis para que possa usá-la mais tarde:
# 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')
Criar um recurso computacional para treino
Um cluster de computação Azure Machine Learning é um recurso de computação totalmente gerido que pode usar para executar o trabalho de treino. Nos exemplos seguintes, cria-se um cluster de computação chamado 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()
Verifique se existe o cluster de computação:
cpu_cluster = ml_client.compute.get("cpu-cluster")
print(f"Compute '{cpu_cluster.name}' provisioning state: {cpu_cluster.provisioning_state}")
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"
}
}
}
}'
Dica
Embora a operação devolva uma resposta após alguns segundos, esta resposta apenas indica que o pedido de criação foi aceite. Pode demorar vários minutos até a criação do cluster terminar.
Submeter o trabalho de formação
Para executar este script, use um command que executa o script main.py Python localizado sob ./sdk/python/jobs/single-step/lightgbm/iris/src/. Submetes o comando como job para 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",
)
Submeter o trabalho na mesma sessão de Python:
# 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
Nos exemplos anteriores, configurou:
-
code - caminho onde se encontra o código para executar o comando.
-
command - comando que precisa de correr.
-
environment - o ambiente necessário para executar o script de treino. Neste exemplo, utilize um ambiente curado ou pronto fornecido por Azure Machine Learning chamado AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu@latest. Também pode usar ambientes personalizados especificando uma imagem Docker base e, em complemento, um ficheiro YAML do Conda.
-
inputs - dicionário de entradas usando pares de nomes-valores para o comando. A chave é um nome para a entrada dentro do contexto do trabalho e o valor é o valor da entrada. Faça referência às entradas no command usando a expressão ${{inputs.<input_name>}}. Para usar ficheiros ou pastas como entradas, use a Input classe. Para mais informações, consulte SDK e expressões CLI v2.
Para mais informações, consulte a documentação de referência.
Quando submetes o trabalho, o serviço devolve uma URL para o estado do trabalho no Estúdio do Azure Machine Learning. Usa a interface do estúdio para ver o progresso do trabalho. Também podes usar returned_job.status para verificar o estado atual do trabalho.
print(f"Studio URL: {returned_job.studio_url}")
O az ml job create comando neste exemplo requer um ficheiro de definição de trabalho YAML. O ficheiro utilizado neste exemplo contém o seguinte conteúdo:
$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.
No YAML anterior, você configurou:
-
code - caminho onde se encontra o código para executar o comando.
-
command - comando que precisa de ser executado.
-
inputs - dicionário de entradas usando pares de nomes-valores para o comando. A chave é um nome para a entrada dentro do contexto do trabalho e o valor é o valor da entrada. As entradas são referenciadas no command usando a ${{inputs.<input_name>}} expressão. Para mais informações, consulte SDK e expressões CLI v2.
-
environment - o ambiente necessário para executar o script de treino. Neste exemplo, utilize um ambiente curado ou pronto fornecido por Azure Machine Learning chamado AzureML-lightgbm-3.3@latest. Também pode usar ambientes personalizados especificando uma imagem Docker base e, em complemento, um ficheiro YAML do Conda.
Para submeter a tarefa, use o seguinte comando. O ID da execução (nome) do trabalho de treino é armazenado na $run_id variável:
run_id=$(az ml job create -f jobs/single-step/lightgbm/iris/job.yml --query name -o tsv)
Use o ID de execução armazenado para devolver informações sobre o trabalho. O parâmetro --web abre a interface web Estúdio do Azure Machine Learning onde podes aprofundar os detalhes do trabalho:
az ml job show -n $run_id --web
Quando submetes um trabalho, precisas de carregar os scripts de treino e os dados para um local de armazenamento na cloud onde o teu espaço de trabalho Azure Machine Learning possa aceder.
Use o seguinte comando CLI do Azure para carregar o script de treino. O comando especifica o diretório que contém os ficheiros necessários para o treino, não um ficheiro individual. Se quiser usar REST para carregar os dados, veja a referência 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
Crie uma referência versionada aos dados de treino. Neste exemplo, os dados já estão na cloud e localizados em https://azuremlexamples.blob.core.windows.net/datasets/iris.csv. Para mais informações sobre referenciação de dados, veja Dados em 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\"
}
}"
Regista uma referência versionada ao script de treino para usar numa tarefa. Neste exemplo, a localização do script é a conta de armazenamento e o contentor predefinidos para onde carregaste no passo 1. O ID do código de treino versionado é devolvido e armazenado na $TRAIN_CODE variável:
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')
Crie o ambiente que o cluster usa para executar o script de treino. Neste exemplo, utilize um ambiente curado ou pronto fornecido por Azure Machine Learning chamado AzureML-lightgbm-3.3.
Azure Resource Manager não suporta um atalho @latest para IDs de ambiente. O comando seguinte lista as versões do ambiente e seleciona o ID da versão mais recentemente modificado, que é então armazenado na $ENVIRONMENT variável.
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')
Por fim, submeta o trabalho. O exemplo seguinte mostra como submeter o trabalho, referenciar o ID do código de treino, ID do ambiente, URL dos dados de entrada e o ID do cluster de computação. A localização da saída do trabalho é armazenada na $JOB_OUTPUT variável:
Dica
O nome do trabalho tem de ser único. Neste exemplo, uuidgen é usado para gerar um valor único para o 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
Os trabalhos de treino e de comandos do Azure Machine Learning não suportam os Registos de Contentores do Azure (ACR) que utilizam rótulos de domínio personalizados. Trabalhos que fazem referência a tal registro podem falhar durante o início devido a extração de imagem ou erros de resolução do ambiente. Para evitar este problema:
- Use o formato padrão do servidor de login (
<registry-name>.azurecr.io) para o seu ACR.
- Ao criar o registo, defina o âmbito da etiqueta do nome de domínio para Inseguro.
Monitorizar o trabalho de formação
Espera que o trabalho de formação termine antes de registares o modelo. O estado da tarefa passa por Starting → Preparing → Running → Completed.
Use ml_client.jobs.stream() para monitorizar a saída do trabalho em tempo real:
ml_client.jobs.stream(returned_job.name)
Alternativamente, verifique o estado do emprego programaticamente:
returned_job = ml_client.jobs.get(returned_job.name)
print(f"Job status: {returned_job.status}")
Use o az ml job show comando com --query status para verificar o estado do trabalho:
az ml job show -n $run_id --query status -o tsv
Para acompanhar os registos da tarefa em tempo real até à sua conclusão:
az ml job stream -n $run_id
Verifique o estado da tarefa com um pedido GET:
curl --location --request GET "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" | jq -r '.properties.status'
Registar o modelo treinado
Os exemplos seguintes demonstram como registar um modelo no seu espaço de trabalho do Azure Machine Learning.
Dica
O trabalho de formação devolve uma name propriedade. Use este nome como parte do caminho para o modelo.
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)
Verifique se o modelo estava registado:
registered_model = ml_client.models.get("run-model-example", version="1")
print(f"Model '{registered_model.name}' version {registered_model.version} registered successfully.")
Dica
Use o nome armazenado na $run_id variável como parte do caminho para o modelo.
az ml model create -n sklearn-iris-example -v 1 -p runs:/$run_id/model --type mlflow_model
Dica
Use o nome armazenado na $run_id variável como parte do caminho para o modelo.
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\"
}
}"
Limpeza de recursos
Se não planeias usar o cluster de computação para mais trabalhos de treino, elimina-o para evitar que tenhas cobranças. O cluster continua a faturar enquanto existe, mesmo com zero nós a funcionar.
ml_client.compute.begin_delete("cpu-cluster").wait()
az ml compute delete -n cpu-cluster --yes
curl --location --request DELETE "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.MachineLearningServices/workspaces/$WORKSPACE/computes/$COMPUTE_NAME?api-version=$API_VERSION" \
--header "Authorization: Bearer $TOKEN"
Solucionar erros comuns
| Erro |
Motivo |
Resolução |
ImportError: No module named 'azure.identity' |
Pacote em falta azure-identity |
Executar pip install azure-identity |
DefaultAzureCredential failed |
Sem sessão iniciada no Azure |
Execute az login primeiro ou defina variáveis de ambiente para autenticação com entidade de serviço |
ComputeNotFound |
Incompatibilidade no nome do cluster ou cluster eliminado |
Verifique o nome do cluster e verifique o estado de provisionamento |
EnvironmentNotFound |
Ambiente curado obsoleto ou indisponível |
Liste os ambientes disponíveis com ml_client.environments.list() e utilize uma versão atual |
QuotaExceeded |
Quota insuficiente de vCPU para o tamanho da VM |
Peça um aumento de quota ou use uma VM de tamanho menor |
Para problemas específicos do ambiente, consulte Resolução de problemas de compilações de imagens de ambiente.
Próximos passos
Agora que tens um modelo treinado, aprende a implementá-lo usando um endpoint online.
Para mais exemplos, consulte o repositório Azure Machine Learning exemplos GitHub.
Para mais informações sobre os comandos CLI do Azure, classes SDK Python ou APIs REST utilizadas neste artigo, consulte a seguinte documentação de referência: