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

  • Artigo

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

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

Se preferir uma experiência sem código, também pode Configurar a formação de AutoML sem código no estúdio de Aprendizagem de Máquina do Azure.

Pré-requisitos

Para usar as informações do SDK , instale o SDK do Azure Machine Learning v2 para Python.

Para instalar o SDK, você pode,

  • Crie uma instância de computação, que já tenha instalado o SDK Python do Azure Machine Learning mais recente e esteja pré-configurada para fluxos de trabalho de ML. Consulte Criar uma instância de computação do Azure Machine Learning para obter mais informações.
  • Instale o SDK em sua máquina local

Configurar a sua área de trabalho

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

Os detalhes do MLClient espaço de trabalho são usados no de para obter um identificador para o espaço de azure.ai.ml trabalho necessário do Azure Machine Learning.

No exemplo a seguir, a autenticação padrão do Azure é usada junto com a configuração padrão do espaço de trabalho ou de qualquer config.json arquivo que você possa ter copiado para a estrutura de pastas. Se não config.json for encontrado, você precisará introduzir manualmente o subscription_id, o resource_group e o espaço de trabalho ao criar MLCliento .

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)

Origem de dados e formato

Para fornecer dados de treinamento ao AutoML no SDK v2, você precisa carregá-los na 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 ML automatizado v2 (Python SDK e CLI/YAML) aceita ativos de dados MLTable (v2), embora para compatibilidade com versões anteriores também suporte conjuntos de dados tabulares v1 de v1 (um conjunto de dados tabulares registrado) através das mesmas propriedades de conjunto de dados de entrada. No entanto, a recomendação é usar MLTable disponível na v2. Neste exemplo, assumimos que os dados são armazenados no caminho local, ./train_data/bank_marketing_train_data.csv

Você pode criar um MLTable usando o SDK do Python mltable como no exemplo a seguir:

import mltable

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

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

Esse código cria um novo arquivo, ./train_data/MLTable, que contém o formato do arquivo e instruções de carregamento.

Agora a ./train_data pasta 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 o artigo de instruções mltable

Dados de treinamento, validação e teste

Você pode especificar dados de treinamento separados e conjuntos de dados de validação, no entanto, os dados de treinamento devem ser fornecidos para o training_data parâmetro na função de fábrica do seu trabalho de ML automatizado.

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

Tamanho dos dados de treinamento Técnica de validação
Maior que 20.000 linhas É aplicada a divisão de dados de comboio/validação. O padrão é tomar 10% do conjunto de dados de treinamento inicial como o conjunto de validação. Por sua vez, esse conjunto de validação é usado para o cálculo de métricas.
Menor ou igual a 20.000 linhas É aplicada a abordagem de validação cruzada. O número padrão de dobras depende do número de linhas.
Se o conjunto de dados tiver menos de 1.000 linhas, 10 dobras serão usadas.
Se as linhas forem iguais ou entre 1.000 e 20.000, então três dobras são usadas.

Computação para executar a experimentação

Atualmente, os trabalhos de ML automatizados com o SDK do Python v2 (ou CLI v2) só são suportados na computação remota do Azure Machine Learning (cluster ou instância de computação).

Saiba mais sobre como criar computação com o Python SDKv2 (ou CLIv2)..

Definir as configurações do experimento

Há várias opções que você pode usar para configurar seu experimento de ML 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 profissional e critérios de saída com as training configurações 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 5 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
)

Selecione o tipo de tarefa de aprendizado de máquina (problema de ML)

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

O ML automatizado suporta tarefas baseadas em dados tabulares (classificação, regressão, previsão), tarefas de visão computacional (como Classificação de Imagem e Deteção de Objetos) e tarefas de processamento de linguagem natural (como tarefas de classificação de texto e reconhecimento de entidade). Consulte o nosso artigo sobre tipos de tarefas para obter mais informações. Consulte o nosso guia de previsão de séries cronológicas para obter mais detalhes sobre como configurar trabalhos de previsão.

Algoritmos suportados

O aprendizado de máquina automatizado 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 de tarefa determina a lista de algoritmos/modelos a serem aplicados. Use os allowed_training_algorithms parâmetros ou blocked_training_algorithms na training configuração do trabalho AutoML para modificar ainda mais as iterações com os modelos disponíveis para incluir ou excluir.

Na lista de links a seguir, você pode explorar os algoritmos suportados por tarefa de aprendizado de máquina listados abaixo.

Classificação Regressão Previsão de Série Temporal
Regressão Logística* Rede Elástica* AutoARIMA
GBM leve* GBM leve* Profeta
Aumento de gradiente* Aumento de gradiente* Rede Elástica
Árvore de Decisão* Árvore de Decisão* GBM leve
K Vizinhos mais próximos* K Vizinhos mais próximos* K Nearest Neighbors
Linear SVC* LARS Laço* Árvore de Decisão
Classificação vetorial de suporte (SVC)* Descida de gradiente estocástico (SGD)* Arimax
Floresta aleatória* Floresta aleatória LARS Laço
Árvores extremamente aleatórias* Árvores extremamente aleatórias* Árvores extremamente aleatórias*
Xgboost* Xgboost* Floresta aleatória
Bayes ingênuo* Xgboost TCNForecaster
Descida de gradiente estocástico (SGD)* Descida de gradiente estocástico (SGD) Aumento de gradiente
Suavização Exponencial
SazonalNaive
Média
Ingênuo
SazonalMédia

Com algoritmos adicionais abaixo.

Siga este link para obter exemplos de blocos de anotações de cada tipo de tarefa.

Métrica primária

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

A escolha de uma métrica primária para ML automatizado para 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 (tamanho dos dados, intervalo, distribuição de classes, etc.). 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.

Saiba mais sobre as definições específicas dessas métricas em Compreender os resultados do aprendizado de máquina automatizado.

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/visão computacional e NLP-Texto.

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 ML automatizado, você pode escolher o modelo vencedor com base na métrica mais adequada às suas necessidades de negócios.

Metric Exemplo(s) de caso(s) de uso
accuracy Classificação de imagem, Análise de sentimento, Previsão de churn
AUC_weighted Deteção de fraudes, Classificação de imagens, Deteção de anomalias/spam
average_precision_score_weighted Análise de sentimentos
norm_macro_recall Previsão de churn
precision_score_weighted

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

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

  • Para classificação de imagem multi-label, as métricas primárias suportadas são definidas no Enum ClassificationMultilabelPrimaryMetrics

Métricas para cenários de NLP Text NER (Named Entity Recognition)

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

Métricas para cenários de regressão

r2_score, normalized_mean_absolute_error e normalized_root_mean_squared_error todos estão tentando 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 terão uma penalidade muito maior para erros com valores absolutos maiores. Dependendo se erros maiores devem ser punidos mais ou não, pode-se optar por otimizar erro quadrado ou erro absoluto.

A principal diferença entre r2_score e normalized_root_mean_squared_error é a forma como eles são normalizados e seus significados. normalized_root_mean_squared_error é o erro quadrático médio da raiz normalizado pelo intervalo e pode ser interpretado como a magnitude média do erro para 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 pode ser capturada pelo modelo.

Nota

r2_score e normalized_root_mean_squared_error também se comportam de forma semelhante como métricas primárias. Se um conjunto de validação fixo for aplicado, essas duas métricas otimizarão o mesmo destino, erro quadrado médio e serão otimizadas pelo mesmo modelo. Quando apenas um conjunto de treinamento está disponível e a validação cruzada é aplicada, eles seriam ligeiramente diferentes, pois o normalizador para normalized_root_mean_squared_error é fixado como o intervalo do conjunto de treinamento, mas o normalizador para r2_score variaria para cada dobra, pois é a variância para cada dobra.

Se a classificação, em vez do valor exato é de interesse, pode ser uma escolha melhor, spearman_correlation pois mede a correlação de classificação 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. Observe que essas métricas são indefinidas quando quaisquer valores de observação são zero, portanto, nem sempre podem ser boas escolhas.

Metric Exemplo(s) de caso(s) de uso
spearman_correlation
normalized_root_mean_squared_error Previsão de preços (casa/produto/dica), Previsão de pontuação de revisão
r2_score Atraso da companhia aérea, estimativa salarial, tempo de resolução de bugs
normalized_mean_absolute_error

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

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

Metric Exemplo(s) de caso(s) de uso
normalized_root_mean_squared_error Previsão de preços (previsão), Otimização de estoque, Previsão de demanda
r2_score Previsão de preços (previsão), Otimização de estoque, Previsão de demanda
normalized_mean_absolute_error

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

  • Para a Deteção de Objeto de Imagem, as métricas principais suportadas são definidas no Enum 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 métricas principais suportadas são definidas no Enum InstanceSegmentationPrimaryMetrics

Featurização de dados

Em cada experimento automatizado de ML, seus dados são automaticamente transformados em números e vetores de números e também 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.

Nota

Etapas automatizadas de featurização de aprendizado de máquina (normalização de recursos, manipulação de dados ausentes, conversão de texto em numérico, etc.) tornam-se parte do modelo subjacente. Ao usar o modelo para previsões, as mesmas etapas de featurização aplicadas durante o treinamento são aplicadas aos seus dados de entrada automaticamente.

Ao configurar seus trabalhos de ML automatizados, você pode ativar/desabilitar as featurization configurações.

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

Configuração de Featurização Description
"mode": 'auto' Indica que, como parte do pré-processamento, as proteções de dados e as etapas de featurização são executadas automaticamente. Configuração padrão.
"mode": 'off' Indica que a etapa de featurização não deve ser feita automaticamente.
"mode": 'custom' Indica que a etapa de featurização personalizada deve ser usada.

O código a seguir mostra como a featurização personalizada pode ser fornecida 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"},
)

Critérios de saída

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

Critérios descrição
Sem critérios Se você não definir nenhum parâmetro de saída, o experimento continuará até que nenhum progresso adicional seja feito em sua métrica principal.
timeout Define por quanto tempo, em minutos, seu experimento deve continuar a ser executado. Se não for especificado, o tempo limite total do trabalho padrão é de 6 dias (8.640 minutos). Para especificar um tempo limite menor ou igual a 1 hora (60 minutos), verifique se o tamanho do conjunto de dados não é maior que 10.000.000 (coluna de tempos de linha) ou se um erro resulta.

Este tempo limite inclui execuções de configuração, featurização e treinamento, mas não inclui as execuções de montagem e explicabilidade do modelo no final do processo, uma vez que essas ações precisam acontecer uma vez que todos os testes (trabalhos infantis) são feitos.
trial_timeout_minutes Tempo máximo em minutos que cada avaliação (trabalho filho) pode ser executada antes de terminar. Se não for especificado, é utilizado um valor de 1 mês ou 43200 minutos
enable_early_termination Se deve terminar o trabalho se a pontuação não estiver melhorando no curto prazo
max_trials O número máximo de testes/execuções cada um com uma combinação diferente de algoritmo e hiperparâmetros para tentar durante um trabalho AutoML. Se não for especificado, o padrão é 1000 avaliações. Se utilizar enable_early_termination o número de ensaios utilizados pode ser menor.
max_concurrent_trials Representa o número máximo de tentativas (trabalhos infantis) que seriam executadas em paralelo. É uma boa prática fazer a correspondência entre esse número e o número de nós do cluster

Executar experimentação

Nota

Se você executar um experimento com as mesmas definições de configuração e métrica primária várias vezes, provavelmente verá variação na pontuação final de cada experimento e nos modelos gerados. Os algoritmos que o ML automatizado emprega têm aleatoriedade inerente que pode causar uma pequena variação na saída dos modelos pelo experimento e na pontuação final das métricas do modelo recomendado, como precisão. Você provavelmente também verá resultados com o mesmo nome de modelo, mas diferentes hiperparâmetros usados.

Aviso

Se você tiver definido regras no firewall e/ou no Grupo de Segurança de Rede em seu espaço de trabalho, verifique se as permissões necessárias são dadas ao tráfego de rede de entrada e saída, conforme definido em Configurar tráfego de rede de entrada e saída.

