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

APLICA-SE A:CLI do Azure ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

Neste artigo, saiba como configurar um trabalho de treinamento do AutoML com o SDK do Python do Azure Machine Learning v2. O AutoML seleciona um algoritmo e hiperparâmetros para você e gera um modelo pronto para implantação. Este artigo fornece detalhes das várias opções que você pode usar para configurar experimentos AutoML.

Se preferir uma experiência sem código, você também pode configurar o treinamento AutoML sem código para dados tabulares com a interface do usuário do estúdio.

Pré-requisitos

• Uma subscrição do Azure. Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga do Azure Machine Learning.
• Uma área de trabalho do Azure Machine Learning. Se você não tiver um, consulte Criar recursos para começar.

Configurar a sua área de trabalho

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, InteractiveBrowserCredential
from azure.ai.ml import MLClient

try:
    credential = DefaultAzureCredential()
    credential.get_token("https://management.azure.com/.default")
except Exception:
    credential = InteractiveBrowserCredential()
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 a fonte de dados e o formato

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

Requisitos para carregar dados em um MLTable:

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

Os dados de treinamento devem estar acessíveis a partir da computação remota. O AutoML v2 (Python SDK e CLI/YAML) aceita ativos de dados MLTable (v2). Para compatibilidade com versões anteriores, suporta também Conjuntos de Dados Tabulares v1 da v1, isto é, um Conjunto de Dados Tabular registado, através das mesmas propriedades do conjunto de dados de entrada. Recomendamos que você use MLTable, disponível na v2. Neste 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, consulte Trabalhando com tabelas no Azure Machine Learning.

Dados de treinamento, validação e teste

Você pode especificar dados de treinamento separados e conjuntos de dados de validação. Você deve fornecer dados de treino ao parâmetro training_data na função de fábrica da sua tarefa do AutoML.

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

Computação para executar a experimentação

Atualmente, os trabalhos de AutoML com o SDK do Python v2 (ou CLI v2) só têm suporte 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, consulte Treinar modelos com a CLI do Azure Machine Learning, SDK e API REST.

Definir as configurações do experimento

Você pode usar várias opções para configurar seu experimento AutoML. Esses parâmetros de configuração são definidos em seu método de tarefa. Você também pode definir configurações de treinamento profissional e critérios de saída com as training configurações e limits .

O exemplo seguinte mostra os parâmetros necessários para uma tarefa de classificação que especifica a exatidão como a métrica principal e cinco partições 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 AutoML, determine o tipo de problema de aprendizado de máquina que você deseja resolver. Este aspeto determina que função a sua tarefa utiliza e que algoritmos de modelo aplica.

O AutoML suporta 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
  • Deteção de Objetos

• Tarefas de processamento de linguagem natural, incluindo

  • Classificação de textos
  • Reconhecimento de entidades

Para obter mais informações, consulte Tipos de tarefas. Para obter mais informações sobre como configurar trabalhos de previsão, consulte Configurar o AutoML para treinar um modelo de previsão de séries temporais.

Algoritmos suportados

O AutoML experimenta 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 task determina a lista de algoritmos ou modelos a serem aplicados. Para personalizar ainda mais as iterações com os modelos disponíveis a incluir ou a excluir, use os parâmetros allowed_training_algorithms ou blocked_training_algorithms na configuração training da tarefa.

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

Com outros algoritmos:

• Algoritmos multiclasse de classificação de imagem
• Algoritmos de classificação multirrótulo de imagens
• Algoritmos de deteção de objeto de imagem
• Algoritmos de classificação multirrótulo de texto em PNL
• Algoritmos de reconhecimento de entidade nomeada (NER) de texto NLP

Por exemplo, blocos de anotações de cada tipo de tarefa, consulte automl-standalone-jobs.

Métrica primária

O primary_metric parâmetro 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 o AutoML otimizar depende de muitos fatores. Recomendamos que a sua principal consideração seja escolher a métrica que melhor represente as necessidades do seu negócio. Em seguida, considere se a métrica é adequada para o perfil do conjunto de dados, incluindo tamanho de 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, consulte avaliar os resultados do experimento AutoML.

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

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 otimizar tão bem para conjuntos de dados que são pequenos, têm grande distorção de classe (desequilíbrio de classe) ou quando o valor de métrica esperado é muito próximo de 0,0 ou 1,0. Nesses casos, AUC_weighted pode ser uma escolha melhor para a métrica primária. Após a conclusão do AutoML, 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 classificação de vários rótulos

Para classificação de texto multi-label, atualmente 'Precisão' é a única métrica primária suportada.

Para a classificação multilabel de imagens, as principais métricas suportadas estão definidas na enumeração ClassificationMultilabelPrimaryMetrics.

Métricas para cenários de reconhecimento de entidades nomeadas em texto de PNL

Para texto NLP Named Entity Recognition (NER), atualmente 'Precisão' é a única métrica primária suportada.

Métricas para cenários de regressão

r2_score, normalized_mean_absolute_errore normalized_root_mean_squared_error todos tentam minimizar os erros de previsão. r2_score e normalized_root_mean_squared_error ambos minimizam os erros quadrados médios enquanto normalized_mean_absolute_error minimizam o valor absoluto médio dos erros. O valor absoluto trata os erros em todas as magnitudes da mesma forma e os erros quadrados têm uma penalidade muito maior para erros com valores absolutos maiores. Dependendo se erros maiores devem ser punidos mais ou não, você pode optar por otimizar erro quadrado ou erro absoluto.

A principal diferença entre r2_score e normalized_root_mean_squared_error é como eles são normalizados e seus significados. normalized_root_mean_squared_error é a raiz do erro quadrático médio normalizada pela amplitude e pode ser interpretada como a magnitude média do erro de previsão. r2_score é o erro quadrático médio normalizado por uma estimativa de variância dos dados. É a proporção de variação que o modelo pode capturar.

Se a classificação, em vez do valor exato, é de interesse, spearman_correlation pode ser uma escolha melhor. Mede a correlação hierárquica entre valores reais e previsões.

Atualmente, o AutoML não suporta 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_errore normalized_root_mean_squared_error são todas medidas de diferença absoluta. Por exemplo, se uma previsão difere de uma observação por 10 unidades, essas métricas calculam o mesmo valor se a observação for de 20 unidades ou 20.000 unidades. Em contrapartida, uma diferença percentual, que é uma medida relativa, dá erros de 50% e 0,05%, respectivamente. Para otimizar a diferença relativa, você pode executar o AutoML com uma métrica primária suportada e, em seguida, selecionar o modelo com o 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, nem sempre podem ser boas escolhas.

Métricas para cenários de previsão de séries temporais

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

Métricas para cenários de deteção de objetos de imagem

Para a Deteção de Objetos em imagens, as métricas primárias 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âncias em imagens, as principais métricas suportadas são definidas no enum InstanceSegmentationPrimaryMetrics.

Featurização de dados

Em cada experimento AutoML, 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 sensíveis a recursos que estão em escalas diferentes. Essas transformações de dados são chamadas de featurização.

Ao configurar trabalhos AutoML, você pode habilitar ou desabilitar as featurization configurações.

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

O código a seguir mostra como fornecer featurização personalizada neste 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

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

Executar experimentação

Submeta a experiência para execução e para gerar um modelo.

Com o MLClient criado nos pré-requisitos, você pode executar o seguinte comando no espaço de trabalho.

# 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ários filhos são executados em clusters

Você pode executar o experimento filho do AutoML em um cluster que já esteja executando outro experimento. 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 AutoML, isso significa uma execução filho. Se todos os nós estiverem ocupados, o AutoML coloca um novo experimento em fila. Se houver nós disponíveis, o novo experimento executa as execuções subordinadas em paralelo nos nós ou nas máquinas virtuais disponíveis.

Para ajudar a gerir as execuções subordinadas e quando podem ser executadas, recomendamos que crie um cluster dedicado por experiência e faça corresponder o número de max_concurrent_iterations da sua experiência ao número de nós do cluster. Desta forma, utiliza todos os nós do cluster ao mesmo tempo, com o número de execuções subordinadas simultâneas e iterações que pretender.

Configure max_concurrent_iterations na configuração de limits. Se não estiver configurado, por predefinição, só é permitida uma execução/iteração subordinada em simultâneo por experimento. Para uma instância de computação, você pode definir max_concurrent_trials como igual ao número de núcleos na máquina virtual da instância de computação.

Explore modelos e métricas

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

• Para obter definições e exemplos dos gráficos e métricas de desempenho fornecidos para cada execução, consulte avaliar os resultados do experimento AutoML.

A partir da interface do Azure Machine Learning na página do modelo, pode visualizar um resumo de características e perceber que funcionalidades foram adicionadas a um determinado modelo. Também pode visualizar os hiperparâmetros usados quando treina um modelo específico e visualizar e personalizar o código de treino interno do modelo utilizado.

Registrar e implantar modelos

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

Usar AutoML em pipelines

Para usar o AutoML em seus fluxos de trabalho de operações de aprendizado de máquina, você pode adicionar etapas de Trabalho AutoML aos seus Pipelines de Aprendizado de Máquina do Azure. Essa abordagem permite automatizar todo o fluxo de trabalho conectando seus scripts de preparação de dados ao AutoML. Em seguida, registre e valide o melhor modelo resultante.

Este código é um pipeline de exemplo com um componente de classificação AutoML 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://registries/azureml/environments/sklearn-1.5/labels/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://registries/azureml/environments/sklearn-1.5/labels/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 o AutoML em escala: treinamento distribuído

Para cenários de dados grandes, o AutoML oferece suporte a treinamento distribuído para um conjunto limitado de modelos:

Os algoritmos de treinamento distribuídos particionam e distribuem automaticamente seus dados em vários nós de computação para treinamento de modelos.

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

Para utilizar o treino distribuído para classificação ou regressão, defina as propriedades training_mode e max_nodes do objeto job.

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, consulte Previsão em escala. Para usar o treinamento distribuído para previsão, você precisa definir o training_mode, enable_dnn_training, max_nodese, opcionalmente, as max_concurrent_trials propriedades 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 exemplos de código de configuração completo, consulte as seções anteriores sobre configuração e envio de trabalho.

Conteúdos relacionados

• 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éries temporais.