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'exemple d'application exploite 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 basées sur les invites entrantes.

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

Pour suivre ce tutoriel, vous devez d'abord effectuer le tutoriel Diffuser des modèles ouverts Gemma à l'aide de GPU sur GKE avec Hugging Face TGI. Le framework TGI facilite la mise en service du modèle.

Pourquoi utiliser GKE et BigQuery ?

BigQuery est un entrepôt de données sans serveur entièrement géré, de type Platform as a Service (PaaS), 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 informations pertinentes tout en utilisant le langage SQL familier et le machine learning intégré.

En utilisant des 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. Ensuite, 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, analyste ou 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 insights 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 transmettre 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 de GKE, traite rapidement les données du parcours utilisateur, en identifiant les tendances et les modèles. Vous pouvez obtenir des insights pour identifier les combinaisons de produits populaires, révéler les points d'abandon courants dans le processus de paiement 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 dans 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, en générant des prédictions beaucoup plus rapidement qu'avec les processeurs basés sur le processeur.
  • Réduction des coûts et du temps : gagnez du temps et des ressources en utilisant le modèle de langage Gemma Open Source pré-entraîné, ce qui vous évite d'avoir à créer un modèle personnalisé à partir de zéro.

Objectifs

Dans ce tutoriel, vous allez apprendre à effectuer les opérations suivantes :

  1. Déployer le modèle et l'exposer : créez un fichier YAML de service pour définir un équilibreur de charge interne afin d'accéder au modèle Gemma.
  2. Créer une fonction distante BigQuery : exécutez du code Python pour définir une fonction distante qui prend les données Google Analytics, crée des prompts pour le modèle, envoie des requêtes au point de terminaison du modèle à l'aide de l'équilibreur de charge et renvoie la réponse du modèle.
  3. Configurer le réseau VPC (cloud privé virtuel) : configurez un réseau VPC et un connecteur VPC pour activer la communication sécurisée entre BigQuery et le cluster GKE. Cela est essentiel pour que la fonction distante puisse accéder au point de terminaison du modèle.
  4. Analyser les données : analysez les données à l'aide de BigQuery DataFrames, ou directement en SQL à l'aide de l'outil de ligne de commande bq. Exécutez les extraits de code fournis dans un notebook Colab Enterprise pour :
    • interroger les données Google Analytics à partir de BigQuery à l'aide de SQL ;
    • appliquer la fonction distante aux données pour générer des insights à partir du modèle Gemma ;
    • afficher les résultats.

Architecture

Le schéma d'architecture suivant montre les composants impliqués et leur interaction :

Architecture d'analyse des données

  • Utilisez un notebook Colab Enterprise pour exécuter votre code Python. Avec Python, vous pouvez utiliser la bibliothèque bigframes pour simplifier vos interactions SQL.
  • BigQuery sert de moteur de traitement de big data, ce qui permet d'utiliser SQL pour interagir avec les données.
  • La fonction distante appelle une fonction Cloud Run. Les données sont automatiquement acheminées vers la fonction distante où elles sont préparées et envoyées à GKE pour inférence.
  • Les résultats sont renvoyés à BigQuery et affichés dans un tableau.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud:

Obtenez une estimation des coûts en fonction de votre utilisation prévue, utilisez le simulateur de coût.

Les nouveaux utilisateurs de peuvent bénéficier d'un essai sans frais. Google Cloud

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Assurez-vous de remplir les conditions préalables suivantes :

Sélectionner ou créer un projet

Vous pouvez utiliser un projet existant ou en créer un pour ce tutoriel.

  1. Connectez-vous à votre Google Cloud compte. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits sans frais pour exécuter, tester et déployer des charges de travail.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  5. Verify that billing is enabled for your Google Cloud project.

Activer les API

Activez les API Artifact Registry, Compute Engine, GKE, IAM Service Account Credentials, Cloud Functions, Cloud Build, Cloud Run Admin, Cloud Logging, Accès au VPC sans serveur, BigQuery, Dataform et Vertex AI.

Rôles requis pour activer les API

Pour activer les API, vous avez besoin du rôle IAM Administrateur d'utilisation du service (roles/serviceusage.serviceUsageAdmin), qui contient l'autorisation serviceusage.services.enable. Découvrez comment attribuer des rôles.

Activer les API

Configurer Cloud Shell

Dans ce tutoriel, vous utilisez Cloud Shell pour exécuter gcloud et kubectl commandes. Cloud Shell est un environnement shell permettant de gérer les ressources hébergées sur Google Cloud. Il est préinstallé avec le Google Cloud CLI et l'outil de ligne de commande kubectl.

Dans la Google Cloud console, activez Cloud Shell.

Activer Cloud Shell

Une session Cloud Shell s'ouvre dans un cadre situé en bas de la console.

Avant d'exécuter des commandes dans ce tutoriel, assurez-vous que votre projet par défaut est défini sur l'ID du projet dans lequel vous souhaitez déployer l'exemple d'application. Si ce n'est pas déjà fait, exécutez la commande suivante dans Cloud Shell :

gcloud config set project PROJECT_ID

Remplacez PROJECT_ID par votre ID du projet

Accorder des rôles IAM

Assurez-vous que votre compte utilisateur et le compte de service Compute Engine par défaut de votre projet disposent des rôles IAM (Identity and Access Management) requis pour ce tutoriel.

Attribuez des rôles à votre compte utilisateur. Exécutez la commande suivante une fois pour chacun des rôles IAM suivants : roles/aiplatform.colabEnterpriseAdmin, roles/run.invoker, roles/container.admin, roles/iam.serviceAccountAdmin, roles/logging.logWriter 

gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE

Remplacez les éléments suivants :

  • PROJECT_ID : ID de votre projet
  • USER_IDENTIFIER : identifiant de votre compte utilisateur Par exemple, myemail@example.com.
  • ROLE : rôle IAM que vous accordez à votre compte utilisateur

Attribuez des rôles à votre compte de service Compute Engine par défaut. Exécutez la commande suivante une fois pour chacun des rôles IAM suivants : roles/logging.logWriter, roles/artifactregistry.writer, roles/storage.objectViewer

gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com" --role=ROLE
  • Remplacez PROJECT_ID par votre ID du projet
  • Remplacez PROJECT_NUMBER par le numéro de votre projet pour créer le domaine du compte de service Compute Engine par défaut de votre projet. Par exemple, 123456789012-compute@developer.gserviceaccount.com.
  • Remplacez ROLE par chaque rôle individuel.

Diffuser un modèle Gemma

Accédez au tutoriel Diffuser des modèles ouverts Gemma à l'aide de GPU sur GKE avec Hugging Face TGI et suivez les instructions à partir de la section 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 le réseau VPC

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

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 est défini par défaut sur 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

Suivez ces instructions pour créer un équilibreur de charge interne dans votre cluster GKE :

  1. 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

  2. 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

  3. Obtenez l'adresse IP de l'équilibreur de charge. Vous devrez peut-être attendre 1 à 2 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 la section Accès au VPC sans serveur.

Dans ce tutoriel, vous allez créer un connecteur avec un nouveau sous-réseau 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 et 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.

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

Créer un notebook

Dans ce tutoriel, vous utilisez 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

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

    Accéder à Notebooks

  2. Dans le menu Région, sélectionnez us-central1. Il s'agit de la même région dans laquelle vous créez tous vos services dans ce tutoriel.

  3. À 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 nouvelle cellule de code dans votre notebook 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, entre autres, à l'aide de la bibliothèque bigframes. Dans cette section, utilisez bigframes pour créer une fonction distante appelée process_incoming. Cette fonction distante prend les données Google Analytics en entrée, crée un prompt et l'envoie à votre modèle Gemma pour analyse.

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

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

  2. 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 :

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

  3. Cliquez sur Exécuter la cellule.

La sortie 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 distante process_incoming de l'une des deux manières suivantes :

  • à l'aide de BigQuery DataFrames
  • à l'aide de 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éé :

  1. Cliquez sur + Code pour insérer une nouvelle cellule de code.
  2. 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)

La sortie suivante montre les 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 une analyse 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éé :

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

  2. 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}

  3. Cliquez sur Exécuter la cellule.

La sortie suivante montre les exemples de résultats de la requête :

user_pseudo_id string_value event_timestamp reverse_event_number résultat
86037838.0267811614 https://shop.googlemerchandisestore.com/Google+Redesign/Apparel/Google+Dino+Game+Tee 1612128627715585 1 {"generated_text":"Answer:\n The most popular page was https://shop.googlemerchandisestore.com/Google+Redesign/Apparel/Google+Dino+Game+Tee\n The next most popular page was the page they came from.\n\n Explanation:\n\nThe provided data shows that the current user visited Google's merchandise store specifically for the product "Google Dino Game Tee."} \n \nImportant Considerations:\n\n* Data Interpretation: You can't definitively say the"}
4024190.3037653934 https://shop.googlemerchandisestore.com/Google+Redesign/Apparel/Google+Black+Cloud+Zip+Hoodie 1612085948486438 1 {"generated_text":"\n ```python\n import pandas as pd\n\n data = {'user_pseudo_id': ['4024190.3037653934', '4024190.3037653934', '4024190.3037653934'],\n 'string_value': ['https://shop.googlemerchandisestore.com"}

Libérer de l'espace

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Pour éviter que les ressources utilisées dans ce tutoriel ne soient facturées sur votre Google Cloud compte, supprimez les ressources individuelles.

  1. Supprimez votre notebook Colab Enterprise.
  2. Supprimez votre environnement d'exécution Colab Enterprise.
  3. Supprimez votre fonction BigQuery. Assurez-vous que votre compte de service dispose de l'autorisation bigquery.routines.delete. Pour en savoir plus, consultez Autorisations BigQuery.
  4. Supprimez votre connexion externe BigQuery.
  5. Supprimez vos fonctions Cloud Run.
  6. Supprimez votre cluster GKE.
  7. Supprimez votre connecteur VPC.

Étape suivante