Retail est renommé Vertex AI Search pour le commerce. Nous sommes en train de mettre à jour le contenu pour refléter le nouveau branding.

Cette page a été traduite par l'API Cloud Translation.

Générer des prévisions de ventes à partir de données de vente au détail

Cette page fournit des conseils pour obtenir des prédictions de Vertex AI, en fonction des données de commerce exportées vers BigQuery. Nous fournissons plusieurs blocs de code SQL pour vous aider à transformer les données sur les produits et les événements utilisateur en un format utilisable par Vertex AI. Ces blocs de code sont suivis de procédures permettant à la console Vertex AI de créer un ensemble de données, d'entraîner un modèle, puis de générer une prévision.

Avant de commencer

Avant de pouvoir générer des prévisions de ventes à l'aide de vos données de vente au détail, vous devez:

Importez vos données de vente au détail à l'aide de Vertex AI Search pour le commerce. Pour en savoir plus, consultez les pages suivantes :
Exporter vos données de vente au détail depuis Vertex AI Search pour le commerce vers BigQuery Vous disposez ainsi d'une table de produits et d'une table d'événements utilisateur dans BigQuery, que vous pouvez utiliser dans les procédures suivantes. Pour en savoir plus, consultez Exporter vos données vers BigQuery.

Si vos données sur les produits et les événements utilisateur se trouvent déjà dans BigQuery, vous pouvez utiliser ces données dans Vertex AI Search pour le format retail afin de générer des prévisions de ventes à partir de données retail. Dans ce cas, vous n'avez pas besoin d'importer vos données de vente au détail et de les exporter vers BigQuery. Pour en savoir plus sur le format, consultez Schéma de produit et À propos des événements utilisateur.
Assurez-vous d'avoir reçu le rôle IAM roles/aiplatform.user pour pouvoir effectuer les procédures à l'aide de la console Vertex AI.

Créer un tableau des ventes agrégé

Le code SQL de cette section transforme la table des événements utilisateur en une table de ventes agrégée. Cela signifie que pour chaque produit de la table des événements utilisateur ayant été vendu au moins une fois, la quantité de ventes du produit est agrégée sur une période hebdomadaire. En outre, le code SQL effectue les opérations suivantes:

Pour chaque produit de la table des événements utilisateur, si des codes temporels sont manquants entre la première vente du produit dans la table et la dernière vente de n'importe quel produit dans la table, chacun des codes temporels manquants est remplacé par une nouvelle ligne avec zéro vente. Cela permet d'éliminer les lacunes dans l'historique des ventes.
Si aucun produit de la table des événements utilisateur ne comporte au moins 20 codes temporels, un produit de la table est choisi au hasard et est complété par suffisamment de lignes (chacune avec zéro vente) pour atteindre 20 codes temporels. Cela permet de répondre à l'exigence de Vertex AI d'avoir au moins 20 codes temporels lors de l'entraînement d'un modèle.

Pour créer une table de ventes agrégée:

Remplacez les variables dans l'exemple de code SQL suivant comme suit:

starting_day_of_week. Jour de début de la semaine. Valeurs valides : MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY et SUNDAY.
rdm_user_event_table. ID du projet, de l'ensemble de données et de la table de la table des événements utilisateur que vous avez exportée vers BigQuery. Il a le format suivant : project_id.dataset_id.table_id.
rdm_product_table. ID du projet, de l'ensemble de données et de la table de la table de produits que vous avez exportée vers BigQuery. Il a le format suivant : project_id.dataset_id.table_id.
aggregated_sales_table. Les ID du projet, de l'ensemble de données et de la table dans BigQuery pour la nouvelle table de ventes agrégées. Utilisez le même ID de projet que pour les tables des événements produit et utilisateur. Utilisez l'ID d'un ensemble de données existant. Spécifiez un ID de table, mais n'utilisez pas l'ID d'une table existante, sauf si vous souhaitez l'écraser. Il a le format suivant : project_id.dataset_id.table_id.

Exemple de code SQL

  DECLARE max_date DATE;

  SET max_date = (SELECT LAST_DAY(DATETIME(max(event_time)),
  WEEK(STARTING_DAY_OF_WEEK)) FROM `RDM_USER_EVENT_TABLE`);

  CREATE OR REPLACE TABLE `AGGREGATED_SALES_TABLE` AS
  WITH flatten_sku AS
  (
    SELECT * EXCEPT(quantity, product), COALESCE(quantity, 1) as quantity,
    product.id as sku FROM
    (
      SELECT * EXCEPT(product_details),
      FROM `RDM_USER_EVENT_TABLE`,
      UNNEST(product_details) AS product_detail
    )
    WHERE product IS NOT NULL
  ),

  aggregate_by_type as
  (
      SELECT event_type, sum(quantity) as quantity, sku,
      LAST_DAY(DATETIME(event_time), WEEK(STARTING_DAY_OF_WEEK)) as
      last_day_of_week
      from flatten_sku group by event_type, sku, last_day_of_week
  ),

  sales_table as
  (
      SELECT quantity, sku, last_day_of_week FROM aggregate_by_type where
      event_type = 'purchase-complete'
  ),

  sales_table_with_known_products as
  (
      SELECT * EXCEPT (product_table_sku) FROM
      (
          SELECT s.*, p.id as product_table_sku FROM sales_table as s LEFT JOIN
          `RDM_PRODUCT_TABLE` as p
          ON s.sku = p.id
      )
      WHERE product_table_sku is NOT NULL
  ),

  fill_gap as
  (
      SELECT sku, sale_date as last_day_of_week, 0 as quantity
      FROM
      (
          SELECT sku, GENERATE_DATE_ARRAY(min_date, max_date, INTERVAL 7 DAY)
          date_range FROM
          (
              SELECT sku , MIN(last_day_of_week) as min_date FROM
              sales_table_with_known_products GROUP BY sku
          )
      ),
      UNNEST(date_range) sale_date
  ),

  sales_table_backfill as
  (
      SELECT fill_gap.sku, fill_gap.last_day_of_week, coalesce(original.quantity,
      fill_gap.quantity) as quantity
      FROM
      fill_gap LEFT JOIN sales_table_with_known_products original
      ON fill_gap.sku = original.sku and fill_gap.last_day_of_week =
      original.last_day_of_week
  ),

  one_sku_extend_history as
  (
      SELECT sku, GENERATE_DATE_ARRAY(IF(min_date < DATE_SUB(max_date, INTERVAL
      140 DAY), min_date, DATE_SUB(max_date, INTERVAL 140 DAY)), max_date,
      INTERVAL 7 DAY) date_range FROM
      (
          SELECT sku , MIN(last_day_of_week) as min_date FROM sales_table_backfill
          GROUP BY sku LIMIT 1
      )
  ),

  one_sku_extend_history2 as
  (
      SELECT backfill.sku, backfill.sale_date as last_day_of_week,
      coalesce(original.quantity, backfill.sale_quantity) as quantity
      FROM
      (
          SELECT sku, sale_date, 0 as sale_quantity
          FROM one_sku_extend_history,
              UNNEST(date_range) sale_date
      ) backfill
      LEFT JOIN sales_table_backfill original
      ON backfill.sku = original.sku and backfill.sale_date =
      original.last_day_of_week
  ),

  sales_table_extend_history as
  (
      SELECT quantity, sku, last_day_of_week
      FROM sales_table_backfill
      WHERE sku not in
      (select sku from one_sku_extend_history)
      UNION ALL
      SELECT quantity, sku, last_day_of_week
      FROM
      one_sku_extend_history2
  ),

  other_event_table as
  (
      SELECT sku, last_day_of_week,
      SUM(category_page_view_quantity) as category_page_view_quantity,
      SUM(search_quantity) as search_quantity,
      SUM(detail_page_view_quantity) as detail_page_view_quantity,
      SUM(add_to_cart_quantity) as add_to_cart_quantity
      FROM
      (
          SELECT sku, last_day_of_week,
          CASE
              WHEN event_type = 'category-page-view' THEN quantity
          END as category_page_view_quantity,
          CASE
              WHEN event_type = 'search' THEN quantity
          END as search_quantity,
          CASE
              WHEN event_type = 'detail-page-view' THEN quantity
          END as detail_page_view_quantity,
          CASE
              WHEN event_type = 'add-to-cart' THEN quantity
          END as add_to_cart_quantity,
          FROM aggregate_by_type WHERE event_type != 'purchase-complete'
      ) GROUP BY sku, last_day_of_week
  )

  SELECT t1.*, t2.category_page_view_quantity, t2.search_quantity,
  t2.detail_page_view_quantity, t2.add_to_cart_quantity
  FROM sales_table_extend_history as t1 left join other_event_table as t2
  ON t1.sku = t2.sku AND t1.last_day_of_week = t2.last_day_of_week

