APLICÁVEL A:
Extensão CLI do Azure ml v2 (atual)
SDK Python azure-ai-ml v2 (atual)
Azure Machine Learning fornece várias maneiras de enviar trabalhos de treinamento de ML. Neste artigo, você aprenderá a enviar trabalhos usando os seguintes métodos:
- CLI do Azure extensão para machine learning: a extensão
ml, também conhecida como CLI v2.
- Python SDK v2 para Azure Machine Learning.
- API REST: a API na qual a CLI e o SDK são criados.
Pré-requisitos
Para usar as informações da API REST , você precisa dos seguintes itens:
Uma entidade de serviço no workspace. Use autenticação de entidades de serviço para solicitações REST administrativas.
Um token de autenticação da entidade de serviço. Siga as etapas descritas em Recuperar um token de autenticação da entidade de serviço para obter este token.
O utilitário curl . O programa curl está disponível no Subsistema do 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 se torna Invoke-WebRequest -Body "key=val" -Method POST -Uri uri.
Embora seja possível chamar a API REST do PowerShell, os exemplos neste artigo pressupõem que você esteja usando o Bash.
O utilitário jq para processamento JSON. Use esse utilitário para extrair valores dos documentos JSON que as chamadas à API REST retornam.
Clonar o repositório de exemplos
Os trechos de código neste artigo são baseados em exemplos no repositório GitHub Azure Machine Learning. Para clonar o repositório em 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 a confirmação mais recente no repositório, o que reduz o tempo para concluir a operação.
Os comandos restantes neste artigo pressupõem que você esteja executando no azureml-examples diretório.
Trabalho de exemplo
Os exemplos neste artigo usam o conjunto de dados da flor íris para treinar um modelo do MLFlow.
Treinar na nuvem
Ao treinar na nuvem, você deve se conectar ao seu workspace Azure Machine Learning e selecionar um recurso de computação para executar o trabalho de treinamento.
Conectar-se ao espaço de trabalho
Dica
Use as guias a seguir para selecionar o método que você deseja usar para treinar um modelo. Selecionar uma guia alterna automaticamente todas as guias deste artigo para a mesma guia. Você pode selecionar outra guia a qualquer momento.
Para se conectar ao workspace, você precisa de parâmetros de identificador – uma assinatura, um grupo de recursos e um nome de workspace. Utilize esses detalhes no MLClient do namespace azure.ai.ml para obter um identificador do Workspace do Azure Machine Learning necessário. Para autenticar, use a autenticação padrão do Azure. Para obter mais informações sobre como configurar credenciais e se conectar a um workspace, consulte esta 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)
Verifique a conexão imprimindo o nome do workspace:
print(ml_client.workspace_name)
Ao usar o CLI do Azure, você precisa de parâmetros de identificador – uma assinatura, um grupo de recursos e um nome de workspace. Embora você possa especificar esses parâmetros para cada comando, você também pode definir padrões que todos os comandos usam. Use os comandos a seguir para definir valores padrão. Substitua <subscription ID>, <Azure Machine Learning workspace name> e <resource group> pelos valores de 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 marcadores de posição $SUBSCRIPTION_ID, $RESOURCE_GROUP, $LOCATION, e $WORKSPACE. Substitua os espaços reservados por seus próprios valores da seguinte maneira:
-
$SUBSCRIPTION_ID: sua ID de assinatura Azure.
-
$RESOURCE_GROUP: O grupo de recursos Azure que contém seu espaço de trabalho.
-
$LOCATION: a região do Azure em que seu workspace está localizado.
-
$WORKSPACE: o nome do seu workspace de Azure Machine Learning.
-
$COMPUTE_NAME: o nome do cluster de computação Azure Machine Learning.
As solicitações REST administrativas exigem um token de autenticação da entidade de serviço. Você pode recuperar um token com o comando a seguir. O token é armazenado na variável de $TOKEN ambiente:
TOKEN=$(az account get-access-token --query accessToken -o tsv)
O provedor de serviços usa o api-version argumento para garantir a compatibilidade. O api-version argumento varia de serviço para serviço.
Este artigo usa os endpoints do Gerenciador de Recursos do Azure (management.azure.com). Defina API_VERSION para a versão Azure Machine Learning Resource Manager atual:
API_VERSION="2025-09-01"
Se você usar as APIs do plano de dados do Azure Machine Learning, elas poderão usar uma versão diferente. Por exemplo, a referência do plano de dados Azure AI Assets usa 2024-04-01-preview. Para obter mais informações, consulte os grupos de operações REST para Azure Machine Learning (Resource Manager) e Azure ativos de IA (plano de dados).
Ao treinar usando a API REST, você deve carregar dados e scripts de treinamento em uma conta de armazenamento que o workspace pode acessar. O exemplo a seguir obtém as informações de armazenamento para seu workspace e as salva em variáveis para que você 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 de computação para treinamento
Um cluster de computação Azure Machine Learning é um recurso de computação totalmente gerenciado que você pode usar para executar o trabalho de treinamento. Nos exemplos a seguir, você cria 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 o cluster de computação existe:
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 retorne uma resposta após alguns segundos, essa resposta indica apenas que a solicitação de criação é aceita. Pode levar vários minutos para que a criação do cluster seja concluída.
Enviar a tarefa de treinamento
Para executar esse script, use um command que executa o script main.py Python localizado em ./sdk/python/jobs/single-step/lightgbm/iris/src/. Envie o comando como um 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",
)
Envie 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, você configurou:
-
code - caminho em que o código para executar o comando está localizado.
-
command - comando que precisa ser executado.
-
environment – o ambiente necessário para executar o script de treinamento. Neste exemplo, use um ambiente selecionado ou pronto fornecido pelo Azure Machine Learning chamado AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu@latest. Você também pode utilizar ambientes personalizados especificando uma imagem base do Docker e definindo um arquivo yaml do conda sobre ela.
-
inputs – dicionário de entradas usando pares nome-valor para o comando. A chave é um nome para a entrada dentro do contexto do trabalho e o valor é o valor de entrada. Referencie entradas no command usando a expressão ${{inputs.<input_name>}}. Para usar arquivos ou pastas como entradas, use a Input classe. Para obter mais informações, consulte expressões SDK e CLI v2.
Para obter mais informações, consulte a documentação de referência.
Quando você envia o trabalho, o serviço retorna uma URL para o status do trabalho no Estúdio do Azure Machine Learning. Use a UI do Studio para exibir o progresso da tarefa. Você também pode usar returned_job.status para verificar o status atual do trabalho.
print(f"Studio URL: {returned_job.studio_url}")
O az ml job create comando neste exemplo requer um arquivo de definição de trabalho YAML. O arquivo usado 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 em que o código para executar o comando está localizado.
-
command - comando que precisa ser executado.
-
inputs – dicionário de entradas usando pares nome-valor para o comando. A chave é um nome para a entrada dentro do contexto do trabalho e o valor é o valor de entrada. As entradas são referenciadas no command pelo uso da expressão ${{inputs.<input_name>}}. Para obter mais informações, consulte expressões SDK e CLI v2.
-
environment – o ambiente necessário para executar o script de treinamento. Neste exemplo, use um ambiente selecionado ou pronto fornecido pelo Azure Machine Learning chamado AzureML-lightgbm-3.3@latest. Você também pode utilizar ambientes personalizados especificando uma imagem base do Docker e definindo um arquivo yaml do conda sobre ela.
Para enviar o trabalho, use o comando a seguir. A ID de execução (nome) do trabalho de treinamento é armazenada na $run_id variável:
run_id=$(az ml job create -f jobs/single-step/lightgbm/iris/job.yml --query name -o tsv)
Use a ID de execução armazenada para retornar informações sobre o trabalho. O parâmetro --web abre a interface do usuário da Web Estúdio do Azure Machine Learning em que você pode detalhar o trabalho:
az ml job show -n $run_id --web
Ao enviar um trabalho, você precisa carregar os scripts de treinamento e os dados para um local de armazenamento em nuvem que seu workspace Azure Machine Learning pode acessar.
Use o comando CLI do Azure a seguir para carregar o script de treinamento. O comando especifica o diretório que contém os arquivos necessários para treinamento, não um arquivo individual. Se você quiser usar REST para carregar os dados, consulte 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 com controle de versão aos dados de treinamento. Neste exemplo, os dados já estão na nuvem e localizados em https://azuremlexamples.blob.core.windows.net/datasets/iris.csv. Para obter mais informações sobre como referenciar dados, consulte Data no 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\"
}
}"
Registre uma referência versionada do script de treinamento para uso em uma tarefa. Neste exemplo, o local do script é a conta de armazenamento padrão e o contêiner para o qual você carregou na etapa 1. A ID do código de treinamento com versão é retornada e armazenada 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 treinamento. Neste exemplo, use um ambiente selecionado ou pronto fornecido pelo Azure Machine Learning chamado AzureML-lightgbm-3.3.
Azure Resource Manager não dá suporte a um atalho @latest para IDs de ambiente. O comando a seguir lista as versões de ambiente e seleciona a ID da versão modificada mais recentemente, que é armazenada 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 a seguir mostra como enviar o trabalho, fazer referência à ID do código de treinamento, À ID do ambiente, à URL dos dados de entrada e à ID do cluster de computação. O local de saída do trabalho é armazenado na $JOB_OUTPUT variável:
Dica
O nome do trabalho deve ser exclusivo. Neste exemplo, uuidgen é usado para gerar um valor exclusivo 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 treinamento e comando do Azure Machine Learning não dão suporte a Registros de Contêiner do Azure que usam rótulos personalizados para nomes de domínio. Trabalhos que fazem referência a esse registro podem falhar durante a inicialização devido a erros de pull de imagem ou resolução de ambiente. Para evitar esse problema:
- Utilize o formato padrão de servidor de logon (
<registry-name>.azurecr.io) para o ACR.
- Ao criar o registro, defina o escopo do rótulo de nome de domínio como Não seguro.
Monitorar o trabalho de treinamento
Aguarde até que o trabalho de treinamento seja concluído antes de registrar o modelo. O status do trabalho passa por Starting → Preparing → Running → Completed.
Use ml_client.jobs.stream() para monitorar a saída do trabalho em tempo real:
ml_client.jobs.stream(returned_job.name)
Como alternativa, verifique o status da tarefa programaticamente:
returned_job = ml_client.jobs.get(returned_job.name)
print(f"Job status: {returned_job.status}")
Use o comando az ml job show com --query status para verificar o status da tarefa:
az ml job show -n $run_id --query status -o tsv
Para acompanhar os logs da tarefa até sua conclusão:
az ml job stream -n $run_id
Verifique o status do trabalho com uma solicitação 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'
Registrar o modelo treinado
Os exemplos a seguir demonstram como registrar um modelo em seu workspace Azure Machine Learning.
Dica
O trabalho de treinamento retorna uma name propriedade. Use esse nome como parte do caminho de acesso 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 foi registrado:
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\"
}
}"
Limpar os recursos
Se você não planeja usar o cluster de computação para mais trabalhos de treinamento, exclua-o para parar de incorrer em encargos. O cluster continuará sendo cobrado enquanto existir, mesmo com zero nó em execução.
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 |
Cause |
Resolução |
ImportError: No module named 'azure.identity' |
Pacote azure-identity não encontrado |
Execute pip install azure-identity |
DefaultAzureCredential failed |
Não conectado ao Azure |
Execute az login primeiro, ou defina variáveis de ambiente para autenticação de entidade de serviço |
ComputeNotFound |
Nome do cluster incompatível ou cluster excluído |
Verificar o nome do cluster e verificar o estado de provisionamento |
EnvironmentNotFound |
Ambiente selecionado obsoleto ou indisponível |
Listar ambientes disponíveis com ml_client.environments.list() e usar uma versão atual |
QuotaExceeded |
Cota de vCPU insuficiente para o tamanho da VM |
Solicitar um aumento de cota ou usar um tamanho de VM menor |
Para problemas específicos do ambiente, consulte Solucionar problemas de compilações de imagens de ambiente.
Próximas etapas
Agora que você tem um modelo treinado, saiba como implantá-lo usando um ponto de extremidade online.
Para obter mais exemplos, consulte os Azure Machine Learning exemplos GitHub repositório.
Para obter mais informações sobre os comandos CLI do Azure, Python classes SDK ou APIs REST usadas neste artigo, consulte a seguinte documentação de referência: