Entrena un modelo de previsión

En esta página, se muestra cómo entrenar un modelo de previsión a partir de un conjunto de datos tabular mediante la consola de Google Cloud o la API de Vertex AI.

Antes de comenzar

Antes de entrenar un modelo de previsión, debes completar lo siguiente:

Entrenar un modelo

Consola de Google Cloud

  1. En la sección Vertex AI de la consola de Google Cloud, ve a la página Conjuntos de datos.

    Ir a la página Conjuntos de datos

  2. Haz clic en el nombre del conjunto de datos que deseas usar para entrenar tu modelo a fin de abrir su página de detalles.

  3. Si tu tipo de datos usa conjuntos de anotaciones, selecciona el conjunto de anotaciones que deseas usar para este modelo.

  4. Haga clic en Entrenar un modelo nuevo.

  5. Selecciona Otros.

  6. En la página Método de entrenamiento, configura lo siguiente:

    1. Selecciona el método de entrenamiento de modelos. Para obtener más información, consulta Métodos de entrenamiento de modelos.

    2. Haz clic en Continuar.

  7. En la página Detalles del modelo, configura lo siguiente:

    1. Ingresa el nombre visible de tu modelo nuevo.

    2. Selecciona la columna objetivo.

      La columna objetivo es el valor que el modelo predecirá. Obtén más información sobre los requisitos de las columnas de destino.

    3. Si no configuraste las columnas Identificador de la serie y Marca de tiempo en el conjunto de datos, selecciónalas ahora.

    4. Selecciona el Nivel de detalle de los datos. Selecciona Daily si deseas usar el modelado de efectos de días festivos. Obtén información sobre cómo elegir el nivel de detalle de los datos.

    5. Opcional: En el menú desplegable Regiones de festividades, elige una o más regiones geográficas para habilitar el modelado de efectos de festividades. Durante el entrenamiento, Vertex AI crea atributos categóricos para las festividades dentro del modelo en función de la fecha en la columna de marca de tiempo y las regiones geográficas especificadas. Puedes seleccionar esta opción solo cuando el nivel de detalle de los datos se establece en Daily. De forma predeterminada, el modelado de efectos de festividades está inhabilitado. Para obtener información acerca de las regiones geográficas que se usan para el modelado de efectos de festividades, consulta Regiones de festividades.

    6. Ingresa la ventana de contexto y el horizonte de previsión.

      El horizonte de previsión determina hasta qué punto del futuro el modelo predice el valor objetivo de cada fila de datos de predicción. El horizonte de previsión se especifica en unidades de nivel de detalle de datos.

      La ventana de contexto establece la extensión del período que el modelo consulta durante el entrenamiento (y para las previsiones). En otras palabras, para cada dato de entrenamiento, la ventana de contexto determina la extensión del período en el que el modelo busca patrones predictivos. La ventana de contexto se especifica en unidades de nivel de detalle de datos.

      Obtén más información.

    7. Si deseas exportar tu conjunto de datos de prueba a BigQuery, marca Exportar conjunto de datos de prueba a BigQuery y proporciona el nombre de la tabla.

    8. Si deseas controlar manualmente la división de tus datos o configurar la ventana de previsión, abre las Opciones avanzadas.

    9. La división de datos predeterminada es cronológica, con los porcentajes estándar 80/10/10. Si deseas especificar de forma manual qué filas se asignan a qué división, selecciona Manual y especifica la columna de división de datos.

      Obtén más información sobre las divisiones de datos.

    10. Selecciona una estrategia de ventana progresiva para la generación de ventanas de previsión. La estrategia predeterminada es Recuento.

      • Recuento: Establece el valor para la cantidad máxima de ventanas en el cuadro de texto proporcionado.
      • Segmento: establece el valor de la longitud del segmento en el cuadro de texto proporcionado.
      • Columna: Selecciona el nombre de la columna adecuado en el menú desplegable proporcionado.

      Para obtener más información, consulta Estrategias de ventana progresiva.

    11. Haz clic en Continuar.

  8. En la página Opciones de entrenamiento, configura lo siguiente:

    1. Si aún no lo hiciste, haz clic en Generar estadísticas.

      La generación de estadísticas propaga los menús desplegables de Transformación.

    2. Revisa la lista de columnas y excluye las columnas del entrenamiento que no se deberían usar para entrenar el modelo.

      Si usas una columna de división de datos, esta debe incluirse.

    3. Revisa las transformaciones seleccionadas para los atributos incluidos y realiza las actualizaciones necesarias.

      Las filas que contienen datos que no son válidos para la transformación seleccionada se excluyen del entrenamiento. Obtén más información sobre las transformaciones.

    4. Para cada columna que incluiste en el entrenamiento, especifica el Tipo de atributo para indicar cómo se relaciona ese atributo con su serie temporal y si está disponible en el momento de la previsión. Obtén más información sobre el tipo y la disponibilidad de los atributos.

    5. Si deseas especificar una columna de ponderación, cambiar tu objetivo de optimización del valor predeterminado o habilitar la previsión jerárquica, abre Opciones avanzadas.

    6. Opcional. Si deseas especificar una columna de ponderación, selecciónala en la lista desplegable. Obtén más información sobre las columnas de ponderación.

    7. Opcional. Si deseas seleccionar el objetivo de optimización, selecciónalo de la lista. Obtén más información sobre los objetivos de optimización.

    8. Opcional. Si deseas usar la previsión jerárquica, selecciona Habilitar la previsión jerárquica. Puedes elegir entre tres opciones de agrupación:

      • No grouping
      • Group by columns
      • Group all

      También puedes optar por establecer los siguientes pesos de pérdida agregada:

      • Group total weight Este campo solo se puede configurar si seleccionas la opción Group by columns o Group all.
      • Temporal total weight
      • Group temporal total weight Este campo solo se puede configurar si seleccionas la opción Group by columns o Group all.

      Obtén más información sobre la predicción jerárquica.

    9. Haz clic en Continuar.

  9. En la página Procesamiento y precios, realiza la configuración de la siguiente manera:

    1. Ingresa el número máximo de horas para las que deseas que se entrene el modelo. Esta configuración te ayuda a limitar los costos de entrenamiento. El tiempo real transcurrido puede ser más largo que este valor, ya que hay otras operaciones involucradas en la creación de un modelo nuevo.

      El tiempo de entrenamiento sugerido se relaciona con el tamaño del horizonte de previsión y los datos de entrenamiento. En la siguiente tabla, se muestran algunas ejecuciones de entrenamiento de previsión de muestra y el intervalo de tiempo de entrenamiento necesario para entrenar un modelo de alta calidad.

      Filas Características Horizonte de previsión Tiempo de entrenamiento
      12 millones 10 6 De 3 a 6 horas
      20 millones 50 13 De 6 a 12 horas
      16 millones 30 365 De 24 a 48 horas

      Para obtener información sobre los precios de entrenamiento, consulta la página de precios.

    2. Haga clic en Comenzar entrenamiento.

      El entrenamiento de modelos puede tardar muchas horas, según el tamaño y la complejidad de tus datos y tu presupuesto de entrenamiento, si especificaste uno. Puedes cerrar esta pestaña y regresar a ella más tarde. Recibirás un correo electrónico cuando tu modelo haya finalizado el entrenamiento.

