Insights generativos com o SQL do BigQuery e a Vertex AI

1. Introdução

Neste codelab, vamos criar um app de recomendação e previsão da classificação de filmes com consultas SQL do BigQuery e a API PaLM da Vertex AI. O modelo usado para gerar texto é o text-bison, que é hospedado como uma função remota no BigQuery.

Os serviços usados são:

1. BigQuery ML
2. API PaLM da Vertex AI
3. Cloud Shell

O que você vai criar

Você vai criar

• Um conjunto de dados do BigQuery para conter o modelo
• Um modelo do BigQuery ML que prevê a pontuação de sucesso de um filme com base nos atributos GÊNERO e DURAÇÃO.
• Um modelo do BigQuery que hospeda a API PaLM da Vertex AI como uma função remota
• Uma conexão externa para estabelecer a conexão entre o BigQuery e a Vertex AI

2. Requisitos

• Use um navegador, como o Chrome ou o Firefox.
• Tenha um projeto do Google Cloud com o faturamento ativado.

Antes de começar

1. No console do Google Cloud, na página de seletor de projetos, selecione ou crie um projeto do Google Cloud.
2. Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto.
3. Verifique se todas as APIs necessárias (API BigQuery, API Vertex AI e API BigQuery Connection) estão ativadas.
4. Você vai usar o Cloud Shell, um ambiente de linha de comando executado no Google Cloud que vem pré-carregado com bq. Consulte a documentação para ver o uso e os comandos gcloud.

No console do Cloud, clique em "Ativar o Cloud Shell" no canto superior direito:

Se o projeto não estiver definido, use este comando:

gcloud config set project <YOUR_PROJECT_ID>

5. Acesse o console do BigQuery diretamente inserindo o seguinte URL no navegador: https://console.cloud.google.com/bigquery

3. Preparando os dados

Neste caso de uso, vamos usar o conjunto de dados de filmes derivado da fonte movielens.

1. Crie um conjunto de dados:

Um conjunto de dados do BigQuery é uma coleção de tabelas. Todas as tabelas em um conjunto de dados são armazenadas no mesmo local de dados. Também é possível anexar controles de acesso personalizados para limitar o acesso a um conjunto de dados e às tabelas dele.

No Cloud Shell, use o comando bq mk para criar um conjunto de dados chamado "movie_insights".

bq mk --location=us-central1 movie_insights

2. Clone o arquivo de origem na sua máquina do Cloud Shell:

git clone https://github.com/AbiramiSukumaran/movie_score_genai_insights

3. Navegue até o novo diretório do projeto criado na sua máquina do Cloud Shell:

cd movie_score_genai_insights

4. Use o comando bq load para carregar o arquivo CSV em uma tabela do BigQuery. Também é possível fazer upload diretamente da interface do BigQuery:

bq load --source_format=CSV --skip_leading_rows=1 movie_insights.movie_score \
./movies_data.csv \ Id:numeric,name:string,rating:string,genre:string,year:numeric,released:string,score:string,director:string,writer:string,star:string,country:string,budget:numeric,company:string,runtime:numeric,data_cat:string

5. É possível consultar uma amostra para verificar se a tabela movie_score e os dados foram criados no conjunto de dados:

bq query --use_legacy_sql=false \
SELECT name, rating, genre, runtime FROM movie_insights.movie_score limit 3;

4. Dados para ML

Vamos criar um modelo de classificação para prever a pontuação de sucesso do filme com base nos atributos GÊNERO e DURAÇÃO. Vamos usar a instrução CREATE MODEL com a opção "LOGISTIC_REG" para criar e treinar um modelo de regressão logística.

Execute a consulta abaixo na seção "EDITOR DE CONSULTAS" do espaço de trabalho SQL do console do BigQuery:

CREATE OR REPLACE MODEL
  `movie_insights.model_rating_by_runtime_genre`
OPTIONS
  ( model_type='LOGISTIC_REG',
    auto_class_weights=TRUE,
    data_split_method='NO_SPLIT',
    model_registry='vertex_ai',   
    vertex_ai_model_version_aliases=['logistic_reg', 'experimental'],
    input_label_cols=['score']
  ) AS
SELECT name, genre,runtime, score
FROM
  movie_insights.movie_score
WHERE
  data_cat = 'TRAIN';

Detalhes da consulta:

1. A instrução CREATE MODEL treina um modelo usando os dados de treinamento na instrução SELECT.
2. A cláusula OPTIONS especifica o tipo de modelo e as opções de treinamento. Aqui, a opção LOGISTIC_REG especifica um tipo de modelo de regressão logística. Não é preciso especificar um modelo de regressão logística binária ou multiclasse: o BigQuery ML consegue determinar qual deles treinar com base no número de valores exclusivos na coluna de rótulo.
3. data_split_method=‘NO_SPLIT' força o BQML a treinar nos dados de acordo com as condições da consulta (data_cat = ‘TRAIN'). Também é melhor usar ‘AUTO_SPLIT' nessa opção para permitir que a estrutura (ou o serviço, nesse caso) randomizar a partição das divisões de treinamento/teste.
4. A opção "input_label_cols" especifica qual coluna na instrução SELECT deve ser usada como a coluna de rótulo. Aqui, a coluna de rótulo é "score", então o modelo vai aprender qual dos 10 valores de "score" é mais provável com base nos outros valores presentes em cada linha.
5. A opção "auto_class_weights=TRUE" equilibra os rótulos de classe nos dados de treinamento. Por padrão, os dados de treinamento não são ponderados. Se os rótulos nos dados de treinamento estiverem desequilibrados, o modelo poderá aprender a prever a classe mais comum de rótulos com mais intensidade.
6. A instrução SELECT consulta a tabela que carregamos com os dados CSV. A cláusula WHERE filtra as linhas na tabela de entrada para que apenas o conjunto de dados TRAIN seja selecionado nesta etapa.
7. As construções a seguir são OPCIONAIS para que o BigQuery ML possa registrá-las explicitamente no Vertex AI Model Registry. Saiba mais sobre isso neste blog. model_registry='vertex_ai', vertex_ai_model_version_aliases=['logistic_reg', 'experimental']

Depois de criado, o seguinte aparece na seção "ESQUEMA" do espaço de trabalho do BigQuery SQL:

Depois de criar o modelo, avalie o desempenho dele usando a função ML.EVALUATE. A função ML.EVALUATE avalia os valores previstos em relação aos dados reais.

Você também pode conferir as métricas de avaliação do modelo na página "MODELO":

Principais métricas em um relance:

Precisão: qual proporção de identificações positivas estava correta? Precisão = Verdadeiro positivo / (Verdadeiro positivo + Falso positivo) Recall: qual proporção de positivos verdadeiros foi identificada corretamente? Recall = Verdadeiro positivo / (Verdadeiro positivo + Falso negativo) Acurácia: uma métrica para avaliar modelos de classificação. É a fração de previsões que nosso modelo acertou. Acurácia = Número de previsões corretas / Número total de previsões

5. Prever a pontuação de um filme usando o modelo

Hora da previsão!!!! A consulta a seguir prevê a pontuação de cada filme no conjunto de dados categorizado como dados "TEST".

Execute a consulta abaixo na seção "EDITOR DE CONSULTAS" do espaço de trabalho SQL do console do BigQuery:

SELECT
  *
FROM
  ML.PREDICT (MODEL movie_insights.model_rating_by_runtime_genre,
    (
    SELECT
      *
    FROM
      movie_insights.movie_score
    WHERE
      data_cat= 'TEST'
     )
  );

O resultado será assim:

O resultado do modelo mostra o predicted_score do filme em uma escala de 1 a 10 (classificação). Talvez você esteja se perguntando por que há várias linhas de previsão para cada filme. Isso acontece porque o modelo retornou os possíveis rótulos previstos e a probabilidade de ocorrência de cada um em ordem decrescente.

Analisar os resultados previstos e o modelo:

Você pode realizar duas etapas de análise importantes com a previsão para entender os resultados:

1. Para entender por que seu modelo está gerando esses resultados de previsão, use a função ML.EXPLAIN_PREDICT.
2. Para saber quais recursos são os mais importantes para determinar a faixa de renda em geral, use a função ML.GLOBAL_EXPLAIN.

Leia sobre essas etapas em detalhes na documentação.

6. Dados para a IA generativa

Vamos gerar insights sobre o conjunto de dados de filmes pedindo ao LLM (modelo de linguagem grande) o resumo dos fatores que influenciam a pontuação do filme a ser maior que 5, com a IA generativa usando o modelo text-bison (mais recente) da Vertex AI usando apenas consultas SQL.

1. A tabela movie_score criada também será a entrada para esta etapa.
2. Uma conexão externa será criada para estabelecer o acesso entre o BigQuery ML e os serviços da Vertex.
3. A estrutura GENERATE_TEXT do BigQuery será usada para invocar a API PaLM remotamente da Vertex AI.

7. Criar uma conexão externa

Ative a API BigQuery Connection, se ainda não tiver feito isso, e anote o ID da conta de serviço nos detalhes da configuração da conexão:

1. Clique no botão +ADICIONAR no painel do BigQuery Explorer (à esquerda do console do BigQuery) e clique em "Conexão com fontes de dados externas" nas fontes mais usadas listadas.
2. Selecione "BigLake e funções remotas" como tipo de conexão, "Região" como tipo de local e "us-central1 (Iowa)" como valor, além de "bq_llm_connection" como ID da conexão.

3. Depois que a conexão for criada, anote a conta de serviço gerada nos detalhes da configuração da conexão.

Conceder permissões

Nesta etapa, vamos conceder permissões à conta de serviço para acessar o serviço da Vertex AI:

Abra o IAM e adicione a conta de serviço que você copiou depois de criar a conexão externa como principal e selecione o papel "Usuário da Vertex AI".

