GSP1249

Visão geral

Neste laboratório, você vai aprender a usar o BigQuery Machine Learning com modelos remotos (Gemini Flash) para extrair palavras-chave e avaliar o sentimento nas avaliações feitas por clientes.

O BigQuery é uma plataforma de análise de dados totalmente gerenciada e pronta para IA que ajuda a impulsionar o valor dos dados, funcionando com vários mecanismos, formatos e multicloud. Um dos principais recursos dele é o BigQuery Machine Learning, que permite criar e executar modelos de machine learning (ML) usando consultas SQL ou notebooks do Colab Enterprise.

Gemini é uma família de modelos de IA generativa desenvolvida pelo Google DeepMind, criada para casos de uso multimodais. A API Gemini dá acesso ao modelo Gemini Flash.

No final deste laboratório, você vai criar um app de atendimento ao cliente baseado em Python em um notebook do Colab Enterprise no BigQuery, usando o modelo Gemini Flash para responder a avaliações de clientes feitas em áudio.

Objetivos

Neste laboratório, você vai aprender a:

• Criar um notebook Python no BigQuery usando o Colab Enterprise.
• Criar uma conexão de recurso do Cloud no BigQuery.
• Criar o conjunto de dados e as tabelas no BigQuery.
• Criar os modelos remotos do Gemini no BigQuery.
• Pedir que o Gemini analise palavras-chave e sentimentos (positivos ou negativos) em avaliações de clientes feitas em texto.
• Gerar um relatório com uma contagem de avaliações positivas e negativas.
• Responder às avaliações dos clientes em larga escala.
• Criar um app para que os representantes de atendimento ao cliente respondam a avaliações de clientes feitas em áudio.

Configuração e requisitos

Antes de clicar no botão Começar o Laboratório

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é ativado quando você clica em Iniciar laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, e não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima (recomendado) ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório: não se esqueça que, depois de começar, não será possível pausar o laboratório.

Observação: use apenas a conta de estudante neste laboratório. Se usar outra conta do Google Cloud, você poderá receber cobranças nela.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar por ele, uma caixa de diálogo vai aparecer para você selecionar a forma de pagamento. No painel Detalhes do Laboratório, à esquerda, você vai encontrar o seguinte:

   • O botão Abrir Console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer Login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Username"}}}

   Você também encontra o nome de usuário no painel Detalhes do Laboratório.

4. Clique em Próxima.

5. Copie a Senha abaixo e cole na caixa de diálogo de Olá.

   {{{user_0.password | "Password"}}}

   Você também encontra a senha no painel Detalhes do Laboratório.

6. Clique em Próxima.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: para acessar os produtos e serviços do Google Cloud, clique no Menu de navegação ou digite o nome do serviço ou produto no campo Pesquisar.

Tarefa 1: criar um notebook Python no BigQuery e conectá-lo ao ambiente de execução

Nesta tarefa, você vai criar um notebook Python no BigQuery e conectá-lo ao ambiente de execução.

Criar um notebook Python no BigQuery

1. No console do Google Cloud, acesse o menu de navegação e clique em BigQuery.

2. Clique em CONCLUÍDO no pop-up de boas-vindas.

3. Clique em Notebook.

4. Selecione para a região.

5. Clique em SELECIONAR.

   O notebook Python também é adicionado à seção de notebooks do explorador no projeto.

6. Exclua todas as células do notebook clicando no ícone de Lixeira que é exibido quando você passa o cursor sobre cada célula.

Depois disso, o notebook estará em branco e você poderá passar para a próxima etapa.

Conectar ao ambiente de execução

1. No editor de notebooks do BigQuery, clique em Conectar.

2. Na janela pop-up do OAuth que vai abrir, clique em Abrir.

3. Clique no ID do estudante do Qwiklabs.

   Aguarde. Pode levar até 3 minutos para estabelecer a conexão com o ambiente de execução.

   Em algum momento, o status da conexão será atualizado para "Conectado" na parte inferior da janela do navegador.

Clique em Verificar meu progresso para conferir o objetivo. Criar um notebook Python no BigQuery e conectá-lo ao ambiente de execução

Tarefa 2: criar a conexão de recurso do Cloud e conceder o papel do IAM

Criar a conexão de recurso do Cloud no BigQuery

Nesta tarefa, você vai criar uma conexão de recurso do Cloud no BigQuery para trabalhar com o modelo Gemini Flash. Você também vai conceder permissões do IAM à conta de serviço da conexão do recurso do Cloud usando um papel para permitir que ela acesse os serviços da Agent Platform.

Você vai usar o SDK Python e a CLI do Google Cloud para criar a conexão de recurso. Mas antes disso, é preciso importar bibliotecas Python e definir as variáveis project_id e region.

1. No editor de notebooks do BigQuery, clique em + Código para criar uma célula de código. Adicione o seguinte código:

   # Import Python libraries import vertexai from vertexai.generative_models import GenerativeModel, Part from google.cloud import bigquery from google.cloud import storage import json import io import matplotlib.pyplot as plt from IPython.display import HTML, display from IPython.display import Audio from pprint import pprint

   Esse código vai importar as bibliotecas Python.

2. Execute essa célula. As bibliotecas agora estão carregadas e prontas para serem usadas.

3. Clique em + Código para criar uma célula e inclua o código abaixo:

   import os PROJECT_ID = "{{{project_0.project_id | PROJECT_ID}}}" LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global") Observação: PROJECT_ID e LOCATION são salvas aqui como variáveis Python, não SQL. Portanto, só é possível se referir a elas em células usando código Python.

4. Execute essa célula. As variáveis para PROJECT_ID e LOCATION foram definidas.

5. Clique em + Código para criar uma célula e inclua o código abaixo:

   # Create the resource connection !bq mk --connection \ --connection_type=CLOUD_RESOURCE \ --location=US \ gemini_conn

   Esse código vai usar o comando bq mk --connection da CLI do Google Cloud para criar a conexão de recurso.

6. Execute essa célula. A conexão de recurso agora está criada.

7. Clique no botão Ver ações ao lado do ID do projeto no Explorador.

8. Selecione Atualizar conteúdo.

9. Expanda Conexões no projeto . us.gemini_conn vai aparecer como uma conexão externa.

10. Clique em us.gemini_conn.

11. No painel "Informações da conexão", copie o ID da conta de serviço em um arquivo de texto para usar na próxima tarefa.

Conceder o papel de usuário da Agent Platform à conta de serviço da conexão

1. No console, acesse o menu de navegação e clique em IAM e admin.

2. Clique em Permitir acesso.

3. No campo Novos principais, digite o ID da conta de serviço que você copiou anteriormente.

4. No campo "Selecionar papel", digite Agent Platform e selecione o papel Usuário da Agent Platform.

5. Clique em Salvar.

   Agora, a conta de serviço tem a função do "Usuário da Agent Platform".

Clique em Verificar meu progresso para conferir o objetivo. Criar a conexão de recurso do Cloud e conceder o papel do IAM

Tarefa 3: analisar os arquivos de áudio e o conjunto de dados e conceder o papel do IAM à conta de serviço

Nesta tarefa, você vai analisar o conjunto de dados e os arquivos de áudio e conceder permissões do IAM à conta de serviço da conexão de recurso do Cloud.

Analisar os arquivos de áudio, os arquivos de imagem e o conjunto de dados de avaliações dos clientes no Cloud Storage

Antes de tudo, você precisa analisar o conjunto de dados e os arquivos de imagem.

1. No console do Google Cloud, selecione o menu de navegação () e Cloud Storage > Buckets.

2. Clique no bucket do Cloud Storage .

3. O bucket contém a pasta gsp1249, que você precisa abrir. Ela tem quatro itens:

   • A pasta audio contém todos os arquivos de áudio que você vai analisar. Você pode acessar essa pasta quando quiser.
   • O arquivo customer_reviews.csv é o conjunto de dados que contém as avaliações dos clientes feitas em texto.
   • A pasta images contém um arquivo de imagem que você vai usar mais tarde neste laboratório. Você pode acessar essa pasta quando quiser.
   • notebook.ipynb é uma cópia do notebook que você vai criar neste laboratório. Você pode conferir esse notebook quando quiser.
   Observação: você pode usar o URL autenticado para baixar e analisar cada item.

Conceder o papel de "Administrador de objetos do Storage" do IAM à conta de serviço da conexão

Ao conceder permissões do IAM à conta de serviço da conexão de recurso antes de começar a trabalhar no BigQuery, você evita erros de acesso negado ao executar consultas.

1. Retorne à raiz do bucket.

2. Clique em PERMISSÕES.

3. Clique em PERMITIR ACESSO.

4. No campo Novos principais, digite o ID da conta de serviço que você copiou anteriormente.

5. No campo "Selecionar um papel", digite Administrador de objetos do Storage e selecione o papel.

6. Clique em Salvar.

   Agora, a conta de serviço tem o papel de Administrador de objetos do Storage.

Clique em Verificar meu progresso para conferir o objetivo. Analisar as imagens e o conjunto de dados e conceder o papel do IAM à conta de serviço

Tarefa 4: criar o conjunto de dados e a tabela de avaliações dos clientes no BigQuery

Nesta tarefa, você vai criar um conjunto de dados para o projeto: a tabela de avaliações dos clientes.

Criar o conjunto de dados

Use as seguintes propriedades para o conjunto de dados:

Campo	Valor
ID do conjunto de dados	gemini_demo
Tipo de local	Selecione Multirregional.
Multirregional	Selecione EUA.

1. Volte ao notebook Python no BigQuery.

2. Clique em + Código para criar uma célula e inclua o código abaixo:

   # Create the dataset %%bigquery CREATE SCHEMA IF NOT EXISTS `{{{project_0.project_id | PROJECT ID | disablehighlight}}}.gemini_demo` OPTIONS(location="US");

   Observe que o código começa com %%bigquery, o que informa ao Python que o código imediatamente posterior à instrução será SQL.

3. Execute essa célula.

4. Clique no botão Ver ações ao lado do ID do projeto no Explorador.

5. Selecione Atualizar conteúdo.

   O código SQL vai criar o conjunto de dados gemini_demo no projeto que está na região dos EUA listada abaixo do projeto no Explorador do BigQuery.

Criar a tabela de avaliações dos clientes com dados de amostra

Para criar a tabela de avaliações dos clientes, você vai usar uma consulta SQL.

1. Clique em + Código para criar uma célula e inclua o código abaixo:

   # Create the customer reviews table %%bigquery LOAD DATA OVERWRITE gemini_demo.customer_reviews (customer_review_id INT64, customer_id INT64, location_id INT64, review_datetime DATETIME, review_text STRING, social_media_source STRING, social_media_handle STRING) FROM FILES ( format = 'CSV', uris = ['gs://{{{project_0.project_id | PROJECT ID | disablehighlight}}}-bucket/gsp1249/customer_reviews.csv']);

2. Execute essa célula.

   A tabela customer_reviews é criada com dados de amostra de avaliações dos clientes, incluindo customer_review_id, customer_id, location_id, review_datetime, review_text, social_media_source e social_media_handle para cada avaliação no conjunto de dados.

3. Clique no botão Ver ações ao lado do ID do projeto no Explorador.

4. Selecione Atualizar conteúdo.

5. No Explorador, navegue até o conjunto de dados gemini_demo e clique na tabela customer_reviews para revisar o esquema e os detalhes.

6. Crie uma célula com o código abaixo para consultar a tabela e analisar os registros.

   # Create the customer reviews table %%bigquery SELECT * FROM `gemini_demo.customer_reviews` ORDER BY review_datetime

7. Execute essa célula.

   Como resultado, os registros são exibidos na tabela com todas as colunas incluídas.

Clique em Verificar meu progresso para conferir o objetivo. Criar o conjunto de dados e a tabela de avaliações dos clientes no BigQuery

Tarefa 5: criar o modelo Gemini Flash no BigQuery

Agora que as tabelas foram criadas, você pode começar a trabalhar com elas. Nesta tarefa, você vai criar o modelo Gemini Flash no BigQuery.

1. Volte ao notebook Python.

2. Clique em + Código para criar uma célula e inclua o código abaixo:

   # Create the customer reviews table %%bigquery CREATE OR REPLACE MODEL `gemini_demo.gemini_flash` REMOTE WITH CONNECTION `us.gemini_conn` OPTIONS (endpoint = '{{{project_0.startup_script.gemini_flash_model_id | model_id | disablehighlight}}}')

3. Execute essa célula.

   O modelo gemini_flash é criado e adicionado ao conjunto de dados gemini_demo na seção de modelos.

4. Clique no botão Ver ações ao lado do ID do projeto no Explorador.

5. Selecione Atualizar conteúdo.

6. No Explorador, acesse o conjunto de dados gemini_demo, clique no modelo gemini_flash e revise os detalhes e o esquema.

Clique em Verificar meu progresso para conferir o objetivo. Crie o modelo Gemini Flash no BigQuery

Tarefa 6: solicitar que o Gemini analise as avaliações dos clientes em busca de palavras-chave e sentimentos

Nesta tarefa, você vai usar o modelo Gemini Flash para analisar cada avaliação de cliente em busca de sentimentos positivos ou negativos.

Analisar as avaliações dos clientes em busca de sentimentos positivos e negativos

1. Clique em + Código para criar uma célula e inclua o código abaixo:

   # Create the sentiment analysis table %%bigquery CREATE OR REPLACE TABLE `gemini_demo.customer_reviews_analysis` AS ( SELECT ml_generate_text_llm_result, social_media_source, review_text, customer_id, location_id, review_datetime FROM ML.GENERATE_TEXT( MODEL `gemini_demo.gemini_flash`, ( SELECT social_media_source, customer_id, location_id, review_text, review_datetime, CONCAT( 'Classify the sentiment of the following text as positive or negative.', review_text, "In your response don't include the sentiment explanation. Remove all extraneous information from your response, it should be a boolean response either positive or negative.") AS prompt FROM `gemini_demo.customer_reviews` ), STRUCT( 0.2 AS temperature, TRUE AS flatten_json_output)));

2. Execute essa célula.

   Essa consulta extrai as avaliações dos clientes da tabela customer_reviews para criar o comando e as usa com o modelo gemini_flash para classificar o sentimento de cada avaliação. Em seguida, os resultados são armazenados em uma nova tabela customer_reviews_analysis para uso em análises futuras.

   Aguarde. O modelo leva cerca de 30 segundos para processar os registros das avaliações dos clientes.

   Depois disso, a tabela customer_reviews_analysis é criada.

3. Clique no botão Ver ações ao lado do ID do projeto no Explorador.

4. Selecione Atualizar conteúdo.

5. No Explorador, clique na tabela customer_reviews_analysis e analise o esquema e os detalhes.

6. Clique em + Código para criar uma célula e inclua o código abaixo:

   # Pull the first 50 records from the customer_reviews_analysis table %%bigquery SELECT * FROM `gemini_demo.customer_reviews_analysis` ORDER BY review_datetime

7. Execute essa célula.

   Como resultado, serão criadas linhas com a coluna ml_generate_text_llm_result (contendo a análise de sentimento), o texto da avaliação do cliente, o ID do cliente e o ID do local.

   Confira alguns dos registros. Observe que alguns dos resultados positivos e negativos podem não estar formatados corretamente. Eles têm caracteres estranhos, como pontos ou espaços extras. Você pode limpar os registros usando a visualização abaixo.

Criar uma visualização para limpar os registros

1. Clique em + Código para criar uma célula e inclua o código abaixo:

   # Sanitize the records within a new view %%bigquery CREATE OR REPLACE VIEW gemini_demo.cleaned_data_view AS SELECT REPLACE(REPLACE(LOWER(ml_generate_text_llm_result), '.', ''), ' ', '') AS sentiment, REGEXP_REPLACE( REGEXP_REPLACE( REGEXP_REPLACE(social_media_source, r'Google(\+|\sReviews|\sLocal|\sMy\sBusiness|\sreviews|\sMaps)?', 'Google'), 'YELP', 'Yelp' ), r'SocialMedia1?', 'Social Media' ) AS social_media_source, review_text, customer_id, location_id, review_datetime FROM `gemini_demo.customer_reviews_analysis`;

2. Execute essa célula.

   O código cria a visualização cleaned_data_view e inclui os resultados do sentimento, o texto da avaliação, o ID do cliente e o ID do local. Em seguida, ele analisa o resultado do sentimento (positivo ou negativo) para garantir que todas as letras sejam minúsculas e que caracteres estranhos, como pontos ou espaços extras, sejam removidos. A visualização resultante vai facilitar as análises em outras etapas deste laboratório.

3. Clique em + Código para criar uma célula e inclua o código abaixo:

   # Pull the first 50 records from the cleaned_data_view view %%bigquery SELECT * FROM `gemini_demo.cleaned_data_view` ORDER BY review_datetime

4. Execute essa célula.

   Observe que a coluna sentiment agora tem valores limpos para as avaliações positivas e negativas. Você vai usar essa visualização em etapas futuras para criar um relatório.

Criar um relatório que conta avaliações positivas e negativas

Você pode usar Python e a biblioteca Matplotlib para criar um relatório de gráfico de barras que conta as avaliações positivas e negativas.

1. Crie uma nova célula de código, Nela, você vai usar o cliente do BigQuery para consultar a cleaned_data_view em busca de avaliações positivas e negativas e agrupar as avaliações por sentimento, armazenando os resultados em um DataFrame.

   # Task 6.5 - Create the BigQuery client, and query the cleaned data view for positive and negative reviews, store the results in a dataframe and then show the first 10 records client = bigquery.Client() query = "SELECT sentiment, COUNT(*) AS count FROM `gemini_demo.cleaned_data_view` WHERE sentiment like 'negative%' OR sentiment like 'positive%' GROUP BY sentiment;" query_job = client.query(query) results = query_job.result().to_dataframe() results.head(10)

2. Execute essa célula.

   O resultado é uma tabela com as contagens totais de avaliações positivas e negativas.

3. Crie uma célula para definir as variáveis do relatório.

   # Define variable for the report. sentiment = results["sentiment"].tolist() count = results["count"].tolist()

4. Execute essa célula. Não há saída.

5. Crie uma célula para criar o relatório.

   # Task 6.7 - Build the report. plt.bar(sentiment, count, color='skyblue') plt.xlabel("Sentiment") plt.ylabel("Total Count") plt.title("Bar Chart from BigQuery Data") plt.show()

6. Execute essa célula.

   O resultado é um gráfico de barras com as contagens das avaliações positivas e negativas.

7. Como alternativa, você pode usar o código abaixo para criar um relatório simples e codificado por cores para mostrar as contagens de sentimentos negativos e positivos:

   # Create an HTML table for the counts of negative and positive sentiment and color codes the results. html_counts = f"""

   Negative	Positive
   {count[0]}	{count[1]}

   """ # Display the HTML tables display(HTML(html_counts))

Clique em Verificar meu progresso para conferir o objetivo. Pedir que o Gemini analise as avaliações dos clientes em busca de palavras-chave e sentimentos

Tarefa 7: responder às avaliações dos clientes

A empresa Data Beans quer fazer experimentos com as avaliações dos clientes usando imagens e gravações de áudio. Nesta seção do notebook, você vai usar o Cloud Storage, o BigQuery, o Gemini Flash e o Python para executar análises de sentimentos em avaliações de clientes fornecidas à Data Beans como imagens e arquivos de áudio. Com base na análise resultante, você vai gerar respostas para enviar aos clientes, agradecendo a avaliação e informando o que a cafeteria pode fazer de acordo com a avaliação.

Você vai fazer isso em larga escala e, mais tarde, vai usar um arquivo de imagem e áudio para aprender a criar um app de prova de conceito para os representantes de atendimento ao cliente. Com isso, é possível adotar uma estratégia de "human-in-the-loop" para o processo de feedback dos clientes, em que os representantes podem tomar medidas para ajudar os clientes e as cafeterias.

Processamento de arquivos de áudio em larga escala com respostas JSON

1. Crie uma célula para realizar a análise de sentimento em arquivos de áudio e responder aos clientes.

   # Conduct sentiment analysis on audio files and respond to the customer. vertexai.init(project="{{{project_0.project_id | Project ID | disablehighlight }}}", location="{{{project_0.default_region | Region | disablehighlight}}}") model = GenerativeModel(model_name="{{{project_0.startup_script.gemini_flash_model_id |model_id | disablehighlight}}}") prompt = """ Please provide a transcript for the audio. Then provide a summary for the audio. Then identify the keywords in the transcript. Be concise and short. Do not make up any information that is not part of the audio and do not be verbose. Then determine the sentiment of the audio: positive, neutral or negative. Also, you are a customer service representative. How would you respond to this customer review? From the customer reviews provide actions that the location can take to improve. The response and the actions should be simple, and to the point. Do not include any extraneous characters in your response. Answer in JSON format with five keys: transcript, summary, keywords, sentiment, response and actions. Transcript should be a string, summary should be a sting, keywords should be a list, sentiment should be a string, customer response should be a string and actions should be string. """ bucket_name = "{{{project_0.project_id | PROJECT ID | disablehighlight}}}-bucket" folder_name = 'gsp1249/audio' # Include the trailing '/' def list_mp3_files(bucket_name, folder_name): storage_client = storage.Client() bucket = storage_client.bucket(bucket_name) print('Accessing ', bucket, ' with ', storage_client) blobs = bucket.list_blobs(prefix=folder_name) mp3_files = [] for blob in blobs: if blob.name.endswith('.mp3'): mp3_files.append(blob.name) return mp3_files file_names = list_mp3_files(bucket_name, folder_name) if file_names: print("MP3 files found:") print(file_names) for file_name in file_names: audio_file_uri = f"gs://{bucket_name}/{file_name}" print('Processing file at ', audio_file_uri) audio_file = Part.from_uri(audio_file_uri, mime_type="audio/mpeg") contents = [audio_file, prompt] response = model.generate_content(contents) print(response.text) else: print("No MP3 files found in the specified folder.")

   Algumas observações importantes sobre essa célula:

   • Como a primeira linha inicializa an Agent Platform com o ID e a região do projeto, você precisa preencher esses valores.
   • A próxima linha cria um modelo no BigQuery chamado "model", com base no modelo Gemini Flash.
   • Em seguida, defina um comando a ser usado pelo modelo Gemini Flash. O comando converte o arquivo de áudio em texto, analisa o sentimento do texto e, depois, cria uma resposta para o cliente com base em cada arquivo.
   • Você precisa definir o bucket como a variável de string bucket_name. Observação: folder_name também é usado para a subpasta gsp1249/audio. Não faça nenhuma alteração.
   • Uma função list_mp3_files é criada para identificar todos os arquivos MP3 no bucket. Em seguida, esses arquivos são processados pelo modelo Gemini Flash dentro da instrução if.

2. Execute essa célula.

   Todos os 5 arquivos de áudio são analisados e a saída da análise é fornecida como uma resposta JSON. A resposta JSON pode ser devidamente analisada e encaminhada para os apps apropriados a fim de fornecer a resposta ao cliente ou ao local com ações para melhoria.

Criar um app para os representantes de atendimento ao cliente

Nesta seção do laboratório, você vai aprender a criar um app de atendimento ao cliente com base em uma análise de avaliação negativa. Você vai fazer o seguinte:

• Usar o mesmo comando da célula anterior para analisar uma única avaliação negativa.
• Gerar a transcrição do arquivo de áudio da avaliação negativa, criar o objeto JSON da saída do modelo com a formatação apropriada e salvar partes específicas do objeto JSON como variáveis Python para usá-las com HTML no app.
• Gerar a tabela HTML, carregar a imagem que o cliente enviou na avaliação e carregar o arquivo de áudio no player.
• Exibir a tabela HTML, com a imagem e o player para o arquivo de áudio.

1. Crie uma célula e insira o código a seguir para transcrever o arquivo de áudio da avaliação negativa e criar o objeto JSON e as variáveis associadas.

   # Generate the transcript for the negative review audio file, create the JSON object, and associated variables audio_file_uri = f"gs://{bucket_name}/{folder_name}/data-beans_review_7061.mp3" print(audio_file_uri) audio_file = Part.from_uri(audio_file_uri, mime_type="audio/mpeg") contents = [audio_file, prompt] response = model.generate_content(contents) print('Generating Transcript...') #print(response.text) results = response.text # print("your results are", results, type(results)) print('Transcript created...') print('Transcript ready for analysis...') json_data = results.replace('```json', '') json_data = json_data.replace('```', '') jason_data = '"""' + results + '"""' # print(json_data, type(json_data)) data = json.loads(json_data) # print(data) transcript = data["transcript"] summary = data["summary"] sentiment = data["sentiment"] keywords = data["keywords"] response = data["response"] actions = data["actions"]

   Algumas observações importantes sobre essa célula:

   • O código na célula vai selecionar um arquivo de áudio específico do Cloud Storage (data-beans_review_7061.mp3).
   • Em seguida, ele envia o arquivo para o comando na célula anterior rotulada como "Task 7.1" para ser processado pelo modelo Gemini Flash.
   • A resposta do modelo é extraída no formato JSON.
   • Por fim, os dados JSON são analisados e as variáveis Python (relacionadas a resumo, transcrição, sentimento, palavras-chave, resposta ao cliente e ações) são armazenadas.

2. Execute a célula.

   A saída é mínima e contém apenas o URI do arquivo de áudio processado e as mensagens de processamento.

3. Crie uma tabela baseada em HTML com base nos valores selecionados e carregue no player o arquivo de áudio que contém a avaliação negativa.

   # Create an HTML table (including the image) from the selected values. html_string = f"""

   customer_id: 7061 - @coffee_lover789

   {transcript}	{sentiment} feedback
   	{keywords[0]} {keywords[1]} {keywords[2]} {keywords[3]}
   Customer summary:{summary}
   Recommended actions:{actions}
   Suggested Response:{response}

   """ print('The table has been created.')

   Algumas observações importantes sobre essa célula:

   • O código na célula vai criar uma string de tabela HTML.
   • Em seguida, insira os valores de transcrição, sentimento, palavras-chave, imagem, resumo, ações e resposta nas células da tabela.
   • O código também vai aplicar um estilo aos elementos da tabela.
   • Quando a célula for executada, a saída dela vai indicar quando a tabela foi criada.

4. Procure a tag <td style="padding:10px;"> com a saída {summary} incluída. Adicione uma nova linha de código antes dessa tag.

5. Cole <td rowspan="3" style="padding: 10px;"><img src="<authenticated url here>" alt="Customer Image" style="max-width: 300px;"></td> na nova linha de código.

6. Encontre o URL autenticado do arquivo image_7061.png. Acesse o Cloud Storage, selecione o único bucket existente e depois clique na pasta images e na imagem.

7. Na página resultante, copie o URL autenticado da imagem.

8. Volte ao notebook Python no BigQuery. Substitua <authenticated url here> pelo URL autenticado real que está presente no código que você acabou de colar.

9. Execute a célula.

   A saída novamente será mínima. Ela conterá apenas algumas mensagens de processamento que indicam que cada etapa foi concluída.

10. Crie uma célula e use o código abaixo para baixar o arquivo de áudio e carregá-lo no player:

# Download the audio file from Google Cloud Storage and load into the player storage_client = storage.Client() bucket = storage_client.bucket(bucket_name) blob = bucket.blob(f"{folder_name}/data-beans_review_7061.mp3") audio_bytes = io.BytesIO(blob.download_as_bytes()) # Assuming a sample rate of 44100 Hz (common for MP3 files) sample_rate = 44100 print('The audio file is loaded in the player.')

Algumas observações importantes sobre essa célula:

• O código na célula acessa o bucket do Cloud Storage e recupera o arquivo de áudio específico (data-beans_review_7061.mp3).
• Em seguida, ele baixa o arquivo como um fluxo de bytes e determina a taxa de amostragem do arquivo, para que ele possa ser reproduzido em um player diretamente no notebook.
• Quando a célula é executada, a saída dela avisa que o arquivo de áudio foi carregado no player e está pronto para reprodução.

11. Execute a célula.

12. Crie uma célula e insira o código abaixo:

# Task 7.5 - Build the mockup as output to the cell. print('Analysis complete. Review the results below.') display(HTML(html_string)) display(Audio(audio_bytes.read(), rate=sample_rate, autoplay=True))

13. Execute a célula.

Essa célula é fundamental para o processo. O método de exibição é usado para mostrar o arquivo HTML e o arquivo de áudio carregado no player. Analise a saída da célula. Ela deve ser idêntica à imagem abaixo:

Clique em Verificar meu progresso para conferir o objetivo. Responder às avaliações dos clientes

Parabéns!

Você criou a conexão de recurso do Cloud no BigQuery. Você também criou um conjunto de dados, tabelas e modelos para pedir que o Gemini analise o sentimento e as palavras-chave nas avaliações dos clientes. Por fim, você usou o Gemini para analisar as avaliações dos clientes feitas em áudio e gerar resumos e palavras-chave para responder a elas em um app de atendimento ao cliente.

Próximas etapas / Saiba mais

• Introdução ao BigQuery ML
• Escalonamento do machine learning com o mecanismo de inferência do BigQuery ML – Blog (em inglês)
• Modelos do Gemini
• IA generativa

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 5 de novembro de 2025

Laboratório testado em 5 de novembro de 2025

Copyright 2026 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.