Prevedi la domanda in base al feedback dei clienti utilizzando Lakehouse e l'AI

Questo tutorial mostra come analizzare il feedback dei clienti in formato libero non strutturato con i dati di vendita strutturati in Lakehouse per valutare il lancio di un nuovo prodotto.

Immagina di essere un data scientist di Froyo, un'azienda fittizia di yogurt ghiacciato che prevede di lanciare un nuovo gusto chiamato Midnight Swirl. Prima di impegnarsi in un lancio globale, l'attività deve rispondere a tre domande:

  • Quali allergeni e problemi relativi al feedback dei clienti si applicano al nuovo gusto?
  • Quale domanda dovrebbe aspettarsi l'azienda per i gusti esistenti nei prossimi 12 mesi?
  • In che modo il sentiment dei clienti e l'intenzione di acquisto ripetuto si confrontano con la domanda prevista?

Questo tutorial è destinato ad analisti di dati, data scientist e data engineer che hanno familiarità con BigQuery e SQL di base. Completa ogni passaggio utilizzando Cloud Shell e la console Google Cloud .

Obiettivi

  • Crea un catalogo nel catalogo del runtime Lakehouse, quindi crea tabelle Apache Iceberg che archiviano i dati di prodotti, vendite e feedback dei clienti nel tuo Lakehouse.
  • Utilizza le funzioni AI di BigQuery AI.CLASSIFY e AI.IF per estrarre il sentiment, gli argomenti e l'intenzione di acquisto da un testo non strutturato memorizzato in una tabella Iceberg.
  • Utilizza l'analisi conversazionale in BigQuery Studio per prevedere la domanda su 12 mesi con AI.FORECAST e unisci la previsione agli approfondimenti su prodotti e feedback.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Esegui la pulizia.

Prima di iniziare

  1. Nella console Google Cloud , nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud .

    Vai al selettore di progetti

  2. Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare le attività di questo tutorial, chiedi all'amministratore di concederti i seguenti ruoli IAM nel tuo progetto:

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

prepara l'ambiente

Attiva Cloud Shell, imposta le variabili di ambiente per le tue risorse e abilita le API richieste:

  1. Nella console Google Cloud , attiva Cloud Shell. Se ti viene richiesto, fai clic su Autorizza.

    Attiva Cloud Shell

  2. In Cloud Shell, imposta le variabili di ambiente per l'ID progetto, la regione, il nome del bucket, l'ID catalogo e lo spazio dei nomi in modo da poterle riutilizzare in questo tutorial:

    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. Abilita le API richieste per il tuo progetto:

    • API BigQuery (bigquery.googleapis.com)
    • API BigLake (biglake.googleapis.com), che fornisce l'accesso al catalogo di runtime Lakehouse
    • API Storage di Cloud (storage.googleapis.com)
    • API Agent Platform (aiplatform.googleapis.com)
    • API Conversational Analytics (geminidataanalytics.googleapis.com)
    • API Gemini for Google Cloud (cloudaicompanion.googleapis.com)

    Abilita queste API in 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}

Crea un bucket Cloud Storage

In Cloud Shell, crea un bucket Cloud Storage per archiviare i file della tabella Iceberg:

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

Crea un catalogo nel catalogo di runtime Lakehouse

Utilizzando l'endpoint del catalogo REST Iceberg, crea un catalogo in modalità di distribuzione delle credenziali in modo che utilizzi il suo account di servizio di cui è stato eseguito il provisioning automatico per accedere al bucket e non devi creare una connessione BigQuery:

  1. In Cloud Shell, crea un catalogo multi-bucket in modalità di distribuzione delle credenziali:

    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. Concedi al account di servizio di cui è stato eseguito il provisioning automatico del catalogo il ruolo Storage Object User (roles/storage.objectUser) nel tuo 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. Crea uno spazio dei nomi per le tabelle nel catalogo:

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

Creare tabelle Iceberg

Crea tre tabelle Iceberg nel catalogo e caricale con dati di esempio:

  • products: memorizza l'elenco dei prodotti, incluso il nuovo gusto Midnight Swirl e il gusto esistente su cui si basa.
  • sales_history: memorizza 24 mesi di vendite mensili di unità per i gusti esistenti, per regione.
  • customer_feedback: memorizza i record di feedback. Ogni riga accoppia metadati strutturati (feedback_id, submitted_date, flavor_name e channel) con una colonna comment STRING che memorizza testo libero non strutturato.

In BigQuery, fai riferimento alle tabelle Lakehouse utilizzando la struttura di denominazione P.C.N.T. in quattro parti (Project.Catalog.Namespace.Table).

  1. In Cloud Shell, crea le tabelle products, sales_history e customer_feedback e compilale con dati di esempio. Lo script esegue ogni istruzione in ordine e richiede circa un minuto per essere completato:

    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. Verifica che il catalogo elenchi le tabelle products, sales_history e customer_feedback:

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

