Treinar um modelo de previsão

Nesta página, mostramos como treinar um modelo de previsão com base em um conjunto de dados tabular usando o console do Google Cloud ou a API Vertex AI.

Antes de começar

Antes de treinar um modelo de estimativa, é preciso concluir as seguintes etapas:

Treinar um modelo

Console do Google Cloud

  1. No Console do Google Cloud, na seção da Vertex AI, acesse a página Conjuntos de dados.

    Acessar a página "Conjuntos de dados"

  2. Clique no nome do conjunto de dados que você quer usar para treinar seu modelo para abrir a página de detalhes.

  3. Se o tipo de dados usar conjuntos de anotações, selecione o conjunto que você quer usar neste modelo.

  4. Clique em Treinar novo modelo.

  5. Selecione Outras.

  6. Na página Método de treinamento, configure da seguinte maneira:

    1. Selecione o método de treinamento do modelo. Para saber mais, consulte Métodos de treinamento de modelo.

    2. Clique em Continuar.

  7. Na página Detalhes do modelo, configure o seguinte:

    1. Digite o nome de exibição do novo modelo.

    2. Selecione a coluna de destino.

      A coluna de destino é o valor que o modelo fará a previsão. Saiba mais sobre os requisitos da coluna de destino.

    3. Se você não definiu as colunas Identificador de série e Carimbo de data/hora no conjunto de dados, selecione-as agora.

    4. Selecione a Granularidade de dados. Selecione Daily se quiser usar uma modelagem de efeito de datas comemorativas. Saiba como escolher a granularidade dos dados.

    5. Opcional: no menu suspenso Regiões de feriados, escolha uma ou mais regiões geográficas para ativar a modelagem de efeitos de feriados. Durante o treinamento, a Vertex AI cria recursos categóricos de datas comemorativas de acordo com o modelo com base na data da coluna de tempo e nas regiões geográficas especificadas. Só é possível selecionar essa opção quando a Granularidade de dados está definida como Daily. Por padrão, a modelagem de efeitos de datas comemorativas está desativada. Para saber mais sobre as regiões geográficas usadas para a modelagem de efeitos de feriados, consulte Regiões de feriados.

    6. Insira a Janela de contexto e o Horizonte de previsão.

      O horizonte de previsão determina em que ponto do modelo o valor desejado será determinado para cada linha de dados de previsão. O horizonte de previsão é especificado em unidades da granularidade de dados.

      A janela de contexto define o período de deslocamento do modelo durante o treinamento (e as previsões). Em outras palavras, para cada ponto de dados de treinamento, a janela de contexto determina até onde o modelo procura padrões preditivos. A janela de contexto é especificada nas unidades de granularidade de dados.

      Saiba mais.

    7. Se você quiser exportar o conjunto de dados de teste para o BigQuery, marque Exportar conjunto de dados de teste para o BigQuery e forneça o nome da tabela.

    8. Se você quiser controlar manualmente a divisão de dados ou configurar a janela de previsão, abra as Opções avançadas.

    9. A divisão de dados padrão é cronológica, com as porcentagens padrão de 80/10/10. Se quiser especificar manualmente quais linhas são atribuídas a cada divisão, selecione Manual e especifique a coluna de divisão de dados.

      Saiba mais sobre as divisões de dados.

    10. Selecione uma estratégia de janela contínua para a geração da janela de previsão. A estratégia padrão é Contagem.

      • Count: Defina o valor para o número máximo de janelas na caixa de texto fornecida.
      • Stride: Defina o valor do tamanho da passada na caixa de texto fornecida.
      • Column: Selecione o nome da coluna apropriada no menu suspenso fornecido.

      Para saber mais, consulte Estratégias de janela contínua.

    11. Clique em Continuar.

  8. Na página Opções de treinamento, configure da seguinte maneira:

    1. Clique em Gerar estatísticas se ainda não tiver feito isso.

      A geração de estatísticas preenche os menus suspensos Transformação.

    2. Analise a lista de colunas e exclua as colunas do treinamento que não podem ser usadas para treinar o modelo.

      Se você usar uma coluna de divisão de dados, ela precisa ser incluída.

    3. Revise as transformações selecionadas para os atributos incluídos e faça as atualizações necessárias.

      As linhas que contêm dados inválidos para a transformação selecionada são excluídas do treinamento. Saiba mais sobre transformações.

    4. Para cada coluna incluída no treinamento, especifique o Tipo de atributo para saber como ele está relacionado à série temporal e se ele está disponível no momento da previsão. Saiba mais sobre tipo e disponibilidade de recursos.

    5. Caso queira especificar uma coluna de peso, mudar o objetivo de otimização do padrão ou ativar a previsão hierárquica, abra Opções avançadas.

    6. Opcional. Se você quiser especificar uma coluna de peso, selecione-a na lista suspensa. Saiba mais sobre colunas de peso.

    7. Opcional. Se você quiser escolher o objetivo de otimização, escolha-o na lista. Saiba mais sobre os objetivos de otimização.

    8. Opcional. Se você quiser usar a previsão hierárquica, selecione Ativar previsão hierárquica. É possível escolher entre três opções de agrupamento:

      • No grouping
      • Group by columns
      • Group all

      Também é possível definir os seguintes pesos agregados para perda:

      • Group total weight. Esse campo só poderá ser definido se você selecionar a opção Group by columns ou Group all.
      • Temporal total weight.
      • Group temporal total weight. Esse campo só poderá ser definido se você selecionar a opção Group by columns ou Group all.

      Saiba mais sobre a estimativa hierárquica.

    9. Clique em Continuar.

  9. Na página Computação e preços, configure da seguinte maneira:

    1. Insira o número máximo de horas que você quer que o modelo treine. Essa configuração ajuda a limitar os custos de treinamento. O tempo decorrido real pode ser maior do que esse valor, porque há outras operações envolvidas na criação de um novo modelo.

      O tempo de treinamento sugerido está relacionado ao tamanho do horizonte da previsão e aos dados de treinamento. A tabela abaixo apresenta algumas amostras de execuções de treinamento e o tempo de treinamento necessários para treinar um modelo de alta qualidade.

      Linhas Recursos Horizonte de previsão Tempo de treinamento
      12 milhões 10 6 3-6 horas
      20 milhões 50 13 6-12 horas
      16 milhões 30 365 24-48 horas

      Para mais informações sobre preços de treinamento, consulte a página de preços.

    2. Clique em Iniciar treinamento.

      O treinamento do modelo pode levar muitas horas dependendo do tamanho e da complexidade dos dados, além do orçamento de treinamento, se você tiver especificado um. Você pode fechar essa guia e voltar a ela mais tarde. Você receberá um e-mail quando o treinamento do seu modelo for concluído.

API

Selecione uma guia para seu idioma ou ambiente:

REST

Use o comando trainingPipelines.create para treinar um modelo.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION: sua região.
  • PROJECT: o ID do projeto.
  • TRAINING_PIPELINE_DISPLAY_NAME: nome de exibição do pipeline de treinamento criado para esta operação.
  • TRAINING_TASK_DEFINITION: o método de treinamento de modelo.
    • Codificador denso de série temporal (TiDE)
      gs://google-cloud-aiplatform/schema/trainingjob/definition/time_series_dense_encoder_forecasting_1.0.0.yaml
    • Transformador de fusão temporal (TFT)
      gs://google-cloud-aiplatform/schema/trainingjob/definition/temporal_fusion_transformer_time_series_forecasting_1.0.0.yaml
    • AutoML (L2L)
      gs://google-cloud-aiplatform/schema/trainingjob/definition/automl_forecasting_1.0.0.yaml
    • Seq2Seq+
      gs://google-cloud-aiplatform/schema/trainingjob/definition/seq2seq_plus_time_series_forecasting_1.0.0.yaml
    Para saber mais, consulte Métodos de treinamento de modelo.
  • TARGET_COLUMN: a coluna (valor) que você quer que esse modelo preveja.
  • TIME_COLUMN: A coluna Data/hora Saiba mais.
  • TIME_SERIES_IDENTIFIER_COLUMN: a coluna do identificador de série temporal. Saiba mais.
  • WEIGHT_COLUMN: (opcional) a coluna de peso. Saiba mais
  • TRAINING_BUDGET: o tempo máximo que você quer que o modelo seja treinado, em mil horas de uso do nó (1.000 horas de uso do nó equivalem a uma hora de uso do nó).
  • GRANULARITY_UNIT: a unidade a ser usada para a granularidade dos dados de treinamento e o horizonte da previsão e a janela de contexto. Pode ser minute, hour, day, week, month ou year. Selecione day se quiser usar uma modelagem de efeito de datas comemorativas. Saiba como escolher a granularidade dos dados.
  • GRANULARITY_QUANTITY: o número de unidades de granularidade que compõem o intervalo entre as observações nos dados de treinamento. Precisa ser uma para todas as unidades, exceto minutos, que pode ser 1, 5, 10, 15 ou 30. Saiba como escolher a granularidade dos dados.
  • GROUP_COLUMNS: nomes de colunas na tabela de entrada de treinamento que identificam o agrupamento para o nível de hierarquia. As colunas precisam ser "time_series_attribute_columns". Saiba mais.
  • GROUP_TOTAL_WEIGHT: peso da perda agregada do grupo em relação à perda individual. Desativado se for definido como "0.0" ou não for definido. Se a coluna de grupo não for definida, todas as séries temporais serão tratadas como parte do mesmo grupo e serão agregadas em todas as séries temporais. Saiba mais.
  • TEMPORAL_TOTAL_WEIGHT: peso da perda agregada do tempo em relação à perda individual. Desativado se for definido como "0.0" ou não for definido. Saiba mais.
  • GROUP_TEMPORAL_TOTAL_WEIGHT: ponderação do total de perda agregada (grupo x tempo) em relação à perda individual. Desativado se for definido como "0.0" ou não for definido. Se a coluna de grupo não for definida, todas as séries temporais serão tratadas como parte do mesmo grupo e serão agregadas em todas as séries temporais. Saiba mais.
  • HOLIDAY_REGIONS: (opcional) é possível selecionar uma ou mais regiões geográficas para ativar a modelagem de efeitos de feriados. Durante o treinamento, a Vertex AI cria atributos categóricos de fim de ano no modelo com base na data de TIME_COLUMN e nas regiões geográficas especificadas. Para ativá-lo, defina GRANULARITY_UNIT como day e especifique uma ou mais regiões no campo HOLIDAY_REGIONS. Por padrão, a modelagem de efeitos de datas comemorativas está desativada. Para saber mais, consulte Regiões de férias.
  • FORECAST_HORIZON: o horizonte de previsão determina em que ponto do modelo o valor desejado será determinado para cada linha de dados de previsão. O horizonte da previsão é especificado em unidades de granularidade de dados (GRANULARITY_UNIT). Saiba mais.
  • CONTEXT_WINDOW: a janela de contexto define o período de deslocamento do modelo durante o treinamento (e as previsões). Em outras palavras, para cada ponto de dados de treinamento, a janela de contexto determina até onde o modelo procura padrões preditivos. A janela de contexto é especificada em unidades de granularidade de dados (GRANULARITY_UNIT). Saiba mais.
  • OPTIMIZATION_OBJECTIVE: por padrão, a Vertex AI minimiza a raiz do erro médio quadrático (RMSE, na sigla em inglês). Se você quiser um objetivo de otimização diferente para seu modelo de previsão, escolha uma das opções em Objetivos de otimização para modelos de previsão. Se você optar por minimizar a perda de quantil, também vai precisar especificar um valor para QUANTILES.
  • PROBABILISTIC_INFERENCE: (opcional) se definido como true, a Vertex AI modela a distribuição de probabilidade da previsão. A inferência probabilística pode melhorar a qualidade do modelo ao processar dados com ruído e quantificar a incerteza. Se QUANTILES forem especificados, a Vertex AI também vai retornar os quantis da distribuição de probabilidade. A inferência probabilística só é compatível com Time series Dense Encoder (TiDE) and the AutoML (L2L) training methods. It is incompatible with hierarchical forecasting and the minimize-quantile-loss optimization objective.
  • QUANTILES: Quantiles to use for the minimize-quantile-loss optimization objective and probabilistic inference. Provide a list of up to five unique numbers between 0 and 1, exclusive.
  • TIME_SERIES_ATTRIBUTE_COL: The name or names of the columns that are time series attributes. Learn more.
  • AVAILABLE_AT_FORECAST_COL: The name or names of the covariate columns whose value is known at forecast time. Learn more.
  • UNAVAILABLE_AT_FORECAST_COL: The name or names of the covariate columns whose value is unknown at forecast time. Learn more.
  • TRANSFORMATION_TYPE: The transformation type is provided for each column used to train the model. Learn more.
  • COLUMN_NAME: The name of the column with the specified transformation type. Every column used to train the model must be specified.
  • MODEL_DISPLAY_NAME: Display name for the newly trained model.
  • DATASET_ID: ID for the training Dataset.
  • You can provide a Split object to control your data split. For information about controlling data split, see Control the data split using REST.
  • You can provide a windowConfig object to configure a rolling window strategy for forecast window generation. For further information, see Configure the rolling window strategy using REST.
  • PROJECT_NUMBER: Your project's automatically generated project number

