Compartilhar via

Configurar o AutoML para treinar um modelo de previsão de séries temporais com o SDK e a CLI

  • Artigo

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

O AutoML (machine learning automatizado) no Azure Machine Learning usa os modelos de machine learning padrão, juntamente com os modelos de série temporal conhecidos para criar previsões. Essa abordagem incorpora informações históricas sobre a variável de destino com os recursos fornecidos pelo usuário nos dados de entrada e os recursos projetados automaticamente. Os algoritmos de pesquisa de modelo ajudam a identificar modelos com a melhor precisão preditiva. Para obter mais informações, confira metodologia de previsão e varredura e seleção de modelos.

Este artigo descreve como configurar o AutoML para previsão de série temporal com o Machine Learning usando o SDK do Python do Azure Machine Learning](/python/api/overview/azure/ai-ml-readme). O processo inclui a preparação de dados para treinamento e configuração de parâmetros de série temporal em um trabalho de previsão (referência de classe). Em seguida, você treina, infere e avalia os modelos usando componentes e pipelines.

Para uma experiência low-code, confira o Tutorial: Previsão de demanda com o machine learning automatizado. Esse recurso é um exemplo de previsão de série temporal que usa o AutoML no Estúdio do Azure Machine Learning.

Pré-requisitos

Preparar os dados de treinamento e validação

Os dados de entrada para previsão do AutoML devem conter uma série temporal válida no formato tabular. Cada variável deve ter sua própria coluna correspondente na tabela de dados. O AutoML requer pelo menos duas colunas: uma coluna de tempo para representar o eixo de tempo e uma coluna de destino para a quantidade a ser prevista. Outras colunas podem servir como preditores. Para obter mais informações, confira Como o AutoML usa seus dados.

Importante

Ao treinar um modelo para prever valores futuros, certifique-se de que todos os recursos usados no treinamento podem ser usados ao executar previsões para o período de tempo pretendido.

Considere um recurso para o preço atual das ações, que pode aumentar massivamente a precisão do treinamento. Se você fizer previsões para um futuro distante, talvez não consiga prever com precisão os valores futuros das ações que correspondem aos pontos futuros da série temporal. Essa abordagem pode reduzir a precisão do modelo.

