Prévoir la demande à partir des commentaires des clients à l'aide de Lakehouse et de l'IA

Ce tutoriel vous explique comment analyser les commentaires non structurés des clients en texte libre avec des données de vente structurées dans Lakehouse pour évaluer le lancement d'un nouveau produit.

Imaginez que vous êtes data scientist chez Froyo, une entreprise fictive de yaourts glacés qui prévoit de lancer une nouvelle saveur appelée Midnight Swirl. Avant de s'engager dans un lancement mondial, l'entreprise doit répondre à trois questions :

  • Quels sont les allergènes et les commentaires des clients concernant la nouvelle saveur ?
  • Quelle demande l'entreprise doit-elle prévoir pour les saveurs existantes au cours des 12 prochains mois ?
  • Comment le sentiment des clients et leur intention d'achat récurrent se comparent-ils à la demande prévue ?

Ce tutoriel s'adresse aux analystes de données, aux data scientists et aux ingénieurs de données qui connaissent BigQuery et les bases de SQL. Vous effectuerez chaque étape à l'aide de Cloud Shell et de la console Google Cloud .

Objectifs

  • Créez un catalogue dans le catalogue du runtime Lakehouse, puis créez des tables Apache Iceberg qui stockent les données sur les produits, les ventes et les commentaires des clients dans votre Lakehouse.
  • Utilisez les fonctions d'IA BigQuery AI.CLASSIFY et AI.IF pour extraire le sentiment, les thèmes et l'intention d'achat à partir de texte non structuré stocké dans une table Iceberg.
  • Utilisez l'analyse conversationnelle dans BigQuery Studio pour prévoir la demande sur 12 mois avec AI.FORECAST et associer la prévision aux insights sur les produits et les commentaires.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Pour obtenir une estimation des coûts en fonction de votre utilisation prévue, utilisez le simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

  1. Dans la console Google Cloud , sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud .

    Accéder au sélecteur de projet

  2. Vérifiez que la facturation est activée pour votre projet Google Cloud .

Rôles requis

Pour obtenir les autorisations nécessaires pour effectuer les tâches de ce tutoriel, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Préparer votre environnement

Activez Cloud Shell, définissez les variables d'environnement pour vos ressources et activez les API requises :

  1. Dans la console Google Cloud , activez Cloud Shell. Si vous y êtes invité, cliquez sur Autoriser.

    Activer Cloud Shell

  2. Dans Cloud Shell, définissez les variables d'environnement pour l'ID de votre projet, la région, le nom du bucket, l'ID du catalogue et l'espace de noms afin de pouvoir les réutiliser tout au long de ce tutoriel :

    export PROJECT_ID=$(gcloud config get-value project)
export REGION="us-central1"
export BUCKET_NAME="${PROJECT_ID}-froyo-lakehouse"
export CATALOG_ID="froyo_catalog"
export NAMESPACE_ID="froyo_lakehouse"

  3. Activez les API requises pour votre projet :

    • API BigQuery (bigquery.googleapis.com)
    • L'API BigLake (biglake.googleapis.com), qui permet d'accéder au catalogue d'environnements d'exécution Lakehouse
    • API Cloud Storage (storage.googleapis.com)
    • API Agent Platform (aiplatform.googleapis.com)
    • API Conversational Analytics (geminidataanalytics.googleapis.com)
    • API Gemini pour Google Cloud (cloudaicompanion.googleapis.com)

    Activez les API suivantes dans Cloud Shell :

    gcloud services enable \
    bigquery.googleapis.com \
    biglake.googleapis.com \
    storage.googleapis.com \
    aiplatform.googleapis.com \
    geminidataanalytics.googleapis.com \
    cloudaicompanion.googleapis.com \
    --project=${PROJECT_ID}

Créer un bucket Cloud Storage

Dans Cloud Shell, créez un bucket Cloud Storage pour stocker les fichiers de votre table Iceberg :

gcloud storage buckets create gs://${BUCKET_NAME} \
    --project=${PROJECT_ID} \
    --location=${REGION}

Créer un catalogue dans le catalogue d'environnements d'exécution Lakehouse