HTTP method and URL: 

POST http://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/trainingPipelines

Request JSON body: 

{
    "displayName": "TRAINING_PIPELINE_DISPLAY_NAME",
    "trainingTaskDefinition": "TRAINING_TASK_DEFINITION",
    "trainingTaskInputs": {
        "targetColumn": "TARGET_COLUMN",
        "timeColumn": "TIME_COLUMN",
        "timeSeriesIdentifierColumn": "TIME_SERIES_IDENTIFIER_COLUMN",
        "weightColumn": "WEIGHT_COLUMN",
        "trainBudgetMilliNodeHours": TRAINING_BUDGET,
        "dataGranularity": {"unit": "GRANULARITY_UNIT", "quantity": GRANULARITY_QUANTITY},
        "hierarchyConfig": {"groupColumns": GROUP_COLUMNS, "groupTotalWeight": GROUP_TOTAL_WEIGHT, "temporalTotalWeight": TEMPORAL_TOTAL_WEIGHT, "groupTemporalTotalWeight": GROUP_TEMPORAL_TOTAL_WEIGHT}
        "holidayRegions" : ["HOLIDAY_REGIONS_1", "HOLIDAY_REGIONS_2", ...]
        "forecast_horizon": FORECAST_HORIZON,
        "context_window": CONTEXT_WINDOW,
        "optimizationObjective": "OPTIMIZATION_OBJECTIVE",
        "quantiles": "QUANTILES",
        "enableProbabilisticInference": "PROBABILISTIC_INFERENCE",
        "time_series_attribute_columns": ["TIME_SERIES_ATTRIBUTE_COL_1", "TIME_SERIES_ATTRIBUTE_COL_2", ...]
        "available_at_forecast_columns": ["AVAILABLE_AT_FORECAST_COL_1", "AVAILABLE_AT_FORECAST_COL_2", ...]
        "unavailable_at_forecast_columns": ["UNAVAILABLE_AT_FORECAST_COL_1", "UNAVAILABLE_AT_FORECAST_COL_2", ...]
        "transformations": [
            {"TRANSFORMATION_TYPE_1":  {"column_name" : "COLUMN_NAME_1"} },
            {"TRANSFORMATION_TYPE_2":  {"column_name" : "COLUMN_NAME_2"} },
            ...
    },
    "modelToUpload": {"displayName": "MODEL_DISPLAY_NAME"},
    "inputDataConfig": {
      "datasetId": "DATASET_ID",
    }
}

To send your request, expand one of these options:

You should receive a JSON response similar to the following:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/trainingPipelines/TRAINING_PIPELINE_ID",
  "displayName": "myModelName",
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/automl_tabular_1.0.0.yaml",
  "modelToUpload": {
    "displayName": "myModelName"
  },
  "state": "PIPELINE_STATE_PENDING",
  "createTime": "2020-08-18T01:22:57.479336Z",
  "updateTime": "2020-08-18T01:22:57.479336Z"
}

