Train a model with Tabular Workflow for Forecasting

This page shows you how to train a forecasting model from a tabular dataset with Tabular Workflow for Forecasting.

To learn about the service accounts used by this workflow, see Service accounts for Tabular Workflows.

If you receive an error related to quotas while running Tabular Workflow for Forecasting, you might need to request a higher quota. To learn more, see Manage quotas for Tabular Workflows.

Tabular Workflow for Forecasting does not support model export.

Workflow APIs

This workflow uses the following APIs:

• Vertex AI
• Dataflow
• Compute Engine
• Cloud Storage

Get the URI of the previous hyperparameter tuning result

If you have previously completed a Tabular Workflow for Forecasting run, you can use the hyperparameter tuning result from the previous run to save training time and resources. You can find the previous hyperparameter tuning result by using the Google Cloud console or by loading it programmatically with the API.

def get_task_detail(
  task_details: List[Dict[str, Any]], task_name: str
) -> List[Dict[str, Any]]:
  for task_detail in task_details:
      if task_detail.task_name == task_name:
          return task_detail

pipeline_task_details = job.gca_resource.job_detail.task_details

stage_1_tuner_task = get_task_detail(
    pipeline_task_details, "automl-forecasting-stage-1-tuner"
)
stage_1_tuning_result_artifact_uri = (
    stage_1_tuner_task.outputs["tuning_result_output"].artifacts[0].uri
)

Train a model

The following sample code demonstrates how you can run a model training pipeline:

job = aiplatform.PipelineJob(
    ...
    template_path=template_path,
    parameter_values=parameter_values,
    ...
)
job.run(service_account=SERVICE_ACCOUNT)

The optional service_account parameter in job.run() lets you set the Vertex AI Pipelines service account to an account of your choice.

Vertex AI supports the following methods for training your model:

• Time series Dense Encoder (TiDE). To use this model training method, define your pipeline and parameter values by using the following function:

  template_path, parameter_values = automl_forecasting_utils.get_time_series_dense_encoder_forecasting_pipeline_and_parameters(...)
  

• Temporal Fusion Transformer (TFT). To use this model training method, define your pipeline and parameter values by using the following function:

  template_path, parameter_values = automl_forecasting_utils.get_temporal_fusion_transformer_forecasting_pipeline_and_parameters(...)
  

• AutoML (L2L). To use this model training method, define your pipeline and parameter values by using the following function:

  template_path, parameter_values = automl_forecasting_utils.get_learn_to_learn_forecasting_pipeline_and_parameters(...)
  

• Seq2Seq+. To use this model training method, define your pipeline and parameter values by using the following function:

  template_path, parameter_values = automl_forecasting_utils.get_sequence_to_sequence_forecasting_pipeline_and_parameters(...)
  

To learn more, see Model training methods.

The training data can be either a CSV file in Cloud Storage or a table in BigQuery.

The following is a subset of model training parameters:

Transformations

You can provide a dictionary mapping of auto- or type-resolutions to feature columns. The supported types are: auto, numeric, categorical, text, and timestamp.

The following code provides a helper function for populating the transformations parameter. It also demonstrates how you can use this function to apply automatic transformations to a set of columns defined by a features variable.

def generate_transformation(
      auto_column_names: Optional[List[str]]=None,
      numeric_column_names: Optional[List[str]]=None,
      categorical_column_names: Optional[List[str]]=None,
      text_column_names: Optional[List[str]]=None,
      timestamp_column_names: Optional[List[str]]=None,
    ) -> List[Dict[str, Any]]:
    if auto_column_names is None:
      auto_column_names = []
    if numeric_column_names is None:
      numeric_column_names = []
    if categorical_column_names is None:
      categorical_column_names = []
    if text_column_names is None:
      text_column_names = []
    if timestamp_column_names is None:
      timestamp_column_names = []
    return {
        "auto": auto_column_names,
        "numeric": numeric_column_names,
        "categorical": categorical_column_names,
        "text": text_column_names,
        "timestamp": timestamp_column_names,
    }

transformations = generate_transformation(auto_column_names=features)

To learn more about transformations, see Data types and transformations.

Workflow customization options

You can customize the Tabular Workflow for Forecasting by defining argument values that are passed in during pipeline definition. You can customize your workflow in the following ways:

• Configure hardware
• Skip architecture search

Configure hardware

The following model training parameter lets you configure the machine types and the number of machines for training. This option is a good choice if you have a large dataset and want to optimize the machine hardware accordingly.

The following code demonstrates how to set n1-standard-8 machine type for the TensorFlow chief node and n1-standard-4 machine type for the TensorFlow evaluator node:

worker_pool_specs_override = [
  {"machine_spec": {"machine_type": "n1-standard-8"}}, # override for TF chief node
  {},  # override for TF worker node, since it's not used, leave it empty
  {},  # override for TF ps node, since it's not used, leave it empty
  {
    "machine_spec": {
        "machine_type": "n1-standard-4" # override for TF evaluator node
    }
  }
]

Skip architecture search

The following model training parameter lets you run the pipeline without the architecture search and provide a set of hyperparameters from a previous pipeline run instead.

What's next

• Learn about batch predictions for forecasting models.
• Learn about pricing for model training.