Esta página foi traduzida pela API Cloud Translation.

Analise dados no GKE com o BigQuery, o Cloud Run e o Gemma

Este tutorial demonstra como obter estatísticas a partir de grandes conjuntos de dados através do BigQuery, do Cloud Run e do LLM Gemma. Neste tutorial, implementa uma aplicação de exemplo no Google Kubernetes Engine (GKE). A app de exemplo tira partido do BigQuery para o armazenamento e o tratamento de dados, do Cloud Run para o tratamento de pedidos e do MDG Gemma para analisar dados e gerar previsões com base em comandos recebidos.

Este tutorial destina-se a administradores e arquitetos da plataforma na nuvem, especialistas em dados e IA, engenheiros de ML> e profissionais de MLOps (DevOps). Antes de ler esta página, certifique-se de que conhece o Kubernetes e um ambiente de bloco de notas como o Jupyter.

Como pré-requisito para este tutorial, tem de concluir o tutorial Publicar modelos abertos Gemma com GPUs no GKE com o TGI do Hugging Face. A framework TGI facilita o processo de publicação de modelos.

Porquê o GKE e o BigQuery

O BigQuery é uma plataforma como serviço (PaaS), um armazém de dados sem servidor totalmente gerido que permite a análise escalável de petabytes de dados. O BigQuery permite-lhe focar-se na análise de dados para encontrar estatísticas significativas enquanto usa o SQL familiar e a aprendizagem automática integrada.

Ao usar GPUs no GKE com a TGI, pode implementar um modelo de linguagem Gemma para analisar e resumir as interações dos utilizadores em linguagem natural. Posteriormente, ao integrar o BigQuery com o GKE, pode usar o BigQuery para processar eficientemente conjuntos de dados massivos (como o Google Analytics) e as capacidades de compreensão da linguagem natural do modelo para gerar estatísticas significativas.

Por exemplo, como cientista de dados ou analista, ou como decisor empresarial numa empresa de comércio eletrónico, pode querer compreender o comportamento dos utilizadores no seu Website ou app. Esta estatística pode ajudar a otimizar e personalizar os percursos dos utilizadores, bem como a tomar decisões empresariais informadas para aumentar as vendas.

Neste cenário, pode usar dados não tratados do Google Analytics do BigQuery, introduzi-los no modelo Gemma e receber resumos de visitas às páginas e estatísticas em linguagem natural. O modelo Gemma, que é executado numa infraestrutura escalável com aceleração de GPU do GKE, processa rapidamente os dados do percurso do utilizador, identificando padrões e tendências. Pode obter informações para identificar combinações de produtos populares, revelar pontos de abandono comuns no processo de pagamento e realçar campanhas de marketing bem-sucedidas que geram tráfego para páginas de destino específicas.

Vantagens

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

Integração do BigQuery: use o BigQuery para armazenar e processar grandes conjuntos de dados (como os dados do Google Analytics neste tutorial). Isto permite-lhe consultar e agregar os dados necessários para a análise do modelo.
Aceleração de GPU: execute o modelo Gemma num cluster do GKE com suporte de GPU para acelerar o processo de inferência, gerando previsões muito mais rapidamente do que com os processadores baseados na CPU.
Redução do custo e do tempo: poupe tempo e recursos usando o modelo de linguagem Gemma pré-preparado de código aberto, o que elimina a necessidade de criar um modelo personalizado de raiz.

Implemente um modelo Gemma

Aceda ao tutorial Implemente modelos abertos Gemma com GPUs no GKE com o TGI do Hugging Face e siga as instruções a partir da secção Antes de começar até à secção Interaja com o modelo através do curl para garantir que o seu modelo Gemma é implementado com êxito e que pode interagir com ele.

Para efeitos deste tutorial, implemente o modelo Gemma 2B-it.

Configure a rede de VPC