À l'aide du point de terminaison du catalogue REST Iceberg, créez un catalogue en mode de distribution d'identifiants afin que le catalogue utilise son compte de service provisionné automatiquement pour accéder à votre bucket. Vous n'avez pas besoin de créer de connexion BigQuery :

  1. Dans Cloud Shell, créez un catalogue multibuckets en mode de distribution des identifiants :

    gcloud biglake iceberg catalogs create ${CATALOG_ID} \
    --project=${PROJECT_ID} \
    --catalog-type=biglake \
    --default-location=gs://${BUCKET_NAME} \
    --primary-location=${REGION} \
    --credential-mode=vended-credentials

  2. Attribuez le rôle Utilisateur d'objets de stockage (roles/storage.objectUser) au compte de service provisionné automatiquement du catalogue sur votre bucket :

    CATALOG_SA=$(gcloud biglake iceberg catalogs describe ${CATALOG_ID} \
    --project=${PROJECT_ID} \
    --format='value(biglake-service-account)')

gcloud storage buckets add-iam-policy-binding gs://${BUCKET_NAME} \
    --member="serviceAccount:${CATALOG_SA}" \
    --role="roles/storage.objectUser"

  3. Créez un espace de noms pour vos tables dans le catalogue :

    gcloud biglake iceberg namespaces create ${NAMESPACE_ID} \
    --project=${PROJECT_ID} \
    --catalog=${CATALOG_ID}

Créer des tables Iceberg

Créez trois tables Iceberg dans votre catalogue et chargez-les avec des exemples de données :

  • products : stocke la liste des produits, y compris la nouvelle saveur Midnight Swirl et la saveur existante sur laquelle elle est basée.
  • sales_history : stocke 24 mois de ventes mensuelles d'unités pour les saveurs existantes, par région.
  • customer_feedback, qui stocke les enregistrements de commentaires. Chaque ligne associe des métadonnées structurées (feedback_id, submitted_date, flavor_name et channel) à une colonne comment STRING qui stocke du texte libre non structuré.

Dans BigQuery, vous référencez les tables Lakehouse à l'aide de la structure de nommage en quatre parties P.C.N.T. (Project.Catalog.Namespace.Table).

  1. Dans Cloud Shell, créez les tables products, sales_history et customer_feedback, puis remplissez-les avec des exemples de données. Le script exécute chaque instruction dans l'ordre et prend environ une minute :

    bq query --project_id=${PROJECT_ID} --location=${REGION} --use_legacy_sql=false << EOF
