Configurar o AutoML para treinar um modelo de previsão de série temporal usando o SDK e a CLI

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 modelos de machine learning padrão, juntamente com 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, consulte a 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 e a CLI do Azure. O processo inclui a preparação de dados para treinamento e a configuração dos parâmetros de séries temporais 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. Este artigo fornece um exemplo de previsão de série temporal que usa o AutoML no estúdio do Azure Machine Learning.

Pré-requisitos

Um Workspace do Azure Machine Learning. Para obter mais informações, consulte Criar recursos de workspace.
A capacidade de iniciar trabalhos de treinamento do AutoML. Para obter mais informações, consulte Configurar o treinamento do AutoML para dados tabulares com a CLI do Azure Machine Learning e o SDK do Python.

Preparar 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, consulte Como o AutoML usa seus dados.

Importante

Ao treinar um modelo para prever valores futuros, verifique se todos os recursos usados no treinamento também podem ser usados ao executar previsões para o horizonte pretendido.

Considere um recurso para o preço atual das ações, que pode aumentar a precisão do treinamento. Se você prever com um horizonte longo, talvez não seja capaz de prever com precisão os valores futuros de 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, consulte Trabalhando com tabelas.

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

SDK do Python
CLI do Azure

Você pode criar um MLTable objeto usando o membro do SDK do Python mltable:

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:

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ê pode definir um novo MLTable objeto copiando o snippet YAML a seguir para um novo arquivo, ./train_data/MLTable.

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

type: mltable
paths:
    - file: ./timeseries_train.csv

transformations:
    - read_delimited:
        delimiter: ','
        encoding: ascii

Comece a criar a configuração YAML para o trabalho do AutoML com os dados de treinamento especificados conforme mostrado no exemplo a seguir:

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

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

# Training data MLTable for the AutoML job.
training_data:
    path: "./train_data"
    type: mltable

validation_data:
    # Optional validation data.

compute: # Compute for training job.
primary_metric: # Primary metric.  

target_column_name: # Target column name.
n_cross_validations: # Cross-validation setting.

limits:
    # Limit settings.

forecasting:
    # Forecasting-specific settings.

training:
    # Training settings.

Você adicionará mais detalhes a essa configuração nas seções subsequentes deste artigo. Neste exemplo, o local é ./automl-forecasting-job.yml.

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.

SDK do Python
CLI do Azure

O exemplo a seguir cria um cluster de cálculo 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()

Você pode criar uma nova computação nomeada cpu-compute usando o seguinte comando da CLI do Azure:

az ml compute create -n cpu-compute --type amlcompute --min-instances 0 --max-instances 4

Faça referência ao cálculo na definição de trabalho da seguinte maneira:

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

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

# Set training data MLTable for the AutoML job.
training_data:
    path: "./train_data"
    type: mltable

# Set compute for the training job to use. 
compute: azureml:cpu-compute

primary_metric: # Primary metric.  

target_column_name: # Target column name.
n_cross_validations: # Cross-validation setting.

limits:
    # Limit settings.

forecasting:
    # Forecasting-specific settings.

training:
    # Training settings.

Configurar o experimento

O exemplo a seguir mostra como configurar o experimento.

SDK do Python
CLI do Azure

Você usa as funções de fábrica de 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 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,
)

Configure as propriedades gerais do trabalho AutoML, incluindo:

A métrica primária.
O nome da coluna de destino nos dados de treinamento.
As configurações de validação cruzada.
Limites de recursos no trabalho.

Para obter mais informações, consulte o esquema do YAML do trabalho de comando de previsão, os parâmetros de treinamento e os limites.

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

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

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

compute: azureml:cpu-compute

# Settings for primary metric, target/label column name, cross validation.
primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

# Settings for training job limits on time, concurrency, and others.
limits:
    timeout_minutes: 120
    trial_timeout_minutes: 30
    max_concurrent_trials: 4

forecasting:
    # Forecasting-specific settings.

training:
    # Training settings.

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.

SDK do Python
CLI do Azure

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
)

Essas configurações são configuradas na seção forecasting da configuração YAML do trabalho:

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

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

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

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

limits:
    timeout_minutes: 120
    trial_timeout_minutes: 30
    max_concurrent_trials: 4

# Forecasting-specific settings.
# Set the horizon to 24 for this example. The horizon generally depends on the business scenario.
forecasting:
    time_column_name: <time_column_name>
    forecast_horizon: 24

