Prever a demanda com base no feedback dos clientes usando o Lakehouse e a IA

Neste tutorial, mostramos como analisar o feedback de clientes em texto livre não estruturado com dados de vendas estruturados no data lake para avaliar o lançamento de um novo produto.

Imagine que você é um cientista de dados da Froyo, uma empresa fictícia de iogurte congelado que planeja lançar um novo sabor chamado Midnight Swirl. Antes de se comprometer com um lançamento global, a empresa precisa responder a três perguntas:

• Quais alérgenos e preocupações de feedback dos clientes se aplicam ao novo sabor?
• Qual demanda a empresa deve esperar nos próximos 12 meses para os sabores atuais?
• Como o sentimento do cliente e a intenção de compra recorrente se comparam à demanda prevista?

Este tutorial é destinado a analistas, cientistas e engenheiros de dados que conhecem o BigQuery e o SQL básico. Você conclui cada etapa usando o Cloud Shell e o console Google Cloud .

Objetivos

• Crie um catálogo no catálogo do ambiente de execução do Lakehouse e tabelas do Apache Iceberg que armazenam dados de produtos, vendas e feedback dos clientes no seu Lakehouse.
• Use as funções de IA do BigQuery AI.CLASSIFY e AI.IF para extrair sentimento, temas e intenção de compra de texto não estruturado armazenado em uma tabela do Iceberg.
• Use a análise conversacional no BigQuery Studio para prever a demanda de 12 meses com AI.FORECAST e combine a previsão com insights de produtos e feedback.

Custos

Neste documento, você vai usar os seguintes componentes faturáveis do Google Cloud:

• Lakehouse
• BigQuery, including conversational analytics
• Cloud Storage
• Gemini Enterprise Agent Platform, for the Gemini models that AI functions call

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços.

Novos usuários do Google Cloud podem estar qualificados para um teste sem custo financeiro.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Para mais informações, consulte Limpeza.

Antes de começar

1. No console do Google Cloud , na página do seletor de projetos, selecione ou crie um projeto do Google Cloud .

   Acessar o seletor de projetos

   Observação: se você não pretende manter os recursos criados neste tutorial, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir, exclua o projeto para remover todos os recursos associados a ele.

2. Verifique se o faturamento está ativado para o projeto do Google Cloud .

Funções exigidas

Para conseguir as permissões necessárias a fim de concluir as tarefas neste tutorial, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

• Crie e exclua o catálogo, o namespace e as tabelas no catálogo de ambientes de execução do Lakehouse: Administrador do BigLake (roles/biglake.admin)
• Crie e exclua um bucket do Cloud Storage e conceda à conta de serviço do catálogo acesso a ele: Administrador do Storage (roles/storage.admin)
• Criar e modificar tabelas do BigQuery: Editor de dados do BigQuery (roles/bigquery.dataEditor)
• Execute consultas e use a análise conversacional no BigQuery Studio:
  • Usuário do BigQuery Studio (roles/bigquery.studioUser)
  • Usuário de chat sem estado do Gemini Data Analytics (roles/geminidataanalytics.dataAgentStatelessUser)
  • Usuário do Gemini para Google Cloud (roles/cloudaicompanion.user)
• Chamar modelos do Gemini usando funções de IA do BigQuery: Usuário da Agent Platform (roles/aiplatform.user)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Preparar o ambiente

Ative o Cloud Shell, defina variáveis de ambiente para seus recursos e ative as APIs necessárias:

1. No console do Google Cloud , ative o Cloud Shell. Se for solicitado, clique em Autorizar.

   Ativar o Cloud Shell

2. No Cloud Shell, defina variáveis de ambiente para o ID do projeto, região, nome do bucket, ID do catálogo e namespace para que possam ser reutilizadas ao longo deste 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. Ative as APIs necessárias para seu projeto:

   • API BigQuery (bigquery.googleapis.com)
   • API BigLake (biglake.googleapis.com), que fornece acesso ao catálogo de ambientes de execução do Lakehouse
   • API Cloud Storage (storage.googleapis.com)
   • API Agent Platform (aiplatform.googleapis.com)
   • API Conversational Analytics (geminidataanalytics.googleapis.com)
   • API Gemini para Google Cloud (cloudaicompanion.googleapis.com)

   Ative estas APIs no 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}

Criar um bucket do Cloud Storage

No Cloud Shell, crie um bucket do Cloud Storage para armazenar os arquivos da tabela do Iceberg:

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

Criar um catálogo no catálogo do ambiente de execução do Lakehouse

Usando o endpoint do catálogo REST do Iceberg, crie um catálogo no modo de venda de credenciais para que ele use a conta de serviço provisionada automaticamente para acessar seu bucket. Assim, você não precisa criar uma conexão do BigQuery:

1. No Cloud Shell, crie um catálogo de vários buckets no modo de venda de credenciais:

   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. Conceda à conta de serviço provisionada automaticamente do catálogo o papel de Usuário de objetos do Storage (roles/storage.objectUser) no 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. Crie um namespace para suas tabelas no catálogo:

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

Criar tabelas Iceberg

Crie três tabelas do Iceberg no catálogo e carregue-as com dados de amostra:

• products: armazena a lista de produtos, incluindo o novo sabor Midnight Swirl e o sabor atual em que ele se baseia.
• sales_history: armazena 24 meses de vendas mensais de unidades para os sabores existentes, por região.
• customer_feedback: armazena registros de feedback. Cada linha combina metadados estruturados (feedback_id, submitted_date, flavor_name e channel) com uma coluna comment STRING que armazena texto livre não estruturado.

No BigQuery, você referencia tabelas do Lakehouse usando a estrutura de nomenclatura de quatro partes P.C.N.T. (Project.Catalog.Namespace.Table).

1. No Cloud Shell, crie as tabelas products, sales_history e customer_feedback e preencha-as com dados de amostra. O script executa cada instrução em ordem e leva cerca de um minuto para ser concluído:

   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. Verifique se o catálogo lista as tabelas products, sales_history e customer_feedback:

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

Analisar feedback com funções de IA

A coluna comment na tabela customer_feedback contém texto não estruturado que não pode ser agregado ou unido diretamente. Use as funções de IA do BigQuery para extrair valores estruturados de cada comentário e criar uma nova tabela feedback_insights:

• O AI.CLASSIFY atribui a cada comentário um sentimento (positive, neutral ou negative) e um tema principal (como taste, texture, price ou allergens) de listas de categorias definidas por você.
• AI.IF avalia uma condição de linguagem natural para cada comentário e retorna um valor BOOL. Nesse caso, o valor indica se o cliente pretende comprar o produto novamente.

Essas funções gerenciadas de IA usam suas credenciais de usuário para chamar o Gemini. Assim, não é necessário criar um modelo ou uma conexão remota.

1. No Cloud Shell, crie e preencha a tabela 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. Resuma as métricas de feedback para cada opção:

   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

   O resultado será o seguinte:

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

Previsão de demanda com análise conversacional

Com a análise conversacional no BigQuery Studio, é possível analisar suas tabelas Iceberg usando linguagem natural. Ele recupera esquemas de tabelas do catálogo do ambiente de execução do Lakehouse, gera e executa o SQL do BigQuery (incluindo funções de IA, como AI.FORECAST) e retorna tabelas e gráficos diretamente na conversa.

Iniciar uma conversa com suas tabelas

1. No console Google Cloud , acesse a página Agentes do BigQuery.

   Acessar "Agentes"

2. No painel do editor do BigQuery Studio, clique na guia Agentes para abrir o painel de conversa e clique em Novo chat.

3. No painel Conversar com seus dados, clique na guia Fontes de conhecimento. No campo Pesquisar fontes, pesquise e selecione as três tabelas do Iceberg usando os seguintes valores. Substitua PROJECT_ID pelo ID do projeto:

   • PROJECT_ID.froyo_catalog.froyo_lakehouse.products
   • PROJECT_ID.froyo_catalog.froyo_lakehouse.feedback_insights
   • PROJECT_ID.froyo_catalog.froyo_lakehouse.sales_history
   Dica: para filtrar a lista, insira namespace: froyo_lakehouse ou catalog: froyo_catalog no campo Pesquisar fontes.

4. Clique em Chat.

Faça perguntas para prever a demanda e avaliar o lançamento

Faça uma sequência de perguntas em linguagem natural para responder às três perguntas comerciais sobre o lançamento do Midnight Swirl:

1. No campo Fazer uma pergunta, insira o comando a seguir para verificar os detalhes do produto e o feedback dos clientes da Midnight Swirl e clique em send_spark Enviar:

   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?
   

   O agente consulta as duas tabelas e informa que o Midnight Swirl é baseado no Classic Chocolate e contém leite e soja. Ele também informa uma participação de sentimento positivo de 0,67, com três de seis clientes pretendendo comprar novamente, e destaca preocupações sobre a rotulagem de alérgenos de soja e o amargor do chocolate amargo.

2. Insira o comando a seguir para prever a demanda de 12 meses em todos os sabores atuais e clique em send_spark Enviar:

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

   A análise de dados de conversação executa uma consulta com AI.FORECAST, que usa o modelo TimesFM integrado no BigQuery ML sem treinar um modelo separado e mostra um gráfico da previsão de 12 meses para cada sabor.

3. Digite o comando a seguir para combinar a previsão de demanda com o feedback dos clientes e receber recomendações de lançamento. Depois, clique em send_spark Enviar:

   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. Opcional: para inspecionar a consulta SQL gerada ou conferir as etapas de raciocínio do agente, expanda Mostrar raciocínio.

Neste ponto, você pode fazer perguntas complementares na conversa (como detalhar a previsão por região) ou clicar em Criar agente no painel Detalhes para salvar e compartilhar um agente de dados reutilizável com sua equipe.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Excluir o projeto

Cuidado: a exclusão de um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos nele.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um ID do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar várias arquiteturas, tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda limites da cota.

1. No console Google Cloud , acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir recursos individuais

Se você quiser manter o projeto, exclua os recursos individuais que criou.

1. Para excluir sua conversa, no painel do editor do BigQuery Studio, selecione a guia Agentes. No painel de navegação à esquerda, que talvez precise ser expandido, encontre sua conversa em Conversas recentes e clique em more_vert Ver ações > Excluir.

2. No Cloud Shell, exclua as quatro tabelas, o namespace, o catálogo e o bucket do 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}

A seguir

Para conhecer outras maneiras de trabalhar com os dados do Lakehouse, consulte os seguintes recursos:

• Saiba mais sobre como consultar tabelas do Iceberg em linguagem natural com a análise conversacional no Lakehouse.
• Configure instruções personalizadas, consultas verificadas e glossários de negócios criando agentes de dados no BigQuery.
• Gere descrições e consultas sugeridas para suas tabelas com insights de dados.
• Saiba como gerenciar tabelas do Iceberg no catálogo do ambiente de execução do Lakehouse.