Submeta a experimentação para executar e 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

Vários filhos são executados em clusters

As execuções filhas automatizadas de experimentos de ML podem ser executadas 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, isso significa uma execução filho. Se todos os nós estiverem ocupados, um novo experimento será enfileirado. Mas se houver nós livres, o novo experimento executará execuções filho de ML automatizadas em paralelo nos nós/VMs disponíveis.

Para ajudar a gerenciar execuções filho e quando elas podem ser executadas, recomendamos que você crie um cluster dedicado por experimento e faça a correspondência entre o número do max_concurrent_iterations experimento e o 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/iterações filhas simultâneas desejadas.

Configure max_concurrent_iterations na limits configuração. Se não estiver configurado, então, por padrão, apenas uma execução/iteração filho simultânea é permitida por experimento. No caso da instância de computação, max_concurrent_trials pode ser definido como o mesmo número de núcleos na VM da instância de computação.

Explore modelos e métricas

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

  • Para obter definições e exemplos dos gráficos e métricas de desempenho fornecidos para cada execução, consulte Avaliar resultados de experimentos de aprendizado de máquina automatizados.

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

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

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.

Gorjeta

Para modelos registrados, a implantação com um clique está disponível por meio do estúdio do Azure Machine Learning. Veja como implantar modelos registrados a partir do estúdio.

AutoML em pipelines

Para aproveitar o AutoML em seus fluxos de trabalho de MLOps, você pode adicionar etapas de Trabalho de AutoML aos seus Pipelines de Aprendizado de Máquina do Azure. Isso permite que você automatize todo o seu fluxo de trabalho, conectando seus scripts de preparação de dados ao AutoML e, em seguida, registrando e validando o melhor modelo resultante.

Abaixo está um pipeline de exemplo com um componente de classificação AutoML e um componente de comando que mostra a saída AutoML resultante. Observe como as entradas (dados de treinamento e validação) e as saídas (melhor modelo) são referenciadas 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

Para obter mais exemplos sobre como incluir o AutoML em seus pipelines, confira nosso repositório de exemplos.

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:

Algoritmo distribuído Tarefas suportadas Limite de tamanho dos dados (aproximado)
LightGBM Classificação, regressão 1 TB
TCNForecaster Previsão 200GB

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

Nota

Validação cruzada, modelos de conjunto, suporte ONNX e geração de código não são suportados atualmente no modo de treinamento distribuído. Além disso, o AutoML pode fazer escolhas como restringir os dados disponíveis e os dados de subamostragem usados para validação, explicabilidade e avaliação do modelo.

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

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

Property Description
training_mode Indica o modo de treino; distributed ou non_distributed. O padrão é non_distributed.
max_nodes O número de nós a serem usados para treinamento em cada avaliação do AutoML. Essa configuração deve ser maior ou igual a 4.

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
)

Nota

Atualmente, o treinamento distribuído para tarefas de classificação e regressão não oferece suporte a vários ensaios simultâneos. Os modelos de ensaios são executados sequencialmente com cada ensaio usando max_nodes nós. A max_concurrent_trials configuração de limite é ignorada no momento.

Treinamento distribuído para previsão

Para saber como funciona o treinamento distribuído para tarefas de previsão, consulte nosso artigo de 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.

Property Description
training_mode Indica o modo de treino; distributed ou non_distributed. O padrão é non_distributed.
enable_dnn_training Sinalizar para habilitar modelos de redes neurais profundas.
max_concurrent_trials Este é o número máximo de modelos experimentais para treinar em paralelo. O padrão é 1.
max_nodes O número total de nós a serem usados para treinamento. Essa configuração deve ser maior ou igual a 2. Para tarefas de previsão, cada modelo de avaliação é treinado usando os nós $\text{max}\left(2, \text{floor}( \text{max_nodes} / \text{max_concurrent_trials}) \right)$.

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
)

Consulte as seções anteriores sobre configuração e envio de tarefas para obter exemplos de código de configuração completo.

Próximos passos