API

Selecciona una pestaña para tu idioma o entorno:

REST

Usa el comando trainingPipelines.create para entrenar un modelo.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION: Tu región.
  • PROJECT: El ID del proyecto.
  • TRAINING_PIPELINE_DISPLAY_NAME: El nombre visible de la canalización de entrenamiento creada para esta operación.
  • TRAINING_TASK_DEFINITION: Es el método de entrenamiento de modelos.
    • Codificador denso de la serie temporal (TiDE)
      gs://google-cloud-aiplatform/schema/trainingjob/definition/time_series_dense_encoder_forecasting_1.0.0.yaml
    • Transformador de fusión 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 obtener más información, consulta Métodos de entrenamiento de modelos.
  • TARGET_COLUMN: La columna (valor) que deseas que prediga este modelo.
  • TIME_COLUMN: La columna de tiempo. Obtén más información.
  • TIME_SERIES_IDENTIFIER_COLUMN: La columna de identificador de serie temporal. Obtén más información.
  • WEIGHT_COLUMN: la columna de ponderación (opcional). Obtén más información.
  • TRAINING_BUDGET: la cantidad máxima de tiempo que deseas que se entrene el modelo, en milihoras de procesamiento de nodos (1,000 milihoras de procesamiento de nodos equivalen a una hora de procesamiento de nodos).
  • GRANULARITY_UNIT: La unidad que se usará para el nivel de detalle de tus datos de entrenamiento y el horizonte de previsión y la ventana contextual. Puede ser minute, hour, day, week, month o year. Selecciona day si deseas usar el modelado de efectos de festividades. Obtén información sobre cómo elegir el nivel de detalle de los datos.
  • GRANULARITY_QUANTITY: La cantidad de unidades de nivel de detalle que conforman el intervalo entre las observaciones en los datos de entrenamiento Debe ser la misma para todas las unidades, excepto los minutos, que pueden ser 1, 5, 10, 15 o 30. Obtén información sobre cómo elegir el nivel de detalle de los datos.
  • GROUP_COLUMNS: Nombres de columnas en tu tabla de entrada de entrenamiento que identifican la agrupación para el nivel de jerarquía. Las columnas deben ser `time_series_attributes_columns`. Más información.
  • GROUP_TOTAL_WEIGHT: Peso de la pérdida agregada del grupo en relación con la pérdida individual. Se inhabilita si se establece en “0.0” o si no se establece. Si no se configura la columna de grupo, todas las series temporales se tratarán como parte del mismo grupo y se agregarán a todas las series temporales. Obtén más información.
  • TEMPORAL_TOTAL_WEIGHT: Peso del tiempo agregado de pérdida relacionado con la pérdida individual. Se inhabilita si se establece en “0.0” o si no se establece. Obtén más información.
  • GROUP_TEMPORAL_TOTAL_WEIGHT: Peso de la pérdida total (grupo x tiempo) relativa a la pérdida individual. Se inhabilita si se establece en “0.0” o si no se establece. Si no se configura la columna de grupo, todas las series temporales se tratarán como parte del mismo grupo y se agregarán a todas las series temporales. Obtén más información.
  • HOLIDAY_REGIONS: Puedes seleccionar una o más regiones geográficas para habilitar el modelado de efectos de festividades (opcional). Durante el entrenamiento, Vertex AI crea atributos categóricos para las festividades dentro del modelo según la fecha de TIME_COLUMN y las regiones geográficas especificadas. Para habilitarlo, configura GRANULARITY_UNIT en day y especifica una o más regiones en el campo HOLIDAY_REGIONS. De forma predeterminada, el modelado de efectos de festividades está inhabilitado. Para obtener más información, consulta Regiones de festividades.
  • FORECAST_HORIZON: El horizonte de previsión determina hasta qué punto del futuro el modelo predice el valor objetivo de cada fila de datos de predicción. El horizonte de previsión se especifica en unidades de nivel de detalle de los datos (GRANULARITY_UNIT). Más información.
  • CONTEXT_WINDOW: La ventana de contexto establece la extensión del período que el modelo consulta durante el entrenamiento (y para las previsiones). En otras palabras, para cada dato de entrenamiento, la ventana de contexto determina la extensión del período en el que el modelo busca patrones predictivos. La ventana de contexto se especifica en unidades de datos detallados (GRANULARITY_UNIT). Más información.
  • OPTIMIZATION_OBJECTIVE: De forma predeterminada, Vertex AI minimiza la raíz cuadrada del error cuadrático medio (RMSE). Si deseas un objetivo de optimización diferente para tu modelo de previsión, elige una de las opciones en Objetivos de optimización para los modelos de previsión. Si eliges minimizar la pérdida cuantil, también debes especificar un valor para QUANTILES.
  • PROBABILISTIC_INFERENCE: (Opcional) Si está configurado como true, Vertex AI modela la distribución de probabilidad de la previsión. La inferencia probabilística puede mejorar la calidad del modelo; para ello, se manejan los datos ruidosos y la cuantificación de la incertidumbre. Si se especifican QUANTILES, Vertex AI también muestra los cuantiles de la distribución de probabilidad. La inferencia probabilística solo es compatible con 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 https://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