"Retail" devient 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 des données sur le commerce

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 puis les procédures permettant à la console Vertex AI de créer un ensemble de données, entraîner un modèle, puis 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 :
Exportez vos données sur le commerce depuis Vertex AI Search pour le commerce dans dans BigQuery. Vous obtenez alors un tableau des produits table d'événements dans BigQuery, que vous pouvez utiliser procédures. Pour en savoir plus, consultez la section Exporter vos données dans dans BigQuery.

Si vos données produit et d'événement utilisateur BigQuery, dans Vertex AI Search pour le commerce, vous pouvez utiliser ces données pour générer des prévisions de ventes à partir de données sur le commerce. Dans ce cas, vous ne devez pas vous devez importer vos données de vente au détail et les exporter vers BigQuery. Pour plus d'informations sur le consultez les articles Schéma du produit et À propos de l'utilisateur événements.
Assurez-vous que le rôle IAM roles/aiplatform.user vous a été attribué vous pouvez exécuter les procédures à l'aide de la console Vertex AI.

Créer un tableau des ventes agrégées

Le code SQL de cette section transforme le tableau des événements utilisateur en un fichier des ventes. 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. De plus, 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 le tableau des événements utilisateur ne contient pas au moins un produit avec au moins 20 codes temporels, un produit de la table est choisi au hasard et rempli avec suffisamment de lignes (chacune ne générant aucune vente) pour atteindre 20 horodatages. C'est pour pour répondre aux exigences de Vertex AI qui consistent à avoir au moins 20 horodatages lors de l'entraînement d'un modèle.

Pour créer un tableau des ventes agrégées:

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 du produit que vous avez exportée vers BigQuery. Le format est le 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 nouvelle table des ventes agrégées. Utiliser la même l'ID du projet comme tables des événements utilisateur et des produits. Utilisez l'ID d'une ensemble de données. Spécifiez un ID de table, mais n'utilisez pas l'ID d'une table existante à moins que vous ne 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 de produits vers laquelle vous avez exporté BigQuery : supprimer les champs répétés et struct et déimbriquer 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. Le format est le suivant : project_id.dataset_id.table_id
- processed_product_table. Les ID de projet, d'ensemble de données et de table dans BigQuery pour la nouvelle table des produits traités. Utiliser la même l'ID du projet comme tables des événements utilisateur et des produits. Utilisez l'ID d'une ensemble de données. Spécifiez un ID de table, mais n'utilisez pas l'ID d'une table existante, sauf si vous souhaitez l'écraser. Le format est le 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 Exécuter et attendez la requête pour terminer son exécution.

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

Créer une table de prédiction d'événements

Le code SQL de cette section extrait chaque 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. Vous définissez la valeur future_length sur le nombre de semaines à venir que le modèle va prédire. Chaque ligne dans le tableau de prédiction d'événements peuvent être identifiés de manière unique par un SKU et un du 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. Le format est le suivant : project_id.dataset_id.table_id
events_prediction_table. Les ID de projet, d'ensemble de données et de table dans BigQuery pour la nouvelle table de prédiction d'événements. Utiliser la même l'ID du projet comme tables des événements utilisateur et des produits. 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 à moins que vous ne souhaitez l'écraser. Le format est le suivant : project_id.dataset_id.table_id
rdm_product_table. Les ID du projet, de l'ensemble de données et de la table pour le produit que vous avez exportée vers BigQuery. Le format est le suivant : project_id.dataset_id.table_id
future_length. Nombre de semaines dans le futur, après la dernière semaine dans la table des événements utilisateur que le modèle va prédire.

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 votre produit et les tableaux d'événements utilisateur.
Dans le volet Éditeur, collez l'exemple de code SQL.
Cliquez sur Exécuter et attendez la requête pour terminer son exécution.

Votre nouvelle table de prédiction des événements est écrite à l'emplacement 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 le tableau des ventes agrégées aux données de produits. 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 avec le même ID de projet que les tables d'événements utilisateur et de produit. 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 à moins que vous ne souhaitiez 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 votre produit et les tableaux 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 une table de prédiction Vertex AI:

