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 o SDK, instale o SDK do Azure Machine Learning v2 para Python.
Para usar as informações da API REST, você precisa dos seguintes itens:
Uma entidade de serviço no workspace. Use a autenticação da entidade 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 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, 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 do JSON. Use esse utilitário para extrair valores dos documentos JSON que as chamadas à API REST retornam.
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 --depth 1 para clonar apenas a confirmação mais recente no 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 para executar o trabalho de treinamento.
1. 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 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. 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 este exemplo.
#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 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 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: a ID da assinatura do Azure.
-
$RESOURCE_GROUP: O grupo de recursos do Azure que contém seu espaço de trabalho.
-
$LOCATION: A região do Azure onde seu espaço de trabalho está localizado.
-
$WORKSPACE: O nome do seu Workspace do Azure Machine Learning.
-
$COMPUTE_NAME: O nome do seu cluster de computação 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"
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')
2. Criar um recurso de computação para treinamento
Um cluster de computação do 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()
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.
3. Enviar o trabalho de treinamento
Para executar esse script, use um command que execute o script python main.py localizado em ./sdk/python/jobs/single-step/lightgbm/iris/src/. Você envia o comando 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 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. Use a versão mais recente desse ambiente usando a @latest diretiva. 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 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 as 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, confira Expressões do SDK e da CLI v2.
Para saber mais, 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 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 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 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, use um ambiente curado ou pronto para uso fornecido pelo Azure Machine Learning chamado AzureML-lightgbm-3.3. Use a versão mais recente desse ambiente usando a @latest diretiva. 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)
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 do Estúdio do Azure Machine Learning, na qual é possível analisar detalhes sobre 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 do Azure Machine Learning pode 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 enviar 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 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 usa para executar o script de treinamento. Neste exemplo, use um ambiente curado 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 $ENVIRONMENT variável.
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 é 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\"
}
}"
Registrar o modelo treinado
Os exemplos a seguir demonstram como registrar um modelo no workspace do Azure Machine Learning.
Dica
O trabalho de treinamento retorna uma name propriedade. Utilize 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)
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\"
}
}"
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: