Melatih model perkiraan

Halaman ini menunjukkan cara melatih model perkiraan dari set data tabel menggunakan konsol Google Cloud atau Vertex AI API.

Sebelum memulai

Sebelum dapat melatih model perkiraan, Anda harus menyelesaikan langkah-langkah berikut:

Melatih model

Konsol Google Cloud

  1. Di konsol Google Cloud, di bagian Vertex AI, buka halaman Datasets.

    Buka halaman Datasets

  2. Klik nama set data yang ingin Anda gunakan untuk melatih model agar dapat membuka halaman detailnya.

  3. Jika jenis data Anda menggunakan kumpulan anotasi, pilih kumpulan anotasi yang ingin digunakan untuk model ini.

  4. Klik Train new model.

  5. Pilih Lainnya.

  6. Di halaman Metode pelatihan, konfigurasi sebagai berikut:

    1. Pilih metode pelatihan model. Untuk mempelajari lebih lanjut, lihat Metode pelatihan model.

    2. Klik Lanjutkan.

  7. Di halaman Detail model, konfigurasi sebagai berikut:

    1. Masukkan nama tampilan untuk model baru Anda.

    2. Pilih kolom target.

      Kolom target adalah nilai yang akan diperkirakan oleh model. Pelajari persyaratan kolom target lebih lanjut.

    3. Jika Anda belum menetapkan kolom ID seri dan Stempel waktu di set data, pilih kolom tersebut sekarang.

    4. Pilih Perincian data. Pilih Daily jika Anda ingin menggunakan pemodelan efek musim liburan. Pelajari cara memilih tingkat perincian data.

    5. Opsional: Di menu dropdown Wilayah liburan, pilih satu atau beberapa wilayah geografis untuk mengaktifkan pemodelan efek musim liburan. Selama pelatihan, Vertex AI membuat fitur kategori liburan dalam model berdasarkan tanggal dari kolom Stempel waktu dan wilayah geografis yang ditentukan. Anda dapat memilih opsi ini hanya jika Perincian data ditetapkan ke Daily. Secara default, pemodelan efek liburan dinonaktifkan. Untuk mempelajari wilayah geografis yang digunakan untuk pemodelan efek hari libur, lihat Wilayah liburan.

    6. Masukkan Periode konteks dan Horizon perkiraan.

      Horizon perkiraan menentukan seberapa jauh model akan memperkirakan nilai target untuk setiap baris data prediksi di masa mendatang. Horizon perkiraan ditentukan dalam unit Perincian data.

      Periode konteks menetapkan rentang waktu ke belakang model selama pelatihan (dan untuk perkiraan). Dengan kata lain, untuk setiap titik data pelatihan, jendela konteks menentukan seberapa jauh model mencari pola prediktif. Periode konteks ditentukan dalam unit Perincian data.

      Pelajari lebih lanjut.

    7. Jika Anda ingin mengekspor set data pengujian ke BigQuery, centang Ekspor set data pengujian ke BigQuery dan berikan nama tabelnya.

    8. Jika Anda ingin mengontrol pembagian data secara manual atau mengonfigurasi periode perkiraan, buka Opsi lanjutan.

    9. Pembagian data default dilakukan secara kronologis, dengan persentase standar 80/10/10. Jika Anda ingin menentukan baris mana yang ditetapkan ke pemisahan secara manual, pilih Manual dan tentukan kolom Pemisahan data Anda.

      Pelajari pemisahan data lebih lanjut.

    10. Pilih strategi periode bergulir untuk pembuatan periode perkiraan. Strategi defaultnya adalah Jumlah.

      • Jumlah: Tetapkan nilai untuk jumlah maksimum periode di kotak teks yang disediakan.
      • Jangka: Tetapkan nilai panjang jangka waktu di kotak teks yang disediakan.
      • Kolom: Pilih nama kolom yang sesuai dari menu dropdown yang disediakan.

      Untuk mempelajari lebih lanjut, lihat Strategi periode bergulir.

    11. Klik Lanjutkan.

  8. Di halaman Opsi pelatihan, konfigurasikan sebagai berikut:

    1. Jika belum melakukannya, klik Buat statistik.

      Membuat statistik akan mengisi menu dropdown Transformasi.

    2. Tinjau daftar kolom Anda dan kecualikan setiap kolom dari pelatihan yang tidak boleh digunakan untuk melatih model.

      Jika Anda menggunakan kolom pembagian data, kolom tersebut harus disertakan.

    3. Tinjau transformasi yang dipilih untuk fitur yang disertakan dan lakukan update yang diperlukan.

      Baris berisi data yang tidak valid untuk transformasi yang dipilih akan dikecualikan dari pelatihan. Pelajari transformasi lebih lanjut

    4. Untuk setiap kolom yang Anda sertakan untuk pelatihan, tentukan Jenis fitur untuk hubungan fitur tersebut dengan deret waktunya, dan apakah fitur tersebut tersedia pada perkiraan waktu. Pelajari jenis dan ketersediaan fitur lebih lanjut.

    5. Jika Anda ingin menentukan kolom bobot, mengubah objektif pengoptimalan dari default, atau mengaktifkan perkiraan hierarkis, buka Opsi lanjutan.

    6. Opsional. Jika Anda ingin menentukan kolom bobot, pilih kolom tersebut dari daftar dropdown. Pelajari kolom bobot lebih lanjut.

    7. Opsional. Jika Anda ingin memilih tujuan pengoptimalan, pilih tujuan tersebut dari daftar. Pelajari tujuan pengoptimalan lebih lanjut.

    8. Opsional. Jika Anda ingin menggunakan perkiraan hierarkis, pilih Aktifkan peningkatan hierarkis. Anda dapat memilih di antara tiga opsi pengelompokkan:

      • No grouping
      • Group by columns
      • Group all

      Anda juga dapat memilih untuk menetapkan bobot penurunan agregat berikut:

      • Group total weight. Kolom ini hanya dapat ditetapkan jika Anda memilih opsi Group by columns atau Group all.
      • Temporal total weight.
      • Group temporal total weight. Kolom ini hanya dapat ditetapkan jika Anda memilih opsi Group by columns atau Group all.

      Pelajari perkiraan hierarkis lebih lanjut.

    9. Klik Lanjutkan.

  9. Di halaman Komputasi dan harga, konfigurasi sebagai berikut:

    1. Masukkan jumlah jam maksimum yang diinginkan untuk melatih model Anda. Setelan ini membantu Anda membatasi biaya pelatihan. Waktu berlalu sebenarnya bisa lebih lama dari nilai ini, karena ada operasi lain yang terlibat dalam pembuatan model baru.

      Waktu pelatihan yang disarankan berkaitan dengan ukuran horizon perkiraan dan data pelatihan Anda. Tabel di bawah ini memberikan beberapa contoh pelatihan perkiraan yang dijalankan, dan rentang waktu pelatihan yang diperlukan untuk melatih model berkualitas tinggi.

      Baris Fitur Horizon perkiraan Waktu pelatihan
      12 juta 10 6 3-6 jam
      20 juta 50 13 6-12 jam
      16 juta 30 365 24-48 jam

      Untuk informasi tentang harga pelatihan, lihat halaman harga.

    2. Klik Mulai Pelatihan.

      Pelatihan model dapat memerlukan waktu berjam-jam, bergantung pada ukuran dan kompleksitas data serta anggaran pelatihan, jika Anda menentukannya. Anda dapat menutup tab ini dan kembali membukanya lagi di lain waktu. Anda akan menerima email saat model telah menyelesaikan pelatihan.

API

Pilih tab untuk bahasa atau lingkungan Anda:

REST

Anda menggunakan perintah trainingPipelines.create untuk melatih model.

Sebelum menggunakan salah satu data permintaan, lakukan penggantian berikut:

  • LOCATION: Region Anda.
  • PROJECT: Project ID Anda.
  • TRAINING_PIPELINE_DISPLAY_NAME: Nama tampilan untuk pipeline pelatihan yang dibuat untuk operasi ini.
  • TRAINING_TASK_DEFINITION: Metode pelatihan model.
    • Encoder Padat deret waktu (TiDE)
      gs://google-cloud-aiplatform/schema/trainingjob/definition/time_series_dense_encoder_forecasting_1.0.0.yaml
    • Transformator Temporal Fusion (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
    Untuk mempelajari lebih lanjut, lihat Metode pelatihan model.
  • TARGET_COLUMN: Kolom (nilai) yang Anda inginkan untuk diprediksi oleh model ini.
  • TIME_COLUMN: Kolom waktu. Pelajari lebih lanjut.
  • TIME_SERIES_IDENTIFIER_COLUMN: Kolom ID deret waktu. Pelajari lebih lanjut.
  • WEIGHT_COLUMN: (Opsional) Kolom bobot. Pelajari lebih lanjut.
  • TRAINING_BUDGET: Jumlah waktu maksimum yang Anda inginkan untuk dilatih model, dalam milidetik jam node (1.000 milidetik jam node sama dengan satu jam node).
  • GRANULARITY_UNIT: Unit yang akan digunakan untuk perincian data pelatihan serta horizon perkiraan dan periode konteks Anda. Dapat berupa minute, hour, day, week, month, atau year. Pilih day jika Anda ingin menggunakan pemodelan efek musim liburan. Pelajari cara memilih tingkat perincian data.
  • GRANULARITY_QUANTITY: Jumlah unit perincian yang membentuk interval di antara pengamatan dalam data pelatihan Anda. Harus berupa satu untuk semua unit kecuali menit, yang dapat berupa 1, 5, 10, 15, atau 30. Pelajari cara memilih tingkat perincian data.
  • GROUP_COLUMNS: Nama kolom dalam tabel input pelatihan Anda yang mengidentifikasi pengelompokan untuk tingkat hierarki. Kolom harus berupa `time_Series_attribute_columns`. Pelajari lebih lanjut.
  • GROUP_TOTAL_WEIGHT: Berat kerugian gabungan grup relatif terhadap kerugian individual. Dinonaktifkan jika disetel ke `0,0` atau tidak disetel. Jika kolom grup tidak ditetapkan, semua deret waktu akan diperlakukan sebagai bagian dari grup yang sama dan digabungkan pada semua deret waktu. Pelajari lebih lanjut.
  • TEMPORAL_TOTAL_WEIGHT: Berat waktu kerugian gabungan relatif terhadap kerugian individual. Dinonaktifkan jika disetel ke `0,0` atau tidak disetel. Pelajari lebih lanjut.
  • GROUP_TEMPORAL_TOTAL_WEIGHT: Berat kerugian gabungan total (grup x waktu) yang relatif terhadap kerugian individual. Dinonaktifkan jika disetel ke `0,0` atau tidak disetel. Jika kolom grup tidak ditetapkan, semua deret waktu akan diperlakukan sebagai bagian dari grup yang sama dan digabungkan ke semua deret waktu. Pelajari lebih lanjut.
  • HOLIDAY_REGIONS: (Opsional) Anda dapat memilih satu atau beberapa wilayah geografis untuk mengaktifkan pemodelan efek musim liburan. Selama pelatihan, Vertex AI membuat fitur kategori liburan dalam model berdasarkan tanggal dari TIME_COLUMN dan wilayah geografis yang ditentukan. Untuk mengaktifkannya, tetapkan GRANULARITY_UNIT ke day dan tentukan satu atau beberapa region di kolom HOLIDAY_REGIONS. Secara default, pemodelan efek liburan dinonaktifkan. Untuk mempelajari lebih lanjut, lihat Wilayah liburan.
  • FORECAST_HORIZON: Horizon perkiraan menentukan seberapa jauh model memperkirakan nilai target untuk setiap baris data prediksi di masa mendatang. Horizon perkiraan ditentukan dalam unit perincian data (GRANULARITY_UNIT). Pelajari lebih lanjut.
  • CONTEXT_WINDOW: Periode konteks menetapkan rentang waktu ke belakang model selama pelatihan (dan untuk perkiraan). Dengan kata lain, untuk setiap titik data pelatihan, periode konteks menentukan seberapa jauh model mencari pola prediktif. Periode konteks ditentukan dalam unit perincian data (GRANULARITY_UNIT). Pelajari lebih lanjut.
  • OPTIMIZATION_OBJECTIVE: Secara default, Vertex AI meminimalkan error akar rata-rata kuadrat (RMSE). Jika Anda menginginkan tujuan pengoptimalan yang berbeda untuk model perkiraan Anda, pilih salah satu opsi di Tujuan pengoptimalan untuk model perkiraan. Jika memilih untuk meminimalkan kerugian kuantil, Anda juga harus menentukan nilai untuk QUANTILES.
  • PROBABILISTIC_INFERENCE: (Opsional) Jika ditetapkan ke true, Vertex AI akan memodelkan distribusi probabilitas perkiraan. Inferensi probabilistik dapat meningkatkan kualitas model dengan menangani data yang mengandung noise dan mengukur ketidakpastian. Jika QUANTILES ditentukan, maka Vertex AI juga menampilkan kuantil distribusi probabilitas. Inferensi probabilistik hanya kompatibel dengan 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