Os trabalhos de previsão do AutoML exigem que os dados de treinamento sejam representados como um objeto MLTable. Um objeto MLTable especifica uma fonte de dados e as etapas para carregar os dados. Para obter mais informações e casos de uso, confira [Trabalhar com tabelas(how-to-mltable.md).

Para o exemplo a seguir, suponha que seus dados de treinamento estejam contidos em um arquivo CSV em um diretório local, ./train_data/timeseries_train.csv.

Você pode criar um objeto MLTable usando o SDK do Python mltable, conforme mostrado no exemplo a seguir:

import mltable

paths = [
    {'file': './train_data/timeseries_train.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 as instruções de carregamento.

Para iniciar o trabalho de treinamento, defina um objeto de dados de entrada usando o SDK do Python da seguinte maneira:

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

# Training MLTable defined locally, with local data to be uploaded
my_training_data_input = Input(
    type=AssetTypes.MLTABLE, path="./train_data"
)

Especifique os dados de validação de maneira semelhante. Crie um objeto MLTable e especifique uma entrada de dados de validação. Como alternativa, se você não fornecer dados de validação, o AutoML criará automaticamente divisões de validação cruzada de seus dados de treinamento a serem usadas para seleção de modelo. Para saber mais, consulte os recursos a seguir:

Criar computação para executar o experimento

O AutoML usa a Computação do Azure Machine Learning, que é um recurso de computação totalmente gerenciado, para executar o trabalho de treinamento. O exemplo a seguir cria um cluster de cálculo chamado cpu-compute.

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()

Configurar o experimento

O exemplo a seguir mostra como configurar o experimento.

Você usa as funções de fábrica do AutoML para configurar os trabalhos de previsão no SDK do Python. O exemplo a seguir mostra como criar um trabalho de previsão definindo a métrica primária e limites de conjunto na execução de treinamento:

from azure.ai.ml import automl

# Set forecasting variables
# As needed, modify the variable values to run the snippet successfully
forecasting_job = automl.forecasting(
    compute="cpu-compute",
    experiment_name="sdk-v2-automl-forecasting-job",
    training_data=my_training_data_input,
    target_column_name=target_column_name,
    primary_metric="normalized_root_mean_squared_error",
    n_cross_validations="auto",
)

# Set optional limits
forecasting_job.set_limits(
    timeout_minutes=120,
    trial_timeout_minutes=30,
    max_concurrent_trials=4,
)

Configurações do trabalho de previsão

As tarefas de previsão têm muitas configurações específicas para previsão. As configurações mais básicas são o nome da coluna de tempo nos dados de treinamento e no horizonte de previsão.

Use os métodos ForecastingJob para definir estas configurações:

# Forecasting specific configuration
forecasting_job.set_forecast_settings(
    time_column_name=time_column_name,
    forecast_horizon=24
)

O nome da coluna de tempo é uma configuração necessária. Em geral, você deve definir o horizonte de previsão de acordo com o seu cenário de previsão. Se os dados contiverem várias séries temporais, você poderá especificar os nomes das colunas de ID da série temporal. Quando essas colunas são agrupadas, elas definem a série individual. Por exemplo, suponha que você tenha dados que consistem em vendas por hora de diferentes lojas e marcas. O exemplo a seguir mostra como definir as colunas de ID da série temporal supondo que os dados contenham colunas chamadas store e brand:

# Forecasting specific configuration
# Add time series IDs for store and brand
forecasting_job.set_forecast_settings(
    ...,  # Other settings
    time_series_id_column_names=['store', 'brand']
)

O AutoML tenta detectar automaticamente colunas de ID da série temporal em seus dados se nenhuma for especificada.

Outras configurações são opcionais e revisadas na seção a seguir.

Configurações opcionais do trabalho de previsão

Configurações opcionais estão disponíveis para tarefas de previsão, como habilitar o aprendizado profundo e especificar uma agregação de janelas sem interrupção como destino. Uma lista completa de parâmetros está disponível na documentação de referência.

Configurações de pesquisa de modelo

Há duas configurações opcionais que controlam o espaço do modelo em que o AutoML procura o melhor modelo: allowed_training_algorithms e blocked_training_algorithms. Para restringir o espaço de pesquisa a um determinado conjunto de classes de modelo, use o parâmetro allowed_training_algorithms, conforme mostrado no exemplo a seguir:

# Only search ExponentialSmoothing and ElasticNet models
forecasting_job.set_training(
    allowed_training_algorithms=["ExponentialSmoothing", "ElasticNet"]
)

Nesse cenário, o trabalho de previsão pesquisa apenas em classes de modelo de Smoothing Exponencial e Elastic Net. Para remover um determinado conjunto de classes de modelo do espaço de pesquisa, use o blocked_training_algorithms conforme mostrado no exemplo a seguir:

# Search over all model classes except Prophet
forecasting_job.set_training(
    blocked_training_algorithms=["Prophet"]
)

O trabalho pesquisa todas as classes de modelo, exceto Prophet. Para obter uma lista dos nomes de modelo de previsão que são aceitos em allowed_training_algorithms e blocked_training_algorithms, consulte as propriedades de treinamento. Você pode aplicar um ou outro, mas não ambos, allowed_training_algorithms e blocked_training_algorithms, a uma execução de treinamento.

Habilitar o aprendizado para redes neurais profundas

O AutoML é fornecido com um modelo DNN (rede neural profunda) personalizado chamado TCNForecaster. Esse modelo é uma (TCN) rede convolucional temporal, que aplica métodos comuns de tarefa de geração de imagens à modelagem de série temporal. As convoluções "causais" unidimensionais formam a espinha dorsal da rede e permitem que o modelo aprenda padrões complexos por longas durações no histórico de treinamento. Para obter mais informações, consulte Introdução ao TCNForecaster.

Diagrama que mostra os principais componentes do modelo TCNForecaster do AutoML.

O TCNForecaster geralmente obtém maior precisão do que os modelos de séries temporais padrão quando há milhares ou mais observações no histórico de treinamento. No entanto, também leva mais tempo para treinar e varrer os modelos do TCNForecaster devido à sua maior capacidade.

Você pode ativar o TCNForecaster no AutoML definindo o sinalizador enable_dnn_training na configuração de treinamento da seguinte maneira:

# Include TCNForecaster models in the model search
forecasting_job.set_training(
    enable_dnn_training=True
)

Por padrão, o treinamento TCNForecaster é limitado a um único nó de computação e a uma única GPU, se disponível, por avaliação de modelo. Para cenários de dados grandes, a recomendação é distribuir cada avaliação TCNForecaster em vários núcleos/GPUs e nós. Para obter mais informações e exemplos de código, consulte o treinamento distribuído.

Para habilitar o DNN para um experimento do AutoML criado no Estúdio do Azure Machine Learning, confira as configurações de tipo de tarefa nas instruções da interface do usuário do estúdio.

Observação

  • Quando você habilita o DNN para experimentos criados com o SDK, as melhores explicações de modelo são desabilitadas.
  • O suporte de DNN para previsão no Machine Learning Automatizado não é compatível com as execuções iniciadas no Azure Databricks.
  • A abordagem recomendada é usar tipos de computação de GPU quando o treinamento de DNN estiver habilitado.

Recursos de retardo e janela sem interrupção

Os valores recentes do destino geralmente são recursos impactantes em um modelo de previsão. Assim, o AutoML pode criar recursos de agregação de janela sem interrupção e com travamento de tempo para potencialmente melhorar a precisão do modelo.

Considere um cenário de previsão da demanda de energia em que os dados meteorológicos e a demanda histórica estão disponíveis. A tabela mostra a engenharia de recursos resultante que ocorre quando a agregação de janela é aplicada nas três últimas horas. Colunas para mínimo, máximo e soma são geradas em uma janela deslizante de três horas com base nas configurações definidas. Por exemplo, para a observação válida em 8 de setembro de 2017 às 4:00, os valores máximo, mínimo e soma são calculados usando os valores de demanda para 8 de setembro de 2017 de 1:00 às 3:00. Essa janela de três horas se desloca para preencher os dados das linhas restantes. Para obter mais informações e exemplos, confira os Recursos de retardo do para previsão de série temporal no AutoML.

Diagrama de uma tabela com dados que mostram a janela sem interrupção de destino e os valores na coluna Demanda realçados.

Você pode habilitar os recursos de defasagem e agregação de janela de rolagem para o destino definindo o tamanho da janela rolagem e as ordens de defasagem que deseja criar. O tamanho da janela era três no exemplo anterior. Você também pode habilitar atrasos para recursos com a configuração feature_lags. No exemplo a seguir, todas essas configurações são definidas como auto para instruir o AutoML a determinar automaticamente as configurações analisando a estrutura de correlação de seus dados:

forecasting_job.set_forecast_settings(
    ...,  # Other settings
    target_lags='auto', 
    target_rolling_window_size='auto',
    feature_lags='auto'
)

Manipulação de séries curtas

O AutoML considera uma série temporal uma série curta se não houver pontos de dados suficientes para conduzir as fases de treinamento e validação do desenvolvimento do modelo. Para obter mais informações, consulte os requisitos de comprimento dos dados de treinamento.

O AutoML tem várias ações que podem ser executadas para séries curtas. Essas ações são configuráveis com short_series_handling_config. O valor padrão é auto. A seguinte tabela descreve as configurações:

Configuração Descrição Observações
auto O valor padrão para tratamento de série curta. – Se todas as séries forem curtas, preencha os dados.
– Se nem todas as séries forem curtas, solte a série curta.
pad Se a configuração short_series_handling_config = pad for usada, o AutoML adicionará valores aleatórios a cada série curta encontrada. O AutoML agrupa a coluna de destino com ruído branco. Você pode usar os seguintes tipos de coluna com o preenchimento especificado:
– Colunas de objeto, preenchimento com NaNs
– Colunas numéricas, preenchimento com 0 (zero)
– Colunas boolianas/lógicas, preenchimento com False
drop Se a configuração short_series_handling_config = drop for usada, o AutoML descartará a série curta e não será usada para treinamento ou previsão. As previsões para essas séries retornarão NaN.
None Nenhuma série é preenchida ou descartada.

O exemplo a seguir define o tratamento de séries curtas para que todas as séries curtas sejam adicionadas ao comprimento mínimo:

forecasting_job.set_forecast_settings(
    ...,  # Other settings
    short_series_handling_config='pad'
)

Cuidado

O preenchimento pode afetar a precisão do modelo resultante porque apresenta dados artificiais para evitar falhas no treinamento. Se muitas das séries são curtas, você também poderá ver algum impacto nos resultados da explicabilidade.

Frequência e agregação de dados de destino

Use as opções de agregação de dados e frequência para evitar falhas causadas por dados irregulares. Os dados serão irregulares se não seguirem uma cadência definida no tempo, como por hora ou diariamente. Os dados de ponto de venda são um bom exemplo de dados irregulares. Nesses cenários, o AutoML pode agregar seus dados a uma frequência desejada e, em seguida, criar um modelo de previsão a partir das agregações.

Você precisa definir as configurações frequency e target_aggregate_function para lidar com dados irregulares. A configuração de frequência aceita cadeias de caracteres DateOffset do Pandas como entrada. A tabela a seguir mostra os valores com suporte para a função de agregação:

Função Descrição
sum  Soma dos valores de destino
mean  Média de valores de destino
min Valor mínimo de um destino
max Valor máximo de um destino

O AutoML aplica a agregação para as seguintes colunas:

Coluna Método de agregação
Previsores numéricos O AutoML usa as funções sum, mean, min e max. Ele gera novas colunas, onde cada nome de coluna inclui um sufixo que identifica o nome da função de agregação aplicada aos valores da coluna.
Previsores categóricos O AutoML usa o valor do parâmetro forecast_mode para agregar os dados. É a categoria mais proeminente da janela. Para obter mais informações, confira as descrições do parâmetro nas seções de Pipeline de muitos modelos e Pipeline de HTS.
Previsores de dados O AutoML usa o valor de destino mínimo (min), o valor máximo de destino (max) e as configurações de parâmetro forecast_mode para agregar os dados.
Destino O AutoML agrega os valores de acordo com a operação especificada. Normalmente, a função sum é apropriada para a maioria dos cenários.

O exemplo a seguir define a frequência como por hora e a função de agregação como resumo:

# Aggregate the data to hourly frequency
forecasting_job.set_forecast_settings(
    ...,  # Other settings
    frequency='H',
    target_aggregate_function='sum'
)

Configurações de validação cruzada personalizadas

Há duas configurações personalizáveis que controlam a validação cruzada para trabalhos de previsão. Personalize o número de dobras com o parâmetro n_cross_validations e configure o parâmetro cv_step_size para definir o deslocamento de tempo entre as dobras. Para obter mais informações, confira a seleção de modelos de previsão.

Por padrão, o AutoML define ambas as configurações automaticamente com base nas características de seus dados. Os usuários avançados podem querer defini-los manualmente. Por exemplo, suponha que você tenha dados de vendas diários e queira que a configuração de validação consista em cinco dobras com um deslocamento de sete dias entre dobras adjacentes. O código de exemplo a seguir mostra como definir esses valores:

from azure.ai.ml import automl

# Create a job with five CV folds
forecasting_job = automl.forecasting(
    ...,  # Other training parameters
    n_cross_validations=5,
)

# Set the step size between folds to seven days
forecasting_job.set_forecast_settings(
    ...,  # Other settings
    cv_step_size=7
)

Definição de recursos personalizada

Por padrão, o AutoML aumenta os dados de treinamento com recursos projetados para aumentar a precisão dos modelos. Para obter mais informações, consulte engenharia de recursos automatizada. Algumas das etapas de pré-processamento podem ser personalizadas usando a configuração de engenharia de recursos do trabalho de previsão.

A tabela a seguir lista as personalizações com suporte para previsão:

Personalização Descrição Opções
Atualização de finalidade de coluna Substituir o tipo de recurso de autodetecção para a coluna especificada. categorical, dateTime, numeric
Atualização de parâmetro do transformador Atualização dos parâmetros para o transformador especificado. {"strategy": "constant", "fill_value": <value>}, {"strategy": "median"}, {"strategy": "ffill"}

Por exemplo, suponha que você tenha um cenário de demanda de varejo em que os dados incluem preços, um sinalizador on sale e um tipo de produto. O exemplo a seguir mostra como você pode definir os tipos e imputers personalizados para esses recursos:

from azure.ai.ml.automl import ColumnTransformer

# Customize imputation methods for price and is_on_sale features
# Median value imputation for price, constant value of zero for is_on_sale
transformer_params = {
    "imputer": [
        ColumnTransformer(fields=["price"], parameters={"strategy": "median"}),
        ColumnTransformer(fields=["is_on_sale"], parameters={"strategy": "constant", "fill_value": 0}),
    ],
}

# Set the featurization
# Ensure product_type feature is interpreted as categorical
forecasting_job.set_featurization(
    mode="custom",
    transformer_params=transformer_params,
    column_name_and_types={"product_type": "Categorical"},
)

Se você usar o Estúdio do Azure Machine Learning para seu experimento, confira Definir as configurações de engenharia de recursos no estúdio.

Enviar o trabalho de previsão

Depois de definir todas as configurações, você estará pronto para executar o trabalho de previsão. O exemplo a seguir demonstra esse processo.

# Submit the AutoML job
returned_job = ml_client.jobs.create_or_update(
    forecasting_job
)

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

# Get a URL for the job in the studio UI
returned_job.services["Studio"].endpoint

Depois de enviar o trabalho, o AutoML provisionará as recursos de computação, aplicará a engenharia de recursos e outras etapas de preparação aos dados de entrada, e começará a analisar os modelos de previsão. Para obter mais informações, confira metodologia de previsão no AutoML e Varredura e seleção de modelos para previsão no AutoML.

Orquestrar treinamento, inferência e avaliação com componentes e pipelines

Seu fluxo de trabalho de aprendizado de máquina provavelmente requer mais do que apenas treinamento. Inferência ou recuperação de previsões de modelo em dados mais recentes e avaliação da precisão do modelo em um conjunto de testes com valores de destino conhecidos são outras tarefas comuns que você pode orquestrar no Azure Machine Learning juntamente com trabalhos de treinamento. Para dar suporte a tarefas de inferência e avaliação, o Azure Machine Learning fornece componentes, que são blocos de código autônomos que executam uma etapa em um pipeline do Azure Machine Learning.

No exemplo a seguir, recupere o código do componente de um registro de cliente:

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

# Get credential to access AzureML registry
try:
    credential = DefaultAzureCredential()
    # Check if token can be obtained successfully
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential fails
    credential = InteractiveBrowserCredential()

# Create client to access assets in AzureML preview registry
ml_client_registry = MLClient(
    credential=credential,
    registry_name="azureml-preview"
)

# Create client to access assets in AzureML registry
ml_client_metrics_registry = MLClient(
    credential=credential,
    registry_name="azureml"
)

# Get inference component from registry
inference_component = ml_client_registry.components.get(
    name="automl_forecasting_inference",
    label="latest"
)

# Get component to compute evaluation metrics from registry
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

Em seguida, defina uma função de fábrica que cria pipelines orquestrando treinamento, inferência e computação de métrica. Para obter mais informações, consulte Configurar experimento.

from azure.ai.ml import automl
from azure.ai.ml.constants import AssetTypes
from azure.ai.ml.dsl import pipeline

@pipeline(description="AutoML Forecasting Pipeline")
def forecasting_train_and_evaluate_factory(
    train_data_input,
    test_data_input,
    target_column_name,
    time_column_name,
    forecast_horizon,
    primary_metric='normalized_root_mean_squared_error',
    cv_folds='auto'
):
    # Configure training node of pipeline
    training_node = automl.forecasting(
        training_data=train_data_input,
        target_column_name=target_column_name,
        primary_metric=primary_metric,
        n_cross_validations=cv_folds,
        outputs={"best_model": Output(type=AssetTypes.MLFLOW_MODEL)},
    )

    training_node.set_forecasting_settings(
        time_column_name=time_column_name,
        forecast_horizon=max_horizon,
        frequency=frequency,
        # Other settings
        ... 
    )
    
    training_node.set_training(
        # Training parameters
        ...
    )
    
    training_node.set_limits(
        # Limit settings
        ...
    )

    # Configure inference node to make rolling forecasts on test set
    inference_node = inference_component(
        test_data=test_data_input,
        model_path=training_node.outputs.best_model,
        target_column_name=target_column_name,
        forecast_mode='rolling',
        step=1
    )

    # Configure metrics calculation node
    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        ground_truth=inference_node.outputs.inference_output_file,
        prediction=inference_node.outputs.inference_output_file,
        evaluation_config=inference_node.outputs.evaluation_config_output_file
    )

    # Return dictionary with evaluation metrics and raw test set forecasts
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result,
        "rolling_fcst_result": inference_node.outputs.inference_output_file
    }

Defina as entradas de dados de treinamento e teste contidas nas pastas locais ./train_data e ./test_data.

my_train_data_input = Input(
    type=AssetTypes.MLTABLE,
    path="./train_data"
)

my_test_data_input = Input(
    type=AssetTypes.URI_FOLDER,
    path='./test_data',
)

Por fim, construímos o pipeline, definimos sua computação padrão e enviamos o trabalho:

pipeline_job = forecasting_train_and_evaluate_factory(
    my_train_data_input,
    my_test_data_input,
    target_column_name,
    time_column_name,
    forecast_horizon
)

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

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

Depois de enviar a solicitação de execução, o pipeline executará o treinamento do AutoML, a inferência de avaliação sem interrupção e o cálculo da métrica em sequência. Você pode monitorar e inspecionar a execução na interface do usuário do estúdio. Quando a execução for concluída, você poderá baixar as previsões sem interrupção e as métricas de avaliação para o diretório de trabalho local:

# Download metrics JSON
ml_client.jobs.download(returned_pipeline_job.name, download_path=".", output_name='metrics_result')

# Download rolling forecasts
ml_client.jobs.download(returned_pipeline_job.name, download_path=".", output_name='rolling_fcst_result')

Você pode examinar a saída nos seguintes locais:

  • Métricas: ./named-outputs/metrics_results/evaluationResult/metrics.json
  • Previsões: ./named-outputs/rolling_fcst_result/inference_output_file (formato de linhas JSON)

Para obter mais informações sobre a avaliação contínua, consulte Inferência e avaliação de modelos de previsão.

Previsão em escala: Muitos modelos

Os muitos componentes de modelos no AutoML permitem que você treine e gerencie milhões de modelos em paralelo. Para obter mais informações sobre muitos conceitos de modelos, consulte Muitos modelos.

Configuração de treinamento de muitos modelos

O componente de treinamento muitos modelos aceita um arquivo de configuração de formato YAML das configurações de treinamento do AutoML. O componente aplica essas configurações a cada instância do AutoML iniciada. O arquivo YAML tem a mesma especificação que o trabalho de comando de previsão mais os parâmetros partition_column_names e allow_multi_partitions.

Parâmetro Descrição
partition_column_names Nomes de coluna nos dados que, quando agrupados, definem as partições de dados. O componente de treinamento muitos modelos inicia um trabalho de treinamento independente em cada partição.
allow_multi_partitions Um sinalizador opcional que permite treinar um modelo por partição quando cada partição contém mais de uma série temporal exclusiva. O valor padrão é false.

O exemplo a seguir fornece uma configuração YAML de exemplo:

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

description: A time-series forecasting job config
compute: azureml:<cluster-name>
task: forecasting
primary_metric: normalized_root_mean_squared_error
target_column_name: sales
n_cross_validations: 3

forecasting:
  time_column_name: date
  time_series_id_column_names: ["state", "store"]
  forecast_horizon: 28

training:
  blocked_training_algorithms: ["ExtremeRandomTrees"]

limits:
  timeout_minutes: 15
  max_trials: 10
  max_concurrent_trials: 4
  max_cores_per_trial: -1
  trial_timeout_minutes: 15
  enable_early_termination: true
  
partition_column_names: ["state", "store"]
allow_multi_partitions: false

Nos exemplos subsequentes, a configuração é armazenada no caminho ./automl_settings_mm.yml'.

Pipeline de muitos modelos

Em seguida, definimos uma função de fábrica que cria pipelines para orquestração de muitos modelos de treinamento, inferência e computação de métrica. A tabela a seguir descreve os parâmetros para esta função de fábrica:

Parâmetro Descrição
max_nodes Número de nós de computação a serem usados no trabalho de treinamento.
max_concurrency_per_node Número de processos do AutoML a serem executados em cada nó. Portanto, a simultaneidade total de muitos trabalhos de modelos é max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Tempo limite do componente de muitos modelos especificado em número de segundos.
retrain_failed_models Sinalizador para habilitar o novo treinamento de modelos com falha. Esse valor é útil se você fez várias execuções anteriores de modelos que resultaram em trabalhos AutoML com falha em algumas partições de dados. Quando você habilita esse sinalizador, os muitos modelos iniciam apenas os trabalhos de treinamento para as partições que falharam anteriormente.
forecast_mode Modo de inferência para avaliação de modelo. Os valores válidos são recursive (padrão) e rolling. Para obter mais informações, confira Inferência e avaliação de modelos de previsão e a referência da classe ManyModelsInferenceParameters.
step Tamanho da etapa para previsão sem interrupção (o padrão é 1). Para obter mais informações, confira Inferência e avaliação de modelos de previsão e a referência da classe ManyModelsInferenceParameters.

O exemplo a seguir demonstra um método de fábrica para construir pipelines de avaliação de modelos e treinamento de muitos modelos:

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

# Get credential to access AzureML registry
try:
    credential = DefaultAzureCredential()
    # Check if token can be obtained successfully
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential fails
    credential = InteractiveBrowserCredential()

# Get many models training component
mm_train_component = ml_client_registry.components.get(
    name='automl_many_models_training',
    version='latest'
)

# Get many models inference component
mm_inference_component = ml_client_registry.components.get(
    name='automl_many_models_inference',
    version='latest'
)

# Get component to compute evaluation metrics
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

@pipeline(description="AutoML Many Models Forecasting Pipeline")
def many_models_train_evaluate_factory(
    train_data_input,
    test_data_input,
    automl_config_input,
    compute_name,
    max_concurrency_per_node=4,
    parallel_step_timeout_in_seconds=3700,
    max_nodes=4,
    retrain_failed_model=False,
    forecast_mode="rolling",
    forecast_step=1
):
    mm_train_node = mm_train_component(
        raw_data=train_data_input,
        automl_config=automl_config_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        retrain_failed_model=retrain_failed_model,
        compute_name=compute_name
    )

    mm_inference_node = mm_inference_component(
        raw_data=test_data_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        optional_train_metadata=mm_train_node.outputs.run_output,
        forecast_mode=forecast_mode,
        step=forecast_step,
        compute_name=compute_name
    )

    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        prediction=mm_inference_node.outputs.evaluation_data,
        ground_truth=mm_inference_node.outputs.evaluation_data,
        evaluation_config=mm_inference_node.outputs.evaluation_configs
    )

    # Return metrics results from rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Construa o pipeline com a função de fábrica. Os dados de treinamento e teste estão nas pastas locais ./data/train e ./data/test, respectivamente. Por fim, defina a computação padrão e envie o trabalho, conforme mostrado no exemplo a seguir:

pipeline_job = many_models_train_evaluate_factory(
    train_data_input=Input(
        type="uri_folder",
        path="./data/train"
    ),
    test_data_input=Input(
        type="uri_folder",
        path="./data/test"
    ),
    automl_config=Input(
        type="uri_file",
        path="./automl_settings_mm.yml"
    ),
    compute_name="<cluster name>"
)
pipeline_job.settings.default_compute = "<cluster name>"

returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name,
)
ml_client.jobs.stream(returned_pipeline_job.name)

Após a conclusão do trabalho, você poderá baixar as métricas de avaliação localmente usando o mesmo procedimento que no pipeline de execução de treinamento único.

Para obter um exemplo mais detalhado, confira o notebook de previsão de demanda com muitos modelos.

Considerações de treinamento para uma execução de muitos modelos

Os componentes de inferência e treinamento de muitos modelos particionam condicionalmente seus dados de acordo com a configuração partition_column_names para que cada partição esteja em seu próprio arquivo. Esse processo pode ser muito lento ou falhar quando os dados são muito grandes. A recomendação é particionar seus dados manualmente antes de executar e inferência e treinamento de muitos modelos.

Observação

O limite de paralelismo padrão para muitos modelos executados em uma assinatura é definido como 320. Se sua carga de trabalho exigir um limite maior, você poderá entrar em contato com o suporte da Microsoft.