Copiez l'exemple de code SQL.
Ouvrez la page BigQuery dans la console Google Cloud.

Accéder à la page "BigQuery"
Si ce n'est pas déjà fait, sélectionnez le projet contenant vos tables de produits et d'événements utilisateur.
Dans le volet Éditeur, collez l'exemple de code SQL.
Cliquez sur Run (Exécuter) et attendez la fin de l'exécution de la requête.

Votre nouvelle table de ventes agrégées est écrite à l'emplacement dans BigQuery que vous avez défini à l'aide de la variable aggregated_sales_table.

Traiter le tableau des produits

Le code SQL de cette section agit sur la table des produits que vous avez exportée vers BigQuery. Il supprime les champs répétés et struct, et décompose le champ price_info dans ses champs enfants. Cette étape est nécessaire, car Vertex AI n'accepte pas les listes ni les structures imbriquées. Le résultat est le tableau des produits traités.

Pour traiter le tableau des produits:

Remplacez les variables dans l'exemple de code SQL suivant comme suit:
- rdm_product_table. ID du projet, de l'ensemble de données et de la table de la table de produits que vous avez exportée vers BigQuery. Il a le format suivant : project_id.dataset_id.table_id.
- processed_product_table. ID du projet, de l'ensemble de données et de la table dans BigQuery pour la nouvelle table des produits transformés. Utilisez le même ID de projet que pour les tables des événements produit et utilisateur. Utilisez l'ID d'un ensemble de données existant. Spécifiez un ID de table, mais n'utilisez pas l'ID d'une table existante, sauf si vous souhaitez l'écraser. Il a le format suivant : project_id.dataset_id.table_id.
```
CREATE OR REPLACE TABLE `PROCESSED_PRODUCT_TABLE` AS
SELECT * EXCEPT (id, attributes, price_info, rating, expire_time,
available_time, fulfillment_info, images, audience, color_info, promotions,
publish_time, retrievable_fields, categories, brands, conditions, sizes,
collection_member_ids, tags, materials, patterns),
id as sku,
price_info.price as price_info_price,
price_info.currency_code as price_info_currency_code,
price_info.cost as price_info_cost,
FROM `RDM_PRODUCT_TABLE`
```
Copiez l'exemple de code SQL.
Ouvrez la page BigQuery dans la console Google Cloud.

Accéder à la page "BigQuery"
Si ce n'est pas déjà fait, sélectionnez le projet contenant vos tables de produits et d'événements utilisateur.
Dans le volet Éditeur, collez l'exemple de code SQL.
Cliquez sur Run (Exécuter) et attendez la fin de l'exécution de la requête.

Votre nouvelle table de produits traités est écrite dans l'emplacement BigQuery que vous avez défini à l'aide de la variable processed_product_table.

Créer un tableau de prédiction des événements

Le code SQL de cette section extrait chaque code SKU vendu au moins une fois dans le tableau des événements utilisateur. Le code crée une table de prédiction des événements contenant tous les codes SKU extraits pour tous les codes temporels à venir. Les codes temporels futurs sont un tableau de codes temporels hebdomadaires continus, commençant à la dernière semaine du tableau des événements utilisateur + 1 semaine et se terminant à la dernière semaine du tableau des événements utilisateur + future_length semaines. Définissez la valeur future_length sur le nombre de semaines à venir que vous souhaitez que le modèle prédise. Chaque ligne du tableau de prédiction des événements peut être identifiée de manière unique par un SKU et un code temporel.

Pour créer une table de prédiction d'événements:

Remplacez les variables dans l'exemple de code SQL suivant comme suit:

starting_day_of_week. Jour de début de la semaine. Valeurs valides : MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY et SUNDAY.
rdm_user_event_table. ID du projet, de l'ensemble de données et de la table de la table des événements utilisateur que vous avez exportée vers BigQuery. Il a le format suivant : project_id.dataset_id.table_id.
events_prediction_table. ID du projet, de l'ensemble de données et de la table dans BigQuery pour la nouvelle table de prédiction des événements. Utilisez le même ID de projet que pour les tables des événements produit et utilisateur. Utilisez l'ID d'un ensemble de données existant. Spécifiez un ID de table, mais n'utilisez pas l'ID d'une table existante, sauf si vous souhaitez l'écraser. Il a le format suivant : project_id.dataset_id.table_id.
rdm_product_table. ID du projet, de l'ensemble de données et de la table de la table de produits que vous avez exportée vers BigQuery. Il a le format suivant : project_id.dataset_id.table_id.
future_length. Nombre de semaines à venir, après la dernière semaine du tableau des événements utilisateur, que le modèle prédira.

Exemple de code SQL

  DECLARE max_date DATE;

  SET max_date = (SELECT LAST_DAY(DATETIME(max(event_time)),
  WEEK(STARTING_DAY_OF_WEEK)) FROM `RDM_USER_EVENT_TABLE`);

  CREATE OR REPLACE TABLE `EVENTS_PREDICTION_TABLE` AS
  WITH purchase_events as
  (
  SELECT * EXCEPT (product_details, product),
  order_item.product.id as sku
  FROM `RDM_USER_EVENT_TABLE`,
  UNNEST(product_details) as order_item
  WHERE event_type = 'purchase-complete'
  ),

  known_products_in_purchase_events as
  (
      SELECT sku FROM
      (
          SELECT s.sku, p.id as product_table_sku
          FROM (SELECT DISTINCT(sku) FROM purchase_events) as s
          LEFT JOIN `RDM_PRODUCT_TABLE` as p
          ON s.sku = p.id
      )
      WHERE product_table_sku is NOT NULL
  ),

  sales_table_future as
  (
      SELECT sku, future_date as last_day_of_week, NULL as quantity FROM
      (
          SELECT sku, GENERATE_DATE_ARRAY(DATE_ADD(max_date, INTERVAL 1 WEEK),
          DATE_ADD(max_date, INTERVAL FUTURE_LENGTH WEEK), INTERVAL 1
          WEEK)
          date_range
          FROM known_products_in_purchase_events
      ), UNNEST(date_range) future_date
  )
  SELECT * FROM sales_table_future

Copiez l'exemple de code SQL.
Ouvrez la page BigQuery dans la console Google Cloud.

Accéder à la page "BigQuery"
Si ce n'est pas déjà fait, sélectionnez le projet contenant vos tables de produits et d'événements utilisateur.
Dans le volet Éditeur, collez l'exemple de code SQL.
Cliquez sur Run (Exécuter) et attendez la fin de l'exécution de la requête.

Votre nouvelle table de prédiction des événements est écrite à l'emplacement dans BigQuery que vous avez défini à l'aide de la variable events_prediction_table.

Créer un tableau d'entraînement Vertex AI

Le code SQL de cette section joint la table des ventes agrégées à la table des produits traités. Le résultat est un tableau d'entraînement Vertex AI, que Vertex AI utilise pour l'entraînement du modèle.

Pour créer un tableau d'entraînement Vertex AI:

Remplacez les variables dans l'exemple de code SQL suivant comme suit:
- vertex_ai_training_table. ID du projet, de l'ensemble de données et de la table dans BigQuery pour la nouvelle table d'entraînement Vertex AI. Utilisez le même ID de projet que les tables des événements produit et utilisateur. Utilisez l'ID d'un ensemble de données existant. Spécifiez un ID de table, mais n'utilisez pas l'ID d'une table existante, sauf si vous souhaitez l'écraser. Il a le format suivant : project_id.dataset_id.table_id.
- aggregated_sales_table. ID du projet, de l'ensemble de données et de la table dans BigQuery de la table des ventes agrégées que vous avez créée dans Créer une table des ventes agrégées.
- processed_product_table. ID du projet, de l'ensemble de données et de la table dans BigQuery pour la table de produits traitée, que vous avez créée dans Traiter la table des produits.
```
CREATE OR REPLACE TABLE `VERTEX_AI_TRAINING_TABLE` AS
SELECT t1.*, t2.* EXCEPT(sku) FROM `AGGREGATED_SALES_TABLE` AS t1
LEFT
JOIN `PROCESSED_PRODUCT_TABLE` AS t2 ON t1.sku = t2.sku
```
Copiez l'exemple de code SQL.
Ouvrez la page BigQuery dans la console Google Cloud.

