Cette page a été traduite par l'API Cloud Translation.

Analyser des données sur GKE à l'aide de BigQuery, Cloud Run et Gemma

Ce tutoriel explique comment obtenir des insights à partir de grands ensembles de données à l'aide de BigQuery, Cloud Run et du LLM Gemma. Dans ce tutoriel, vous allez déployer un exemple d'application sur Google Kubernetes Engine (GKE). L'application exemple utilise BigQuery pour le stockage et le traitement des données, Cloud Run pour la gestion des requêtes et le LLM Gemma pour l'analyse des données et la génération de prédictions en fonction des requêtes entrantes.

Ce tutoriel est destiné aux administrateurs et architectes de plate-forme cloud, aux spécialistes des données et de l'IA, aux ingénieurs en ML et aux professionnels du MLOps (DevOps). Avant de lire cette page, assurez-vous de maîtriser Kubernetes et un environnement de notebook comme Jupyter.

Avant de suivre ce tutoriel, vous devez avoir terminé le tutoriel Diffuser des modèles ouverts Gemma à l'aide de GPU sur GKE avec Hugging Face TGI. Le framework TGI facilite le processus de diffusion des modèles.

Pourquoi GKE et BigQuery ?

BigQuery est une plate-forme PaaS (Platform as a Service), un entrepôt de données sans serveur entièrement géré qui permet une analyse évolutive de pétaoctets de données. BigQuery vous permet de vous concentrer sur l'analyse des données pour en dégager des insights pertinents, tout en utilisant le langage SQL que vous connaissez et le machine learning intégré.

À l'aide de GPU sur GKE avec TGI, vous pouvez déployer un modèle de langage Gemma pour analyser et résumer les interactions des utilisateurs en langage naturel. En intégrant BigQuery à GKE, vous pouvez utiliser BigQuery pour gérer efficacement des ensembles de données volumineux (comme Google Analytics) et les capacités de compréhension du langage naturel du modèle pour générer des insights pertinents.

Par exemple, en tant que data scientist ou analyste, ou en tant que décideur commercial dans une entreprise d'e-commerce, vous pouvez souhaiter comprendre le comportement des utilisateurs sur votre site Web ou votre application. Ces informations peuvent vous aider à optimiser et à personnaliser les parcours utilisateur, et à prendre des décisions commerciales éclairées pour augmenter vos ventes.

Dans ce scénario, vous pouvez extraire des données Google Analytics brutes de BigQuery, les fournir au modèle Gemma et recevoir des résumés et des insights sur les visites de pages en langage naturel. Le modèle Gemma, qui s'exécute sur une infrastructure évolutive avec accélération GPU depuis GKE, traite rapidement les données du parcours utilisateur, en identifiant les tendances et les schémas. Vous pouvez obtenir des insights pour identifier les combinaisons de produits populaires, révéler les points d'abandon courants dans le processus de règlement et mettre en évidence les campagnes marketing efficaces qui génèrent du trafic vers des pages de destination spécifiques.

Avantages

Cette solution offre un workflow simplifié avec les avantages suivants :

Intégration de BigQuery : utilisez BigQuery pour stocker et traiter de grands ensembles de données (comme les données Google Analytics de ce tutoriel). Cela vous permet d'interroger et d'agréger les données nécessaires à l'analyse du modèle.
Accélération GPU : exécutez le modèle Gemma sur un cluster GKE compatible avec les GPU pour accélérer le processus d'inférence et générer des prédictions beaucoup plus rapidement qu'avec les processeurs basés sur le CPU.
Réduction des coûts et du temps : gagnez du temps et des ressources en utilisant le modèle de langage Gemma pré-entraîné et Open Source, ce qui vous évite de créer un modèle personnalisé à partir de zéro.

Diffuser un modèle Gemma

Consultez le tutoriel Diffuser des modèles ouverts Gemma à l'aide de GPU sur GKE avec Hugging Face TGI et suivez les instructions à partir de Avant de commencer jusqu'à Interagir avec le modèle à l'aide de curl pour vous assurer que votre modèle Gemma est déployé correctement et que vous pouvez interagir avec lui.

Pour les besoins de ce tutoriel, déployez le modèle Gemma 2B-it.

Configurer un réseau VPC

Créez ou utilisez le réseau VPC dans la région us-central1 pour que votre fonction à distance puisse se connecter au cluster GKE. Dans ce tutoriel, utilisez le VPC Default.

Pour vous assurer que votre ensemble de données BigQuery, votre fonction distante et les fonctions Cloud Run sous-jacentes sont déployés dans des emplacements compatibles, le réseau VPC doit se trouver dans la même région que votre fonction distante BigQuery. Dans ce tutoriel, lorsque vous définissez des options BigQuery DataFrames lors de la création d'une fonction distante, vous spécifiez US comme emplacement pour votre ensemble de données, qui correspond par défaut à la région us-central1 pour vos fonctions Cloud Run. Par conséquent, créez ou utilisez le VPC dans la région us-central1.

Créer un équilibreur de charge

Pour créer un équilibreur de charge interne dans votre cluster GKE, procédez comme suit :

Créez le fichier manifeste tgi-2b-lb-service.yaml suivant :

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

Ouvrez un nouveau terminal Cloud Shell et exécutez la commande suivante pour appliquer le fichier manifeste :
```
kubectl apply -f tgi-2b-lb-service.yaml
```
Obtenez l'adresse IP de l'équilibreur de charge. Vous devrez peut-être attendre une à deux minutes avant de pouvoir récupérer cette adresse IP :
```
kubectl get service llm-lb-service --output yaml | grep ip:
```

Vous utiliserez cette adresse IP pour communiquer avec votre application gemma-server qui s'exécute derrière l'équilibreur de charge.

Créer un connecteur

Vous utilisez un connecteur d'accès au VPC sans serveur pour envoyer et recevoir des requêtes via votre réseau VPC sans utiliser l'Internet public. Pour en savoir plus, consultez Accès au VPC sans serveur.

Dans ce tutoriel, vous allez créer un connecteur avec un sous-réseau nouveau et dédié pour éviter tout conflit d'adresse IP avec les ressources existantes dans le VPC. Pour obtenir des instructions, consultez la section Créer un connecteur, puis suivez les instructions gcloud de la section Créer un connecteur et un sous-réseau.

Si vous souhaitez utiliser un sous-réseau existant, suivez les instructions de la section Créer un connecteur à l'aide d'un sous-réseau existant.

applique cette exigence pour assurer une gestion efficace des adresses IP et éviter les conflits potentiels.

Pour en savoir plus, consultez Exigences concernant le sous-réseau du connecteur.

Créer un notebook

Dans ce tutoriel, vous allez utiliser un notebook Colab Enterprise pour exécuter tout votre code afin de définir la fonction distante BigQuery et d'effectuer l'analyse.

Pour créer un notebook Colab Enterprise à l'aide de la console Google Cloud :

Dans la console Google Cloud , accédez à la page Notebooks Colab Enterprise :

Accéder à Notebooks
Dans le menu Région, sélectionnez us-central1. Il s'agit de la même région que celle dans laquelle vous créez tous vos services dans ce tutoriel.
À côté de Fichiers, cliquez sur Créer un notebook.

Votre nouveau notebook s'affiche dans l'onglet Mes notebooks.

Pour exécuter du code dans votre nouveau notebook, insérez une cellule de code pour chaque commande ou extrait de code que vous souhaitez exécuter.

Créer une fonction distante BigQuery

Vous pouvez définir une fonction distante BigQuery à l'aide de la bibliothèque bigframes. Dans cette section, utilisez bigframes pour créer une fonction distante appelée process_incoming. Cette fonction à distance prend les données Google Analytics comme entrée, construit une requête et l'envoie à votre modèle Gemma pour analyse.

Dans le notebook Colab Enterprise que vous avez créé :

Cliquez sur + Code pour insérer une nouvelle cellule de code.

Copiez le code suivant dans la nouvelle cellule de code :

# 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}")

Remplacez les éléments suivants :

LOADBALANCER_IP_ADDRESS : adresse IP et port de l'équilibreur de charge interne que vous avez créé précédemment (par exemple, 10.128.05:8000).
PROJECT_ID : ID de votre projet.
VPC_CONNECTOR_NAME : nom du connecteur d'accès au VPC sans serveur que vous avez créé précédemment.

Dans ce tutoriel, l'emplacement de votre ensemble de données BigQuery est défini sur US, qui correspond par défaut à la région us-central1.

Cliquez sur Exécuter la cellule.

Le résultat affiche le nom de la fonction, comme suit :

The function name is: PROJECT_ID.ga_demo.ga_explain_example

Analyser le comportement des utilisateurs

Dans cette section, vous allez analyser le comportement des utilisateurs sur votre site Web à l'aide de la fonction à distance process_incoming de l'une des deux manières suivantes :

d'utiliser BigQuery DataFrames
en utilisant l'outil de ligne de commande bq pour exécuter une requête directement en SQL.

Utiliser BigQuery DataFrames

Pour exécuter la fonction distante à l'aide de BigQuery DataFrames dans le notebook Colab Enterprise que vous avez créé :

Cliquez sur + Code pour insérer une nouvelle cellule de code.
Copiez le code suivant dans la nouvelle cellule de code, puis cliquez sur Exécuter la cellule.

# 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)

Le résultat suivant montre des exemples de résultats de la requête :

user_pseudo_id	string_value	event_timestamp	reverse_event_number	ga_history	résultats	axe
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...

Utiliser l'outil de ligne de commande `bq`

Vous pouvez également utiliser l'outil de ligne de commande bq pour effectuer des analyses directement à l'aide de SQL.

Pour exécuter la fonction distante à l'aide de l'outil de ligne de commande bq dans le notebook Colab Enterprise que vous avez créé :

Cliquez sur + Code pour insérer une nouvelle cellule de code.

Copiez le code suivant dans la nouvelle cellule de code et remplacez PROJECT_ID par l'ID de votre projet.

# 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}

Cliquez sur Exécuter la cellule.