-- Product list.
CREATE TABLE \`${PROJECT_ID}.${CATALOG_ID}.${NAMESPACE_ID}.products\` (
  product_name STRING,
  base_flavor STRING,
  status STRING,
  allergens STRING,
  target_regions STRING);

INSERT INTO \`${PROJECT_ID}.${CATALOG_ID}.${NAMESPACE_ID}.products\` VALUES
  ('Midnight Swirl', 'Classic Chocolate', 'Planned launch',
   'Milk, Soy', 'North America, Europe'),
  ('Classic Chocolate', 'Classic Chocolate', 'In market',
   'Milk, Soy', 'North America, Europe, Asia Pacific'),
  ('Vanilla Bean', 'Vanilla Bean', 'In market',
   'Milk', 'North America, Europe, Asia Pacific'),
  ('Strawberry Swirl', 'Strawberry Swirl', 'In market',
   'Milk', 'North America, Europe, Asia Pacific');

-- Monthly sales history for the flavors that are in market.
CREATE TABLE \`${PROJECT_ID}.${CATALOG_ID}.${NAMESPACE_ID}.sales_history\` (
  sale_month DATE,
  flavor_name STRING,
  region STRING,
  units_sold INT64);

INSERT INTO \`${PROJECT_ID}.${CATALOG_ID}.${NAMESPACE_ID}.sales_history\`
WITH
  months AS (
    SELECT sale_month
    FROM UNNEST(GENERATE_DATE_ARRAY(
      '2024-01-01', '2025-12-01', INTERVAL 1 MONTH)) AS sale_month
  ),
  flavors AS (
    SELECT * FROM UNNEST([
      STRUCT('Classic Chocolate' AS flavor_name, 1200 AS base_units),
      ('Vanilla Bean', 1000),
      ('Strawberry Swirl', 800)])
  ),
  regions AS (
    SELECT * FROM UNNEST([
      STRUCT('North America' AS region, 1.0 AS region_factor),
      ('Europe', 0.8),
      ('Asia Pacific', 0.6)])
  )
SELECT
  m.sale_month,
  f.flavor_name,
  r.region,
  CAST(
    f.base_units * r.region_factor
    -- Two percent month-over-month growth.
    * (1 + 0.02 * DATE_DIFF(m.sale_month, DATE '2024-01-01', MONTH))
    -- Seasonal peak in July.
    * (1 + 0.25 * SIN(2 * ACOS(-1)
        * (EXTRACT(MONTH FROM m.sale_month) - 4) / 12))
    AS INT64) AS units_sold
FROM months AS m
CROSS JOIN flavors AS f
CROSS JOIN regions AS r;

-- Customer feedback records with unstructured text in the comment column.
CREATE TABLE \`${PROJECT_ID}.${CATALOG_ID}.${NAMESPACE_ID}.customer_feedback\` (
  feedback_id INT64,
  submitted_date DATE,
  flavor_name STRING,
  channel STRING,
  comment STRING);

INSERT INTO \`${PROJECT_ID}.${CATALOG_ID}.${NAMESPACE_ID}.customer_feedback\` VALUES
  (1, '2025-11-03', 'Midnight Swirl', 'Taste panel',
   "Rich, deep chocolate with a hint of salt. Honestly better than the classic chocolate. I'd order this every week."),
  (2, '2025-11-03', 'Midnight Swirl', 'Taste panel',
   "Loved the dark chocolate swirl, but it was a bit too bitter for my kids."),
  (3, '2025-11-04', 'Midnight Swirl', 'Taste panel',
   "Best froyo I've tried this year. Smooth texture and not too sweet."),
  (4, '2025-11-04', 'Midnight Swirl', 'Taste panel',
   "Great taste. I'd definitely buy it again if it's priced like the other flavors."),
  (5, '2025-11-05', 'Midnight Swirl', 'Taste panel',
   "Does this contain soy? I have a soy allergy so I skipped it. Please label it clearly."),
  (6, '2025-11-05', 'Midnight Swirl', 'Taste panel',
   "Tastes like a premium dessert. The sea salt really makes it."),
  (7, '2025-06-12', 'Classic Chocolate', 'App review',
   "Solid chocolate flavor, my go-to order."),
  (8, '2025-07-02', 'Classic Chocolate', 'App review',
   "It's fine, but a little too sweet compared to other brands."),
  (9, '2025-08-19', 'Classic Chocolate', 'Support email',
   "Consistently good. I wish the cups were bigger for the price."),
  (10, '2025-09-07', 'Classic Chocolate', 'Support email',
   "My chocolate froyo was icy this time and the texture was off."),
  (11, '2025-10-21', 'Classic Chocolate', 'App review',
   "Classic for a reason. Always creamy. I'll keep ordering it."),
  (12, '2025-11-05', 'Classic Chocolate', 'Taste panel',
   "Good but forgettable next to the new dark chocolate sample."),
  (13, '2025-05-14', 'Vanilla Bean', 'App review',
   "Real vanilla flavor, you can see the specks. Love it."),
  (14, '2025-06-30', 'Vanilla Bean', 'App review',
   "Pretty plain. I only order it as a base for toppings."),
  (15, '2025-08-02', 'Vanilla Bean', 'App review',
   "Creamy and simple, perfect for my toddler."),
  (16, '2025-09-15', 'Vanilla Bean', 'Support email',
   "The store was out of vanilla bean two weekends in a row."),
  (17, '2025-06-08', 'Strawberry Swirl', 'App review',
   "Tastes like fresh strawberries. Great in the summer."),
  (18, '2025-07-26', 'Strawberry Swirl', 'App review',
   "Too artificial tasting. Not a fan."),
  (19, '2025-08-11', 'Strawberry Swirl', 'Support email',
   "My favorite flavor. Please never discontinue it."),
  (20, '2025-10-03', 'Strawberry Swirl', 'App review',
   "The price went up, but it's still worth it.");
EOF

  2. Vérifiez que votre catalogue liste les tables products, sales_history et customer_feedback :

    gcloud biglake iceberg tables list \
    --project=${PROJECT_ID} \
    --catalog=${CATALOG_ID} \
    --namespace=${NAMESPACE_ID}

Analyser les commentaires avec les fonctions d'IA

La colonne comment du tableau customer_feedback contient du texte non structuré que vous ne pouvez pas agréger ni joindre directement. Utilisez les fonctions d'IA de BigQuery pour extraire des valeurs structurées de chaque commentaire et créer une table feedback_insights :

  • AI.CLASSIFY attribue à chaque commentaire un sentiment (positive, neutral ou negative) et un thème principal (taste, texture, price ou allergens, par exemple) à partir de listes de catégories que vous définissez.
  • AI.IF évalue une condition en langage naturel pour chaque commentaire et renvoie une valeur BOOL. Dans ce cas, la valeur indique si le client a l'intention d'acheter à nouveau le produit.

Ces fonctions d'IA gérées utilisent vos identifiants utilisateur pour appeler Gemini. Vous n'avez donc pas besoin de créer de modèle distant ni de connexion.

  1. Dans Cloud Shell, créez et remplissez la table feedback_insights :

    bq query --project_id=${PROJECT_ID} --location=${REGION} --use_legacy_sql=false << EOF
CREATE TABLE \`${PROJECT_ID}.${CATALOG_ID}.${NAMESPACE_ID}.feedback_insights\` (
  feedback_id INT64,
  flavor_name STRING,
  channel STRING,
  comment STRING,
  sentiment STRING,
  topic STRING,
  would_buy_again BOOL);

INSERT INTO \`${PROJECT_ID}.${CATALOG_ID}.${NAMESPACE_ID}.feedback_insights\`
SELECT
  feedback_id,
  flavor_name,
  channel,
  comment,
  AI.CLASSIFY(
    comment,
    categories => ['positive', 'neutral', 'negative']) AS sentiment,
  AI.CLASSIFY(
    comment,
    categories => ['taste', 'texture', 'price', 'allergens',
                   'availability', 'other']) AS topic,
  AI.IF(
    ('This customer says or implies that they would buy the product ',
     'again. Comment: ', comment)) AS would_buy_again
FROM \`${PROJECT_ID}.${CATALOG_ID}.${NAMESPACE_ID}.customer_feedback\`;
EOF

  2. Résumez les métriques de commentaires pour chaque saveur :

    bq query --project_id=${PROJECT_ID} --location=${REGION} --use_legacy_sql=false << EOF
SELECT
  flavor_name,
  COUNT(*) AS comments,
  COUNTIF(sentiment = 'positive') AS positive,
  COUNTIF(would_buy_again) AS would_buy_again,
  ROUND(COUNTIF(sentiment = 'positive') / COUNT(*), 2) AS positive_share
FROM \`${PROJECT_ID}.${CATALOG_ID}.${NAMESPACE_ID}.feedback_insights\`
GROUP BY flavor_name
ORDER BY positive_share DESC;
EOF

    Le résultat ressemble à ce qui suit :

    +-------------------+----------+----------+-----------------+----------------+
|    flavor_name    | comments | positive | would_buy_again | positive_share |
+-------------------+----------+----------+-----------------+----------------+
| Strawberry Swirl  |        4 |        3 |               2 |           0.75 |
| Midnight Swirl    |        6 |        4 |               3 |           0.67 |
| Vanilla Bean      |        4 |        2 |               2 |            0.5 |
| Classic Chocolate |        6 |        2 |               3 |           0.33 |
+-------------------+----------+----------+-----------------+----------------+

Prévoir la demande avec l'analyse conversationnelle

L'analyse conversationnelle dans BigQuery Studio vous permet d'analyser vos tables Iceberg en langage naturel. Il récupère les schémas de table à partir du catalogue du runtime Lakehouse, génère et exécute du code BigQuery SQL (y compris des fonctions d'IA telles que AI.FORECAST), puis renvoie des tableaux et des graphiques directement dans le chat.

Démarrer une conversation avec vos tableaux

  1. Dans la console Google Cloud , accédez à la page Agents de BigQuery.

    Accéder aux agents

  2. Dans le volet de l'éditeur BigQuery Studio, cliquez sur l'onglet Agents pour ouvrir le volet de conversation, puis cliquez sur Nouveau chat.

  3. Dans le volet Interrogez vos données, cliquez sur l'onglet Sources de connaissances. Dans le champ Rechercher des sources, recherchez et sélectionnez vos trois tables Iceberg en utilisant les valeurs suivantes. Remplacez PROJECT_ID par l'ID de votre projet :

    • PROJECT_ID.froyo_catalog.froyo_lakehouse.products
    • PROJECT_ID.froyo_catalog.froyo_lakehouse.feedback_insights
    • PROJECT_ID.froyo_catalog.froyo_lakehouse.sales_history

  4. Cliquez sur Chat.

Poser des questions pour prévoir la demande et évaluer le lancement

Posez une série de questions en langage naturel pour répondre aux trois questions commerciales concernant le lancement de Midnight Swirl :

  1. Dans le champ Poser une question, saisissez la requête suivante pour vérifier les informations sur le produit et les commentaires des clients concernant Midnight Swirl, puis cliquez sur send_spark Envoyer :

    Using products and feedback_insights, what are Midnight Swirl's allergens,
base flavor, positive sentiment share, would_buy_again count, and customer
concerns from negative or neutral comments?

    L'agent interroge les deux tables et indique que Midnight Swirl est basé sur Classic Chocolate et contient du lait et du soja. Il indique également une part de sentiment positif de 0,67, avec trois clients sur six qui ont l'intention de l'acheter à nouveau, et souligne les préoccupations concernant l'étiquetage des allergènes de soja et l'amertume du chocolat noir.

  2. Saisissez le prompt suivant pour prévoir la demande sur 12 mois pour les saveurs existantes, puis cliquez sur send_spark Envoyer :

    Forecast monthly sales by flavor for the next 12 months, plotting only the
trend lines without confidence intervals.

    L'analyse conversationnelle exécute une requête avec AI.FORECAST, qui utilise le modèle TimesFM intégré dans BigQuery ML sans entraîner de modèle distinct. Elle affiche un graphique des prévisions sur 12 mois pour chaque saveur.

  3. Saisissez le prompt suivant pour combiner les prévisions de la demande avec les commentaires des clients et obtenir des recommandations de lancement, puis cliquez sur send_spark Envoyer :

    Join the total 12-month forecasted units_sold for each flavor with its
positive sentiment share, would_buy_again count, and top complaint topics
from feedback_insights, and recommend next steps for the Midnight Swirl
launch.

  4. Facultatif : Pour inspecter la requête SQL générée ou afficher les étapes de raisonnement de l'agent, développez Afficher le raisonnement.

Vous pouvez ensuite poser des questions complémentaires dans la conversation (par exemple, en demandant à ce que les prévisions soient ventilées par région) ou cliquer sur Créer un agent dans le volet Détails pour enregistrer et partager un agent de données réutilisable avec votre équipe.

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce tutoriel ne soient facturées sur votre compte Google Cloud , supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

  1. Dans la console Google Cloud , accédez à la page Gérer les ressources.

    Accéder à la page "Gérer les ressources"

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer des ressources individuelles

Si vous souhaitez conserver votre projet, supprimez les ressources individuelles que vous avez créées.

  1. Pour supprimer votre conversation, dans le volet de l'éditeur BigQuery Studio, sélectionnez l'onglet Agents. Dans le panneau de navigation de gauche (que vous devrez peut-être développer), recherchez votre conversation sous Discussions récentes, puis cliquez sur more_vert Afficher les actions > Supprimer.

  2. Dans Cloud Shell, supprimez les quatre tables, l'espace de noms, le catalogue et le bucket Cloud Storage :

    for TABLE in products sales_history customer_feedback feedback_insights; do
  gcloud biglake iceberg tables delete ${TABLE} \
      --project=${PROJECT_ID} \
      --catalog=${CATALOG_ID} \
      --namespace=${NAMESPACE_ID} \
      --quiet
done

gcloud biglake iceberg namespaces delete ${NAMESPACE_ID} \
    --project=${PROJECT_ID} \
    --catalog=${CATALOG_ID} \
    --quiet

gcloud biglake iceberg catalogs delete ${CATALOG_ID} \
    --project=${PROJECT_ID} \
    --quiet

gcloud storage rm -r gs://${BUCKET_NAME}

Étapes suivantes

Pour découvrir d'autres façons d'exploiter vos données Lakehouse, consultez les ressources suivantes :