Accéder à la page "BigQuery"
Si ce n'est pas déjà fait, sélectionnez le projet contenant vos tables de produits et d'événements utilisateur.
Dans le volet Éditeur, collez l'exemple de code SQL.
Cliquez sur Run (Exécuter) et attendez la fin de l'exécution de la requête.

Votre nouvelle table d'entraînement Vertex AI est écrite à l'emplacement dans BigQuery que vous avez défini à l'aide de la variable vertex_ai_training_table.

Créer un tableau de prédictions Vertex AI

Le code SQL de cette section ajoute la table de prédiction des événements à la table des ventes agrégées, puis la joint à la table des produits traités. Le résultat est le tableau de prédiction Vertex AI, qui permet de créer une prévision.

Pour créer un tableau de prédiction Vertex AI:

Remplacez les variables dans l'exemple de code SQL suivant comme suit:
- vertex_ai_prediction_table. ID du projet, de l'ensemble de données et de la table dans BigQuery pour la nouvelle table de prédiction Vertex AI. Utilisez le même ID de projet et le même ID d'ensemble de données que ceux que vous avez utilisés pour les tables des événements produit et utilisateur. N'utilisez pas l'ID d'une table existante, sauf si vous souhaitez l'écraser. Il a le format suivant : project_id.dataset_id.table_id.
- aggregated_sales_table. Les ID de projet, d'ensemble de données et de table dans BigQuery pour la table de ventes agrégées que vous avez créée dans Créer une table de ventes agrégées.
- processed_product_table. ID du projet, de l'ensemble de données et de la table dans BigQuery pour la table de produits traitée, que vous avez créée dans Traiter la table des produits.
- events_prediction_table. ID du projet, de l'ensemble de données et de la table dans BigQuery pour la table de prédiction des événements que vous avez créée dans Créer une table de prédiction des événements.
```
CREATE OR REPLACE TABLE `VERTEX_AI_PREDICTION_TABLE` AS
WITH append_predict_to_history AS (
  SELECT add_to_cart_quantity, category_page_view_quantity,
  detail_page_view_quantity, last_day_of_week, quantity, search_quantity, sku
  FROM `AGGREGATED_SALES_TABLE` UNION ALL SELECT NULL AS
  add_to_cart_quantity, NULL AS category_page_view_quantity, NULL AS
  detail_page_view_quantity, last_day_of_week, NULL AS quantity, NULL AS
  search_quantity, sku FROM `EVENTS_PREDICTION_TABLE`
)
SELECT t1.*, t2.* EXCEPT(sku) FROM append_predict_to_history AS t1 LEFT JOIN
`PROCESSED_PRODUCT_TABLE` AS t2 ON t1.sku = t2.sku
```
Copiez l'exemple de code SQL.
Ouvrez la page BigQuery dans la console Google Cloud.

Accéder à la page "BigQuery"
Si ce n'est pas déjà fait, sélectionnez le projet contenant vos tables de produits et d'événements utilisateur.
Dans le volet Éditeur, collez l'exemple de code SQL.
Cliquez sur Run (Exécuter) et attendez la fin de l'exécution de la requête.

Votre nouvelle table de prédiction Vertex AI est écrite à l'emplacement dans BigQuery que vous avez défini à l'aide de la variable vertex_ai_prediction_table.

Créer un ensemble de données Vertex AI

Cette section explique comment créer un ensemble de données Vertex AI que vous pouvez utiliser pour entraîner un modèle de prévision. Pour en savoir plus, consultez Créer un ensemble de données pour entraîner des modèles de prévision dans la documentation Vertex AI.

