Partilhar via

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

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

Aprendizagem automática automatizada (AutoML) no Azure Machine Learning utiliza modelos padrão de aprendizagem automática juntamente com modelos de séries temporais bem conhecidos para criar previsões. Essa abordagem incorpora informações históricas sobre a variável de destino com recursos fornecidos pelo usuário nos dados de entrada e recursos projetados automaticamente. Os algoritmos de pesquisa de modelos ajudam a identificar modelos com a melhor precisão preditiva. Para obter mais informações, consulte a metodologia de previsão e a varredura e seleção de modelos.

Este artigo descreve como configurar o AutoML para previsão de séries temporais com Machine Learning utilizando o Azure Machine Learning Python SDK e a Azure CLI. O processo inclui a preparação de dados para treinamento e a configuração de parâmetros de séries temporais numa tarefa de previsão (referência de classe). Em seguida, você treina, infere e avalia modelos usando componentes e pipelines.

Para obter uma experiência low-code, consulte Tutorial: Prever a demanda com aprendizado de máquina automatizado. Este artigo apresenta um exemplo de previsão de séries temporais que utiliza AutoML no Azure Machine Learning Studio.

Pré-requisitos

Preparar dados de treinamento e validação

Os dados de entrada para previsão de AutoML devem conter uma série temporal válida em 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 do tempo e uma coluna de destino para a quantidade a ser prevista. Outras colunas podem servir como preditores. Para obter mais informações, consulte Como o AutoML usa seus dados.

Importante

Ao treinar um modelo para prever valores futuros, certifique-se de que todas as funcionalidades usadas no treino também podem ser usadas ao executar previsões para o horizonte pretendido.

Considere uma característica para o preço atual das ações, que pode aumentar a precisão do treinamento. Se prever com um horizonte longo, pode não conseguir prever com precisão os valores futuros das ações que correspondam a futuros pontos das séries temporais. 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 MLTable objeto. Um MLTable objeto especifica uma fonte de dados e etapas para carregar os dados. Para mais informações e casos de uso, consulte Trabalhar com tabelas.

Para o exemplo seguinte, assuma que os seus dados de treino estão contidos num ficheiro CSV num diretório local: ./train_data/timeseries_train.csv.

Pode criar um MLTable objeto usando o membro mltable do SDK Python:

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 de arquivo e instruções de carregamento.

Para iniciar o trabalho de treino, defina um objeto de dados de entrada usando o SDK Python:

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

Você especifica os dados de validação de maneira semelhante. Crie um MLTable objeto 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 dos dados de treinamento para usar na seleção de modelos. Para obter mais informações, consulte os seguintes recursos:

Criar computação para executar a experiência

O AutoML utiliza o Azure Machine Learning compute, que é um recurso de computação totalmente gerido, para executar o trabalho de treino.

O exemplo a seguir cria um cluster de computação chamado cpu-cluster.

from azure.ai.ml.entities import AmlCompute

# specify aml compute name.
cpu_compute_target = "cpu-cluster"

try:
    ml_client.compute.get(cpu_compute_target)
except Exception:
    print("Creating a new cpu compute target...")
    compute = AmlCompute(
        name=cpu_compute_target, size="STANDARD_D2_V2", min_instances=0, max_instances=4
    )
    ml_client.compute.begin_create_or_update(compute).result()

Configurar a experiência

O exemplo a seguir mostra como configurar o experimento.

Use as funções de fábrica do AutoML para configurar 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 definindo limites 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,
)

Prever configurações de trabalho

As tarefas de previsão têm muitas configurações específicas para a previsão. As configurações mais básicas são o nome da coluna de tempo nos dados de treinamento e o 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 obrigatória. Geralmente, você deve definir o horizonte de previsão de acordo com 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 as séries individuais. Por exemplo, suponha que você tenha dados que consistem em vendas por hora de diferentes lojas e marcas. O exemplo seguinte mostra como definir as colunas ID de séries temporais, assumindo que os dados contêm colunas nomeadas 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 detetar automaticamente colunas de ID de séries cronológicas em seus dados, se nenhuma for especificada.

Outras configurações são opcionais e descritas na secção seguinte.

Configurações opcionais do trabalho de previsão

Estão disponíveis configurações opcionais para tarefas de previsão, como permitir aprendizagem profunda e especificar uma agregação de janela rolante alvo. 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 onde o AutoML procura o melhor modelo: allowed_training_algorithms e blocked_training_algorithms. Para restringir o espaço de pesquisa a um dado conjunto de classes de modelo, use o allowed_training_algorithms parâmetro, como mostrado aqui:

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

Nesse cenário, o trabalho de previsão procura apenas as classes de modelo Exponential Smoothing e Elastic Net. Para remover um dado conjunto de classes de modelo do espaço de pesquisa, use blocked_training_algorithms, como mostrado aqui:

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

A procura de emprego em todas as classes de modelos, exceto Prophet. Para obter uma lista dos nomes de modelos de previsão aceitos em allowed_training_algorithms e blocked_training_algorithms, consulte Propriedades de treinamento. Você pode aplicar qualquer um, mas não ambos, allowed_training_algorithms e blocked_training_algorithms para uma corrida de treinamento.

Habilite o aprendizado para redes neurais profundas

O AutoML é fornecido com um modelo personalizado de rede neural profunda (DNN) chamado TCNForecaster. Este modelo é uma rede convolucional temporal (TCN), que aplica métodos comuns de tarefas de imagem à modelagem de séries temporais. Convoluções "causais" unidimensionais formam a espinha dorsal da rede e permitem que o modelo aprenda padrões complexos durante 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 AutoML TCNForecaster.

O TCNForecaster frequentemente alcança maior precisão do que os modelos padrão de séries temporais quando existem milhares ou mais de observações no histórico de treino. No entanto, também demora mais tempo a treinar e avaliar os modelos TCNForecaster devido à sua maior capacidade.

Pode ativar o TCNForecaster no AutoML definindo a enable_dnn_training flag na configuração de treino, da seguinte forma:

# 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 uma única GPU, se disponível, por avaliação do modelo. Para cenários de dados grandes, a recomendação é distribuir cada teste TCNForecaster em vários núcleos/GPUs e nós. Para obter mais informações e exemplos de código, consulte treinamento distribuído.

Para ativar o DNN para um experimento AutoML criado no Azure Machine Learning Studio, consulte as definições de tipo de tarefa no artigo da interface do studio.

Nota

  • Quando você habilita a DNN para experimentos criados com o SDK, as melhores explicações de modelo são desabilitadas.
  • O suporte DNN para previsão em aprendizagem automática automática não é suportado para execuções iniciadas no Azure Databricks.
  • A abordagem recomendada é usar tipos de computação de GPU quando o treinamento DNN estiver habilitado.

Características de atraso e janela rolante

Os valores recentes da meta são muitas vezes características impactantes em um modelo de previsão. Assim, o AutoML pode criar funcionalidades de agregação com atraso temporal e janelas rolantes para potencialmente melhorar a precisão do modelo.

Considere um cenário de previsão da procura de energia em que estejam disponíveis dados meteorológicos e a procura histórica. A tabela mostra a engenharia de recursos resultante que ocorre quando a agregação de janelas é aplicada nas três horas mais recentes. As 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 a 8 de setembro de 2017, às 4:00 da manhã, os valores máximo, mínimo e soma são calculados utilizando os valores da procura para 8 de setembro de 2017, das 1:00 às 3:00 da manhã. Essa janela de três horas se desloca para preencher os dados das linhas restantes. Para obter mais informações e exemplos, consulte os recursos de atraso para previsão de séries cronológicas no AutoML.

Uma tabela com dados que mostram a janela móvel de destino. Os valores na coluna de Demanda estão destacados.

Podes ativar as funcionalidades de lag e agregação de janelas rolantes para o alvo, definindo o tamanho da janela rolante e as ordens de lag que queres criar. O tamanho da janela é três no exemplo anterior. Também podes ativar atrasos para funcionalidades usando a feature_lags definição. No exemplo a seguir, todas essas configurações são definidas para auto 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'
)

