APLICA-SE A:
Extensão de ML da CLI do Azure v2 (atual)
SDK do Python azure-ai-ml v2 (atual)
O 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:
- Extensão da CLI do Azure para machine learning: a extensão
ml
, também conhecida como CLI v2.
- SDK do Python v2 para o Azure Machine Learning.
- API REST: a API na qual a CLI e o SDK foram criados.
Pré-requisitos
Para usar as informações da API REST, você precisa dos seguintes itens:
Uma entidade de serviço no workspace. As solicitações REST administrativas usam a autenticação da entidade de serviço.
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 recuperar esse token.
O utilitário de curl. O programa de curl está disponível no Subsistema do Windows para Linux ou em qualquer distribuição do UNIX.
Dica
No PowerShell, o curl
é um alias para Invoke-WebRequest
e 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 do JSON. Esse utilitário é usado para extrair valores dos documentos JSON que são retornados das chamadas à API REST.
Clone o repositório de exemplos
Os snippets de código deste artigo são baseados nos exemplos do Repositório GitHub de exemplos do Azure Machine Learning. Para clonar o repositório para seu ambiente de desenvolvimento, use o seguinte comando:
git clone --depth 1 https://github.com/Azure/azureml-examples
Dica
Use o --depth 1
para clonar apenas a confirmação mais recente para o repositório, o que reduz o tempo para concluir a operação.
Exemplo de trabalho
Os exemplos neste artigo usam o conjunto de dados de flores de íris para treinar um modelo do MLFlow.
Treinar na nuvem
Ao treinar na nuvem, você deve se conectar ao workspace do Azure Machine Learning e selecionar um recurso de computação que será usado para executar o trabalho de treinamento.
1. Conectar-se ao espaço de trabalho
Dica
Use as guias abaixo para selecionar o método que deseja usar para treinar um modelo. A seleção de uma guia alternará automaticamente todas as guias deste artigo para a mesma guia. É possível selecionar outra guia a qualquer momento.
Para se conectar ao espaço de trabalho, você precisa de parâmetros de identificador, uma assinatura, um grupo de recursos e um nome de espaço de trabalho. Você usará esses detalhes no MLClient
do namespace azure.ai.ml
para obter um identificador para o espaço de trabalho do Azure Machine Learning necessário. Para autenticar, use a autenticação padrão do Azure. Verifique este exemplo para obter mais detalhes sobre como configurar credenciais e se conectar a um espaço de trabalho.
#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)
Ao usar a CLI do Azure, você precisa de parâmetros de identificador, uma assinatura, um grupo de recursos e um nome de espaço de trabalho. Embora você possa especificar esses parâmetros para cada comando, você também pode definir padrões que serão usados para todos os comandos. Use os comandos a seguir para definir os valores padrão. Substitua <subscription ID>
, <Azure Machine Learning workspace name>
e <resource group>
pelos valores para a sua configuração:
az account set --subscription <subscription ID>
az configure --defaults workspace=<Azure Machine Learning workspace name> group=<resource group>
Os exemplos de API REST neste artigo usam os espaços reservados $SUBSCRIPTION_ID
, $RESOURCE_GROUP
, $LOCATION
e $WORKSPACE
. Substitua os espaços reservados pelos seus próprios valores, da seguinte forma:
-
$SUBSCRIPTION_ID
: Sua ID da assinatura do Azure.
-
$RESOURCE_GROUP
: o grupo de recursos que contém seu workspace.
-
$LOCATION
: a região do Azure onde seu workspace está localizado.
-
$WORKSPACE
: o nome do workspace do Azure Machine Learning.
-
$COMPUTE_NAME
: o nome do cluster de cálculo do Azure Machine Learning.
As solicitações REST administrativas usam um token de autenticação da entidade de serviço. Você pode recuperar um token com o seguinte comando. O token é armazenado na variável de ambiente $TOKEN
:
TOKEN=$(az account get-access-token --query accessToken -o tsv)
O provedor de serviços usa o argumento api-version
para garantir a compatibilidade. O argumento api-version
varia de serviço para serviço. Defina a versão da API como uma variável para acomodar versões futuras:
API_VERSION="2022-05-01"
Quando você treina usando a API REST, os scripts de dados e treinamento devem ser carregados em uma conta de armazenamento que o workspace pode acessar. O seguinte exemplo obtém as informações de armazenamento do workspace e as salva em variáveis para que possamos 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')
2. Criar um recurso de computação para treinamento
Um cluster de cálculo do Azure Machine Learning é um recurso de computação totalmente gerenciado que pode ser usado para executar o trabalho de treinamento. Nos exemplos a seguir, um cluster de cálculo denominado cpu-compute
é criado.
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"
}
}
}
}'
Dica
Embora uma resposta seja retornada após alguns segundos, isso indica apenas que a solicitação de criação foi aceita. Pode levar vários minutos para que a criação do cluster seja concluída.
3. Enviar o trabalho de treinamento
Para executar esse script, você usará um command
que executa script Python main.py localizado em ./sdk/python/jobs/single-step/lightgbm/iris/src/. O comando será executado com o envio dele como um job
para o 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
Nos exemplos acima, 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, usamos um ambiente coletado ou pronto fornecido pelo Azure Machine Learning chamado AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu
. Usamos a versão mais recente desse ambiente usando a diretiva @latest
. Você também pode usar ambientes personalizados especificando uma imagem base do docker e especificando um yaml conda sobre ele.
-
inputs
– dicionário de entradas usando pares de valor de nome 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 em command
usando a expressão ${{inputs.<input_name>}}
. Para usar arquivos ou pastas como entradas, você pode usar a classe Input
. Para obter mais informações, confira Expressões do SDK e da CLI v2.
Para saber mais, consulte a documentação de referência.
Quando você envia o trabalho, uma URL é retornada para o status do trabalho no Estúdio do Azure Machine Learning. Use a interface do usuário do Estúdio para exibir o progresso do trabalho. Você também pode usar returned_job.status
para verificar o status atual do trabalho.
O comando az ml job create
usado neste exemplo requer um arquivo de definição de trabalho YAML. O conteúdo do arquivo usado neste exemplo é:
$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 acima, 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 de valor de nome 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 em command
usando a expressão ${{inputs.<input_name>}}
. Para obter mais informações, confira Expressões do SDK e da CLI v2.
-
environment
– o ambiente necessário para executar o script de treinamento. Neste exemplo, usamos um ambiente coletado ou pronto fornecido pelo Azure Machine Learning chamado AzureML-lightgbm-3.3
. Usamos a versão mais recente desse ambiente usando a diretiva @latest
. Você também pode usar ambientes personalizados especificando uma imagem base do docker e especificando um yaml conda sobre ele.
Para enviar o trabalho, use o seguinte comando. A ID de execução (nome) do trabalho de treinamento é armazenada na variável $run_id
:
run_id=$(az ml job create -f jobs/single-step/lightgbm/iris/job.yml --query name -o tsv)
Você pode usar 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 do Estúdio do Azure Machine Learning, na qual é possível analisar detalhes sobre o trabalho:
az ml job show -n $run_id --web
Como parte do envio do trabalho, os scripts de treinamento e os dados precisam ser carregados em um local de armazenamento em nuvem que o workspace do Azure Machine Learning possa acessar.
Use o comando da 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, confira a referência Colocar 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 estão localizados em https://azuremlexamples.blob.core.windows.net/datasets/iris.csv
. Para mais informações sobre como referenciar dados, confira Dados 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 com controle de versão para o script de treinamento para uso com um trabalho. 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 controle de versão é retornada e armazenada na variável $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')
Crie o ambiente que o cluster usará para executar o script de treinamento. Neste exemplo, usamos um ambiente coletado ou pronto fornecido pelo Azure Machine Learning chamado AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu
. O comando a seguir recupera uma lista das versões de ambiente, com a mais recente localizada na parte superior da coleção.
jq
é usado para recuperar a ID da versão mais recente ([0]
), que é armazenada na variável $ENVIRONMENT
.
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)
Por fim, envie o trabalho. O exemplo a seguir mostra como enviar o trabalho, referenciar a ID do código de treinamento, a ID do ambiente, a URL dos dados de entrada e a ID do cluster de cálculo. O local de saída do trabalho será armazenado na variável $JOB_OUTPUT
:
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\"
}
}"
Registrar o modelo treinado
Os exemplos a seguir demonstram como registrar um modelo no workspace do Azure Machine Learning.
Dica
A propriedade name
retornada pelo trabalho de treinamento é usada 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)
Dica
O nome (armazenado na variável $run_id
) é usado 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
O nome (armazenado na variável $run_id
) é usado 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\"
}
}"
Próximas etapas
Agora que você tem um modelo treinado, saiba como implantá-lo usando um ponto de extremidade online.
Para ver mais exemplos, confira o repositório GitHub de exemplos do Azure Machine Learning.
Para obter mais informações sobre os comandos da CLI do Azure, as classes do SDK do Python ou APIs REST usadas neste artigo, consulte a seguinte documentação de referência: