GSP1249

Visão geral

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

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 nuvens. 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 fornece acesso aos modelos Gemini Pro, Gemini Pro Vision e 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.
• Solicitar 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 do atendimento ao cliente respondam a avaliações de clientes feitas em áudio.

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o 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, 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 ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

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

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

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, você verá um pop-up para 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 | "Nome de usuário"}}}

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

4. Clique em Seguinte.

5. Copie a Senha abaixo e cole na caixa de diálogo de boas-vindas.

   {{{user_0.password | "Senha"}}}

   Você também encontra a Senha no painel Detalhes do laboratório.

6. Clique em Seguinte.

   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: clique em Menu de navegação no canto superior esquerdo para acessar uma lista de produtos e serviços do Google Cloud.

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 o 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 PYTHON.

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. Clique em Conectar.

2. Clique no ID do estudante do Qwiklabs.

   Aguarde. Pode levar até três 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: estabelecer a conexão do recurso do Cloud e conceder o papel do IAM

Criar a conexão do recurso do Cloud no BigQuery

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

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

1. Crie uma nova célula de código com o código abaixo:

   # 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. Crie uma nova célula de código com o código abaixo:

   # Set Python variables for project_id and region project_id = "{{{project_0.project_id|Project ID}}}" region = " {{{ project_0.default_region | "REGION" }}}" Observação: como project_id e region são salvas aqui como variáveis Python, e não como variáveis SQL, só é possível fazer referência a elas em células usando códigos Python, não códigos SQL.

4. Execute essa célula. As variáveis para project_id e region foram definidas.

5. Crie uma nova célula de código com 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 da CLI do Google Cloud bq mk --connection 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 Conferir ações ao lado do ID do projeto no Explorer.

8. Selecione Atualizar conteúdo.

9. Expanda Conexões externas. Agora, us.gemini_conn está listado como uma conexão externa.

10. Clique em us.gemini_conn.

11. No painel de informações da conexão, copie o ID da conta de serviço para um arquivo de texto a fim de usá-lo na próxima tarefa.

Conceder o papel de usuário da Vertex AI à conta de serviço da conexão

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

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 um papel, digite Vertex AI e selecione o papel Usuário da Vertex AI.

5. Clique em Salvar.

   Agora, a conta de serviço tem o papel de usuário da Vertex AI.

Clique em Verificar meu progresso para conferir o objetivo. Estabelecer a conexão do 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 realizar esta tarefa em que você vai conceder permissões à conta de serviço da conexão de recurso, analise o conjunto de dados e os arquivos de imagem.

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

2. Clique no bucket -bucket.

3. O bucket contém a pasta gsp1249, que você deve abrir. Nela, você vai encontrar cinco itens:

   • A pasta audio contém todos os arquivos de áudio que você vai analisar. Você pode acessar essa pasta e analisar os arquivos de áudio que ela contém.
   • 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 a pasta e conferir esse arquivo de imagem.
   • notebook.ipynb é uma cópia do notebook que você vai criar neste laboratório. Você pode conferir esse notebook.
   Observação: você pode usar o URL autenticado para baixar e analisar cada item.

Conceder o papel do IAM administrador de objetos do Storage à 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ê garante que não ocorram 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 de seleção de papel, digite Objeto do Storage e selecione o papel Administrador de objetos do Storage.

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

Nessa 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. Retorne ao notebook Python no BigQuery.

2. Crie uma nova célula de código com o código abaixo:

   # Create the dataset %%bigquery CREATE SCHEMA IF NOT EXISTS `{{{project_0.project_id|Project ID}}}.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.

   Como resultado, 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 BigQuery Explorer.

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. Crie uma nova célula de código com 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}}}-bucket/gsp1249/customer_reviews.csv']);

2. Execute essa célula.

   Como resultado, a tabela customer_reviews é criada com dados de amostra de avaliações de 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. No Explorer, clique na tabela customer_reviews e confira o esquema e os detalhes.

4. Crie uma célula de código 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

5. 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 Pro no BigQuery

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

1. Retorne ao notebook Python.

2. Crie uma nova célula de código com o código abaixo:

   # Create the customer reviews table %%bigquery CREATE OR REPLACE MODEL `gemini_demo.gemini_pro` REMOTE WITH CONNECTION `us.gemini_conn` OPTIONS (endpoint = 'gemini-pro')

3. Execute essa célula.

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

4. No Explorer, clique no modelo gemini_pro e analise os detalhes e o esquema.

Clique em Verificar meu progresso para conferir o objetivo. Criar o modelo Gemini Pro no BigQuery

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

Nessa tarefa, você vai usar o modelo Gemini Pro 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. Crie uma nova célula de código com 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_pro`, ( 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_pro 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 posteriores.

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

   Como resultado, a tabela customer_reviews_analysis é criada.

3. No Explorer, clique na tabela customer_reviews_analysis e analise o esquema e os detalhes.

4. Crie uma nova célula de código com o código abaixo:

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

5. 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, contendo caracteres estranhos, como pontos ou espaço extra. Você pode limpar os registros com a visualização abaixo.

Criar uma visualização para limpar os registros

1. Crie uma nova célula de código com 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 espaços extras ou pontos, sejam removidos. A visualização resultante vai facilitar as análises em etapas posteriores deste laboratório.

3. Crie uma nova célula de código com o código abaixo:

   # Pull the first 100 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 posteriores para criar um relatório.

Criar um relatório de contagem de avaliações positivas e negativas

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

1. Crie uma nova célula de código a fim de 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 IN ('positive', 'negative') GROUP BY sentiment;" query_job = client.query(query) results = query_job.result().to_dataframe() results.head(10)

2. Execute essa célula.

   O resultado da execução da célula é uma tabela com as contagens totais de avaliações positivas e negativas.

3. Crie uma célula para definir variáveis para o 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 das 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. Solicitar 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 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 de atendimento ao cliente 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, posteriormente, vai usar um arquivo de imagem e áudio para aprender a criar um app de prova de conceito para os representantes do 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 do atendimento ao cliente podem tomar medidas tanto com relação aos clientes quanto com relação a cada cafeteria.

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}}}", location="{{{project_0.default_region|region}}}") model = GenerativeModel(model_name="gemini-1.5-flash") 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 customr 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}}}-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 a Vertex AI 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, após a análise, 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.

   Como resultado, todos os cinco 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 do 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 como parte do app.
• Gerar a tabela HTML, carregar a imagem que o cliente enviou para a 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. Criar uma célula e inserir o código a seguir para gerar a transcrição do arquivo de áudio da avaliação negativa e, em seguida, 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 Tarefa 7.1 para ser processado pelo modelo Gemini Flash.
   • A resposta do modelo é extraída no formato JSON.
   • Em seguida, os dados JSON são analisados e variáveis Python são armazenadas neles com relação a resumo, transcrição, sentimento, palavras-chave, resposta do cliente e ações.

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 o arquivo de áudio que contém a avaliação negativa no player.

   # 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 a pasta images e clique na imagem.

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

8. Retorne 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. Use o código abaixo para criar uma célula, a fim de 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 consiste em uma mensagem que informa 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 exibir 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 solicitar 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
• 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 26 de julho de 2024

Laboratório testado em 26 de julho de 2024

Copyright 2024 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.