Configurar o treinamento de AutoML para dados tabulares com a CLI do Azure Machine Learning e o SDK do Python

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

Neste artigo, aprenda a configurar um trabalho de treinamento de aprendizado de máquina automatizado (AutoML) com o Azure Machine Learning Python SDK v2. O ML automatizado escolhe um algoritmo e hiperparâmetros para você e gera um modelo pronto para implantação. Esse artigo fornece detalhes das várias opções que você pode usar para configurar experimentos automatizados de aprendizado de máquina.

Se você preferir uma experiência sem código, também pode Configurar treinamento de ML automatizado sem código para dados tabulares com a IU do estúdio.

Pré-requisitos

• Uma assinatura do Azure. Caso não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga do Azure Machine Learning.
• Um workspace do Azure Machine Learning. Se você não tiver um, veja Criar recursos para começar.

Configurar seu workspace

Para se conectar a um espaço de trabalho, você precisa fornecer uma assinatura, um grupo de recursos e um espaço de trabalho.

from azure.identity import DefaultAzureCredential
from azure.ai.ml import MLClient

credential = DefaultAzureCredential()
ml_client = None
try:
    ml_client = MLClient.from_config(credential)
except Exception as ex:
    print(ex)
    # Enter details of your Azure Machine Learning workspace
    subscription_id = "<SUBSCRIPTION_ID>"
    resource_group = "<RESOURCE_GROUP>"
    workspace = "<AZUREML_WORKSPACE_NAME>"
    ml_client = MLClient(credential, subscription_id, resource_group, workspace)

az login

az configure --defaults group=<RESOURCE_GROUP> workspace=<AZUREML_WORKSPACE_NAME> location=<LOCATION>

Especificar fonte de dados e formato

Para fornecer dados de treinamento no SDK v2, você precisa carregá-los na nuvem por meio de um MLTable.

Requisitos para carregar dados em uma MLTable:

• Os dados devem estar em formato de tabela.
• O valor a ser previsto, coluna de destino, deve estar nos dados.

Os dados de treinamento devem ser acessíveis a partir da computação remota. O ML automatizado v2 (Python SDK e CLI/YAML) aceita ativos de dados MLTable (v2). Para compatibilidade com versões anteriores, ele também oferece suporte a conjuntos de dados tabulares v1 da v1, um conjunto de dados tabular registrado, por meio das mesmas propriedades do conjunto de dados de entrada. Recomendamos que você use o MLTable, disponível na v2. Nesse exemplo, os dados são armazenados no caminho local, ./train_data/bank_marketing_train_data.csv.

import mltable

paths = [
    {'file': './train_data/bank_marketing_train_data.csv'}
]

train_table = mltable.from_delimited_files(paths)
train_table.save('./train_data')

$schema: https://azuremlschemas.azureedge.net/latest/MLTable.schema.json

paths:
  - file: ./bank_marketing_train_data.csv
transformations:
  - read_delimited:
        delimiter: ','
        encoding: 'ascii'

Agora a pasta ./train_data tem o arquivo de definição MLTable mais o arquivo de dados, bank_marketing_train_data.csv.

Para obter mais informações sobre MLTable, veja Trabalhando com tabelas no Azure Machine Learning.

Dados de treinamento, validação e teste

Você pode especificar conjuntos de dados de treinamento e de validação separados. Os dados de treinamento devem ser fornecidos ao parâmetro training_data na função de fábrica do seu trabalho de aprendizado de máquina automatizado.

Se você não especificar explicitamente um parâmetro validation_data ou n_cross_validation, o Automated ML aplicará técnicas padrão para determinar como a validação será realizada. Essa determinação depende do número de linhas no conjuntos de dados atribuído ao parâmetro training_data.

Computação para executar o experimento

Atualmente, trabalhos automatizados de aprendizado de máquina com o Python SDK v2 (ou CLI v2) só são suportados no cluster de computação remota ou na instância de computação do Azure Machine Learning. Para obter mais informações sobre como criar computação com o Python SDKv2 ou CLIv2, veja Treinar modelos com o Azure Machine Learning CLI, SDK e REST API.

Configurar as definições do experimento

Há várias opções que você pode usar para configurar experimentos de aprendizado de máquina automatizado. Esses parâmetros de configuração são definidos em seu método de tarefa. Você também pode definir configurações de treinamento de trabalho e critérios de saída com as configurações training e limits.

O exemplo a seguir mostra os parâmetros necessários para uma tarefa de classificação que especifica a precisão como a métrica primária e cinco dobras de validação cruzada.

from azure.ai.ml.constants import AssetTypes
from azure.ai.ml import automl, Input

# note that this is a code snippet -- you might have to modify the variable values to run it successfully

# make an Input object for the training data
my_training_data_input = Input(
    type=AssetTypes.MLTABLE, path="./data/training-mltable-folder"
)

# configure the classification job
classification_job = automl.classification(
    compute=my_compute_name,
    experiment_name=my_exp_name,
    training_data=my_training_data_input,
    target_column_name="y",
    primary_metric="accuracy",
    n_cross_validations=5,
    enable_model_explainability=True,
    tags={"my_custom_tag": "My custom value"}
)

# Limits are all optional
classification_job.set_limits(
    timeout_minutes=600, 
    trial_timeout_minutes=20, 
    max_trials=5,
    enable_early_termination=True,
)

# Training properties are optional
classification_job.set_training(
    blocked_training_algorithms=["logistic_regression"], 
    enable_onnx_compatible_models=True
)

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: <my_exp_name>
description: A classification AutoML job
task: classification

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:<my_compute_name>
primary_metric: accuracy  
target_column_name: y
n_cross_validations: 5
enable_model_explainability: True

tags:
    <my_custom_tag>: <My custom value>

limits:
    timeout_minutes: 600 
    trial_timeout_minutes: 20 
    max_trials: 5
    enable_early_termination: True

training:
    blocked_training_algorithms: ["logistic_regression"] 
    enable_onnx_compatible_models: True

Selecione o tipo de tarefa de aprendizado de máquina

Antes de enviar seu trabalho de ML automatizado, determine o tipo de problema de aprendizado de máquina que você deseja resolver. Esse problema determina qual função seu trabalho usa e quais algoritmos de modelo ele aplica.

O ML automatizado oferece suporte a diferentes tipos de tarefas:

• Tarefas baseadas em dados tabulares

  • classificação
  • regressão
  • previsão

• Tarefas de visão computacional, incluindo

  • Classificação de imagens
  • Detecção de objetos

• Tarefas de processamento de linguagem natural, incluindo

  • Classificação de texto
  • Reconhecimento de Entidade

Para obter mais informações, veja os tipos de tarefas. Para obter mais informações sobre como configurar trabalhos de previsão, veja Configurar o AutoML para treinar um modelo de previsão de série temporal.

Algoritmos compatíveis

O machine learning automatizado testa diferentes modelos e algoritmos durante o processo de automação e ajuste. Como usuário, você não precisa especificar o algoritmo.

O método de tarefa determina a lista de algoritmos ou modelos a serem aplicados. Para modificar ainda mais as iterações com os modelos disponíveis para incluir ou excluir, use os parâmetros allowed_training_algorithms ou blocked_training_algorithms na configuração training do trabalho.

Na tabela a seguir, explore os algoritmos suportados por tarefa de aprendizado de máquina.

Com outros algoritmos:

• Algoritmos de Classificação de Imagem de Várias Classes
• Algoritmos de Classificação de Imagem de Vários Rótulos
• Algoritmos de Detecção de Objeto de Imagem
• Algoritmos de Classificação de Texto PNL de Vários Rótulos
• Algoritmos de Reconhecimento de Entidade Nomeada (NER) de Texto NLP

Para exemplos de notebooks de cada tipo de tarefa, veja automl-standalone-jobs.

Métrica principal

O parâmetro primary_metric determina a métrica a ser usada durante o treinamento do modelo para otimização. O tipo de tarefa escolhido determina as métricas que você pode selecionar.

A escolha de uma métrica primária para otimização do aprendizado de máquina automatizado depende de muitos fatores. Recomendamos que a sua consideração principal seja escolher uma métrica que melhor represente suas necessidades de negócios. Em seguida, considere se a métrica é adequada para o perfil do seu conjunto de dados, incluindo tamanho dos dados, intervalo e distribuição de classe. As seções a seguir resumem as métricas primárias recomendadas com base no tipo de tarefa e no cenário de negócios.

Para saber mais sobre as definições específicas dessas métricas, veja Avaliar resultados de experimentos automatizados de aprendizado de máquina.

Métricas para cenários de várias classes de classificação

Essas métricas se aplicam a todos os cenários de classificação, incluindo dados tabulares, imagens ou visão computacional e texto de processamento de linguagem natural (NLP-Text).

Métricas dependentes de limite, como accuracy, recall_score_weighted, norm_macro_recall, e precision_score_weighted podem não ser otimizadas tão bem para conjuntos de dados pequenos, com grande distorção de classe (desequilíbrio de classe) ou quando o valor da métrica esperado é muito próximo de 0,0 ou 1,0. Nesses casos, AUC_weighted pode ser uma opção melhor para a métrica primária. Após a conclusão do aprendizado de máquina automatizado, você pode escolher o modelo vencedor com base na métrica mais adequada às necessidades do seu negócio.

Métricas para cenários de várias rótulos de classificação

Para classificação de texto com vários rótulos, atualmente “Precisão” é a única métrica primária suportada.

Para classificação de imagem com vários rótulos, as principais métricas suportadas são definidas na enumeração ClassificationMultilabelPrimaryMetrics.

Métricas para cenários de Reconhecimento de Entidade Nomeada de texto NLP

Para o reconhecimento de entidade nomeada de texto NLP (NER), atualmente 'Precisão' é a única métrica primária suportada.

As métricas usadas em cenários de regressão

r2_score, normalized_mean_absolute_error, e normalized_root_mean_squared_error estão todos tentando minimizar erros de previsão. r2_score e normalized_root_mean_squared_error estão minimizando erros ao quadrado médios enquanto normalized_mean_absolute_error minimiza o valor absoluto médio de erros. O valor absoluto trata erros de todas as magnitudes da mesma forma e erros ao quadrado têm uma penalidade muito maior para erros com valores absolutos maiores. Dependendo se erros maiores devem ser mais punidos ou não, você pode escolher otimizar o erro quadrático ou o erro absoluto.

A principal diferença entre r2_score e normalized_root_mean_squared_error é a maneira como são normalizados e seus significados. normalized_root_mean_squared_error é o erro quadrado médio raiz normalizado por intervalo e pode ser interpretado como a magnitude média do erro para previsão. r2_score é o erro quadrado média normalizado por uma estimativa de variação de dados. É a proporção de variação que o modelo consegue capturar.

Se a classificação, em vez do valor exato, for de interesse, spearman_correlation pode ser uma escolha melhor. Ele mede a correlação de classificação entre valores reais e previsões.

Atualmente, o ML automatizado não oferece suporte a nenhuma métrica primária que meça a diferença relativa entre previsões e observações. As métricas r2_score, normalized_mean_absolute_error e normalized_root_mean_squared_error são todas medidas de diferença absoluta. Por exemplo, se uma previsão for diferente de uma observação em 10 unidades, essas métricas calcularão o mesmo valor se a observação for de 20 unidades ou 20.000 unidades. Em contraste, uma diferença percentual, que é uma medida relativa, gera erros de 50% e 0,05%, respectivamente. Para otimizar a diferença relativa, você pode executar o ML automatizado com uma métrica primária compatível e, em seguida, selecionar o modelo com a melhor mean_absolute_percentage_error ou root_mean_squared_log_error. Essas métricas são indefinidas quando quaisquer valores de observação são zero, portanto, elas nem sempre são boas escolhas.

As métricas usadas em cenários de Previsão de Série Temporal

As recomendações são semelhantes às recomendações para cenários de regressão.

Métricas para cenários de Detecção de Objeto de Imagem

Para detecção de objetos de imagem, as principais métricas suportadas são definidas na enumeração ObjectDetectionPrimaryMetrics.

Métricas para cenários de segmentação de instância de imagem

Para cenários de segmentação de instância de imagem, as principais métricas suportadas são definidas na enumeração InstanceSegmentationPrimaryMetrics.

Definição de recursos de dados

Em cada experimento automatizado de aprendizado de máquina, seus dados são automaticamente transformados em números e vetores de números. Os dados também são dimensionados e normalizados para ajudar algoritmos que são sensíveis a recursos que estão em escalas diferentes. Essas transformações de dados são chamadas de definição de recursos.

Ao configurar trabalhos automatizados de aprendizado de máquina, você pode habilitar ou desabilitar as configurações featurization.

A tabela a seguir mostra as configurações aceitas para caracterização.

O código a seguir mostra como a caracterização personalizada pode ser fornecida nesse caso para um trabalho de regressão.

from azure.ai.ml.automl import ColumnTransformer

transformer_params = {
    "imputer": [
        ColumnTransformer(fields=["CACH"], parameters={"strategy": "most_frequent"}),
        ColumnTransformer(fields=["PRP"], parameters={"strategy": "most_frequent"}),
    ],
}
regression_job.set_featurization(
    mode="custom",
    transformer_params=transformer_params,
    blocked_transformers=["LabelEncoding"],
    column_name_and_types={"CHMIN": "Categorical"},
)

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl

experiment_name: <my_exp_name>
description: A classification AutoML job
task: classification

training_data:
    path: "./train_data"
    type: mltable

compute: azureml:<my_compute_name>
primary_metric: accuracy  
target_column_name: y
n_cross_validations: 5
enable_model_explainability: True

featurization:
    mode: custom
    column_name_and_types:
        CHMIN: Categorical
    blocked_transformers: ["label_encoder"]
    transformer_params:
        imputer:
            - fields: ["CACH", "PRP"]
            parameters:
                strategy: most_frequent

limits:
    # limit settings

training:
    # training settings

Critérios de saída

Há algumas opções que você pode definir na set_limits() função para encerrar seu experimento antes que o trabalho seja concluído.

Executar o experimento

Envie o experimento para ser executado e para gerar um modelo.

Com o MLClient criado nos pré-requisitos, é possível executar o comando a seguir no workspace.

# Submit the AutoML job
returned_job = ml_client.jobs.create_or_update(
    classification_job
)  # submit the job to the backend

print(f"Created job: {returned_job}")

# Get a URL for the status of the job
returned_job.services["Studio"].endpoint

run_id=$(az ml job create --file automl-classification-job.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>)

az ml job show -n $run_id --web

Várias execuções filhas em clusters

Execuções filhas de experimento de ML automatizados podem ser realizadas em um cluster que já esteja executando outro experimento. No entanto, o tempo depende de quantos nós o cluster tem e se esses nós estão disponíveis para executar um experimento diferente.

Cada nó no cluster atua como uma máquina virtual (VM) individual que pode realizar uma única execução de treinamento. Para ML automatizado, esse fato significa uma corrida infantil. Se todos os nós estiverem ocupados, um novo experimento será colocado na fila. Se houver nós livres, o novo experimento executará execuções filhas em paralelo nos nós ou máquinas virtuais disponíveis.

Para ajudar a gerenciar execuções secundárias e quando elas podem ser executadas, recomendamos que você crie um cluster dedicado por experimento e corresponda o número de max_concurrent_iterations do seu experimento ao número de nós no cluster. Dessa forma, você usa todos os nós do cluster ao mesmo tempo com o número de execuções simultâneas de filhos e iterações que desejar.

Configure max_concurrent_iterations na configuração limits. Se não estiver configurado, por padrão, apenas uma execução/iteração simultânea do filho será permitida por experimento. Para uma instância de computação, max_concurrent_trials pode ser definido como o mesmo que o número de núcleos na máquina virtual da instância de computação.

Explorar modelos e métricas

O ML automatizado oferece opções para você monitorar e avaliar os resultados do treinamento.

• Para obter definições e exemplos dos gráficos e métricas de desempenho fornecidos para cada execução, confira Avaliar resultados do experimento de machine learning automatizado.

• Para obter um resumo de personalização e entender quais recursos foram adicionados a um modelo específico, confira Transparência da definição de recursos.

Na interface do usuário do Azure Machine Learning na página do modelo, você também pode visualizar os hiperparâmetros usados ​​ao treinar um modelo específico, além de visualizar e personalizar o código de treinamento do modelo interno usado.

Registro e implantação de modelos

Depois de testar um modelo e confirmar que deseja usá-lo na produção, você pode registrá-lo para uso posterior.

Use AutoML em pipelines

Para usar o ML automatizado em seus fluxos de trabalho de operações de aprendizado de máquina, você pode adicionar etapas de trabalho do AutoML aos seus Azure Machine Learning Pipelines. Essa abordagem permite que você automatize todo o seu fluxo de trabalho conectando seus scripts de preparação de dados ao Automated ML. Em seguida, registre e valide o melhor modelo resultante.

Esse código é um pipeline de exemplo com um componente de classificação de ML automatizado e um componente de comando que mostra a saída resultante. O código faz referência às entradas (dados de treinamento e validação) e às saídas (melhor modelo) em diferentes etapas.

# Define pipeline
@pipeline(
    description="AutoML Classification Pipeline",
    )
def automl_classification(
    classification_train_data,
    classification_validation_data
):
    # define the automl classification task with automl function
    classification_node = classification(
        training_data=classification_train_data,
        validation_data=classification_validation_data,
        target_column_name="y",
        primary_metric="accuracy",
        # currently need to specify outputs "mlflow_model" explictly to reference it in following nodes 
        outputs={"best_model": Output(type="mlflow_model")},
    )
    # set limits and training
    classification_node.set_limits(max_trials=1)
    classification_node.set_training(
        enable_stack_ensemble=False,
        enable_vote_ensemble=False
    )

    command_func = command(
        inputs=dict(
            automl_output=Input(type="mlflow_model")
        ),
        command="ls ${{inputs.automl_output}}",
        environment="AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:latest"
    )
    show_output = command_func(automl_output=classification_node.outputs.best_model)


pipeline_job = automl_classification(
    classification_train_data=Input(path="./training-mltable-folder/", type="mltable"),
    classification_validation_data=Input(path="./validation-mltable-folder/", type="mltable"),
)

# set pipeline level compute
pipeline_job.settings.default_compute = compute_name

# submit the pipeline job
returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name
)
returned_pipeline_job

# ...
# Note that this is a snippet from the bankmarketing example you can find in our examples repo -> https://github.com/Azure/azureml-examples/tree/main/sdk/python/jobs/pipelines/1h_automl_in_pipeline/automl-classification-bankmarketing-in-pipeline

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

description: AutoML Classification Pipeline
experiment_name: <exp_name>

# set the default compute for the pipeline steps
settings:
    default_compute: azureml:<my_compute>

# pipeline inputs
inputs:
    classification_train_data:
        type: mltable
        path: "./train_data"
    classification_validation_data:
        type: mltable
        path: "./valid_data"

jobs:
    # Configure the automl training node of the pipeline 
    classification_node:
        type: automl
        task: classification
        primary_metric: accuracy
        target_column_name: y
        training_data: ${{parent.inputs.classification_train_data}}
        validation_data: ${{parent.inputs.classification_validation_data}}
        training:
            max_trials: 1
        limits:
            enable_stack_ensemble: False
            enable_vote_ensemble: False
        outputs:
            best_model:
                type: mlflow_model

    show_output:
        type: command
        inputs:
            automl_output: ${{parent.jobs.classification_node.outputs.best_model}}
        environment: "AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:latest"
        command: >-
            ls ${{inputs.automl_output}}
        

> run_id=$(az ml job create --file automl-classification-pipeline.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>)
> az ml job show -n $run_id --web

Use AutoML em escala: treinamento distribuído

Para cenários de grandes volumes de dados, o ML automatizado oferece suporte ao treinamento distribuído para um conjunto limitado de modelos:

Algoritmos de treinamento distribuídos particionam automaticamente e distribuem seus dados entre vários nós de computação para treinamento de modelo.

Treinamento distribuído para classificação e regressão

Para usar o treinamento distribuído para classificação ou regressão, defina as propriedades training_mode e max_nodes do objeto de trabalho.

O exemplo de código a seguir mostra um exemplo dessas configurações para um trabalho de classificação:

from azure.ai.ml.constants import TabularTrainingMode

# Set the training mode to distributed
classification_job.set_training(
    allowed_training_algorithms=["LightGBM"],
    training_mode=TabularTrainingMode.DISTRIBUTED
)

# Distribute training across 4 nodes for each trial
classification_job.set_limits(
    max_nodes=4,
    # other limit settings
)

# Set the training mode to distributed
training:
    allowed_training_algorithms: ["LightGBM"]
    training_mode: distributed

# Distribute training across 4 nodes for each trial
limits:
    max_nodes: 4

Treinamento distribuído para previsão

Para saber como o treinamento distribuído funciona para tarefas de previsão, veja previsão em escala. Para usar o treinamento distribuído para previsão, você precisa definir as propriedades training_mode, enable_dnn_training, max_nodes e, opcionalmente, max_concurrent_trials do objeto de trabalho.

O exemplo de código a seguir mostra um exemplo dessas configurações para um trabalho de previsão:

from azure.ai.ml.constants import TabularTrainingMode

# Set the training mode to distributed
forecasting_job.set_training(
    enable_dnn_training=True,
    allowed_training_algorithms=["TCNForecaster"],
    training_mode=TabularTrainingMode.DISTRIBUTED
)

# Distribute training across 4 nodes
# Train 2 trial models in parallel => 2 nodes per trial
forecasting_job.set_limits(
    max_concurrent_trials=2,
    max_nodes=4,
    # other limit settings
)

# Set the training mode to distributed
training:
    allowed_training_algorithms: ["TCNForecaster"]
    training_mode: distributed

# Distribute training across 4 nodes
# Train 2 trial models in parallel => 2 nodes per trial
limits:
    max_concurrent_trials: 2
    max_nodes: 4

Para obter amostras do código de configuração completo, veja as seções anteriores sobre configuração e envio de trabalho.

Conteúdo relacionado

• Saiba mais sobre como e onde implantar um modelo.
• Saiba mais sobre como configurar o AutoML para treinar um modelo de previsão de série temporal.