Python

To learn how to install or update the Vertex AI SDK for Python, see Install the Vertex AI SDK for Python. For more information, see the Python API reference documentation. 

def create_training_pipeline_forecasting_time_series_dense_encoder_sample(
    project: str,
    display_name: str,
    dataset_id: str,
    location: str = "us-central1",
    model_display_name: str = "my_model",
    target_column: str = "target_column",
    time_column: str = "date",
    time_series_identifier_column: str = "time_series_id",
    unavailable_at_forecast_columns: List[str] = [],
    available_at_forecast_columns: List[str] = [],
    forecast_horizon: int = 1,
    data_granularity_unit: str = "week",
    data_granularity_count: int = 1,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    budget_milli_node_hours: int = 8000,
    timestamp_split_column_name: str = "timestamp_split",
    weight_column: str = "weight",
    time_series_attribute_columns: List[str] = [],
    context_window: int = 0,
    export_evaluated_data_items: bool = False,
    export_evaluated_data_items_bigquery_destination_uri: Optional[str] = None,
    export_evaluated_data_items_override_destination: bool = False,
    quantiles: Optional[List[float]] = None,
    enable_probabilistic_inference: bool = False,
    validation_options: Optional[str] = None,
    predefined_split_column_name: Optional[str] = None,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    # Create training job
    forecasting_tide_job = aiplatform.TimeSeriesDenseEncoderForecastingTrainingJob(
        display_name=display_name,
        optimization_objective="minimize-rmse",
    )

    # Retrieve existing dataset
    dataset = aiplatform.TimeSeriesDataset(dataset_id)

    # Run training job
    model = forecasting_tide_job.run(
        dataset=dataset,
        target_column=target_column,
        time_column=time_column,
        time_series_identifier_column=time_series_identifier_column,
        unavailable_at_forecast_columns=unavailable_at_forecast_columns,
        available_at_forecast_columns=available_at_forecast_columns,
        forecast_horizon=forecast_horizon,
        data_granularity_unit=data_granularity_unit,
        data_granularity_count=data_granularity_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        predefined_split_column_name=predefined_split_column_name,
        timestamp_split_column_name=timestamp_split_column_name,
        weight_column=weight_column,
        time_series_attribute_columns=time_series_attribute_columns,
        context_window=context_window,
        export_evaluated_data_items=export_evaluated_data_items,
        export_evaluated_data_items_bigquery_destination_uri=export_evaluated_data_items_bigquery_destination_uri,
        export_evaluated_data_items_override_destination=export_evaluated_data_items_override_destination,
        quantiles=quantiles,
        enable_probabilistic_inference=enable_probabilistic_inference,
        validation_options=validation_options,
        budget_milli_node_hours=budget_milli_node_hours,
        model_display_name=model_display_name,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Python

To learn how to install or update the Vertex AI SDK for Python, see Install the Vertex AI SDK for Python. For more information, see the Python API reference documentation. 

def create_training_pipeline_forecasting_temporal_fusion_transformer_sample(
    project: str,
    display_name: str,
    dataset_id: str,
    location: str = "us-central1",
    model_display_name: str = "my_model",
    target_column: str = "target_column",
    time_column: str = "date",
    time_series_identifier_column: str = "time_series_id",
    unavailable_at_forecast_columns: List[str] = [],
    available_at_forecast_columns: List[str] = [],
    forecast_horizon: int = 1,
    data_granularity_unit: str = "week",
    data_granularity_count: int = 1,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    budget_milli_node_hours: int = 8000,
    timestamp_split_column_name: str = "timestamp_split",
    weight_column: str = "weight",
    time_series_attribute_columns: List[str] = [],
    context_window: int = 0,
    export_evaluated_data_items: bool = False,
    export_evaluated_data_items_bigquery_destination_uri: Optional[str] = None,
    export_evaluated_data_items_override_destination: bool = False,
    validation_options: Optional[str] = None,
    predefined_split_column_name: Optional[str] = None,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    # Create training job
    forecasting_tft_job = aiplatform.TemporalFusionTransformerForecastingTrainingJob(
        display_name=display_name,
        optimization_objective="minimize-rmse",
    )

    # Retrieve existing dataset
    dataset = aiplatform.TimeSeriesDataset(dataset_id)

    # Run training job
    model = forecasting_tft_job.run(
        dataset=dataset,
        target_column=target_column,
        time_column=time_column,
        time_series_identifier_column=time_series_identifier_column,
        unavailable_at_forecast_columns=unavailable_at_forecast_columns,
        available_at_forecast_columns=available_at_forecast_columns,
        forecast_horizon=forecast_horizon,
        data_granularity_unit=data_granularity_unit,
        data_granularity_count=data_granularity_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        predefined_split_column_name=predefined_split_column_name,
        timestamp_split_column_name=timestamp_split_column_name,
        weight_column=weight_column,
        time_series_attribute_columns=time_series_attribute_columns,
        context_window=context_window,
        export_evaluated_data_items=export_evaluated_data_items,
        export_evaluated_data_items_bigquery_destination_uri=export_evaluated_data_items_bigquery_destination_uri,
        export_evaluated_data_items_override_destination=export_evaluated_data_items_override_destination,
        validation_options=validation_options,
        budget_milli_node_hours=budget_milli_node_hours,
        model_display_name=model_display_name,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Python

To learn how to install or update the Vertex AI SDK for Python, see Install the Vertex AI SDK for Python. For more information, see the Python API reference documentation. 

def create_training_pipeline_forecasting_sample(
    project: str,
    display_name: str,
    dataset_id: str,
    location: str = "us-central1",
    model_display_name: str = "my_model",
    target_column: str = "target_column",
    time_column: str = "date",
    time_series_identifier_column: str = "time_series_id",
    unavailable_at_forecast_columns: List[str] = [],
    available_at_forecast_columns: List[str] = [],
    forecast_horizon: int = 1,
    data_granularity_unit: str = "week",
    data_granularity_count: int = 1,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    budget_milli_node_hours: int = 8000,
    timestamp_split_column_name: str = "timestamp_split",
    weight_column: str = "weight",
    time_series_attribute_columns: List[str] = [],
    context_window: int = 0,
    export_evaluated_data_items: bool = False,
    export_evaluated_data_items_bigquery_destination_uri: Optional[str] = None,
    export_evaluated_data_items_override_destination: bool = False,
    quantiles: Optional[List[float]] = None,
    enable_probabilistic_inference: bool = False,
    validation_options: Optional[str] = None,
    predefined_split_column_name: Optional[str] = None,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    # Create training job
    forecasting_job = aiplatform.AutoMLForecastingTrainingJob(
        display_name=display_name, optimization_objective="minimize-rmse"
    )

    # Retrieve existing dataset
    dataset = aiplatform.TimeSeriesDataset(dataset_id)

    # Run training job
    model = forecasting_job.run(
        dataset=dataset,
        target_column=target_column,
        time_column=time_column,
        time_series_identifier_column=time_series_identifier_column,
        unavailable_at_forecast_columns=unavailable_at_forecast_columns,
        available_at_forecast_columns=available_at_forecast_columns,
        forecast_horizon=forecast_horizon,
        data_granularity_unit=data_granularity_unit,
        data_granularity_count=data_granularity_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        predefined_split_column_name=predefined_split_column_name,
        timestamp_split_column_name=timestamp_split_column_name,
        weight_column=weight_column,
        time_series_attribute_columns=time_series_attribute_columns,
        context_window=context_window,
        export_evaluated_data_items=export_evaluated_data_items,
        export_evaluated_data_items_bigquery_destination_uri=export_evaluated_data_items_bigquery_destination_uri,
        export_evaluated_data_items_override_destination=export_evaluated_data_items_override_destination,
        quantiles=quantiles,
        enable_probabilistic_inference=enable_probabilistic_inference,
        validation_options=validation_options,
        budget_milli_node_hours=budget_milli_node_hours,
        model_display_name=model_display_name,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Python

To learn how to install or update the Vertex AI SDK for Python, see Install the Vertex AI SDK for Python. For more information, see the Python API reference documentation. 

def create_training_pipeline_forecasting_seq2seq_sample(
    project: str,
    display_name: str,
    dataset_id: str,
    location: str = "us-central1",
    model_display_name: str = "my_model",
    target_column: str = "target_column",
    time_column: str = "date",
    time_series_identifier_column: str = "time_series_id",
    unavailable_at_forecast_columns: List[str] = [],
    available_at_forecast_columns: List[str] = [],
    forecast_horizon: int = 1,
    data_granularity_unit: str = "week",
    data_granularity_count: int = 1,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    budget_milli_node_hours: int = 8000,
    timestamp_split_column_name: str = "timestamp_split",
    weight_column: str = "weight",
    time_series_attribute_columns: List[str] = [],
    context_window: int = 0,
    export_evaluated_data_items: bool = False,
    export_evaluated_data_items_bigquery_destination_uri: Optional[str] = None,
    export_evaluated_data_items_override_destination: bool = False,
    validation_options: Optional[str] = None,
    predefined_split_column_name: Optional[str] = None,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    # Create training job
    forecasting_seq2seq_job = aiplatform.SequenceToSequencePlusForecastingTrainingJob(
        display_name=display_name, optimization_objective="minimize-rmse"
    )

    # Retrieve existing dataset
    dataset = aiplatform.TimeSeriesDataset(dataset_id)

    # Run training job
    model = forecasting_seq2seq_job.run(
        dataset=dataset,
        target_column=target_column,
        time_column=time_column,
        time_series_identifier_column=time_series_identifier_column,
        unavailable_at_forecast_columns=unavailable_at_forecast_columns,
        available_at_forecast_columns=available_at_forecast_columns,
        forecast_horizon=forecast_horizon,
        data_granularity_unit=data_granularity_unit,
        data_granularity_count=data_granularity_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        predefined_split_column_name=predefined_split_column_name,
        timestamp_split_column_name=timestamp_split_column_name,
        weight_column=weight_column,
        time_series_attribute_columns=time_series_attribute_columns,
        context_window=context_window,
        export_evaluated_data_items=export_evaluated_data_items,
        export_evaluated_data_items_bigquery_destination_uri=export_evaluated_data_items_bigquery_destination_uri,
        export_evaluated_data_items_override_destination=export_evaluated_data_items_override_destination,
        validation_options=validation_options,
        budget_milli_node_hours=budget_milli_node_hours,
        model_display_name=model_display_name,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Control the data split using REST

You can control how your training data is split between the training, validation, and test sets. Use a split column to manually specify the data split for each row and provide it as part of a PredefinedSplit Split object in the inputDataConfig of the JSON request.

DATA_SPLIT_COLUMN is the column containing the data split values (TRAIN, VALIDATION, TEST).

 "predefinedSplit": {
   "key": DATA_SPLIT_COLUMN
 },

Learn more about data splits.

Configure the rolling window strategy using REST

You can provide a windowConfig object to configure a rolling window strategy for forecast window generation. The default strategy is maxCount.

  • To use the maxCount option, add the following to trainingTaskInputs of the JSON request. MAX_COUNT_VALUE refers to the maximum number of windows.

     "windowConfig": {
   "maxCount": MAX_COUNT_VALUE
 },
 ```

  • To use the strideLength option, add the following to trainingTaskInputs of the JSON request. STRIDE_LENGTH_VALUE refers to the value of the stride length.

     "windowConfig": {
   "strideLength": STRIDE_LENGTH_VALUE
 },
 ```

  • To use the column option, add the following to trainingTaskInputs of the JSON request. COLUMN_NAME refers to the name of the column with True or False values.

     "windowConfig": {
   "column": "COLUMN_NAME"
 },
 ```

To learn more, see Rolling window strategies.

What's next