Addestra un modello di previsione

Questa pagina mostra come addestrare un modello di previsione da un modello 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 a 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 nella relativa pagina dei dettagli.

  3. Se il tipo di dati utilizza set di annotazioni, seleziona quello che ti interessa da usare 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ù su requisiti della colonna di destinazione.

    3. Se non hai impostato Colonne Identificatore serie e Timestamp sul tuo set di dati, selezionali ora.

    4. Seleziona Granularità dei dati. Seleziona Daily se vuoi utilizzare modellazione degli effetti festivi. 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 per le festività. Durante l'addestramento, Vertex AI crea caratteristiche categoriche per le festività all'interno del modello in base alla data indicata nella colonna Timestamp e al valore in ogni regione geografica. Puoi selezionare questa opzione solo quando Granularità dei dati è impostato su Daily. Per impostazione predefinita, la modellazione degli effetti per le festività è disattivata. A informazioni sulle regioni geografiche utilizzate per la creazione di modelli di effetti per le festività, consulta Regioni per le festività.

    6. Inserisci una finestra di contesto e un orizzonte di previsione.

      L'orizzonte di previsione determina quanto 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 contestuale imposta quanto indietro può tornare il modello durante per l'addestramento (e per le previsioni). In altre parole, per ogni punto dati di addestramento, la finestra contestuale determina quanto indietro nel tempo il modello cerca pattern. La finestra di contesto viene specificata in unità di Granularità dei dati.

      Scopri di più.

    7. Per esportare il set di dati di test in BigQuery, seleziona Export test dataset to BigQuery (Esporta set di dati di test in BigQuery) e specifica il nome di nella tabella.

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

    9. La suddivisione dei dati predefinita è cronologica, con lo standard 80/10/10 percentuali. Per specificare manualmente quali righe vengono assegnate a quale suddivisione, seleziona Manuale e specifica la colonna di suddivisione dati.

      Scopri di più su suddivise di dati.

    10. Seleziona una strategia di finestra temporale continua per la finestra di previsione di classificazione. 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 compila il menu a discesa Trasformazione. menu.

    2. Esamina l'elenco di colonne ed escludi eventuali colonne dell'addestramento che non devono essere usate 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 eventuali aggiornamenti richiesti.

      Righe contenenti dati non validi per la trasformazione selezionata esclusi dall'addestramento. Scopri di più su trasformazioni.

    4. Per ogni colonna che hai incluso per l'addestramento, specifica il Tipo di caratteristica per in che modo la funzionalità è 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, modifica la tua ottimizzazione per l'obiettivo predefinito o abilitare la previsione gerarchica, Opzioni avanzate.

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

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

    8. (Facoltativo) Se desideri 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 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ù su 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. Questo ti aiuta a porre un limite ai costi dell'addestramento. L'effettivo il tempo trascorso può essere maggiore di questo valore, perché ci sono altri necessarie per creare un nuovo modello.

      Il tempo di addestramento suggerito è correlato alla dimensione dell'orizzonte di previsione e dati di addestramento. La tabella seguente fornisce alcuni esempi di esecuzioni di addestramento di previsione. il 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, vedi pagina dei prezzi.

    2. Fai clic su Inizia addestramento.

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

API

Seleziona una scheda per la lingua o l'ambiente:

REST

Puoi utilizzare 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, milli ore nodo (1000 milli ore nodo equivalgono a un'ora nodo).
  • GRANULARITY_UNIT: l'unità da utilizzare per la granularità dei dati di addestramento e orizzonte di previsione e finestra di contesto. Può essere minute, hour, day, week, month o year. Seleziona day se vuoi utilizzare la modellazione degli 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 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 "colonne_attributo_serie_tempo". Scopri di più
  • GROUP_TOTAL_WEIGHT: peso della perdita aggregata del gruppo rispetto al singolo individuo. o una perdita di dati. Disattivato se impostato su "0,0" o se non è impostato. Se la colonna del gruppo non è impostata, tutte le serie temporali verranno trattati come parte dello stesso gruppo e verranno aggregati in tutte le serie temporali. Scopri di più.
  • TEMPORAL_TOTAL_WEIGHT: peso della perdita aggregata temporale rispetto al singolo individuo. o una perdita di dati. 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) rispetto alla perdita individuale. Disattivato se impostato su "0,0" o se non è impostato. Se la colonna del gruppo è non impostato, tutte le serie temporali verranno trattate come parte dello stesso gruppo e verranno aggregate in serie temporali. Scopri di più.
  • HOLIDAY_REGIONS: (facoltativo) puoi selezionare una o più regioni geografiche da attivare modellazione degli effetti festivi. Durante l'addestramento, Vertex AI crea caratteristiche all'interno del modello in base alla data da TIME_COLUMN e all'intervallo regioni geografiche di fatturazione. Per attivarlo, 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 saperne di più, vedi Regioni per le festività.
  • FORECAST_HORIZON: L'orizzonte di previsione determina quanto nel futuro il modello prevede il valore target per ogni riga di dati di previsione. L'orizzonte di previsione è specificato unità di granularità dei dati (GRANULARITY_UNIT). Scopri di più.
  • CONTEXT_WINDOW: La finestra contestuale imposta quanto indietro può tornare il modello durante per l'addestramento (e per le previsioni). In altre parole, per ogni punto dati di addestramento, la finestra contestuale determina quanto indietro nel tempo il modello cerca pattern. La finestra di contesto è specificata unità di granularità dei dati (GRANULARITY_UNIT). Scopri di più.
  • OPTIMIZATION_OBJECTIVE: Per impostazione predefinita, Vertex AI riduce al minimo errore quadratico medio (RMSE). Se vuoi un obiettivo di ottimizzazione diverso per modello di previsione, scegli una delle opzioni 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. Probabilistico l'inferenza può migliorare la qualità del modello gestendo dati rumorosi e quantificando l'incertezza. Se QUANTILES, poi Vertex AI restituisce anche i quantili di la 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 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