Pour créer un ensemble de données Vertex AI:

Dans la console Google Cloud, dans la section Vertex AI, accédez à la page Ensemble de données.

Accéder à la page Ensembles de données
Cliquez sur Créer pour ouvrir la page Créer un ensemble de données.
Dans le champ Nom de l'ensemble de données, saisissez un nom pour votre nouvel ensemble de données.
Sélectionnez l'onglet Tabulaire.
Sélectionnez l'objectif Prévision.
Dans la liste Région, sélectionnez la région que vous avez utilisée lorsque vous avez créé un ensemble de données pour exporter vos données de vente au détail vers BigQuery. Si vous avez sélectionné États-Unis lorsque vous avez créé votre ensemble de données BigQuery, vous pouvez sélectionner n'importe quelle région des États-Unis. De même, si vous avez sélectionné eu lorsque vous avez créé votre ensemble de données BigQuery, vous pouvez sélectionner n'importe quelle région de l'Union européenne. Pour en savoir plus, consultez Exporter vos données vers BigQuery.
Cliquez sur Créer pour créer un ensemble de données vide, puis accédez à l'onglet Source.
Sélectionnez Sélectionner une table ou une vue à partir de BigQuery.
Sous Select a table or view from BigQuery (Sélectionner une table ou une vue dans BigQuery), saisissez les ID du projet, de l'ensemble de données et de la table pour la table d'entraînement Vertex AI que vous avez créée dans Créer une table d'entraînement Vertex AI. Il a le format suivant : project_id.dataset_id.table_id.
Cliquez sur Continuer.

Votre source de données est associée à votre ensemble de données.
Dans l'onglet Analyser, sélectionnez sku dans la liste Colonne "Identifiant de la série" et last_day_of_week dans la liste Colonne "Horodatage".
Cliquez sur Entraîner un nouveau modèle pour accéder à la page Entraîner un nouveau modèle. Pour savoir comment entraîner votre modèle, consultez Entraîner un modèle de prévision.

Entraîner un modèle de prévision

Cette section explique comment entraîner un modèle de prévision à l'aide de l'ensemble de données que vous avez créé dans Créer un ensemble de données Vertex AI. Pour en savoir plus, consultez Entraîner un modèle de prévision dans la documentation Vertex AI.

Avant de commencer

Avant de pouvoir entraîner un modèle de prévision, vous devez créer un ensemble de données Vertex AI.

Entraîner un modèle

Sur la page Méthode d'entraînement, sélectionnez la méthode d'entraînement du modèle. Pour en savoir plus sur les méthodes d'entraînement, consultez la section Entraîner un modèle dans la documentation Vertex AI.

Cliquez sur Continuer.
Sur la page Informations sur le modèle, configurez les éléments comme suit :
1. Sélectionnez Entraîner un nouveau modèle si ce n'est pas déjà fait.
2. Attribuez un nom à votre nouveau modèle.
3. Sélectionnez quantity (INTEGER) [Quantité (ENTIER)] dans la liste Colonne cible.
4. Sélectionnez Hebdomadaire dans la liste Précision de la donnée.
5. 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. Si vous ne spécifiez pas de Fenêtre de contexte, celle-ci est définie par défaut sur la valeur attribuée à l'horizon de prévision. La fenêtre de contexte est spécifiée en unités de précision des données.
  
  Pour en savoir plus, consultez la section Éléments à prendre en compte dans la définition de la fenêtre de contexte et de l'horizon des prévisions dans la documentation Vertex AI.
6. Cliquez sur Continuer.
Sur la page Options d'entraînement, configurez les éléments comme suit : Notez que lorsque la flèche du menu déroulant est grise ou qu'il n'y a pas de flèche, cette valeur ne peut pas être modifiée.
1. Sélectionnez une valeur Transformation pour les colonnes de la liste Nom de la colonne comme suit:
  - Si la valeur Type BigQuery est Nombre à virgule flottante, Entier ou Numérique, définissez la valeur Transformation sur Numérique.
  - Si la valeur Type BigQuery est Chaîne ou Booléen, définissez la valeur Transformation sur Catégorique.
  - Si la valeur Type BigQuery est Date, définissez la valeur Transformation sur Code temporel.
