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 i seguenti passaggi:

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 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ù sui requisiti delle colonne target.

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

    4. Seleziona la 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 con festività, scegli una o più regioni geografiche per attivare la modellazione degli effetti delle festività. Durante l'addestramento, Vertex AI crea nel modello funzionalità categoriche per le festività in base alla data della colonna Timestamp e alle regioni geografiche specificate. Puoi selezionare questa opzione solo se Granularità dei dati è impostata su Daily. Per impostazione predefinita, la definizione del modello per gli effetti delle festività è disattivata. Per informazioni sulle regioni geografiche utilizzate per la definizione del modello degli effetti delle festività, consulta Regioni delle festività.

    6. Inserisci la Finestra del contesto e l'Orizzonte di previsione.

      L'orizzonte di previsione determina per quanto lontano nel futuro il modello deve fare la previsione del valore target per ogni riga di dati di previsione. L'orizzonte di previsione è specificato in unità di granularità dei dati.

      La finestra di contesto imposta 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 è specificata in unità di granularità dei dati.

      Scopri di più.

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

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

    9. La suddivisione dei dati predefinita è cronologica, con le percentuali standard 80/10/10. Se vuoi specificare manualmente le righe da assegnare alla suddivisione, seleziona Manuale e specifica la colonna 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 ancora fatto, fai clic su Genera statistiche.

      La generazione delle statistiche compila i menu a discesa Trasformazione.

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

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

    3. Esamina le trasformazioni selezionate per le funzionalità 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 caratteristica per indicare la relazione tra la caratteristica 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 peso, modificare lo scopo di ottimizzazione predefinito o attivare le previsioni gerarchiche, apri 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 vuoi utilizzare la previsione gerarchica, seleziona Attiva 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 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 addestrare il 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 alle dimensioni dell'orizzonte di previsione e ai 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, 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 di 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 tua lingua o il tuo ambiente:

REST

Utilizza il comando trainingPipelines.create per addestrare un modello.

Prima di utilizzare i dati della richiesta, apporta 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 che il modello preveda.
  • 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 alla perdita singola. 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 è 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 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 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 scoprire di più, consulta Regioni delle 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 in 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 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 è specificata in unità di granularità dei dati (GRANULARITY_UNIT). Scopri di più.
  • OPTIMIZATION_OBJECTIVE: per impostazione predefinita, Vertex AI riduce al minimo l'errore quadratico medio (RMSE). Se vuoi un obiettivo di ottimizzazione diverso per il tuo modello di previsione, scegli una delle opzioni in Obiettivi di ottimizzazione per i modelli di previsione. Se scegli di ridurre al minimo la perdita di quantili, devi anche specificare un valore per QUANTILES.
  • PROBABILISTIC_INFERENCE: (Facoltativo) se impostato su true, Vertex AI modella la distribuzione di probabilità della previsione. L'inferenza probabilistica può migliorare la qualità del modello gestendo i dati con rumore 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