Addestra un modello di previsione

Questa pagina mostra come addestrare un modello di previsione da un set di dati tabulare utilizzando la console Google Cloud o l'API Vertex AI.

Prima di iniziare

Prima di poter addestrare un modello di previsione, devi completare le seguenti operazioni:

Addestra un modello

Console Google Cloud

  1. Nella sezione Vertex AI della console Google Cloud, vai alla pagina Set di dati.

    Vai alla pagina Set di dati

  2. Fai clic sul nome del set di dati da utilizzare per addestrare il modello in modo da aprire la relativa pagina dei dettagli.

  3. Se il tipo di dati utilizza set di annotazioni, seleziona quello da utilizzare per questo modello.

  4. Fai clic su Addestra nuovo modello.

  5. Seleziona Altro.

  6. Nella pagina Metodo di addestramento, configura come segue:

    1. Seleziona il metodo di addestramento del modello. Per scoprire di più, consulta Metodi di addestramento dei modelli.

    2. Fai clic su Continua.

  7. Nella pagina Dettagli modello, configura come segue:

    1. Inserisci il nome visualizzato per il nuovo modello.

    2. Seleziona la colonna di destinazione.

      La colonna target è il valore previsto dal modello. Scopri di più sui requisiti della colonna di destinazione.

    3. Se non hai impostato le colonne Identificatore serie e Timestamp sul set di dati, selezionale ora.

    4. Seleziona Granularità dei dati. Seleziona Daily se vuoi utilizzare la modellazione dell'effetto festività. Scopri come scegliere la granularità dei dati.

    5. (Facoltativo) Nel menu a discesa Regioni per le festività, scegli una o più regioni geografiche per attivare la definizione del modello per gli effetti delle festività. Durante l'addestramento, Vertex AI crea caratteristiche categoriche delle festività all'interno del modello in base alla data indicata nella colonna Timestamp e alle regioni geografiche specificate. Puoi selezionare questa opzione solo quando la Granularità dei dati è impostata su Daily. Per impostazione predefinita, la modellazione degli effetti delle festività è disattivata. Per scoprire di più sulle regioni geografiche utilizzate per la modellazione degli effetti delle festività, consulta Regioni delle festività.

    6. Inserisci la finestra di contesto e l'orizzonte di previsione.

      L'orizzonte di previsione determina per quanto tempo nel futuro il modello prevede il valore target per ogni riga di dati di previsione. L'orizzonte di previsione è specificato in unità di Granularità dei dati.

      La finestra di contesto imposta quanto indietro può essere visualizzato il modello durante l'addestramento (e per le previsioni). In altre parole, per ogni punto dati di addestramento, la finestra di contesto determina quanto indietro nel tempo il modello cerca i pattern predittivi. La finestra di contesto è specificata in unità di Granularità dei dati.

      Scopri di più.

    7. Se vuoi esportare il set di dati di test in BigQuery, seleziona Esporta set di dati di test in BigQuery e specifica il nome della tabella.

    8. Se vuoi controllare manualmente la suddivisione dei dati o configurare la finestra di previsione, apri Opzioni avanzate.

    9. La suddivisione dei dati predefinita è cronologica, con le percentuali standard 80/10/10. Se vuoi specificare manualmente le righe assegnate a una determinata suddivisione, seleziona Manuale e specifica la colonna Suddivisione dati.

      Scopri di più sulle suddivisioni dei dati.

    10. Seleziona una strategia per le finestre temporali continue per la generazione della finestra di previsione. La strategia predefinita è Conteggio.

      • Conteggio: imposta il valore per il numero massimo di finestre nella casella di testo fornita.
      • Corsa: imposta il valore della lunghezza del passo nella casella di testo disponibile.
      • Colonna: seleziona il nome della colonna appropriato dal menu a discesa fornito.

      Per scoprire di più, consulta la sezione Strategie per le finestre temporali continue.

    11. Fai clic su Continua.

  8. Nella pagina Opzioni di addestramento, configura come segue:

    1. Se non l'hai già fatto, fai clic su Genera statistiche.

      La generazione delle statistiche compila i menu a discesa Trasformazione.

    2. Esamina l'elenco delle colonne ed escludi dall'addestramento eventuali colonne che non devono essere utilizzate per addestrare il modello.

      Se utilizzi una colonna di suddivisione dati, devi includerla.

    3. Esamina le trasformazioni selezionate per le funzionalità incluse e apporta gli eventuali aggiornamenti necessari.

      Le righe contenenti dati non validi per la trasformazione selezionata vengono escluse dall'addestramento. Scopri di più sulle trasformazioni.

    4. Per ogni colonna inclusa per l'addestramento, specifica il tipo di funzionalità che spiega in che modo quella funzionalità è correlata alle relative serie temporali e se è disponibile al momento della previsione. Scopri di più su tipo di funzionalità e disponibilità.

    5. Se vuoi specificare una colonna di ponderazione, modifica l'obiettivo di ottimizzazione da quello predefinito o abilita la previsione gerarchica, apri Opzioni avanzate.

    6. (Facoltativo) Se vuoi specificare una colonna di peso, selezionala dall'elenco a discesa. Scopri di più sulle colonne di ponderazione.

    7. (Facoltativo) Se vuoi selezionare l'obiettivo di ottimizzazione, selezionalo dall'elenco. Scopri di più sugli obiettivi di ottimizzazione.

    8. (Facoltativo) Se vuoi utilizzare la previsione gerarchica, seleziona Abilita previsione gerarchica. Puoi scegliere tra tre opzioni di raggruppamento:

      • No grouping
      • Group by columns
      • Group all

      Puoi anche scegliere di impostare i seguenti pesi di perdita aggregati:

      • Group total weight. Questo campo può essere impostato solo se si seleziona l'opzione Group by columns o Group all.
      • Temporal total weight.
      • Group temporal total weight. Questo campo può essere impostato solo se si seleziona l'opzione Group by columns o Group all.

      Scopri di più sulla previsione gerarchica.

    9. Fai clic su Continua.

  9. Nella pagina Calcolo e prezzi, configura come segue:

    1. Inserisci il numero massimo di ore per le quali vuoi eseguire l'addestramento del modello. Questa impostazione consente di fissare un limite ai costi di addestramento. Il tempo effettivo trascorso può essere più lungo di questo valore, perché la creazione di un nuovo modello prevede altre operazioni.

      Il tempo di addestramento suggerito è correlato alle dimensioni dell'orizzonte di previsione e ai dati di addestramento. La tabella riportata di seguito fornisce alcuni esempi di esecuzioni di addestramento della previsione e l'intervallo del tempo di addestramento necessario per addestrare un modello di alta qualità.

      Righe Funzionalità Orizzonte di previsione Tempo di addestramento
      12 milioni 10 6 3-6 ore
      20 milioni 50 13 6-12 ore
      16 milioni 30 365 24-48 ore

      Per informazioni sui prezzi dell'addestramento, consulta la pagina dei prezzi.

    2. Fai clic su Inizia addestramento.

      L'addestramento del modello può richiedere molte ore, a seconda delle dimensioni e della complessità dei dati e del budget per l'addestramento, se ne hai specificato uno. Puoi chiudere questa scheda e riaprirla in un secondo momento. Riceverai un'email al termine dell'addestramento del modello.

