Addestrare 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 nella relativa pagina dei dettagli.

  3. Se il tipo di dati utilizza set di annotazioni, seleziona il set di annotazioni 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 che il modello prevederà. Scopri di più su requisiti della colonna di destinazione.

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

    4. Seleziona Granularità dei dati. Seleziona Daily se vuoi utilizzare la simulazione 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 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 è impostata su Daily. Per impostazione predefinita, la definizione del modello per gli effetti delle 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 la Finestra del contesto e l'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 di contesto imposta il periodo di tempo preso in considerazione dal modello durante l'addestramento (e per le previsioni). In altre parole, per ogni punto dati di addestramento, la finestra di contesto determina fino a che periodo di tempo precedente il modello cerca i pattern predittivi. 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 le percentuali standard 80/10/10. Per specificare manualmente quali righe vengono assegnate a quale suddivisione, seleziona Manuale e specifica la colonna di suddivisione dati.

      Scopri di più sulle suddivisioni dei dati.

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

      • Conta: imposta il valore per il numero massimo di finestre nella casella di testo fornita.
      • Passo: imposta il valore della lunghezza del passo nella casella di testo fornita.
      • 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 il menu a discesa Trasformazione. menu.

    2. Esamina l'elenco delle colonne ed escludi dall'addestramento le 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 eventuali aggiornamenti richiesti.

      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 indicare la relazione tra la funzionalità e la relativa serie temporale e se è disponibile al momento della previsione. Scopri di più sul tipo e sulla disponibilità delle funzionalità.

    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 dall'elenco a discesa. Scopri di più sulle colonne di peso.

    7. (Facoltativo) Se vuoi selezionare l'obiettivo di ottimizzazione, sceglilo dall'elenco. Scopri di più sugli 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 delle perdite aggregate:

      • 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 ti consente di limitare i costi di addestramento. Il tempo reale trascorso può essere superiore a questo valore, perché sono necessarie altre operazioni 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 alcune esecuzioni di addestramento di previsione di esempio 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, 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 e il budget per l'addestramento, se ne hai specificato uno. Puoi chiudere questa scheda e tornarci in un secondo momento. Riceverai un'email al completamento dell'addestramento del modello.

API

Seleziona una scheda per la lingua o l'ambiente:

REST

Utilizza 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.
    • Time series Dense Encoder (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 Metodi di addestramento dei modelli.
  • TARGET_COLUMN: la colonna (valore) che vuoi prevedere con il modello.
  • TIME_COLUMN: la colonna della data e dell'ora. 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: il tempo massimo di addestramento del modello in mille 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é 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 compongono l'intervallo tra le osservazioni nei dati di addestramento. Deve essere pari a 1 per tutte le unità, ad eccezione dei minuti, che possono essere 1, 5, 10, 15 o 30. Scopri come scegliere la granularità dei dati.
  • GROUP_COLUMNS: i nomi delle colonne nella tabella di input per l'addestramento che identificano il raggruppamento per il livello della gerarchia. Le colonne devono essere "time_series_attribute_columns". 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 trattate come parte dello stesso gruppo e verranno aggregate in tutte le serie temporali. Scopri di più.
  • TEMPORAL_TOTAL_WEIGHT: peso della perdita aggregata nel tempo rispetto alla perdita singola. 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 per attivare la modellazione degli effetti delle festività. Durante l'addestramento, Vertex AI crea nel modello caratteristiche categoriche per le festività in base alla data del giorno TIME_COLUMN e alle regioni geografiche specificate. Per attivarlo, imposta GRANULARITY_UNIT su day e specifica una o più regioni nel campo HOLIDAY_REGIONS. Per impostazione predefinita, la definizione del modello per gli effetti delle festività è disattivata. Per saperne di più, vedi Regioni per le festività.
  • FORECAST_HORIZON: l'orizzonte di previsione determina per quanto lontano 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 di contesto imposta il periodo di tempo preso in considerazione dal modello durante la formazione (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 l'errore quadratico medio (RMSE). Se vuoi un obiettivo di ottimizzazione diverso per il tuo 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 vengono specificati i valori QUANTILES, 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