Esta página foi traduzida pela API Cloud Translation.

Analisar dados no GKE usando o BigQuery, o Cloud Run e a Gemma

Este tutorial demonstra como extrair insights de grandes conjuntos de dados usando o BigQuery, o Cloud Run e o LLM Gemma. Neste tutorial, você vai implantar um aplicativo de amostra no Google Kubernetes Engine (GKE). O app de exemplo usa o BigQuery para armazenamento e tratamento de dados, o Cloud Run para processamento de solicitações e o LLM Gemma para analisar dados e gerar previsões com base em comandos recebidos.

Este tutorial é destinado a administradores e arquitetos da plataforma de nuvem, especialistas em dados e IA, engenheiros de ML e profissionais de MLOps (DevOps). Antes de ler esta página, confira se você conhece o Kubernetes e um ambiente de notebook como o Jupyter.

Como pré-requisito para este tutorial, conclua o tutorial Disponibilizar modelos abertos do Gemma usando GPUs no GKE com o TGI Hugging Face. O framework TGI facilita o processo de disponibilização de modelos.

Por que o GKE e o BigQuery

O BigQuery é um data warehouse sem servidor, totalmente gerenciado e de plataforma como serviço (PaaS) que permite análises escalonáveis em petabytes de dados. Com o BigQuery, você se concentra na análise de dados para encontrar insights relevantes usando SQL e machine learning integrados.

Usando GPUs no GKE com TGI, é possível implantar um modelo de linguagem Gemma para analisar e resumir interações do usuário em linguagem natural. Ao integrar o BigQuery ao GKE, você pode usar o BigQuery para processar com eficiência grandes conjuntos de dados (como o Google Analytics) e os recursos de compreensão de linguagem natural do modelo para gerar insights relevantes.

Por exemplo, como cientista ou analista de dados ou tomador de decisões de negócios em uma empresa de e-commerce, talvez você queira entender o comportamento do usuário no seu site ou app. Esse insight pode ajudar você a otimizar e personalizar as jornadas do usuário e tomar decisões de negócios fundamentadas para aumentar as vendas.

Nesse cenário, você pode usar dados brutos do Google Analytics do BigQuery, alimentar o modelo Gemma e receber resumos e insights de visitas à página em linguagem natural. O modelo Gemma, que é executado em uma infraestrutura escalonável com aceleração de GPU do GKE, processa rapidamente os dados da jornada do usuário, identificando padrões e tendências. Você pode receber insights para identificar combinações de produtos populares, revelar pontos de desistência comuns no processo de finalização da compra e destacar campanhas de marketing bem-sucedidas que geram tráfego para páginas de destino específicas.

Vantagens

Essa solução oferece um fluxo de trabalho simplificado com as seguintes vantagens:

Integração com o BigQuery: use o BigQuery para armazenar e processar grandes conjuntos de dados, como os dados do Google Analytics neste tutorial. Isso permite consultar e agregar os dados necessários para a análise do modelo.
Aceleração de GPU: execute o modelo Gemma em um cluster do GKE com suporte a GPU para acelerar o processo de inferência, gerando previsões muito mais rápido do que com os processadores baseados em CPU.
Redução de custos e tempo: economize tempo e recursos usando o modelo de linguagem Gemma pré-treinado de código aberto, eliminando a necessidade de criar um modelo personalizado do zero.

Disponibilizar um modelo Gemma

Acesse o tutorial Disponibilizar modelos abertos do Gemma usando GPUs no GKE com o TGI do Hugging Face e siga as instruções de Antes de começar até Interagir com o modelo usando curl para garantir que o modelo Gemma seja implantado com sucesso e que você possa interagir com ele.

Para os fins deste tutorial, implante o modelo Gemma 2B-it.

Configurar a rede VPC

Crie ou use a rede VPC na região us-central1 para que sua função remota possa se conectar ao cluster do GKE. Neste tutorial, use a VPC Default.

Para garantir que o conjunto de dados do BigQuery, a função remota e as funções do Cloud Run subjacentes sejam implantados em locais compatíveis, a rede VPC precisa estar na mesma região que a função remota do BigQuery. Neste tutorial, ao definir as opções do BigQuery DataFrames ao criar uma função remota, você especifica US como um local para seu conjunto de dados, que é definido como padrão para a região us-central1 das suas funções do Cloud Run. Portanto, crie ou use a VPC na região us-central1.

Criar um balanceador de carga

Siga estas instruções para criar um balanceador de carga interno no cluster do GKE:

Crie o seguinte manifesto tgi-2b-lb-service.yaml:

apiVersion: v1
kind: Service
metadata:
name: llm-lb-service
annotations:
    networking.gke.io/load-balancer-type: "Internal"
spec:
selector:
  app: gemma-server
type: LoadBalancer
ports:
- protocol: TCP
  port: 8000
  targetPort: 8000

Abra um novo terminal do Cloud Shell e execute o seguinte comando para aplicar o manifesto:
```
kubectl apply -f tgi-2b-lb-service.yaml
```
Consiga o endereço IP do balanceador de carga. Talvez seja necessário aguardar de um a dois minutos antes que esse endereço IP possa ser buscado:
```
kubectl get service llm-lb-service --output yaml | grep ip:
```

Você vai usar esse endereço IP para se comunicar com o aplicativo gemma-server que está sendo executado por trás do balanceador de carga.

Criar um conector

Você usa um conector de acesso VPC sem servidor para enviar e receber solicitações pela rede VPC sem usar a Internet pública. Para mais informações, consulte Acesso VPC sem servidor.

Neste tutorial, você vai criar um conector com uma sub-rede nova e dedicada para evitar conflitos de endereços IP com recursos atuais na VPC. Para instruções, consulte a seção Criar um conector e siga as instruções gcloud para a seção Criar um conector e uma nova sub-rede.

Se preferir usar uma sub-rede, siga as instruções na seção Criar um conector usando uma sub-rede.

Para mais informações, consulte Requisitos de sub-rede do conector.

Criar um notebook

Neste tutorial, você vai usar um notebook do Colab Enterprise para executar todo o código de definição da função remota do BigQuery e realizar a análise.

Para criar um bloco do Colab Enterprise usando o console Google Cloud :

No console do Google Cloud , acesse a página Notebooks do Colab Enterprise:

Acesse o Notebooks
No menu Região, selecione us-central1. Essa é a mesma região em que você cria todos os serviços neste tutorial.
Ao lado de Arquivos, clique em Criar um notebook.

O novo notebook aparece na guia Meus notebooks.

Para executar o código no novo notebook, insira uma célula de código para cada comando ou snippet que você quer executar.

Criar uma função remota do BigQuery

Uma das maneiras de definir uma função remota do BigQuery é usando a biblioteca bigframes. Nesta seção, use bigframes para criar uma função remota chamada process_incoming. Essa função remota usa dados do Google Analytics como entrada, cria um comando e o envia para análise ao seu modelo da Gemma.

No bloco do Colab Enterprise que você criou:

Clique em + Código para inserir uma nova célula de código.

Copie o código a seguir na nova célula de código:

# Install the necessary packages on the notebook runtime
%pip install --upgrade bigframes --quiet

import bigframes.pandas as bpd
import os
import ast
import requests

# Replace the following  variables
# Use the format ip:port
# For example, "10.128.05:8000"
lb_url = "LOADBALANCER_IP_ADDRESS:8000"

# Set BigQuery DataFrames options
bpd.options.bigquery.project = "PROJECT_ID"
bpd.options.bigquery.location = "US"
# Update the VPC connector name with the one you created
vpc_connector_name = "VPC_CONNECTOR_NAME"

# Create a remote function using bigframes
# https://cloud.google.com/bigquery/docs/remote-functions#bigquery-dataframes

@bpd.remote_function(
  dataset="ga_demo",
  name="ga_explain_example",
  bigquery_connection="bigframes-rf-conn",
  reuse=True,
  packages=["requests"],
  cloud_function_vpc_connector=VPC_CONNECTOR_NAME,
  cloud_function_service_account="default",
)
def process_incoming(data: str) -> str:
  ga_data = ast.literal_eval(data)
  USER_PROMPT = """
      'The following are the results from Google Analytics.
      They are reverse ranked.
      reverse_event_number 1 is the last page visited.
      reverse_event_number 2 is the second last page visited.
      You are given the following data.
      {}
      Can you summarize what was the most popular page people landed on and what page they came from?
  """.format(ga_data)

  url = 'http://{}/generate'.format(lb_url)

  myobj = {
      "inputs": USER_PROMPT,
      "temperature": 0.90,
      "top_p": 0.95,
      "max_tokens": 2048
  }
  x = requests.post(url, json=myobj)
  result = x.text
  return (result)

function_name = process_incoming.bigframes_remote_function
print (f"The function name is: {function_name}")

Substitua:

LOADBALANCER_IP_ADDRESS: o endereço IP e a porta do balanceador de carga interno que você criou antes, por exemplo, 10.128.05:8000.
PROJECT_ID: o ID do projeto.
VPC_CONNECTOR_NAME: o nome do conector de acesso VPC sem servidor que você criou anteriormente.

Neste tutorial, a localização do conjunto de dados do BigQuery está definida como US, que usa a região us-central1 por padrão.

Clique em Executar célula.

A saída mostra o nome da função, semelhante a este:

The function name is: PROJECT_ID.ga_demo.ga_explain_example

Analisar o comportamento do usuário

Nesta seção, você vai analisar o comportamento do usuário no seu site usando a função remota process_incoming de uma das duas maneiras a seguir:

usando DataFrames do BigQuery
usando a ferramenta de linha de comando bq para executar uma consulta diretamente em SQL.

Usar DataFrames do BigQuery

Para executar a função remota usando o DataFrames do BigQuery no notebook do Colab Enterprise que você criou:

Clique em + Código para inserir uma nova célula de código.
Copie o código a seguir na nova célula de código e clique em Executar célula.

# Generate a list of all matchups and their histories as a JSON

grouping_sql = """
with
data_table as (
 SELECT
 distinct
   user_pseudo_id,
   events.value.string_value,
   event_timestamp,
   rank() over (partition by user_pseudo_id order by event_timestamp desc) as reverse_event_number
 FROM
   `bigquery-public-data.ga4_obfuscated_sample_ecommerce.events_20210131` as events20210131,
   unnest (events20210131.event_params) as events
 where events.key = 'page_location'
 qualify reverse_event_number < 3
)
select
*,TO_JSON_STRING (data_table) as ga_history
from data_table
limit 10;

"""

ga_df = bpd.read_gbq(grouping_sql)
post_processed = ga_df.assign(results=ga_df['ga_history'].apply(process_incoming),axis=1)
post_processed.head(10)

A saída a seguir mostra os resultados de amostra da consulta:

user_pseudo_id	string_value	event_timestamp	reverse_event_number	ga_history	resultados	eixo
0	2342103247.0307162928	https://shop.googlemerchandisestore.com/Google...	1612096237169825	2	{"user_pseudo_id":"2342103247.0307162928","str...	{"generated_text":"\n 'The following are...
1	48976087.6959390698	https://www.googlemerchandisestore.com/	1612056537823270	2	{"user_pseudo_id":"48976087.6959390698","strin...	{"generated_text":"\n \n ```python\n imp...

Usar a ferramenta de linha de comando `bq`

Outra opção é usar a ferramenta de linha de comando bq para fazer análises diretamente com SQL.

Para executar a função remota usando a ferramenta de linha de comando bq no bloco de notas do Colab Enterprise que você criou:

Clique em + Código para inserir uma nova célula de código.

Copie o código a seguir na nova célula de código e substitua PROJECT_ID pelo ID do projeto.

# Update with your PROJECT_ID

function_name = 'PROJECT_ID.ga_demo.ga_explain_example'

new_sql = """'with \
data_table as ( \
SELECT \
distinct \
  user_pseudo_id, \
  events.value.string_value, \
  event_timestamp, \
  rank() over (partition by user_pseudo_id order by event_timestamp desc) as reverse_event_number \
FROM \
  `bigquery-public-data.ga4_obfuscated_sample_ecommerce.events_20210131` as events20210131, \
  unnest (events20210131.event_params) as events \
where events.key = "page_location" \
qualify reverse_event_number < 3 \
) \
select \
*, `{}`(TO_JSON_STRING (data_table)) as result \
from data_table \
limit 10;' \
""".format(function_name)

# Run query using bq cli directly in a notebook cell

!bq query --use_legacy_sql=false \
{new_sql}

Clique em Executar célula.