Analizzare il feedback con le funzioni AI

La colonna comment nella tabella customer_feedback contiene testo non strutturato che non puoi aggregare o unire direttamente. Utilizza le funzioni BigQuery AI per estrarre valori strutturati da ogni commento e creare una nuova tabella feedback_insights:

  • AI.CLASSIFY assegna a ogni commento un sentimento (positive, neutral o negative) e un argomento principale (ad esempio taste, texture, price o allergens) da elenchi di categorie che definisci.
  • AI.IF valuta una condizione in linguaggio naturale per ogni commento e restituisce un valore BOOL. In questo caso, il valore indica se il cliente intende acquistare di nuovo il prodotto.

Queste funzioni di AI gestita utilizzano le tue credenziali utente per chiamare Gemini, quindi non devi creare un modello remoto o una connessione.

  1. In Cloud Shell, crea e popola la tabella 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. Riepiloga le metriche di feedback per ogni sapore:

    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

    L'output è simile al seguente:

    +-------------------+----------+----------+-----------------+----------------+
|    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 |
+-------------------+----------+----------+-----------------+----------------+

Prevedere la domanda con l'analisi conversazionale

L'analisi conversazionale in BigQuery Studio ti consente di analizzare le tabelle Iceberg utilizzando il linguaggio naturale. Recupera gli schemi delle tabelle dal catalogo di runtime di Lakehouse, genera ed esegue BigQuery SQL (incluse le funzioni AI come AI.FORECAST) e restituisce tabelle e grafici direttamente nella chat.

Avviare una conversazione con le tabelle

  1. Nella console Google Cloud , vai alla pagina Agenti di BigQuery.

    Vai ad Agenti

  2. Nel riquadro dell'editor di BigQuery Studio, fai clic sulla scheda Agenti per aprire il riquadro della conversazione, quindi fai clic su Nuova chat.

  3. Nel riquadro Chatta con i tuoi dati, fai clic sulla scheda Fonti di conoscenza. Nel campo Cerca origini, cerca e seleziona le tre tabelle Iceberg utilizzando i seguenti valori. Sostituisci PROJECT_ID con l'ID progetto:

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

  4. Fai clic su Chat.

Fare domande per prevedere la domanda e valutare il lancio

Poni una sequenza di domande in linguaggio naturale per rispondere alle tre domande aziendali per il lancio di Midnight Swirl:

  1. Nel campo Fai una domanda, inserisci il seguente prompt per controllare i dettagli del prodotto e il feedback dei clienti di Midnight Swirl, quindi fai clic su send_spark Invia:

    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'agente esegue query su entrambe le tabelle e segnala che Midnight Swirl è a base di Classic Chocolate e contiene latte e soia. Inoltre, riporta una quota di sentiment positivo pari a 0,67, con tre clienti su sei che intendono acquistarlo di nuovo, ed evidenzia i dubbi sull'etichettatura degli allergeni della soia e sull'amarezza del cioccolato fondente.

  2. Inserisci il seguente prompt per prevedere la domanda di 12 mesi per i gusti esistenti e poi fai clic su send_spark Invia:

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

    L'analisi conversazionale esegue una query con AI.FORECAST, che utilizza il modello TimesFM integrato in BigQuery ML senza addestrare un modello separato e mostra un grafico della previsione di 12 mesi per ogni gusto.

  3. Inserisci il seguente prompt per combinare la previsione della domanda con il feedback dei clienti e ricevere consigli per il lancio, quindi fai clic su send_spark Invia:

    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. (Facoltativo) Per esaminare la query SQL generata o visualizzare i passaggi del ragionamento dell'agente, espandi Mostra ragionamento.

Da qui, puoi porre domande aggiuntive nella conversazione (ad esempio, suddividere la previsione per regione) o fare clic su Crea agente nel riquadro Dettagli per salvare e condividere un agente dati riutilizzabile con il tuo team.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

  1. Nella console Google Cloud , vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

Elimina singole risorse

Se vuoi conservare il progetto, elimina le singole risorse che hai creato.

  1. Per eliminare la conversazione, nel riquadro dell'editor di BigQuery Studio, seleziona la scheda Agenti. Nel pannello di navigazione a sinistra, che potresti dover espandere, trova la conversazione in Chat recenti, quindi fai clic su more_vert Visualizza azioni > Elimina.

  2. In Cloud Shell, elimina le quattro tabelle, lo spazio dei nomi, il catalogo e il 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}

Passaggi successivi

Per scoprire altri modi per lavorare con i dati di Lakehouse, consulta le seguenti risorse: