APLICA-SE A:
Azure CLI ml extension v2 (current)
Python SDK azure-ai-ml v2 (current)
O Azure Machine Learning fornece várias maneiras de enviar trabalhos de treinamento de ML. Neste artigo, aprende como submeter ofertas de trabalho utilizando os seguintes métodos:
- Extensão da CLI do Azure para aprendizado de máquina: a
ml extensão, 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 em seu espaço de trabalho. Use autenticação de entidade de serviço para pedidos REST administrativos.
Um token de autenticação da entidade de serviço. Siga os passos em Retrieve a service principal authentication token para obter este token.
O utilitário curl . O programa curl está disponível no Subsistema Windows para Linux ou qualquer distribuição UNIX.
Gorjeta
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.
O utilitário jq para processar JSON. Use esta utilidade para extrair valores dos documentos JSON que a API REST chama return.
Clone o repositório de exemplos
Os trechos de código neste artigo são baseados em exemplos no repositório GitHub de exemplos do Aprendizado de Máquina do Azure. Para clonar o repositório para seu ambiente de desenvolvimento, use o seguinte comando:
git clone --depth 1 https://github.com/Azure/azureml-examples
Gorjeta
Use --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 da flor da íris para treinar um modelo MLFlow.
Treine na nuvem
Quando treina na cloud, deve ligar-se ao seu espaço de trabalho de Machine Learning Azure e selecionar um recurso de computação para executar o trabalho de treino.
1. Conecte-se ao espaço de trabalho
Gorjeta
Utilize as seguintes abas para selecionar o método que quer usar para treinar um modelo. Selecionar um separador muda automaticamente todos os separadores neste artigo para o mesmo separador. Pode mudar para outro separador quando quiser.
Para se conectar ao espaço de trabalho, você precisa de parâmetros de identificador - uma assinatura, um grupo de recursos e um nome do espaço de trabalho. Use estes detalhes no MLClient do namespace azure.ai.ml para obter um acesso ao espaço de trabalho necessário do Azure Machine Learning. 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, veja 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)
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 comandos a seguir para definir valores padrão. Substitua <subscription ID>, <Azure Machine Learning workspace name>e <resource group> pelos valores para 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 $SUBSCRIPTION_ID, $RESOURCE_GROUP, $LOCATIONe $WORKSPACE espaços reservados. Substitua os espaços reservados pelos seus próprios valores da seguinte forma:
-
$SUBSCRIPTION_ID: Sua ID de 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 espaço de trabalho do Azure Machine Learning.
-
$COMPUTE_NAME: O nome do cluster de computação do Azure Machine Learning.
O REST administrativo solicita 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 $TOKEN ambiente:
TOKEN=$(az account get-access-token --query accessToken -o tsv)
O provedor de serviços usa o argumento para garantir a api-version compatibilidade. O api-version argumento 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 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')
2. Crie um recurso de computação para treinamento
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()
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"
}
}
}
}'
Gorjeta
Embora a operação devolva uma resposta após alguns segundos, esta resposta apenas indica que o pedido de criação foi aceite. Pode levar vários minutos para que a criação do cluster seja concluída.
3. Apresentar 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 um job para o Azure Machine Learning.
Nota
Para usar computação sem servidor, exclua compute="cpu-cluster" este código.
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, 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 guião de formação. Neste exemplo, utilize um ambiente curado ou pronto fornecido pelo Azure Machine Learning chamado AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu. Utilize a versão mais recente deste ambiente utilizando a @latest diretiva. Você também pode usar ambientes personalizados especificando uma imagem docker base e especificando um conda yaml sobre ela.
-
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. Referencie entradas no command pela expressão ${{inputs.<input_name>}}. Para usar ficheiros 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 submeteres a tarefa, o serviço devolve um URL para o estado da tarefa no Azure Machine Learning studio. 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 ficheiro de definição de trabalho YAML. O ficheiro utilizado neste exemplo contém o seguinte conteúdo:
Nota
Para usar computação sem servidor, exclua compute: azureml:cpu-cluster" este código.
$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 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 no command usando a ${{inputs.<input_name>}} expressão. Para obter mais informações, consulte Expressões SDK e CLI v2.
-
environment - o ambiente necessário para executar o guião de formação. Neste exemplo, utilize um ambiente curado ou pronto fornecido pelo Azure Machine Learning chamado AzureML-lightgbm-3.3. Utilize a versão mais recente deste ambiente utilizando a @latest diretiva. Você também pode usar ambientes personalizados especificando uma imagem docker base e especificando um conda yaml sobre ela.
Para enviar o trabalho, use o seguinte comando. O ID de execução (nome) do trabalho de treinamento é 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 --web parâmetro abre a interface do usuário da Web do estúdio de Aprendizado de Máquina do Azure, onde você pode detalhar o 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 de Machine Learning Azure possa aceder.
Use o seguinte comando da CLI do Azure 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 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 para os 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 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 versionada ao 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 versionado é 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 treino. Neste exemplo, utilize 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 do ambiente, com a mais recente na parte superior da coleção.
jq é usado para recuperar o ID da versão mais recente (),[0] que é depois armazenado 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, fazer referência à ID do código de treinamento, à ID do ambiente, à URL dos dados de entrada e à ID do cluster de computação. A localização da saída do trabalho é armazenada na $JOB_OUTPUT variável:
Gorjeta
O nome do trabalho deve ser exclusivo. Neste exemplo, uuidgen é usado para gerar um valor exclusivo para o nome.
Nota
Para usar computação sem servidor, exclua a \"computeId\": linha neste código.
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 em seu espaço de trabalho do Azure Machine Learning.
Gorjeta
O trabalho de formação devolve uma name propriedade. Use este nome como parte do caminho de acesso ao 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)
Gorjeta
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
Gorjeta
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óximos passos
Agora que você tem um modelo treinado, saiba como implantá-lo usando um endpoint online.
Para obter mais exemplos, consulte o repositório GitHub de exemplos do Azure Machine Learning.
Para obter mais informações sobre os comandos da CLI do Azure, classes do SDK Python ou APIs REST usadas neste artigo, consulte a seguinte documentação de referência: