Entraîner un modèle de prévision

Cette page explique comment entraîner un modèle de prévision à partir d'un ensemble de données tabulaire à l'aide de la console Google Cloud ou de l'API Vertex AI.

Avant de commencer

Pour pouvoir entraîner un modèle de prévision, vous devez effectuer les opérations suivantes :

Entraîner un modèle

console Google Cloud

  1. Dans Google Cloud Console, dans la section Vertex AI, accédez à la page Ensembles de données.

    Accéder à la page Ensembles de données

  2. Cliquez sur le nom de l'ensemble de données que vous souhaitez utiliser pour entraîner votre modèle afin d'ouvrir sa page d'informations.

  3. Si votre type de données utilise des ensembles d'annotations, sélectionnez celui que vous souhaitez utiliser pour ce modèle.

  4. Cliquez sur Entraîner le nouveau modèle.

  5. Sélectionnez Autre.

  6. Sur la page Méthode d'entraînement, configurez les éléments comme suit :

    1. Sélectionnez la méthode d'entraînement de modèle. Pour en savoir plus, consultez Méthodes d'entraînement des modèles.

    2. Cliquez sur Continuer.

  7. Sur la page Informations sur le modèle, configurez les éléments comme suit :

    1. Saisissez le nom à afficher pour votre nouveau modèle.

    2. Sélectionnez votre colonne cible.

      La colonne cible correspond à la valeur que le modèle prévoit En savoir plus sur les exigences relatives aux colonnes cibles.

    3. Si vous n'avez pas défini les colonnes Identifiant de la série et Horodatage de votre ensemble de données, sélectionnez-les dès maintenant.

    4. Sélectionnez Précision de la donnée. Sélectionnez Daily si vous souhaitez utiliser la modélisation des effets des jours fériés. Découvrez comment choisir le niveau de précision des données.

    5. Facultatif : Dans la liste déroulante Jours fériés par région, sélectionnez une ou plusieurs régions géographiques pour activer la modélisation des effets des jours fériés. Pendant l'entraînement, Vertex AI crée des caractéristiques catégorielles de jours fériés dans le modèle en fonction de la date de la colonne Horodatage et des régions géographiques spécifiées. Vous ne pouvez sélectionner cette option que si le paramètre Précision des données est défini sur Daily. Par défaut, la modélisation des effets des jours fériés est désactivée. Pour en savoir plus sur les régions géographiques utilisées pour la modélisation des effets des jours fériés, consultez la section Jours fériés par région.

    6. Saisissez la fenêtre de contexte et l'horizon des prévisions.

      L'horizon de prévision détermine jusqu'à quand le modèle prévoit la valeur cible pour chaque ligne de données de prédiction. L'horizon de prévision est spécifié en unités de précision des données.

      La fenêtre de contexte définit jusqu'où le modèle remonte dans le temps lors de l'entraînement (et des prévisions). En d'autres termes, pour chaque point de données d'entraînement, la fenêtre de contexte détermine jusqu'à quelle période le modèle recherche des modèles prédictifs. La fenêtre de contexte est spécifiée en unités de précision des données.

      En savoir plus

    7. Si vous souhaitez exporter votre ensemble de données de test vers BigQuery, cochez la case Exporter l'ensemble de données de test vers BigQuery et indiquez le nom de la table.

    8. Si vous souhaitez contrôler manuellement votre répartition des données ou configurer la période de prévision, ouvrez les options avancées.

    9. La répartition des données par défaut est chronologique, avec les pourcentages standards 80/10/10. Si vous souhaitez spécifier manuellement les lignes à affecter à une répartition donnée, sélectionnez Manuel et spécifiez la colonne de répartition des données.

      En savoir plus sur les répartitions de données.

    10. Sélectionnez une stratégie de fenêtre glissante afin de générer une période de prévision. La stratégie par défaut est Count (Nombre).

      • Nombre : définissez la valeur du nombre maximal de fenêtres dans la zone de texte fournie.
      • Pas : définissez la valeur du pas dans la zone de texte fournie.
      • Colonne : sélectionnez le nom de colonne approprié dans la liste déroulante fournie.

      Pour en savoir plus, consultez la section Stratégies de fenêtre glissante.

    11. Cliquez sur Continuer.

  8. Sur la page Options d'entraînement, configurez les éléments comme suit :

    1. Si ce n'est pas déjà fait, cliquez sur Générer les statistiques.

      La génération de statistiques remplit les menus déroulants Transformation.

    2. Examinez votre liste de colonnes et excluez de l'entraînement toutes les colonnes qui ne doivent pas être utilisées pour entraîner le modèle.

      Si vous utilisez une colonne de répartition des données, vous devez l'inclure.

    3. Examinez les transformations sélectionnées pour les caractéristiques incluses et effectuez les mises à jour requises.

      Les lignes contenant des données non valides pour la transformation sélectionnée sont exclues de l'entraînement. Apprenez-en plus sur les transformations.

    4. Pour chaque colonne que vous avez incluse pour l'entraînement, spécifiez le Type de caractéristique en fonction de la relation entre cette caractéristique et sa série temporelle, et si celle-ci est disponible ou non au moment de la prévision. En savoir plus sur le type de fonctionnalité et la disponibilité

    5. Si vous souhaitez spécifier une colonne de pondération, modifier votre objectif d'optimisation par défaut ou activer les prévisions hiérarchiques, ouvrez la section Options avancées.

    6. Facultatif. Si vous souhaitez spécifier une colonne de pondération, sélectionnez-la dans la liste déroulante. Apprenez-en plus sur les colonnes de pondération.

    7. Facultatif. Si vous souhaitez sélectionner l'objectif d'optimisation, sélectionnez-le dans la liste. Apprenez-en plus sur les objectifs d'optimisation.

    8. Facultatif. Si vous souhaitez utiliser la prévision hiérarchique, sélectionnez Activer la prévision hiérarchique. Vous avez le choix entre trois options de regroupement :

      • No grouping
      • Group by columns
      • Group all

      Vous pouvez également choisir de définir les pondérations des pertes agrégées suivantes :

      • Group total weight : ce champ ne peut être défini que si vous sélectionnez l'option Group by columns ou Group all.
      • Temporal total weight.
      • Group temporal total weight : ce champ ne peut être défini que si vous sélectionnez l'option Group by columns ou Group all.

      Apprenez-en plus sur les prévisions hiérarchiques.

    9. Cliquez sur Continuer.

  9. Sur la page Options de calcul et tarifs, configurez les éléments suivants :

    1. Saisissez la durée maximale (en heures) d'entraînement de votre modèle. Ce paramètre vous permet de définir un plafond pour les coûts d'entraînement. Le temps écoulé peut être supérieur à cette valeur, car la création d'un modèle implique d'autres opérations.

      La durée d'entraînement suggérée dépend de la taille de votre horizon de prévision et de vos données d'entraînement. Le tableau ci-dessous contient des exemples d'exécutions d'entraînement de prévision et la plage de temps nécessaire pour entraîner un modèle de haute qualité.

      Rows (Lignes) Fonctionnalités Horizon de prévision Durée d'entraînement
      12 millions 10 6 3 à 6 heures
      20 millions 50 13 6 à 12 heures
      16 millions 30 365 24 à 48 heures

      Pour plus d'informations sur la tarification de l'entraînement, consultez la page des tarifs.

    2. Cliquez sur Démarrer l'entraînement.

      L'entraînement de modèle peut prendre plusieurs heures, en fonction de la taille et de la complexité de vos données et du budget d'entraînement, le cas échéant. Vous pouvez fermer cet onglet et y revenir plus tard. Vous recevrez un e-mail une fois l'entraînement terminé.

API

Sélectionnez un onglet pour votre langage ou environnement :

REST

Vous utilisez la commande trainingPipelines.create pour entraîner un modèle.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • LOCATION : votre région.
  • PROJECT : l'ID de votre projet.
  • TRAINING_PIPELINE_DISPLAY_NAME : nom à afficher du pipeline d'entraînement créé pour cette opération.
  • TRAINING_TASK_DEFINITION : méthode d'entraînement du modèle.
    • Encodeur dense de séries temporelles (TiDE)
      gs://google-cloud-aiplatform/schema/trainingjob/definition/time_series_dense_encoder_forecasting_1.0.0.yaml
    • Transformateur de fusion temporelle (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
    Pour en savoir plus, consultez Méthodes d'entraînement des modèles.
  • TARGET_COLUMN : colonne (valeur) que le modèle doit prédire.
  • TIME_COLUMN : colonne Heure. En savoir plus
  • TIME_SERIES_IDENTIFIER_COLUMN : colonne de l'identifiant de série temporelle. En savoir plus
  • WEIGHT_COLUMN (facultatif) : colonne de pondération. En savoir plus
  • TRAINING_BUDGET : durée maximale pendant laquelle le modèle doit être entraîné, en milli-nœuds-heure (1 000 milli-nœuds-heure correspondent à un nœud-heure).
  • GRANULARITY_UNIT : unité à utiliser pour la précision de vos données d'entraînement, de l'horizon de prévision et de la fenêtre de contexte. Il peut s'agir de minute, hour, day, week, month ou year. Sélectionnez day si vous souhaitez utiliser la modélisation des effets des jours fériés. Découvrez comment choisir le niveau de précision des données.
  • GRANULARITY_QUANTITY : nombre d'unités de précision qui composent l'intervalle entre les observations dans vos données d'entraînement. Doit être égal à un pour toutes les unités sauf les minutes, pouvant correspondre à 1, 5, 10, 15 ou 30. Découvrez comment choisir le niveau de précision des données.
  • GROUP_COLUMNS : noms de colonne de votre table d'entrée d'entraînement qui identifient le regroupement au niveau de la hiérarchie. La ou les colonnes doivent être "time_series_attribute_columns". Apprenez-en plus.
  • GROUP_TOTAL_WEIGHT : pondération de la perte agrégée du groupe par rapport à la perte individuelle. Désactivée si la valeur est définie sur "0.0" ou n'est pas définie. Si la colonne de groupe n'est pas définie, toutes les séries temporelles seront traitées dans le même groupe et agrégées sur toutes les séries temporelles. En savoir plus
  • TEMPORAL_TOTAL_WEIGHT : pondération de la perte agrégée dans le temps par rapport à la perte individuelle. Désactivée si la valeur est définie sur "0.0" ou n'est pas définie. En savoir plus
  • GROUP_TEMPORAL_TOTAL_WEIGHT : pondération de la perte totale (groupe x temps) par rapport à la perte individuelle. Désactivée si la valeur est définie sur "0.0" ou n'est pas définie. Si la colonne de groupe n'est pas définie, toutes les séries temporelles seront traitées dans le même groupe et agrégées sur toutes les séries temporelles. En savoir plus
  • HOLIDAY_REGIONS (facultatif) : vous pouvez sélectionner une ou plusieurs régions géographiques pour activer la modélisation des effets des jours fériés. Pendant l'entraînement, Vertex AI crée des caractéristiques catégorielles de jours fériés dans le modèle en fonction de la date de TIME_COLUMN et des régions géographiques spécifiées. Pour activer cette fonctionnalité, définissez GRANULARITY_UNIT sur day, puis spécifiez une ou plusieurs régions dans le champ HOLIDAY_REGIONS. Par défaut, la modélisation des effets des jours fériés est désactivée. Pour en savoir plus, consultez la page Jours fériés par région.
  • FORECAST_HORIZON : L'horizon de prévision détermine jusqu'à quand le modèle prévoit la valeur cible pour chaque ligne de données de prédiction. L'horizon de prévision est spécifié en unités de précision des données (GRANULARITY_UNIT). En savoir plus
  • CONTEXT_WINDOW : La fenêtre de contexte définit jusqu'où le modèle remonte dans le temps lors de l'entraînement (et des prévisions). En d'autres termes, pour chaque point de données d'entraînement, la fenêtre de contexte détermine jusqu'à quelle période le modèle recherche des modèles prédictifs. La fenêtre de contexte est spécifiée en unités de précision des données (GRANULARITY_UNIT). En savoir plus.
  • OPTIMIZATION_OBJECTIVE : par défaut, Vertex AI minimise la racine carrée de l'erreur quadratique moyenne (RMSE). Si vous souhaitez un objectif d'optimisation différent pour votre modèle de prévision, choisissez l'une des options décrites dans la section Objectifs d'optimisation pour les modèles de prévision. Si vous choisissez de minimiser la perte de quantiles, vous devez également spécifier une valeur pour QUANTILES.
  • PROBABILISTIC_INFERENCE : (facultatif) si le champ est défini sur true, Vertex AI modélise la distribution de probabilité de la prévision. L'inférence probabiliste peut améliorer la qualité du modèle en gérant les données comportant du bruit et en quantifiant l'incertitude. Si une valeur QUANTILES est spécifiée, Vertex AI renvoie également les quantiles de la distribution de probabilité. L'inférence probabiliste n'est compatible qu'avec 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 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 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 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 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