Manuseamento em 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 Requisitos de comprimento de dados de treinamento.

AutoML tem várias ações que pode tomar para séries curtas. Podes configurar estas ações usando a short_series_handling_config definição. O valor predefinido é auto. A tabela a seguir descreve as configurações:

Definição Descrição Notas
auto O valor padrão para manipulação de séries curtas. - Se todas as séries forem curtas, preencha os dados.
- Se nem todas as séries forem curtas, abandone as séries curtas.
pad Se a configuração for usada, o short_series_handling_config = pad AutoML adicionará valores aleatórios a cada série curta encontrada. O AutoML preenche a coluna de destino com ruído branco. Você pode usar os seguintes tipos de coluna com o preenchimento especificado:
- Colunas de objetos, preencher com NaNs.
- Colunas numéricas, preencher com 0 (zero).
- Colunas booleanas/logicas, preenchidas com False.
drop Se a configuração for usada, o short_series_handling_config = drop AutoML descartará a série curta e ela não será usada para treinamento ou previsão. As previsões para estas séries regressam NaN.
None Nenhuma série é acolchoada ou descartada.

O exemplo seguinte define o tratamento das séries curtas para que todas as séries curtas sejam preenchidas ao comprimento mínimo:

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

Atenção

O preenchimento pode afetar a precisão do modelo resultante porque introduz dados artificiais para evitar falhas de treino. Se muitas das séries forem curtas, você também pode ver algum impacto nos resultados de explicabilidade.

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

Use as opções de frequência e agregação de dados para evitar falhas causadas por dados irregulares. Seus dados são irregulares se não seguirem uma cadência definida no tempo, como por hora ou por dia. Os dados dos pontos 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 frequency configurações e target_aggregate_function para lidar com dados irregulares. A configuração de frequência aceita cadeias de caracteres Pandas DateOffset como entrada. A tabela a seguir mostra os valores suportados para a função de agregação:

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

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

Coluna Método de agregação
Preditores numéricos O AutoML usa as sumfunções , mean, min, e max . Gera novas colunas. Cada nome de coluna inclui um sufixo que identifica o nome da função de agregação aplicada aos valores das colunas.
Preditores categóricos O AutoML usa o valor do forecast_mode parâmetro para agregar os dados. É a categoria mais proeminente na janela. Para mais informações, consulte as descrições do parâmetro nas secções do pipeline Many-models e do pipeline HTS.
Preditores de dados O AutoML usa o valor de destino mínimo (min), o valor de destino máximo (max) e forecast_mode as configurações de parâmetro para agregar os dados.
Destino AutoML agrega os valores de acordo com a operação especificada. Normalmente, a função é apropriada para a sum maioria dos cenários.

O exemplo a seguir define a frequência como horária e a função de agregação como soma:

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

Configurações personalizadas de validação cruzada

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

Por padrão, o AutoML define ambas as configurações automaticamente com base nas características dos 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 sua configuração de validação consista em cinco dobras com um deslocamento de sete dias entre dobras adjacentes. O exemplo de código 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
)

Featurização personalizada

Por padrão, o AutoML aumenta os dados de treinamento com recursos projetados para aumentar a precisão dos modelos. Para mais informações, consulte Engenharia de funcionalidades automatizada. Pode personalizar alguns dos passos de pré-processamento usando a configuração de características do trabalho de previsão.

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

Personalização Descrição Opções
Atualização da finalidade da coluna Substitua o tipo de recurso detetado automaticamente para a coluna especificada. categorical, dateTime, numeric
Atualização dos parâmetros do transformador Atualizar os parâmetros para o imputador 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 incluam preços, um on sale sinalizador e um tipo de produto. O exemplo a seguir mostra como você pode definir tipos e imputadores 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, consulte Configurar configurações de featurização no estúdio.

Submeter 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 provisiona recursos de computação, aplica etapas de featurização e outras etapas de preparação aos dados de entrada e começa a varrer os modelos de previsão. Para mais informações, consulte Metodologia de previsão em AutoML e Varredura e seleção de modelos para previsão em AutoML.

Orquestrar treino, inferência e avaliação utilizando componentes e pipelines