Remplacez les variables dans l'exemple de code SQL suivant comme suit :
- vertex_ai_prediction_table. Les ID de projet, d'ensemble de données et de table dans BigQuery pour la nouvelle table de prédiction Vertex AI. Utilisez les mêmes ID de projet et ID d'ensemble de données que ceux que vous avez utilisés pour le produit et l'utilisateur des tableaux d'événements. 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 des ventes agrégée, que vous avez créée dans Créer un tableau 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.
- 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 votre produit et les tableaux 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 dans l'emplacement La table BigQuery que vous définissez à l'aide de la table vertex_ai_prediction_table .

Créer un ensemble de données Vertex AI

Cette section vous explique comment créer un ensemble de données Vertex AI que vous pouvez pour entraîner un modèle de prévision. Pour en savoir plus, consultez la section 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 le nom du 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 sélectionné us lors de la création de l'ensemble de données BigQuery, peut 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 l'article Exporter vos données dans BigQuery.
Cliquez sur Créer pour créer un ensemble de données vide, puis accédez à l'onglet Source.
Cliquez sur Sélectionner une table ou une vue à partir de BigQuery.
Sous Sélectionner une table ou une vue à partir de BigQuery, saisissez le 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éés dans Créer Vertex AI tableau. 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 colonne Identifiant de série. et last_day_of_week dans la liste Timestamp column.
Cliquez sur Entraîner un nouveau modèle pour accéder à la page Entraîner un nouveau modèle. Pour pour entraîner votre modèle, consultez la page 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 la section Entraîner un modèle de prévision dans dans la documentation de Vertex AI.

Avant de commencer

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

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 le nouveau modèle si ce n'est pas déjà fait.
2. Attribuez un nom à votre nouveau modèle.
3. Sélectionnez quantité (INTEGER) dans la liste Colonne cible.
4. Sélectionnez Hebdomadaire dans la liste Précision des données.
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 la durée de l'entraînement du modèle. (et pour les 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 Contexte, la valeur par défaut est la définie pour 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 lorsqu'un la flèche du menu déroulant est grise, ou lorsqu'il n'y a pas de flèche du menu déroulant, 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 du type BigQuery est String (Chaîne) ou Booléen : définissez la valeur Transformation sur Catégorielle.
  - 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 Type de caractéristique sur Covariée.
  - Parmi les colonnes restantes, pour celles qui peuvent être modifiées, définissez le Type de caractéristique 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, saisissez le nombre maximal d'heures pendant lesquelles pour l'entraînement de votre modèle. Ce paramètre permet de limiter l'entraînement les coûts. 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 la nécessaire à l'entraînement de modèles de haute qualité, consultez la section Entraîner de ML dans la documentation de Vertex AI.
Cliquez sur Démarrer l'entraînement.

L'entraînement du modèle peut prendre plusieurs heures, selon la taille et la complexité vos données et votre budget d'entraînement, si vous en avez spécifié un. Vous pouvez fermer cet onglet et y revenir plus tard. Vous recevez un e-mail lorsque votre modèle terminé la formation. 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 Canaux d'entraînement. La que vous entraînez figure 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 à page Prédictions par lots.

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é à l'étape 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 elle n'est pas déjà sélectionnée.
  2. Saisir les ID du projet, de l'ensemble de données et de la table dans BigQuery pour la table de prédiction Vertex AI que vous avez créée à l'étape Créer une prédiction Vertex AI. tableau. Le format est le 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. La 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é. 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 le dans le projet BigQuery que vous avez spécifié. La le nom de votre nouvelle table de sortie est "predictions_" suivi de la ligne l'horodatage du démarrage du job de prédiction. Pour en savoir plus sur pour récupérer et interpréter vos résultats de prévision, consultez la section Récupération les résultats de prédiction et les fonctions Interpréter des résultats prévisionnels dans l'application Vertex AI dans la documentation Google Cloud.