Partilhar via

Configurar o AutoML para treinar um modelo de previsão de séries cronológicas com SDK e CLI

  • Artigo

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

O Aprendizado de Máquina Automatizado (AutoML) no Aprendizado de Máquina do Azure usa modelos padrão de aprendizado de máquina 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 cronológicas com o Aprendizado de Máquina usando o SDK Python do Azure Machine Learning](/python/api/overview/azure/ai-ml-readme). O processo inclui a preparação de dados para treinamento e a configuração de parâmetros de séries temporais em um trabalho 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 recurso é um exemplo de previsão de série temporal que usa o AutoML no estúdio do Azure Machine Learning.

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 todos os recursos usados no treinamento também possam ser usados ao executar previsões para o horizonte pretendido.

Considere um recurso para o preço atual das ações, que pode aumentar enormemente a precisão do treinamento. Se você fizer previsões com um horizonte longo, talvez não seja capaz de prever com precisão os valores futuros das ações que correspondem aos pontos de séries temporais futuras. 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 obter mais informações e casos de uso, consulte [Trabalhando com tabelas(how-to-mltable.md).

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

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

import mltable

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

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

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

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

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

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

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 experimento

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

from azure.ai.ml.entities import AmlCompute

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

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

Configurar 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 a seguir mostra como definir as colunas de ID de série temporal assumindo que os dados contêm colunas denominadas 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 revisadas na seção a seguir.

Configurações opcionais do trabalho de previsão

Configurações opcionais estão disponíveis para tarefas de previsão, como habilitar o aprendizado profundo e especificar uma agregação de janela contínua de 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 onde 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 como mostrado no exemplo a seguir:

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

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

# 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 geralmente alcança maior precisão do que os modelos de séries temporais padrão quando há milhares ou mais observações no histórico de treinamento. No entanto, também leva mais tempo para treinar e varrer os modelos TCNForecaster devido à sua maior capacidade.

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

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

Por padrão, o treinamento TCNForecaster é limitado a um único nó de computação e 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 habilitar a DNN para um experimento AutoML criado no estúdio do Azure Machine Learning, consulte as configurações de tipo de tarefa no tutorial da interface do usuário do estúdio.

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 no Automated Machine Learning 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.

Recursos 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 recursos de agregação de janelas com atraso de tempo e rolagem 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 em 8 de setembro de 2017 às 4h00, os valores máximo, mínimo e soma são calculados usando os valores de demanda para 8 de setembro de 2017, das 1h00 às 3h00. 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.

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

Você pode habilitar os recursos de agregação de janelas de atraso e rolagem para o destino definindo o tamanho da janela rolante e as ordens de atraso que deseja criar. O tamanho da janela era três no exemplo anterior. Você também pode ativar atrasos para recursos com a feature_lags configuraçã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. Essas ações são configuráveis com a short_series_handling_config configuraçã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, pad com NaNs
- Colunas numéricas, almofada com 0 (zero)
- Colunas booleanas/lógicas, almofada 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 a seguir define a manipulação de séries curtas para que todas as séries curtas sejam acolchoadas com o 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 treinamento. 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:

Function Description
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:

Column Método de agregação
Preditores numéricos O AutoML usa as sumfunções , mean, min, e max . Ele gera novas colunas, onde cada nome de coluna inclui um sufixo que identifica o nome da função de agregação aplicada aos valores de coluna.
Preditores categóricos O AutoML usa o valor do forecast_mode parâmetro para agregar os dados. É a categoria mais proeminente na janela. Para obter mais informações, consulte as descrições do parâmetro nas seções Muitos modelos pipeline e HTS pipeline .
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 com 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 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 obter mais informações, consulte Engenharia de recursos automatizada. Algumas das etapas de pré-processamento podem ser personalizadas usando a configuração de featurização do trabalho de previsão.

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

Personalização Description 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.

Enviar 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 obter mais informações, consulte a metodologia de previsão em AutoML e Varredura e seleção de modelos para previsão em AutoML.

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

Seu fluxo de trabalho de aprendizado de máquina provavelmente requer mais do que apenas treinamento. 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Defina as entradas de dados de 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 enviar a solicitação de execução, o pipeline executa o treinamento AutoML, a inferência de avaliação contínua e o cálculo métrico 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 de linhas JSON)

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 muitos componentes de modelos no AutoML permitem treinar e gerenciar milhões de modelos em paralelo. Para obter mais informações sobre muitos conceitos de modelos, consulte Muitos modelos.

Configuração de treinamento de muitos modelos

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

Parâmetro Description
partition_column_names Nomes de colunas nos dados que, quando agrupados, definem as partições de dados. O componente de treinamento de muitos modelos lança 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 predefinido é false.

O exemplo a seguir fornece 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 de muitos modelos

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

Parâmetro Description
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ó. Assim, a simultaneidade total de muitos trabalhos de modelos é max_nodes * max_concurrency_per_node.
parallel_step_timeout_in_seconds O tempo limite do componente de muitos modelos é especificado em número de segundos.
retrain_failed_models Sinalizador para permitir o retreinamento de modelos com falha. Esse valor é útil se você fez execuções anteriores de muitos modelos que resultaram em trabalhos de AutoML com falha em algumas partições de dados. Quando você habilita esse sinalizador, muitos modelos só iniciam trabalhos de treinamento para partições com falha anterior.
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 da etapa 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 a seguir demonstra um método de fábrica para construir muitos pipelines de treinamento e avaliação de modelos de modelos:

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

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

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

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

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

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

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

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

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

Construa a tubulação com a função de fábrica. Os dados de treinamento e teste estão nas pastas locais ./data/train e ./data/test, respectivamente. 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)

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

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

Considerações de treinamento para muitos modelos executados

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

Nota

O limite de paralelismo padrão para muitos modelos executados em uma assinatura é definido como 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 treinar um grande número de modelos em dados com 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 essas configurações a cada instância do AutoML que inicia. Este arquivo YAML tem a mesma especificação que o trabalho de comando Forecasting, além de outros parâmetros relacionados às informações de hierarquia:

Parâmetro Description
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.

O exemplo a seguir fornece 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

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

Parâmetro Description
forecast_level O nível da hierarquia para o qual recuperar previsões.
allocation_method Método de repartição a utilizar quando as previsões são desagregadas. Os valores válidos são proportions_of_historical_average e average_historical_proportions.
max_nodes Número de nós de computação a serem usados no trabalho de treinamento.
max_concurrency_per_node Número de processos AutoML a serem executados em cada nó. Assim, a simultaneidade 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 número de segundos.
forecast_mode Modo de inferência para avaliação do 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 Tamanho da etapa 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 HTSInferenceParameters. 
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

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

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

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

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

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

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

Construa o pipeline usando a função de fábrica. Os dados de treinamento e teste estão nas pastas locais ./data/train e ./data/test, respectivamente. 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)

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

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

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

Os componentes de treinamento e inferência 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. Este processo pode ser muito lento ou falhar quando os dados são muito grandes. A abordagem recomendada é particionar seus dados manualmente antes de executar o treinamento ou a inferência do HTS.

Nota

O limite de paralelismo padrão para uma execução HTS dentro de uma assinatura é definido como 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 com grandes requisitos 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 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