O teu fluxo de trabalho de aprendizagem automática provavelmente requer mais do que apenas treino. A inferência ou a recuperação de previsões de modelo em dados mais recentes e a 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 Aprendizado de Máquina do Azure junto com trabalhos de treinamento. Para dar suporte a tarefas de inferência e avaliação, o Aprendizado de Máquina do Azure fornece componentes, que são partes autônomas de código que executam uma etapa em um pipeline do Azure Machine Learning.

O exemplo seguinte recupera código de componente de um registo 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 crie pipelines orquestrando treinamento, inferência e computação métrica. Para mais informações, consulte Configurar a experiência.

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 trem 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',
)

Finalmente, construa o pipeline, defina sua computação padrão e envie 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 submeter o pedido de execução, o pipeline executa treino AutoML, inferência de avaliação contínua e cálculo das métricas 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 contínuas 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 revisar 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 JSON Lines)

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

Previsão em escala: Muitos modelos

Os componentes de muitos modelos no AutoML permitem-lhe treinar e gerir milhões de modelos em paralelo. Para mais informações, consulte Muitos modelos.

Configuração de treino de vários modelos

O componente de treino de múltiplos modelos aceita um ficheiro de configuração em formato YAML para as configurações de treino do AutoML. O componente aplica estas definições a cada instância de AutoML que inicia. O ficheiro YAML tem a mesma especificação do comando Forecasting, mais os parâmetros partition_column_names e allow_multi_partitions.

Parâmetro Descrição
partition_column_names Nomes de colunas nos dados que, quando agrupados, definem as partições de dados. O componente de treino de múltiplos modelos inicia um trabalho de treino 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 predefinido é false.

Aqui está um exemplo de configuração YAML:

$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

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

Pipeline para múltiplos modelos

De seguida, vais definir uma função de fábrica que cria pipelines para a orquestração de muitos modelos: treino, inferência e computação métrica. A tabela a seguir descreve os parâmetros para essa 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 AutoML a serem executados em cada nó. A concorrência total de um trabalho com muitos modelos é max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds Muitos modelos incluem um tempo limite para componentes, especificado em segundos.
retrain_failed_models Sinalizador para permitir o retreinamento de modelos com falha. Este valor é útil se fizeste execuções anteriores com muitos modelos que resultaram em falhas em tarefas de AutoML em algumas partições de dados. Quando ativas esta bandeira, muitos modelos só executam trabalhos de treino para partições previamente falhadas.
forecast_mode Modo de inferência para avaliação do modelo. Os valores válidos são recursive (padrão) e rolling. Para obter mais informações, consulte Inferência e avaliação de modelos de previsão e a referência da classe ManyModelsInferenceParameters.
step Tamanho do passo para previsão contínua. O padrão é 1. Para obter mais informações, consulte Inferência e avaliação de modelos de previsão e a referência da classe ManyModelsInferenceParameters.

O exemplo seguinte demonstra um método de fábrica para construir pipelines de treino e avaliação de modelos com muitos modelos:

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

# Get credential to access azureml registry.
try:
    credential = DefaultAzureCredential()
    # Check whether token can be obtained.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential if 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 a tubulação com a função de fábrica. Os dados de treino e de teste estão nas pastas locais ./data/train e ./data/test. Finalmente, defina o cálculo padrão e envie o trabalho como 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)

Depois de terminar o trabalho, pode descarregar as métricas de avaliação localmente, utilizando o procedimento no pipeline de execução de treino único.

Para um exemplo mais detalhado, consulte o notebook Previsão da Procura utilizando Muitos Modelos.