training:
    # Training settings.

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, vamos supor 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 nomeadas repositório e marca:

SDK do Python
CLI do Azure

# 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']
)

# Forecasting-specific settings.
# Add time series IDs for store and brand.
forecasting:
    # 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 descritas 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 allowed_training_algorithms parâmetro, conforme mostrado aqui:

SDK do Python
CLI do Azure

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

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

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

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

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

limits:
    timeout_minutes: 120
    trial_timeout_minutes: 30
    max_concurrent_trials: 4

forecasting:
    time_column_name: <time_column_name>
    forecast_horizon: 24

# Training settings.
# Only search ExponentialSmoothing and ElasticNet models.
training:
    allowed_training_algorithms: ["ExponentialSmoothing", "ElasticNet"]
    # Other training settings.

Nesse cenário, o trabalho de previsão pesquisa apenas em classes de modelo de Suavização Exponencial e Rede Elástica. Para remover um determinado conjunto de classes de modelo do espaço de pesquisa, use blocked_training_algorithms, conforme mostrado aqui:

SDK do Python
CLI do Azure

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

# Training settings.
# Search over all model classes except Prophet.
training:
    blocked_training_algorithms: ["Prophet"]
    # Other training settings.

O trabalho pesquisa todas as classes de modelo, exceto Prophet. Para obter uma lista dos nomes de modelos 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.

O TCNForecaster geralmente obtém maior precisão do que os modelos de série temporal 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 modelos TCNForecaster devido à sua capacidade mais alta.

Você pode habilitar o TCNForecaster no AutoML ao definir o flag enable_dnn_training na configuração de treinamento, da seguinte forma:

SDK do Python
CLI do Azure

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

# Training settings.
# Include TCNForecaster models in the model search.
training:
    enable_dnn_training: true
    # Other training settings.

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 a DNN para um experimento de AutoML criado no estúdio do Azure Machine Learning, consulte as configurações de tipo de tarefa no artigo 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 execuções iniciadas no Azure Databricks.
A abordagem recomendada será usar tipos de computação de GPU quando o treinamento de DNN estiver habilitado.

Recursos de latência 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 4h, os valores máximo, mínimo e soma são calculados usando os valores de demanda para 8 de setembro de 2017, das 13h às 3h. 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 latência para previsão de série temporal no AutoML.

Você pode habilitar os recursos de agregação de janela sem interrupção e latência para o destino definindo o tamanho da janela sem interrupção e as ordens de latência que você deseja criar. O tamanho da janela é três no exemplo anterior. Você também pode habilitar latência para recursos usando a configuraçãofeature_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:

SDK do Python
CLI do Azure

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

# Forecasting-specific settings.
# Auto configure lags and rolling-window features.
forecasting:
    target_lags: auto
    target_rolling_window_size: auto
    feature_lags: auto
    # Other settings.

Manipulação de séries curtas

O AutoML automatizado considera uma série temporal uma pequena sequência se não houver pontos de dados suficientes para conduzir as fases de treinamento e validação do desenvolvimento de 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. Você pode configurar essas ações usando a short_series_handling_config configuração. O valor padrão é auto. A tabela a seguir 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, descarte as séries curtas.
`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, preencha com `NaN`s. - Colunas numéricas, pad com 0 (zero). - Colunas booleanas/lógicas, preencha 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 é preenchimento ou descartado.

O exemplo a seguir define o tratamento de séries curtas para que todas as séries curtas sejam preenchidas até o comprimento mínimo.

SDK do Python
CLI do Azure

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

# Forecasting-specific settings.
# Auto configure lags and rolling-window features.
forecasting:
    short_series_handling_config: pad
    # Other settings.

Atenção

O preenchimento pode afetar a precisão do modelo resultante porque ele introduz dados artificiais para evitar falhas de 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 compatíveis para a função de agregação:

Função	Descrição
`sum`	Soma dos valores de destino
`mean`	Média ou 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
Previsões numéricas	O AutoML usa as funções `sum`, `mean`, `min` e `max`. Ele gera novas colunas. Cada nome de coluna inclui um sufixo que identifica o nome da função de agregação aplicada aos valores de coluna.
Previsões categóricas	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, consulte as descrições do parâmetro nas seções Many-models pipeline e HTS pipeline.
Previsões de dados	O AutoML usa o valor mínimo de destino (`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:

SDK do Python
CLI do Azure

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

# Forecasting-specific settings.
# Auto-configure lags and rolling-window features.
forecasting:
    frequency: H
    target_aggregate_function: sum
    # Other settings.

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 usando o parâmetro n_cross_validations e configure o parâmetro cv_step_size para definir o deslocamento de tempo entre dobras. Para obter mais informações, consulte 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:

SDK do Python
CLI do Azure

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
)

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

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

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

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

# Use five CV folds.
n_cross_validations: 5

# Set the step size between folds to seven days.
forecasting:
    cv_step_size: 7
    # Other settings.

limits:
    # Limit settings.

training:
    # Training settings.

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. Você pode personalizar algumas etapas de pré-processamento usando a configuração de definição de recursos do trabalho de previsão.

A tabela a seguir lista as personalizações compatíveis 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, vamos supor que você tenha um cenário de demanda de varejo no qual os dados incluem preços, um on sale sinalizador e um tipo de produto. O exemplo a seguir mostra como você pode definir os tipos e insertores personalizados para esses recursos:

SDK do Python
CLI do Azure

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

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

experiment_name: cli-v2-automl-forecasting-job
description: A time-series forecasting AutoML job
task: forecasting

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

compute: azureml:cpu-compute

primary_metric: normalized_root_mean_squared_error
target_column_name: <target_column_name>
n_cross_validations: auto

# Customize imputation methods for price and is_on_sale features.
# Median value imputation for price, constant value of zero for is_on_sale.
featurization:
    mode: custom
    column_name_and_types:
        product_type: Categorical
    transformer_params:
        imputer:
            - fields: ["price"]
            parameters:
                strategy: median
            - fields: ["is_on_sale"]
            parameters:
                strategy: constant
                fill_value: 0

forecasting:
    # Forecasting-specific settings.

limits:
    # Limit settings.

training:
    # Training settings.

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

Enviar o trabalho de previsão

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

SDK do Python
CLI do Azure

# 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

No comando da CLI do Azure a seguir, a configuração yaml do trabalho está no diretório de trabalho atual no caminho ./automl-forecasting-job.yml. Se você executar o comando de um diretório diferente, precisará alterar o caminho conforme necessário.

run_id=$(az ml job create --file automl-forecasting-job.yml)

Você pode usar a ID de execução armazenada para retornar informações sobre o trabalho. O --web parâmetro abre a interface do usuário da Web do Azure Machine Learning Studio, na qual você pode ver detalhes sobre o trabalho:

az ml job show -n $run_id --web

Depois de enviar o trabalho, o AutoML provisionará os recursos de computação, aplicará a definição 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, consulte a 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 usando 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.

SDK do Python
CLI do Azure

O exemplo a seguir recupera 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 que orquestram treinamento, inferência e computação de métrica. Para obter mais informações, consulte Configurar o 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, crie 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

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

description: AutoML Forecasting Pipeline
experiment_name: cli-v2-automl-forecasting-pipeline

# Set default compute for pipeline steps.
settings:
    default_compute: cpu-compute

# Pipeline inputs.
inputs:
    train_data_input:
        type: mltable
        path: "./train_data"
    test_data_input:
        type: uri_folder
        path: "./test_data"
    target_column_name: <target column name>
    time_column_name: <time column name>
    forecast_horizon: <forecast horizon>
    primary_metric: normalized_root_mean_squared_error
    cv_folds: auto

# Set pipeline outputs.
# Output the evaluation metrics and raw test set rolling forecasts.
outputs: 
    metrics_result:
        type: uri_file
        mode: upload
    rolling_fcst_result:
        type: uri_file
        mode: upload

jobs:
  # Configure automl training node of pipeline.
    training_node:
        type: automl
        task: forecasting
        primary_metric: ${{parent.inputs.primary_metric}}
        target_column_name: ${{parent.inputs.target_column_name}}
        training_data: ${{parent.inputs.train_data_input}}
        n_cross_validations: ${{parent.inputs.cv_folds}}
        training:
            # Training settings.
        forecasting:
            time_column_name: ${{parent.inputs.time_column_name}}
            forecast_horizon: ${{parent.inputs.forecast_horizon}}
            # Other forecasting-specific settings.
        limits:
            # Limit settings.
        outputs:
            best_model:
                type: mlflow_model

    # Configure inference node to make rolling forecasts on test set.
    inference_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_forecasting_inference
        inputs:
            target_column_name: ${{parent.inputs.target_column_name}}
            forecast_mode: rolling
            step: 1
            test_data: ${{parent.inputs.test_data_input}}
            model_path: ${{parent.jobs.training_node.outputs.best_model}}
        outputs:
            inference_output_file: ${{parent.outputs.rolling_fcst_result}}
            evaluation_config_output_file:
                type: uri_file

    # Configure metrics calculation node.
    compute_metrics:
        type: command
        component: azureml://registries/azureml/compute_metrics
        inputs:
            task: "tabular-forecasting"
            ground_truth: ${{parent.jobs.inference_node.outputs.inference_output_file}}
            prediction: ${{parent.jobs.inference_node.outputs.inference_output_file}}
            evaluation_config: ${{parent.jobs.inference_node.outputs.evaluation_config_output_file}}
        outputs:
            evaluation_result: ${{parent.outputs.metrics_result}}

O AutoML requer dados de treinamento no formato MLTable.

Inicie a execução do pipeline usando o comando a seguir. A configuração do pipeline está no caminho ./automl-forecasting-pipeline.yml:

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

Depois de enviar a solicitação de execução, o pipeline executará o treinamento AutoML, a inferência de avaliação contínua e o cálculo de 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 sem interrupção e as métricas de avaliação para o diretório de trabalho local:

SDK do Python
CLI do Azure

# 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')

az ml job download --name $run_id --download-path . --output-name metrics_result
az ml job download --name $run_id --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 linhas JSON)

Para obter mais informações sobre a avaliação sem interrupção, 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 que você treine e gerencie milhões de modelos em paralelo. Para obter mais informações, consulte Muitos modelos.

Configuração de treinamento com múltiplos modelos

O componente de treinamento de múltiplos modelos aceita um arquivo de configuração no 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, além dos 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 de múltiplos 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`.

Aqui está 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, você definirá uma função de fábrica que cria pipelines para a orquestração de muitos modelos de treinamento, inferência e computação de métrica. A tabela a seguir descreve os parâmetros desta 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ó. A simultaneidade total de uma tarefa de muitos modelos é `max_nodes` * `max_concurrency_per_node`.
`parallel_step_timeout_in_seconds`	O tempo limite para muitos componentes de 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ê já executou diversos modelos anteriormente e que resultaram em falhas nos trabalhos de AutoML em certas partições de dados. Quando você habilita esse sinalizador, vários modelos só executam trabalhos de treinamento para 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, consulte 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, consulte 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 criar pipelines de treinamento e avaliação de modelo de muitos modelos:

SDK do Python
CLI do Azure

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
    }

Crie 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. 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)

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

description: AutoML Many Models Forecasting Pipeline
experiment_name: cli-v2-automl-mm-forecasting-pipeline

# Set default compute for pipeline steps.
settings:
    default_compute: azureml:cpu-compute

# Set pipeline inputs.
inputs:
    train_data_input:
        type: uri_folder
        path: "./train_data"
        mode: direct
    test_data_input:
        type: uri_folder
        path: "./test_data"
    automl_config_input:
        type: uri_file
        path: "./automl_settings_mm.yml"
    max_nodes: 4
    max_concurrency_per_node: 4
    parallel_step_timeout_in_seconds: 3700
    forecast_mode: rolling
    step: 1
    retrain_failed_model: False

# Set pipeline outputs.
# Output the evaluation metrics and raw test set rolling forecasts.
outputs: 
    metrics_result:
        type: uri_file
        mode: upload

jobs:
    # Configure AutoML many-models training component.
    mm_train_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_many_models_training
        inputs:
            raw_data: ${{parent.inputs.train_data_input}}
            automl_config: ${{parent.inputs.automl_config_input}}
            max_nodes: ${{parent.inputs.max_nodes}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
            retrain_failed_model: ${{parent.inputs.retrain_failed_model}}
        outputs:
            run_output:
                type: uri_folder

    # Configure inference node to make rolling forecasts on test set.
    mm_inference_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_many_models_inference
        inputs:
            raw_data: ${{parent.inputs.test_data_input}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
            forecast_mode: ${{parent.inputs.forecast_mode}}
            step: ${{parent.inputs.step}}
            max_nodes: ${{parent.inputs.max_nodes}}
            optional_train_metadata: ${{parent.jobs.mm_train_node.outputs.run_output}}
        outputs:
            run_output:
                type: uri_folder
            evaluation_configs:
                type: uri_file
            evaluation_data:
                type: uri_file

    # Configure metrics calculation node.
    compute_metrics:
        type: command
        component: azureml://registries/azureml/components/compute_metrics
        inputs:
            task: "tabular-forecasting"
            ground_truth: ${{parent.jobs.mm_inference_node.outputs.evaluation_data}}
            prediction: ${{parent.jobs.mm_inference_node.outputs.evaluation_data}}
            evaluation_config: ${{parent.jobs.mm_inference_node.outputs.evaluation_configs}}
        outputs:
            evaluation_result: ${{parent.outputs.metrics_result}}

Inicie o trabalho de pipeline com o comando a seguir. A configuração do pipeline de muitos modelos está no caminho ./automl-mm-forecasting-pipeline.yml:

az ml job create --file automl-mm-forecasting-pipeline.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>

Após o término da tarefa, você pode baixar as métricas de avaliação localmente usando o procedimento no pipeline de execução de treinamento único.

Para obter um exemplo mais detalhado, consulte a Previsão de Demanda usando o notebook Muitos Modelos.

Considerações de treinamento para uma execução com múltiplos modelos

Os componentes de treinamento e inferência de muitos modelos particionam condicionalmente seus dados de acordo com a configuração partition_column_names. Esse processo faz com que cada partição fique em seu próprio arquivo. O processo pode ser lento ou falhar quando você tiver muitos dados. Recomendamos que você particione seus dados manualmente antes de executar treinamento ou inferência de muitos modelos.
Durante o treinamento de muitos modelos, os modelos são registrados automaticamente no workspace, portanto, o registro manual de modelos não é necessário. Os modelos são nomeados com base na partição na qual foram treinados e esses nomes não são personalizáveis. As marcas também não são personalizáveis. Essas propriedades são usadas para detectar automaticamente modelos durante a inferência.
Implantar modelos individuais não é escalonável, mas você pode usar PipelineComponentBatchDeployment para facilitar o processo de implantação. Para obter um exemplo, consulte a Previsão de Demanda usando o notebook Muitos Modelos.
Durante a inferência, os modelos apropriados (a versão mais recente) são selecionados automaticamente com base na partição enviada nos dados de inferência. Por padrão, quando você usa training_experiment_name, o modelo mais recente é utilizado, mas você pode substituir esse comportamento selecionando modelos de uma execução de treinamento específica ao fornecer train_run_id também.

Observação

O limite de paralelismo padrão para muitos modelos executados em uma assinatura é 320. Se sua carga de trabalho exigir um limite mais alto, 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 que estão em uma 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 executada. Esse arquivo YAML tem a mesma especificação que o trabalho de comando previsão, mas inclui outros parâmetros relacionados às informações da 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.

Aqui está 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, defina uma função de fábrica que cria pipelines para a orquestração do treinamento, da inferência e da computação de métricas do HTS. A tabela a seguir descreve os parâmetros desta função de fábrica:

Parâmetro	Descrição
`forecast_level`	O nível da hierarquia para o qual as previsões devem ser recuperadas.
`allocation_method`	O método de alocação a ser usado 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 serem usados no trabalho de treinamento.
`max_concurrency_per_node`	O número de processos AutoML a serem executado 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 muitos modelos, especificado em segundos.
`forecast_mode`	O modo de inferência para avaliação de modelo. 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 da etapa para a previsão sem interrupção. 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.

SDK do Python
CLI do Azure

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
    }

Crie 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. 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)

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

description: AutoML Many Models Forecasting Pipeline
experiment_name: cli-v2-automl-mm-forecasting-pipeline

# Set the default compute for pipeline steps.
settings:
    default_compute: cpu-compute

# Set pipeline inputs.
inputs:
    train_data_input:
        type: uri_folder
        path: "./train_data"
        mode: direct
    test_data_input:
        type: uri_folder
        path: "./test_data"
    automl_config_input:
        type: uri_file
        path: "./automl_settings_hts.yml"
    max_concurrency_per_node: 4
    parallel_step_timeout_in_seconds: 3700
    max_nodes: 4
    forecast_mode: rolling
    step: 1
    allocation_method: proportions_of_historical_average
    forecast_level: # forecast level

# Set pipeline outputs.
# Output evaluation metrics and raw test set rolling forecasts.
outputs: 
    metrics_result:
        type: uri_file
        mode: upload

jobs:
    # Configure AutoML many-models training component.
    hts_train_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_hts_training
        inputs:
            raw_data: ${{parent.inputs.train_data_input}}
            automl_config: ${{parent.inputs.automl_config_input}}
            max_nodes: ${{parent.inputs.max_nodes}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
        outputs:
            run_output:
                type: uri_folder


    # Configure inference node to make rolling forecasts on test set.
    hts_inference_node:
        type: command
        component: azureml://registries/azureml-preview/components/automl_hts_inference
        inputs:
            raw_data: ${{parent.inputs.test_data_input}}
            max_concurrency_per_node: ${{parent.inputs.max_concurrency_per_node}}
            parallel_step_timeout_in_seconds: ${{parent.inputs.parallel_step_timeout_in_seconds}}
            forecast_mode: ${{parent.inputs.forecast_mode}}
            step: ${{parent.inputs.step}}
            max_nodes: ${{parent.inputs.max_nodes}}
            optional_train_metadata: ${{parent.jobs.hts_train_node.outputs.run_output}}
            forecast_level: ${{parent.inputs.forecast_level}}
            allocation_method: ${{parent.inputs.allocation_method}}
        outputs:
            run_output:
                type: uri_folder
            evaluation_configs:
                type: uri_file
            evaluation_data:
                type: uri_file

    # Configure metrics calculation node.
    compute_metrics:
        type: command
        component: azureml://registries/azureml/components/compute_metrics
        inputs:
            task: "tabular-forecasting"
            ground_truth: ${{parent.jobs.hts_inference_node.outputs.evaluation_data}}
            prediction: ${{parent.jobs.hts_inference_node.outputs.evaluation_data}}
            evaluation_config: ${{parent.jobs.hts_inference_node.outputs.evaluation_configs}}
        outputs:
            evaluation_result: ${{parent.outputs.metrics_result}}

Para iniciar o trabalho do pipeline, use o seguinte comando. A configuração de pipeline de muitos modelos está no caminho ./automl-hts-forecasting-pipeline.yml.

az ml job create --file automl-hts-forecasting-pipeline.yml -w <Workspace> -g <Resource Group> --subscription <Subscription>

Após o término da tarefa, você pode baixar as métricas de avaliação localmente usando o procedimento no pipeline de execução de treinamento único.

Para obter um exemplo mais detalhado, consulte a Previsão de Demanda usando o notebook HTS.

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 hierarchy_column_names configuração para que cada partição esteja em seu próprio arquivo. Esse processo pode ser lento ou falhar quando você tiver muitos dados. Recomendamos que você particione seus dados manualmente antes de executar o treinamento ou inferência do HTS.

Observação

O limite de paralelismo padrão para uma execução de HTS em uma assinatura é 320. Se sua carga de trabalho exigir um limite mais alto, 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, consulte o Treinamento de rede neural profunda distribuída (versão preliminar).

Para cenários que exigem grandes quantidades de dados, o treinamento distribuído com AutoML está disponível para um conjunto limitado de modelos. Você pode encontrar mais informações e exemplos de código em 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 do GitHub Notebooks de amostra de previsão do AutoML. Aqui estão alguns dos notebooks de exemplo:

Comentários

Esta página foi útil?

Last updated on 2025-12-03

Compartilhar via

Configurar o AutoML para treinar um modelo de previsão de série temporal usando o SDK e a CLI

Pré-requisitos

Preparar dados de treinamento e validação

Criar computação para executar o experimento

Configurar o experimento

Configurações do trabalho de previsão

Configurações opcionais do trabalho de previsão

Configurações de pesquisa de modelo

Habilitar o aprendizado para redes neurais profundas

Recursos de latência e janela sem interrupção

Manipulação de séries curtas

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

Configurações de validação cruzada personalizadas

Definição de recursos personalizada

Enviar o trabalho de previsão

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

Previsão em escala: muitos modelos

Configuração de treinamento com múltiplos modelos

Pipeline de muitos modelos

Considerações de treinamento para uma execução com múltiplos modelos

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

Configuração de treinamento do HTS

Pipeline do HTS

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

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

Explorar notebooks de exemplo

Conteúdo relacionado

Comentários

Recursos adicionais