8. Criar um modelo de ML remoto

Crie o modelo remoto que representa um modelo de linguagem grande hospedado da Vertex AI:

CREATE OR REPLACE MODEL
  movie_insights.llm_model REMOTE
WITH CONNECTION `us-central1.bq_llm_connection` OPTIONS (remote_service_type = 'CLOUD_AI_LARGE_LANGUAGE_MODEL_V1');

Ele cria um modelo chamado llm_model no conjunto de dados movie_insights, que usa a API CLOUD_AI_LARGE_LANGUAGE_MODEL_V1 da Vertex AI como uma função remota. O processo vai levar vários segundos para ser concluído.

9. Gerar texto usando o modelo de ML

Depois de criar o modelo, use-o para gerar, resumir ou categorizar textos.

SELECT
  ml_generate_text_result['predictions'][0]['content'] AS generated_text,
  ml_generate_text_result['predictions'][0]['safetyAttributes']
    AS safety_attributes,
  * EXCEPT (ml_generate_text_result)
FROM
  ML.GENERATE_TEXT(
    MODEL `movie_insights.llm_model`,
    (
 SELECT
      CONCAT('FROM THE FOLLOWING TEXT ABOUT MOVIES, WHAT DO YOU THINK ARE THE FACTORS INFLUENCING A MOVIE SCORE TO BE GREATER THAN 5?: ', movie_data) AS prompt
    FROM (
      SELECT
        REPLACE(STRING_AGG( CONCAT('A movie named ',name, ' from the country ', country, ' with a censor rating of ',rating, ' and a budget of ', budget, ' produced by ', company, ' with a runtime of about ', runtime, ' and in the genre ', genre, ' starring ', star, ' has had a success score of ', score, '') ), ',','. ') AS movie_data
      FROM (
        SELECT
          *
        FROM
          `movie_insights.movie_score`
        WHERE
          CAST(SCORE AS INT64) > 5
        LIMIT
          50) ) AS MOVIES
    ),
    STRUCT(
      0.2 AS temperature,
      100 AS max_output_tokens));

**Explicação:

ml_generate_text_result** é a resposta do modelo de geração de texto no formato JSON que contém atributos de conteúdo e segurança: a. O conteúdo representa o resultado do texto gerado b. Os atributos de segurança representam o filtro de conteúdo integrado com um limite ajustável ativado na API PaLM da Vertex AI para evitar respostas não intencionais ou imprevistas do modelo de linguagem grande. A resposta é bloqueada se violar o limite de segurança.

ML.GENERATE_TEXT é o constructo usado no BigQuery para acessar o LLM da Vertex AI e realizar tarefas de geração de texto.

CONCAT anexa sua instrução PROMPT e o registro do banco de dados

movie_insights é o nome do conjunto de dados e movie_score é o nome da tabela que tem os dados que vamos usar no design do comando.

Temperatura é o parâmetro do comando para controlar a aleatoriedade da resposta. Quanto menor, melhor a relevância.

Max_output_tokens é o número de palavras que você quer na resposta.

A resposta da consulta é semelhante a esta:

Como você pode ver, a resposta é aninhada e não formatada.

10. Aplanar o resultado da consulta

Vamos achatar o resultado para não precisar decodificar o JSON explicitamente na consulta:

SELECT
  *
FROM
  ML.GENERATE_TEXT( MODEL movie_insights.llm_model,
    (
    SELECT
      CONCAT('FROM THE FOLLOWING TEXT ABOUT MOVIES, WHAT DO YOU THINK ARE THE FACTORS INFLUENCING A MOVIE SCORE TO BE GREATER THAN 5?: ', movie_data) AS prompt
    FROM (
      SELECT
        REPLACE(STRING_AGG( CONCAT('A movie named ',name, ' from the country ', country, ' with a censor rating of ',rating, ' and a budget of ', budget, ' produced by ', company, ' with a runtime of about ', runtime, ' and in the genre ', genre, ' starring ', star, ' has had a success score of ', score, '') ), ',','. ') AS movie_data
      FROM (
        SELECT
          *
        FROM
          `movie_insights.movie_score`
        WHERE
          CAST(SCORE AS INT64) > 5
        LIMIT
          50) ) AS MOVIES),
    STRUCT( 0.2 AS temperature,
      100 AS max_output_tokens,
      TRUE AS flatten_json_output));

**Explicação:

**Flatten_json_output** representa o booleano que, se definido como verdadeiro, retorna um texto simples e compreensível extraído da resposta JSON.

A resposta da consulta é semelhante a esta:

11. Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados nesta postagem, exclua o endpoint da Vertex AI criado como parte da etapa de ML. Para isso, acesse a página "Endpoint da Vertex AI".

12. Parabéns

Parabéns! Você criou um modelo do BQML e realizou análises baseadas em LLMs usando uma API da Vertex AI no conjunto de dados de filmes usando apenas consultas SQL. Confira a documentação do produto LLM da Vertex AI para saber mais sobre os modelos disponíveis.