2. Sélectionnez une valeur Type d'élément pour les colonnes de la liste Nom de la colonne comme suit:
  - Pour add_to_cart_quantity, category_page_view_quantity, detail_page_view_quantity et search_quantity, définissez la valeur Feature type (Type de caractéristique) sur Covariate (Covariate).
  - Pour les colonnes restantes pouvant être modifiées, définissez Type d'élément sur Attribut.
3. Sélectionnez une valeur Disponible pour les prévisions pour les colonnes de la liste Type de colonne comme suit:
  - Pour add_to_cart_quantity, category_page_view_quantity, detail_page_view_quantity et search_quantity, définissez la valeur Disponibilité pour les prévisions sur Non disponible.
  - Pour les colonnes restantes qui peuvent être modifiées, définissez la valeur Feature type (Type d'éléments géographiques) sur Available (Disponible).
4. Cliquez sur Continuer.
Sur la page Options de calcul et tarifs, indiquez le nombre maximal d'heures pendant lesquelles votre modèle doit s'entraîner. 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. Pour en savoir plus sur le temps nécessaire pour entraîner des modèles de haute qualité, consultez la section Entraîner un modèle dans la documentation Vertex AI.
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é. Si vous souhaitez surveiller la progression de l'entraînement du modèle, consultez Surveiller la progression de votre entraînement.

Suivre la progression de votre entraînement

Dans la console Google Cloud, dans la section Vertex AI, accédez à la page Entraînement.

Accéder à la page Entraînement
S'il n'est pas déjà sélectionné, sélectionnez l'onglet Pipelines d'entraînement. Le modèle que vous entraînez doit figurer dans la liste. L'entraînement est terminé lorsque l'état passe de Training (Entraînement) à Finished (Terminé).

Créer une prévision

Cette page explique comment créer une prévision à l'aide du modèle de prévision que vous avez entraîné dans Entraîner un modèle de prévision.

Avant de commencer

Pour pouvoir créer une prévision, vous devez entraîner un modèle de prévision.

Envoyer une requête de prédiction par lot au modèle

Dans la console Google Cloud, dans la section Vertex AI, accédez à la page Prédictions par lot.

Accéder à la page "Prédictions par lot"
Cliquez sur Créer pour ouvrir la fenêtre Nouvelle prédiction par lot et procédez comme suit:
1. Saisissez un nom pour la prédiction par lot.
2. Dans la liste Nom du modèle, sélectionnez le modèle que vous avez entraîné dans Entraîner un modèle de prévision.
3. Dans la liste Version, sélectionnez la version du modèle.
4. Sous Sélectionner une source:
  1. Sélectionnez Table BigQuery si ce n'est pas déjà fait.
  2. Saisissez les ID de projet, d'ensemble de données et de table dans BigQuery pour la table de prédiction Vertex AI que vous avez créée dans Créer une table de prédiction Vertex AI. Il a le format suivant : project_id.dataset_id.table_id.
5. Sous Résultat de la prédiction par lot:
  1. Dans la liste Format de sortie, sélectionnez Table BigQuery.
  2. Saisissez les ID de projet et d'ensemble de données dans BigQuery pour la table de sortie de prédiction par lot que vous créez. Utilisez le même ID de projet et le même ID d'ensemble de données que ceux que vous avez utilisés pour les tables des produits et des événements utilisateur. Le format est project_id.dataset_id..
6. Cliquez sur Créer. La page Prédictions par lot s'affiche.
  
  La prédiction est terminée lorsque l'état passe de En attente à Terminée. Vous recevez également un e-mail lorsque la prédiction par lot est terminée. Le résultat de votre requête de prédiction par lot est renvoyé dans l'ensemble de données du projet BigQuery que vous avez spécifié. Le nom de votre nouveau tableau de sortie est "predictions_" suivi de l'horodatage du début de la tâche de prédiction. Pour en savoir plus sur la récupération et l'interprétation des résultats de vos prévisions, consultez les pages Récupérer les résultats de prédiction par lot et Interpréter les résultats de prévision dans la documentation Vertex AI.