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

Autopilot Standard

---

Ce tutoriel explique comment dégager des insights à partir de grands ensembles de données à l'aide de BigQuery, de 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 exploite BigQuery pour le stockage et le traitement des données, Cloud Run pour la gestion des requêtes et le LLM Gemma pour analyser les données et générer des 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 tel que Jupyter.

Vous devez d'abord suivre 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 du modèle.

Pourquoi utiliser GKE et BigQuery ?

BigQuery est un entrepôt de données sans serveur, entièrement géré et PaaS (Platform as a Service) 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 familier 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. 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 fonctionnalités de compréhension du langage naturel du modèle afin de générer des insights pertinents.

Par exemple, en tant que data scientist ou analyste, ou décideur dans une entreprise d'e-commerce, vous pouvez souhaiter comprendre le comportement des utilisateurs sur votre site Web ou dans votre application. Ces insights peuvent vous aider à optimiser et à personnaliser les parcours utilisateur, et à prendre des décisions commerciales éclairées pour booster les 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 des visites de pages et des insights en langage naturel. Le modèle Gemma, qui s'exécute sur une infrastructure évolutive avec l'accélération GPU de GKE, traite rapidement les données sur le parcours utilisateur, en identifiant les tendances et les tendances. Vous pouvez ainsi 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 avant 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). Vous pouvez ainsi interroger et 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: économisez du temps et des ressources en utilisant le modèle de langage Gemma pré-entraîné Open Source, ce qui vous évite de 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 permettant d'accéder au modèle Gemma.
2. Créer une fonction BigQuery distante: exécutez du code Python pour définir une fonction distante qui utilise les données Google Analytics, crée des invites 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 permettre une 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 DataFrames BigQuery 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
   • Appliquez la fonction distante aux données pour générer des insights à partir du modèle Gemma.
   • Affichez les résultats.

Architecture

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

• 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 l'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 :

• Compute Engine instances used by GKE
• GPU resources used by GKE
• BigQuery
• Cloud Load Balancing
• Cloud Run functions

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. 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. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure 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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Make sure that billing is enabled for your Google Cloud project.

Activer les API

Enable the Artifact Registry, Compute Engine, GKE, IAM Service Account Credentials, Cloud Functions, Cloud Build, Cloud Run Admin, Cloud Logging, Serverless VPC Access, BigQuery, Dataform, Vertex AI APIs.

Enable the APIs

Configurer Cloud Shell

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

In the Google Cloud console, activate Cloud Shell.

Activate 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 par défaut Compute Engine de votre projet disposent des rôles IAM (Identity and Access Management) requis pour ce tutoriel.

Grant roles to your user account. Run the following command once for each of the following IAM roles: 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

• Replace PROJECT_ID with your project ID.

• Replace USER_IDENTIFIER with the identifier for your user account. For example, user:[e-mail].

• Replace ROLE with each individual role.

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:[e-mail]" --role=ROLE

• Remplacez PROJECT_ID par l'ID du projet.
• Remplacez PROJECT_NUMBER par votre numéro de projet pour créer le domaine du compte de service Compute Engine par défaut pour votre projet. Exemple : [e-mail].
• 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 Avant de commencer jusqu'à Interagir avec le modèle à l'aide de curl pour vous assurer que votre modèle Gemma est correctement déployé 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 afin que votre fonction distante 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ées 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 lorsque vous créez une fonction distante, vous spécifiez US comme emplacement pour votre ensemble de données, qui est par défaut la région us-central1 pour vos fonctions Cloud Run. Créez ou utilisez donc 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:

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 autre 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 une à deux minutes avant que cette adresse IP puisse être récupérée:

   kubectl get service llm-lb-service --output yaml | grep ip:
   

Vous utiliserez cette adresse IP pour communiquer avec votre application gemma-server exécutée 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 page 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'adresses IP avec les ressources existantes du 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.

Remarque :Chaque connecteur nécessite son propre sous-réseau /28 dédié à usage privé (PRIVATE) avec une plage d'adresses IPv4 principale. Ce sous-réseau ne peut pas être utilisé par d'autres ressources telles que les VM, Private Service Connect ou les équilibreurs de charge. Google Cloud applique cette exigence pour assurer une gestion efficace des adresses IP et éviter les conflits potentiels.

Pour en savoir plus, consultez la section 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 de définition de la fonction distante BigQuery et d'analyse.

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

1. Dans la console Google Cloud , 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 que celle 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 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 BigQuery distante à 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 utilise les données Google Analytics comme entrée, crée une invite 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(
     [str],
     str,
     dataset="ga_demo",
     name="ga_explain_example",
     bigquery_connection="bigframes-rf-conn",
     reuse=True,
     packages=["requests"],
     cloud_function_vpc_connector=VPC_CONNECTOR_NAME
   
   )
   def process_incoming(data):
     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.

3. Cliquez sur  Exécuter la cellule.

La sortie affiche le nom de la fonction, semblable à ce qui 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:

• à 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 Run cell (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 un exemple 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 'Les éléments suivants...
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, puis 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 un exemple 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":"Réponse:\n La page la plus populaire était https://shop.googlemerchandisestore.com/Google+Redesign/Apparel/Google+Dino+Game+Tee\n La page suivante la plus populaire était celle d'où il est venu.\n\n Explication :\n\nLes données fournies montrent que l'utilisateur actuel a accédé à la boutique de produits Google spécifiquement pour le produit "Google Dino Game Tee". \n \nPoints importants à prendre en compte : \n\n* Interprétation des données:vous ne pouvez pas affirmer de manière définitive que"}
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"}

Réussite :vous avez appliqué la fonction distante aux données pour générer des insights à partir du modèle Gemma.

Effectuer un nettoyage

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 soient facturées sur votre compte Google Cloud , 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 la section Autorisations BigQuery.
4. Supprimez votre connexion BigQuery externe.
5. Supprimez vos fonctions Cloud Run.
6. Supprimez votre cluster GKE.
7. Supprimez votre connecteur VPC.

Étape suivante

• Essayez un atelier de programmation pratique pour un cas d'utilisation d'analyse de données structurées et non structurées.
• Consultez les bonnes pratiques pour l'exécution de charges de travail par lot sur GKE.
• Découvrez les cas d'utilisation de l'IA/ML dans BigQuery.
• Découvrez les cas d'utilisation de l'IA et du ML dans GKE.