API

Seleziona una scheda per la tua lingua o il tuo ambiente:

REST

Puoi utilizzare il comando trainingPipelines.create per addestrare un modello.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • LOCATION: la tua regione.
  • PROJECT: il tuo ID progetto.
  • TRAINING_PIPELINE_DISPLAY_NAME: nome visualizzato della pipeline di addestramento creata per questa operazione.
  • TRAINING_TASK_DEFINITION: il metodo di addestramento del modello.
    • Codificatore denso di serie temporali (TiDE)
      gs://google-cloud-aiplatform/schema/trainingjob/definition/time_series_dense_encoder_forecasting_1.0.0.yaml
    • Trasformatore di fusione temporale (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
    Per scoprire di più, consulta i Metodi di addestramento dei modelli.
  • TARGET_COLUMN: la colonna (valore) che il modello deve prevedere.
  • TIME_COLUMN: la colonna dell'ora. Scopri di più.
  • TIME_SERIES_IDENTIFIER_COLUMN: la colonna degli identificatori delle serie temporali. Scopri di più.
  • (Facoltativo) WEIGHT_COLUMN: la colonna del peso. Scopri di più.
  • TRAINING_BUDGET: il tempo massimo durante l'addestramento del modello, in milli ore nodo (1000 milliore di nodo equivalgono a un'ora nodo).
  • GRANULARITY_UNIT: l'unità da utilizzare per la granularità dei dati di addestramento, nonché per l'orizzonte di previsione e la finestra di contesto. Può essere minute, hour, day, week, month o year. Seleziona day se vuoi utilizzare la definizione del modello per gli effetti delle festività. Scopri come scegliere la granularità dei dati.
  • GRANULARITY_QUANTITY: il numero di unità di granularità che costituiscono l'intervallo tra le osservazioni nei dati di addestramento. Deve essere uno per tutte le unità tranne i minuti, che può essere 1, 5, 10, 15 o 30. Scopri come scegliere la granularità dei dati.
  • GROUP_COLUMNS: nomi delle colonne nella tabella di input di addestramento che identificano il raggruppamento per il livello gerarchico. Le colonne devono essere "time_series_attribute_columns". Scopri di più.
  • GROUP_TOTAL_WEIGHT: ponderazione della perdita aggregata del gruppo in relazione alla perdita individuale. Disabilitato se impostato su "0,0" o se non è impostato. Se la colonna del gruppo non è impostata, tutte le serie temporali verranno trattate come parte dello stesso gruppo e aggregate nell'arco di tutte le serie temporali. Scopri di più.
  • TEMPORAL_TOTAL_WEIGHT: ponderazione della perdita aggregata di tempo relativa alla perdita individuale. Disabilitato se impostato su "0,0" o se non è impostato. Scopri di più.
  • GROUP_TEMPORAL_TOTAL_WEIGHT: peso della perdita aggregata totale (gruppo x tempo) relativa alla perdita individuale. Disabilitato se impostato su "0,0" o se non è impostato. Se la colonna del gruppo non viene impostata, tutte le serie temporali verranno trattate come parte dello stesso gruppo e aggregate per tutte le serie temporali. Scopri di più.
  • HOLIDAY_REGIONS: (facoltativo) puoi selezionare una o più regioni geografiche per abilitare la modellazione degli effetti delle festività. Durante l'addestramento, Vertex AI crea caratteristiche categoriche delle festività all'interno del modello in base alla data nel giorno TIME_COLUMN e alle regioni geografiche specificate. Per abilitarlo, imposta GRANULARITY_UNIT su day e specifica una o più regioni nel campo HOLIDAY_REGIONS. Per impostazione predefinita, la modellazione degli effetti delle festività è disattivata. Per scoprire di più, consulta Regioni delle festività.
  • FORECAST_HORIZON: l'orizzonte di previsione determina per quanto tempo nel futuro il modello prevede il valore target per ogni riga di dati di previsione. L'orizzonte di previsione è specificato in unità di granularità dei dati (GRANULARITY_UNIT). Scopri di più.
  • CONTEXT_WINDOW: la finestra di contesto imposta quanto indietro il modello può essere visualizzato durante l'addestramento (e per le previsioni). In altre parole, per ogni punto dati di addestramento, la finestra di contesto determina quanto indietro nel tempo il modello cerca i pattern predittivi. La finestra di contesto è specificata in unità di granularità dei dati (GRANULARITY_UNIT). Scopri di più.
  • OPTIMIZATION_OBJECTIVE: per impostazione predefinita, Vertex AI riduce al minimo l'errore quadratico medio (RMSE). Se vuoi un obiettivo di ottimizzazione diverso per il tuo modello di previsione, scegli una delle opzioni in Obiettivi di ottimizzazione per i modelli di previsione. Se scegli di ridurre al minimo la perdita di quantili, devi specificare anche un valore per QUANTILES.
  • PROBABILISTIC_INFERENCE: (facoltativo) se impostato su true, Vertex AI modella la distribuzione della probabilità della previsione. L'inferenza probabilistica può migliorare la qualità del modello gestendo dati di rumore e quantificando l'incertezza. Se vengono specificati QUANTILES, Vertex AI restituisce anche i quantili della distribuzione della probabilità. L'inferenza probabilistica è compatibile solo 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 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