Prognosemodell trainieren

Auf dieser Seite wird gezeigt, wie Sie mithilfe der Google Cloud Console oder der Vertex AI API ein Prognosemodell aus einem tabellarischen Dataset trainieren.

Hinweis

Bevor Sie ein Prognosemodell trainieren können, müssen Sie die folgenden Schritte ausführen:

Modell trainieren

Google Cloud Console

  1. Rufen Sie in der Google Cloud Console im Abschnitt "Vertex AI" die Seite Datasets auf.

    Zur Seite „Datasets“

  2. Klicken Sie auf den Namen des Datasets, das Sie zum Trainieren Ihres Modells verwenden möchten, um dessen Detailseite zu öffnen.

  3. Wenn Ihr Datentyp Annotationssätze verwendet, wählen Sie den Annotationssatz aus, den Sie für dieses Modell verwenden möchten.

  4. Klicken Sie auf Neues Modell trainieren.

  5. Wählen Sie Sonstiges aus.

  6. Konfigurieren Sie auf der Seite Trainingsmethode Folgendes:

    1. Wählen Sie die Modelltrainingsmethode aus. Weitere Informationen finden Sie unter Methoden für das Modelltraining.

    2. Klicken Sie auf Weiter.

  7. Konfigurieren Sie auf der Seite Modelldetails Folgendes:

    1. Geben Sie den Anzeigenamen für das neue Modell ein.

    2. Wählen Sie die Zielspalte aus.

      Die Zielspalte enthält den Wert, den das Modell prognostiziert. Weitere Informationen zu den Anforderungen an Zielspalten.

    3. Wenn Sie die Spalten Achsenkennzeichnung und Zeitstempel für Ihr Dataset nicht festgelegt haben, wählen Sie sie jetzt aus.

    4. Wählen Sie die Detaillierungsgrad der Daten aus. Wählen Sie Daily aus, wenn Sie die Effektmodellierung für Feiertage verwenden möchten. Weitere Informationen zum Auswählen des Daten-Detaillierungsgrads

    5. Optional: Wählen Sie im Drop-down-Menü Feiertagsregionen eine oder mehrere geografische Regionen aus, um die Effektmodellierung für Feiertage zu aktivieren. Während des Trainings erstellt Vertex AI innerhalb des Modells kategoriale Features basierend auf dem Datum aus der Spalte Zeitstempel und den angegebenen geografischen Regionen. Sie können diese Option nur auswählen, wenn der Detaillierungsgrad der Daten auf Daily gesetzt ist. Standardmäßig ist die Effektmodellierung deaktiviert. Weitere Informationen zu den geografischen Regionen, die für die Effektmodellierung für Feiertage verwendet werden, finden Sie unter Feiertagsregionen.

    6. Geben Sie das Kontextfenster und den Prognosezeitraum ein.

      Der Prognosezeitraum bestimmt, wie weit das Modell den Zielwert für jede Zeile mit Vorhersagedaten prognostiziert. Der Prognosezeitraum wird in Einheiten von Datengranularität angegeben.

      Das Kontextfenster legt fest, wie weit das Modell während des Trainings (und für Prognosen) zurückblickt. Mit anderen Worten: Für jeden Trainingsdatenpunkt bestimmt das Kontextfenster, wie weit das Modell nach Vorhersagemustern sucht. Das Kontextfenster wird in Einheiten von Datengranularität angegeben.

      Weitere Informationen.

    7. Wenn Sie Ihr Test-Dataset nach BigQuery exportieren möchten, klicken Sie das Kästchen Test-Dataset nach BigQuery exportieren an und geben Sie den Namen der Tabelle ein.

    8. Wenn Sie Ihre Datenaufteilung manuell steuern oder das Prognosefenster konfigurieren möchten, gehen Sie zu Erweiterte Optionen.

    9. Die Standarddatenaufteilung ist chronologisch und mit den standardmäßigen Prozentsätzen von 80/10/10. Wenn Sie manuell festlegen möchten, welche Zeilen welcher Aufteilung zugewiesen werden, wählen Sie Manuell aus und geben Sie die Spalte für die Datenaufteilung an.

      Weitere Informationen zur Datenaufteilung.

    10. Wählen Sie eine Strategie für rollierende Fenster zur Generierung von Prognosefenstern aus. Die Standardstrategie ist Anzahl.

      • Anzahl: Legen Sie den Wert für die maximale Anzahl von Fenstern im bereitgestellten Textfeld fest.
      • Schrittlänge: Legen Sie den Wert der Schrittlänge im bereitgestellten Textfeld fest.
      • Spalte: Wählen Sie den entsprechenden Spaltennamen aus dem Drop-down-Menü aus.

      Weitere Informationen finden Sie unter Strategien für rollierende Fenster.

    11. Klicken Sie auf Weiter.

  8. Konfigurieren Sie auf der Seite Trainingsoptionen Folgendes:

    1. Falls noch nicht geschehen, klicken Sie auf Statistiken generieren.

      Durch das Generieren von Statistiken werden die Transformation-Drop-down-Menüs ausgefüllt.

    2. Prüfen Sie die Spaltenliste und schließen Sie Spalten aus dem Training aus, die nicht zum Trainieren des Modells verwendet werden sollen.

      Wenn Sie eine Spalte für die Datenaufteilung verwenden, sollte sie enthalten sein.

    3. Prüfen Sie die für Ihre enthaltenen Features ausgewählten Transformationen und nehmen Sie die erforderlichen Änderungen vor.

      Zeilen mit Daten, die für die ausgewählte Transformation ungültig sind, werden vom Training ausgeschlossen. Weitere Informationen zu Transformationen.

    4. Geben Sie für jede Spalte, die Sie für das Training angegeben haben, den Featuretyp an, wie sich dieses Feature auf seine Zeitreihe bezieht und ob es zum Zeitpunkt der Prognose verfügbar ist. Weitere Informationen zu Featuretypen und Verfügbarkeit

    5. Wenn Sie eine Gewichtungsspalte angeben, ein anderes Optimierungsziel als das standardmäßig nutzen oder die hierarchische Prognose aktivieren möchten, öffnen Sie Erweiterte Optionen.

    6. Optional: Wenn Sie eine Gewichtungsspalte angeben möchten, wählen Sie diese aus der Drop-down-Liste aus. Weitere Informationen zu Gewichtungsspalten.

    7. Optional: Wenn Sie das Optimierungsziel auswählen möchten, wählen Sie es aus der Liste aus. Weitere Informationen zu Optimierungszielen.

    8. Optional: Wenn Sie die hierarchische Prognose verwenden möchten, wählen Sie Hierarchische Prognose aktivieren aus. Sie können zwischen drei Gruppierungsoptionen wählen:

      • No grouping
      • Group by columns
      • Group all

      Sie können auch die folgenden aggregierten Verlustgewichtungen festlegen:

      • Group total weight. Dieses Feld kann nur festgelegt werden, wenn Sie die Option Group by columns oder Group all wählen.
      • Temporal total weight.
      • Group temporal total weight. Dieses Feld kann nur festgelegt werden, wenn Sie die Option Group by columns oder Group all wählen.

      Weitere Informationen zur hierarchischen Prognose.

    9. Klicken Sie auf Weiter.

  9. Konfigurieren Sie auf der Seite Computing und Preise Folgendes:

    1. Geben Sie an, wie viele Stunden das Modell maximal trainiert werden soll. Mit dieser Einstellung können Sie die Trainingskosten begrenzen. Die tatsächlich benötigte Zeit kann aber länger sein als dieser Wert, da auch noch andere Vorgänge am Erstellen eines neuen Modells beteiligt sind.

      Die vorgeschlagene Trainingszeit hängt von der Größe Ihres Prognosezeitraums und Ihren Trainingsdaten ab. In der folgenden Tabelle finden Sie einige Beispiel-Trainingsläufe für Prognosen und den Bereich der Trainingszeit, der für das Trainieren eines qualitativ hochwertigen Modells erforderlich war.

      Zeilen Features Prognosezeitraum Trainingszeit
      12 Millionen 10 6 3 - 6 Stunden
      20 Millionen 50 13 6 - 12 Stunden
      16 Millionen 30 365 24 - 48 Stunden

      Informationen zu den Preisen für Trainings finden Sie auf der Seite "Preise".

    2. Klicken Sie auf Training starten.

      Das Modelltraining kann viele Stunden dauern, je nach Größe und Komplexität Ihrer Daten und Ihres Trainingsbudgets, sofern Sie eines angegeben haben. Sie können diesen Tab schließen und später zu ihm zurückkehren. Wenn das Training für Ihr Modell abgeschlossen ist, erhalten eine E-Mail.

API

Wählen Sie einen Tab für Ihre Sprache oder Ihre Umgebung aus:

REST

Sie verwenden den Befehl trainingPipelines.create, um ein Modell zu trainieren.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION: Ihre Region.
  • PROJECT: Ihre Projekt-ID.
  • TRAINING_PIPELINE_DISPLAY_NAME: Anzeigename für die Trainingspipeline, die für diesen Vorgang erstellt wurde.
  • TRAINING_TASK_DEFINITION: Die Trainingsmethode des Modells.
    • Zeitreihen-Dense-Encoder (TiDE)
      gs://google-cloud-aiplatform/schema/trainingjob/definition/time_series_dense_encoder_forecasting_1.0.0.yaml
    • Temporal Fusion Transformer (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
    Weitere Informationen finden Sie unter Methoden für das Modelltraining.
  • TARGET_COLUMN: Die Spalte (Wert), für die das Modell Vorhersagen treffen soll.
  • Spalte TIME_COLUMNTime (Zeit) Weitere Informationen
  • TIME_SERIES_IDENTIFIER_COLUMN: Die Zeitachsenkennzeichnungs-Spalte. Weitere Informationen
  • WEIGHT_COLUMN: (Optional) Die Gewichtungsspalte. Weitere Informationen
  • TRAINING_BUDGET: Die maximale Zeit, die das Modell trainiert werden soll, in Milli-Knotenstunden (1.000 Milli-Knotenstunden entsprechen einer Knotenstunde).
  • GRANULARITY_UNIT: Die Einheit, die für die Granularität Ihrer Trainingsdaten und den Prognosezeitraum und das Kontextfenster verwendet werden soll. Kann minute, hour, day, week, month oder year sein. Wählen Sie day aus, wenn Sie die Effektmodellierung für Feiertage verwenden möchten. Weitere Informationen zum Auswählen des Daten-Detaillierungsgrads
  • GRANULARITY_QUANTITY: Die Anzahl der Granularitätseinheiten, aus denen das Intervall zwischen Beobachtungen in den Trainingsdaten besteht. Muss für alle Einheiten mit Ausnahme von Minuten eins sein, entweder 1, 5, 10, 15 oder 30. Weitere Informationen zum Auswählen des Daten-Detaillierungsgrads
  • GROUP_COLUMNS: Spaltennamen in der Trainingseingabetabelle, die die Gruppierung für die Hierarchieebene identifizieren. Die Spalten müssen `time_series_attribute_columns` sein. Weitere Informationen
  • GROUP_TOTAL_WEIGHT: Gewichtung der aggregierten Verluste der Gruppe im Verhältnis zum individuellen Verlust. Deaktiviert, wenn "0,0" oder nichts festgelegt ist. Ist die Gruppenspalte nicht festgelegt, werden alle Zeitachsen als Teil derselben Gruppe behandelt und die Aggregierung erfolgt über alle Zeitachsen. Weitere Informationen
  • TEMPORAL_TOTAL_WEIGHT: Gewichtung des aggregierten Verlusts über die Zeit relativ zum individuellen Verlust. Deaktiviert, wenn "0,0" oder nichts festgelegt ist. Weitere Informationen
  • GROUP_TEMPORAL_TOTAL_WEIGHT: Gewichtung des Gesamtverlusts (Gruppe x Zeit) im Verhältnis zum individuellen Verlust. Deaktiviert, wenn "0,0" oder nichts festgelegt ist. Ist die Gruppenspalte nicht festgelegt, werden alle Zeitachsen als Teil derselben Gruppe behandelt und die Aggregierung erfolgt über alle Zeitachsen. Weitere Informationen
  • HOLIDAY_REGIONS: (Optional) Sie können eine oder mehrere geografische Regionen auswählen, um die Effektmodellierung für Feiertage zu aktivieren. Während des Trainings erstellt Vertex AI innerhalb des Modells kategoriale Features basierend auf dem Datum aus TIME_COLUMN und den angegebenen geografischen Regionen. Setzen Sie zur Aktivierung GRANULARITY_UNIT auf day und geben Sie eine oder mehrere Regionen im Feld HOLIDAY_REGIONS an. Standardmäßig ist die Effektmodellierung deaktiviert. Weitere Informationen finden Sie unter Feiertagsregionen.
  • FORECAST_HORIZON: Der Prognosezeitraum bestimmt, wie weit das Modell den Zielwert für jede Zeile mit Vorhersagedaten prognostiziert. Der Prognosezeitraum wird in Einheiten der Datengranularität angegeben (GRANULARITY_UNIT). Weitere Informationen.
  • CONTEXT_WINDOW: Das Kontextfenster legt fest, wie weit das Modell während des Trainings (und für Prognosen) zurückblickt. Mit anderen Worten: Für jeden Trainingsdatenpunkt bestimmt das Kontextfenster, wie weit das Modell nach Vorhersagemustern sucht. Das Kontextfenster wird in der Datengranularität angegeben (GRANULARITY_UNIT). Weitere Informationen
  • OPTIMIZATION_OBJECTIVE: Standardmäßig minimiert Vertex AI die Wurzel der mittleren Fehlerquadratsumme (Root Mean Squared Error, RMSE). Wenn Sie ein anderes Optimierungsziel für Ihr Prognosemodell benötigen, wählen Sie eine der Optionen unter Optimierungsziele für Prognosemodelle aus. Wenn Sie den Quantilverlust minimieren möchten, müssen Sie auch einen Wert für QUANTILES angeben.
  • PROBABILISTIC_INFERENCE: (Optional) Wenn der Wert auf true gesetzt ist, modelliert Vertex AI die Wahrscheinlichkeitsverteilung der Prognose. Die probabilistische Inferenz kann die Modellqualität verbessern, indem ungenaue Daten verarbeitet und Unsicherheiten quantifiziert werden. Wenn QUANTILES angegeben sind, gibt Vertex AI auch die Quantile der Wahrscheinlichkeitsverteilung zurück. Probabilistische Inferenz ist nur kompatibel mit der 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