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 quanto segue:

Addestra un modello

Console Google Cloud

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

    Vai alla pagina Set di dati

  2. Fai clic sul nome del set di dati che vuoi utilizzare per addestrare il modello per 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 saperne di più, consulta Metodi di addestramento del modello.

    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 delle colonne 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 degli effetti delle 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 abilitare la modellazione degli effetti relativi alle festività. Durante l'addestramento, Vertex AI crea caratteristiche categoriche per le festività all'interno del modello in base alla data della colonna Timestamp e alle regioni geografiche specificate. Puoi selezionare questa opzione solo quando Granularità dei dati è impostata su Daily. Per impostazione predefinita, la modellazione degli effetti per le festività è disattivata. Per scoprire le regioni geografiche utilizzate per la creazione di modelli di effetti per le festività, consulta Regioni delle festività.

    6. Inserisci una finestra di contesto e un 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 viene specificato in unità di Granularità dei dati.

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

      Ulteriori informazioni

    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 dati o configurare la finestra di previsione, apri Opzioni avanzate.

    9. La suddivisione dei dati predefinita è cronologica, con le percentuali standard 80/10/10. Per specificare manualmente a quali righe assegnare una determinata suddivisione, seleziona Manuale e specifica la colonna di suddivisione dati.

      Scopri di più sulle suddivisioni dei dati.

    10. Seleziona una strategia finestra temporale continua per la generazione della finestra di previsione. La strategia predefinita è Conteggio.

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

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

    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 popola i menu a discesa Trasformazione.

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

      Se utilizzi una colonna di suddivisione dati, deve essere inclusa.

    3. Esamina le trasformazioni selezionate per le caratteristiche incluse e apporta gli 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à per stabilire in che modo la caratteristica è correlata alle 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, modificare l'obiettivo di ottimizzazione rispetto a quello predefinito o abilitare 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 la previsione gerarchica. Puoi scegliere tra tre opzioni di raggruppamento:

      • No grouping
      • Group by columns
      • Group all

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

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

      Scopri di più sulla previsione gerarchica.

    9. Fai clic su Continua.

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

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

      Il tempo di addestramento suggerito è correlato alla dimensione dell'orizzonte di previsione e dei dati di addestramento. La tabella riportata di seguito fornisce alcuni esempi di esecuzioni di addestramento per la previsione e l'intervallo di 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 specificato. Puoi chiudere questa scheda e tornarla in un secondo momento. Riceverai un'email al termine dell'addestramento del modello.

API

Seleziona una scheda per la lingua o l'ambiente:

REST

Puoi usare 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 per 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 saperne di più, consulta Metodi di addestramento del modello.
  • TARGET_COLUMN: la colonna (valore) che deve essere prevista dal modello.
  • TIME_COLUMN: la colonna data. Scopri di più.
  • TIME_SERIES_IDENTIFIER_COLUMN: la colonna dell'identificatore della serie temporale. Scopri di più.
  • WEIGHT_COLUMN: (facoltativo) la colonna del peso. Scopri di più.
  • TRAINING_BUDGET: la quantità massima di tempo per l'addestramento del modello, in migliaia di ore nodo (1000 milli ore nodo equivalgono a un'ora nodo).
  • GRANULARITY_UNIT: l'unità da utilizzare per la granularità dei dati di addestramento, nonché l'orizzonte di previsione e la finestra contestuale. Può essere minute, hour, day, week, month o year. Seleziona day se vuoi utilizzare la definizione del modello di effetti per le festività. Scopri come scegliere la granularità dei dati.
  • GRANULARITY_QUANTITY: il numero di unità di granularità che compongono l'intervallo tra le osservazioni nei dati di addestramento. Deve essere uno per tutte le unità tranne i minuti, che possono 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: peso della perdita aggregata del gruppo rispetto alla perdita individuale. Disattivato 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 verranno aggregate in tutte le serie temporali. Scopri di più.
  • TEMPORAL_TOTAL_WEIGHT: peso della perdita aggregata temporale rispetto alla perdita individuale. Disattivato 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. Disattivato 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 verranno aggregate in tutte le serie temporali. Scopri di più.
  • HOLIDAY_REGIONS (Facoltativo) Puoi selezionare una o più regioni geografiche per abilitare la modellazione degli effetti relativi alle festività. Durante l'addestramento, Vertex AI crea caratteristiche categoriche per le festività all'interno del modello in base alla data nel periodo 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 per le 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 può tornare il modello durante l'addestramento (e per le previsioni). In altre parole, per ogni punto dati di addestramento, la finestra contestuale determina quanto indietro il modello cerca i pattern predittivi. La finestra contestuale è 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 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 rumorosi e quantificando l'incertezza. Se QUANTILES sono specificati, Vertex AI restituisce anche i quantili della distribuzione di 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 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