Crie ou use a rede VPC na região us-central1 para que a sua função remota possa ligar-se 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 são implementados em localizações compatíveis, a rede VPC tem de estar na mesma região que a função remota do BigQuery. Neste tutorial, quando define as opções dos DataFrames do BigQuery ao criar uma função remota, especifica US como uma localização para o seu conjunto de dados, que é predefinida para a região us-central1 para as suas funções do Cloud Run. Por conseguinte, crie ou use a VPC na região us-central1.

Crie um balanceador de carga

Siga estas instruções para criar um balanceador de carga interno no seu 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
```
Obtenha o endereço IP do balanceador de carga. Pode ter de aguardar 1 a 2 minutos antes de poder obter este endereço IP:
```
kubectl get service llm-lb-service --output yaml | grep ip:
```

Vai usar este endereço IP para comunicar com a sua aplicação gemma-server que está a ser executada atrás do equilibrador de carga.

Crie um conetor

Usa um conetor do Acesso a VPC sem servidor para enviar e receber pedidos através da sua rede VPC sem usar a Internet pública. Para mais informações, consulte o artigo Acesso a VPC sem servidor.

Neste tutorial, cria um conector com uma sub-rede nova e dedicada para evitar conflitos de endereços IP com recursos existentes na VPC. Para ver instruções, consulte a secção Crie um conetor e siga as instruções gcloud da secção Crie um conetor e uma nova sub-rede.

Em alternativa, se quiser usar uma sub-rede existente, siga as instruções na secção Crie um conector com uma sub-rede existente.

Para mais informações, consulte os requisitos da sub-rede do conetor.

Crie um notebook

Neste tutorial, vai usar um bloco de notas do Colab Enterprise para executar todo o código para definir a função remota do BigQuery e realizar a análise.

Para criar um bloco de notas do Colab Enterprise através da Google Cloud consola:

Na Google Cloud consola, aceda à página Blocos de notas do Colab Enterprise:

Aceder a Blocos de notas
No menu Região, selecione us-central1. Esta é a mesma região onde cria todos os seus serviços neste tutorial.
Junto a Ficheiros, clique em Criar um bloco de notas.

O novo bloco de notas é apresentado no separador Os meus blocos de notas.

Para executar código no novo bloco de notas, insira uma nova célula de código no bloco de notas para cada comando ou fragmento de código que quer executar.

Crie uma função remota do BigQuery

Uma das formas de definir uma função remota do BigQuery é usar a biblioteca bigframes. Nesta secção, use bigframes para criar uma função remota denominada process_incoming. Esta função remota usa os dados do Google Analytics como entrada, cria um comando e envia-o para o seu modelo Gemma para análise.

No bloco de notas do Colab Enterprise que criou:

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

Copie o código seguinte 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 o seguinte:

LOADBALANCER_IP_ADDRESS: o endereço IP e a porta do balanceador de carga interno que criou anteriormente, por exemplo, 10.128.05:8000.
PROJECT_ID: o ID do seu projeto.
VPC_CONNECTOR_NAME: o nome do conetor do Acesso a VPC sem servidor que criou anteriormente.

Neste tutorial, a localização do seu conjunto de dados do BigQuery está definida como US, que é predefinida para a região us-central1.

Clique em Executar célula.

O resultado apresenta o nome da função de forma semelhante ao seguinte:

The function name is: PROJECT_ID.ga_demo.ga_explain_example

Analise o comportamento dos utilizadores

Nesta secção, analisa o comportamento do utilizador no seu Website através da process_incomingfunção remota de uma das seguintes duas formas:

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

Use DataFrames do BigQuery

Para executar a função remota através de DataFrames do BigQuery no bloco de notas do Colab Enterprise que criou:

Clique em + Código para inserir uma nova célula de código.
Copie o seguinte código 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 seguinte mostra os resultados de exemplo 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...

Use a ferramenta de linha de comandos `bq`

Em alternativa, pode usar a ferramenta de linha de comandos bq para fazer a análise diretamente com SQL.

Para executar a função remota através da ferramenta de linha de comandos bq no bloco de notas do Colab Enterprise que criou:

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

Copie o código seguinte na nova célula de código e substitua PROJECT_ID pelo ID do seu 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.