Considerações de treino para uma corrida com muitos modelos

  • Os componentes de treino e inferência de múltiplos modelos particionam condicionalmente os seus dados de acordo com a configuração partition_column_names. Este processo resulta em cada partição estar em seu próprio arquivo. O processo pode ser lento ou falhar quando se tem muitos dados. Recomendamos que particione manualmente os seus dados antes de executar treino ou inferência com muitos modelos.

  • Durante o treino de muitos modelos, os modelos são automaticamente registados no espaço de trabalho, pelo que o registo manual dos modelos não é obrigatório. Os modelos são nomeados com base na partição onde foram treinados, e esses nomes não são personalizáveis. As etiquetas também não são personalizáveis. Estas propriedades são usadas para detetar automaticamente modelos durante a inferência.

  • Implementar modelos individuais não é escalável, mas podes usar PipelineComponentBatchDeployment para facilitar o processo de implementação. Por exemplo, consulte o notebook Previsão da Procura utilizando Muitos Modelos.

  • Durante a inferência, os modelos apropriados (a versão mais recente) são automaticamente selecionados com base na partição enviada nos dados de inferência. Por defeito, quando usa training_experiment_name, é utilizado o modelo mais recente, mas pode sobrescrever este comportamento para selecionar modelos de uma execução de treino específica, fornecendo também train_run_id.

Nota

O limite padrão de paralelismo para um sistema de muitos modelos executado numa subscrição é 320. Se a sua carga de trabalho exigir um limite mais elevado, pode contactar o suporte da Microsoft.

Previsão em escala: séries temporais hierárquicas

Os componentes de séries temporais hierárquicas (HTS) no AutoML permitem-te treinar um grande número de modelos com dados numa estrutura hierárquica. Para obter mais informações, consulte Previsão hierárquica de séries temporais.

Configuração de treinamento HTS

O componente de treinamento HTS aceita um arquivo de configuração de formato YAML das configurações de treinamento AutoML. O componente aplica estas definições a cada instância de AutoML que executa. Este ficheiro YAML tem a mesma especificação do comando Forecasting, mas inclui outros parâmetros relacionados com a informação da hierarquia:

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

Aqui está um exemplo de configuração YAML:

$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"

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

Pipeline HTS

De seguida, defina uma função de fábrica que crie pipelines para a orquestração do treino, inferência e cálculo de métricas de HTS. A tabela a seguir descreve os parâmetros para essa função de fábrica:

Parâmetro Descrição
forecast_level O nível da hierarquia para o qual recuperar previsões.
allocation_method O método de alocação a usar quando as previsões são desagregadas. Os valores válidos são proportions_of_historical_average e average_historical_proportions.
max_nodes O número de nós de computação a usar no trabalho de treinamento.
max_concurrency_per_node O número de processos AutoML que serão executados em cada nó. A concorrência total de um trabalho HTS é max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds O tempo limite do componente de múltiplos modelos, especificado em segundos.
forecast_mode O modo de inferência para avaliação de modelos. Os valores válidos são recursive e rolling. Para obter mais informações, consulte Inferência e avaliação de modelos de previsão e a referência da classe HTSInferenceParameters.
step O tamanho do passo para a previsão móvel. O padrão é 1. Para obter mais informações, consulte 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 whether token can be obtained.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential if 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 treino e de teste estão nas pastas locais ./data/train e ./data/test. Finalmente, defina o cálculo padrão e envie o trabalho como 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)

Depois de terminar o trabalho, pode baixar as métricas de avaliação localmente, utilizando o procedimento na pipeline de execução única de treino.

Para um exemplo mais detalhado, veja o notebook Demand Forecasting Using HTS.

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

Os componentes de treino e inferência do HTS particionam condicionalmente os seus dados de acordo com a hierarchy_column_names definição, de modo que cada partição esteja num ficheiro próprio. Este processo pode ser lento ou falhar quando se tem muitos dados. Recomendamos que particione manualmente os seus dados antes de executar o treino ou inferência do HTS.

Nota

O limite padrão de paralelismo para uma execução HTS numa subscrição é 320. Se a sua carga de trabalho exigir um limite mais elevado, pode contactar o suporte da Microsoft.

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

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

Para cenários que requerem grandes quantidades de dados, o treino distribuído com 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.

Explore exemplos de blocos de notas

Exemplos de código detalhados que demonstram configurações avançadas de previsão estão disponíveis no repositório GitHub de blocos de anotações de amostra de previsão AutoML. Aqui estão alguns dos exemplos de cadernos:

Conteúdos relacionados

  • Last updated on