Previsão em escala: Série temporal hierárquica

Os componentes de série temporal hierárquica (HTS) no AutoML permitem treinar um grande número de modelos em dados com estrutura hierárquica. Para obter mais informações, confira Previsão de série temporal hierárquica.

Configuração de treinamento do HTS

O componente de treinamento HTS aceita um arquivo de configuração de formato YAML das configurações de treinamento do AutoML. O componente aplica essas configurações a cada instância do AutoML iniciada. Esse arquivo YAML tem a mesma especificação que o Trabalho de comando de previsão, além de outros parâmetros relacionados às informações de hierarquia:

Parâmetro Descrição
hierarchy_column_names Uma lista de nomes de coluna nos dados que definem a estrutura hierárquica dos dados. A ordem das colunas nesta lista determina os níveis de hierarquia. O grau de agregação diminui com o índice de lista. Ou seja, a última coluna da lista define o nível mais detalhado da hierarquia.
hierarchy_training_level O nível de hierarquia a ser usado para treinamento de modelo de previsão.

O exemplo a seguir fornece uma configuração YAML de exemplo:

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

description: A time-series forecasting job config
compute: azureml:cluster-name
task: forecasting
primary_metric: normalized_root_mean_squared_error
log_verbosity: info
target_column_name: sales
n_cross_validations: 3

forecasting:
  time_column_name: "date"
  time_series_id_column_names: ["state", "store", "SKU"]
  forecast_horizon: 28

training:
  blocked_training_algorithms: ["ExtremeRandomTrees"]

limits:
  timeout_minutes: 15
  max_trials: 10
  max_concurrent_trials: 4
  max_cores_per_trial: -1
  trial_timeout_minutes: 15
  enable_early_termination: true
  
hierarchy_column_names: ["state", "store", "SKU"]
hierarchy_training_level: "store"

Nos exemplos subsequentes, a configuração é armazenada no caminho ./automl_settings_hts.yml.

Pipeline do HTS

Em seguida, definimos uma função de fábrica que cria pipelines para orquestração de treinamento, inferência e computação de métrica do HTS. A tabela a seguir descreve os parâmetros para esta função de fábrica:

Parâmetro Descrição
forecast_level O nível da hierarquia para o qual recuperar as previsões.
allocation_method Método de alocação a ser usado quando as previsões forem desagregados. Os valores válidos são proportions_of_historical_average e average_historical_proportions.
max_nodes Número de nós de computação a serem usados no trabalho de treinamento.
max_concurrency_per_node Número de processos do AutoML a serem executados em cada nó. Portanto, a simultaneidade total de um trabalho do HTS é max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Tempo limite do componente de muitos modelos especificado em número de segundos.
forecast_mode Modo de inferência para avaliação de modelo. Os valores válidos são recursive e rolling. Para obter mais informações, confira Inferência e avaliação de modelos de previsão e a referência da classe HTSInferenceParameters.
step Tamanho da etapa para previsão sem interrupção (o padrão é 1). Para obter mais informações, confira Inferência e avaliação de modelos de previsão e a referência da classe HTSInferenceParameters. 
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

# Get credential to access AzureML registry
try:
    credential = DefaultAzureCredential()
    # Check if token can be obtained successfully
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential fails
    credential = InteractiveBrowserCredential()

# Get HTS training component
hts_train_component = ml_client_registry.components.get(
    name='automl_hts_training',
    version='latest'
)

# Get HTS inference component
hts_inference_component = ml_client_registry.components.get(
    name='automl_hts_inference',
    version='latest'
)

# Get component to compute evaluation metrics
compute_metrics_component = ml_client_metrics_registry.components.get(
    name="compute_metrics",
    label="latest"
)

@pipeline(description="AutoML HTS Forecasting Pipeline")
def hts_train_evaluate_factory(
    train_data_input,
    test_data_input,
    automl_config_input,
    max_concurrency_per_node=4,
    parallel_step_timeout_in_seconds=3700,
    max_nodes=4,
    forecast_mode="rolling",
    forecast_step=1,
    forecast_level="SKU",
    allocation_method='proportions_of_historical_average'
):
    hts_train = hts_train_component(
        raw_data=train_data_input,
        automl_config=automl_config_input,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        max_nodes=max_nodes
    )
    hts_inference = hts_inference_component(
        raw_data=test_data_input,
        max_nodes=max_nodes,
        max_concurrency_per_node=max_concurrency_per_node,
        parallel_step_timeout_in_seconds=parallel_step_timeout_in_seconds,
        optional_train_metadata=hts_train.outputs.run_output,
        forecast_level=forecast_level,
        allocation_method=allocation_method,
        forecast_mode=forecast_mode,
        step=forecast_step
    )
    compute_metrics_node = compute_metrics_component(
        task="tabular-forecasting",
        prediction=hts_inference.outputs.evaluation_data,
        ground_truth=hts_inference.outputs.evaluation_data,
        evaluation_config=hts_inference.outputs.evaluation_configs
    )

    # Return metrics results from rolling evaluation
    return {
        "metrics_result": compute_metrics_node.outputs.evaluation_result
    }

Construa o pipeline usando a função de fábrica. Os dados de treinamento e teste estão nas pastas locais ./data/train e ./data/test, respectivamente. Por fim, defina a computação padrão e envie o trabalho, conforme mostrado no exemplo a seguir:

pipeline_job = hts_train_evaluate_factory(
    train_data_input=Input(
        type="uri_folder",
        path="./data/train"
    ),
    test_data_input=Input(
        type="uri_folder",
        path="./data/test"
    ),
    automl_config=Input(
        type="uri_file",
        path="./automl_settings_hts.yml"
    )
)
pipeline_job.settings.default_compute = "cluster-name"

returned_pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job,
    experiment_name=experiment_name,
)
ml_client.jobs.stream(returned_pipeline_job.name)

Após a conclusão do trabalho, as métricas de avaliação poderão ser baixadas localmente usando o mesmo procedimento que no pipeline de execução de treinamento único.

Para obter um exemplo mais detalhado, consulte a previsão de demanda com notebook de séries temporais hierárquicas.

Considerações de treinamento para uma execução de HTS

Os componentes de treinamento e inferência do HTS particionam condicionalmente seus dados de acordo com a configuração hierarchy_column_names para que cada partição esteja em seu próprio arquivo. Esse processo pode ser muito lento ou falhar quando os dados são muito grandes. A abordagem recomendada é particionar seus dados manualmente antes de executar o treinamento ou a inferência do HTS.

Observação

O limite de paralelismo padrão para uma execução de HTS em uma assinatura é definido como 320. Se sua carga de trabalho exigir um limite maior, você poderá entrar em contato com o suporte da Microsoft.

Previsão em escala: Treinamento de DNN distribuído

Conforme descrito anteriormente neste artigo, você pode habilitar o aprendizado para DNN (redes neurais profundas). Para saber como o treinamento distribuído funciona para tarefas de previsão de DNN, confira o Treinamento de rede neural profunda distribuída (versão prévia).

Para cenários com requisitos de dados grandes, o treinamento distribuído com o AutoML está disponível para um conjunto limitado de modelos. Você pode encontrar mais informações e exemplos de código no AutoML em escala: Treinamento distribuído.

Explorar notebooks de exemplo

Os exemplos de código detalhados que demonstram as configurações avançadas de previsão estão disponíveis no repositório GitHub Notebooks de Exemplo de Previsão do AutoML. Aqui estão alguns dos notebooks de exemplo:

Conteúdo relacionado