Gemini 2.0 Flash : Comment traiter des documents volumineux sans RAG

Pourquoi utiliser Gemini 2.0 Flash au lieu de RAG ?

Gemini 2.0 Flash dispose d'une fenêtre contextuelle de 1 000 000 de tokens, ce qui permet de traiter l'ensemble des données sans avoir recours à des mécanismes de découpage ou d'extraction. En outre, il est plus économique que des modèles plus importants comme le Gemini Ultra.

De nombreuses applications utilisent la génération augmentée par récupération (RAG) pour l'analyse des données structurées, mais Gemini 2.0 Flash élimine le besoin de RAG car :

• Sa limite de jetons élevée permet de traiter un ensemble complet de données en une seule demande.
• Il permet une analyse directe des données structurées, éliminant ainsi la complexité de la recherche.
• Elle permet un traitement plus rapide et plus rentable que les approches basées sur le RAG.

Si vous souhaitez utiliser Gemini 2.0 Flash Lite pour optimiser les coûts, vous pouvez le faire, mais sachez qu'au moment de la publication de cet article, son débit est limité à 60 requêtes par minute et qu'il n'est disponible que dans la région us-central1.

Vue d'ensemble : Outil d'analyse des ventes SaaS avec Gemini 2.0 Flash

Décrivons les principales étapes que nous allons suivre :

• Le processus commence par le chargement et la préparation de l'ensemble de données AWS SaaS Sales de Kaggle.
• Nous allons ensuite initialiser Google Cloud Vertex AI et Gemini 2.0 Flash pour le traitement de l'IA.
• Ensuite, nous extrairons des industries et des produits uniques pour la sélection des utilisateurs.
• Nous utiliserons Tiktoken pour gérer la taille de l'ensemble de données dans la limite du jeton.
• Les filtres sélectionnés par l'utilisateur déclencheront le calcul d'indicateurs de vente clés et d'informations alimentées par l'IA.
• L'analyse des sentiments permettra de classer les performances, et une fonction de questions-réponses fournira des informations sur les ventes.
• Enfin, nous intégrerons l'outil dans Gradio pour une interaction dynamique avec l'utilisateur et une exploration en temps réel.

Étape 1 : Conditions préalables

Avant de commencer, nous devons nous assurer que les outils et bibliothèques suivants sont installés :

• Python 3.8+.
• Kaggle
• Google-genai
• Ensembles de données
• Tiktoken
• Gradio

Exécutez les commandes suivantes pour installer les dépendances nécessaires :

!pip install gradio -q
!pip install --upgrade --quiet google-genai
!pip install datasets -q
!pip install tiktoken -q
!pip install kaggle -q

Une fois les dépendances ci-dessus installées, exécutez les commandes d'importation suivantes :

import sys
import os
import tiktoken
from datasets import load_dataset
import pandas as pd
import gradio as gr
import vertexai
from vertexai.preview.generative_models import GenerativeModel

Étape 2 : Charger l'ensemble de données

Nous utiliserons l'ensemble de données Jeu de données AWS SAAS Sales pour ce projet, qui est disponible sur Kaggle. Commencez par configurer les informations d'identification Kaggle et transmettez respectivement le nom de l'auteur et le nom de l'ensemble de données.

# Set Kaggle API credentials
os.environ["KAGGLE_CONFIG_DIR"] = os.path.expanduser("~/.kaggle")

# Download dataset
!kaggle datasets download -d nnthanh101/aws-saas-sales --unzip

Maintenant que le jeu de données a été téléchargé dans notre environnement, nous pouvons commencer à travailler avec lui. Nous utiliserons la bibliothèque pandas pour charger et lire le jeu de données à partir du chemin d'accès.

dataset_path = "path_to_your_data.csv"  # Load dataset from specified path
dataset_df = pd.read_csv(dataset_path)  

Cet ensemble de données contient 9 994 transactions avec des colonnes telles que :

• L'industrie : Catégorie de l'industrie de l'entreprise.
• Produit : Le produit SaaS vendu.
• Ventes: Recettes provenant de la transaction.
• Quantité : Nombre de licences vendues.
• Bénéfice : Bénéfice de la transaction.
• Remise : Toutes les réductions sont appliquées.

Étape 3 : Configuration de Google Cloud Vertex AI

Pour utiliser Gemini 2.0 Flash, nous devons nous authentifier auprès de Google Cloud.

if "google.colab" in sys.modules:
    from google.colab import auth
    auth.authenticate_user()

Pour initialiser Vertex AI, recherchez l'API Vertex AI et activez-la (assurez-vous que la facturation est activée sur votre compte).

Enregistrez l'identifiant et l'emplacement du projet pour référence ultérieure. L'exécution de Gemini 2.0 Flash pour ce projet a coûté environ 0,07 $ pour environ cinq appels à l'API.

# Set up Google Cloud Vertex AI
PROJECT_ID = "Your_project_id"
LOCATION = "Your_location"
vertexai.init(project=PROJECT_ID, location=LOCATION)
model = GenerativeModel("gemini-2.0-flash")

Pour en savoir plus sur Vertex AI, consultez ce tutoriel d'introduction à Vertex AI.

Étape 4 : Prétraitement des données

Pour garantir un traitement correct des données, normalisez les noms des colonnes et extrayez les catégories clés. Nous trouvons des industries et des produits uniques qui servent de source à notre démarque dans la démo. Si vous utilisez un autre ensemble de données, choisissez vos catégories en conséquence.

# Normalize column names to prevent key errors
df.columns = df.columns.str.strip().str.lower()
print("Dataset columns:", df.columns)  # Debugging

# Extract unique industry names and product categories
unique_industries = sorted(df["industry"].dropna().unique().tolist())
unique_industries.insert(0, "All Industries")  # Add "All Industries" option
unique_products = sorted(df["product"].dropna().unique().tolist())
unique_products.insert(0, "All Products")  # Add "All Products" option

Étape 5 : Comptage des jetons dans l'ensemble de données

Maintenant que nous avons traité notre ensemble de données, nous allons compter les jetons. Gemini 2.0 Flash ayant une limite de 1 000 000 de jetons, il est important de calculer le nombre de jetons dans l'ensemble de données avant de le transmettre au modèle. Cet ensemble de données contient 805447 jetons.

# Initialize tokenizer (use "cl100k_base" for Gemini/GPT models)
encoder = tiktoken.get_encoding("cl100k_base")

# Choose relevant text columns
text_columns = ['industry', 'product', 'sales', 'quantity', 'discount', 'profit']

# Create a combined text column for tokenization
df["combined_text"] = df[text_columns].astype(str).agg(" | ".join, axis=1)

# Function to count tokens
def count_tokens(texts):
    total_tokens = sum(len(encoder.encode(str(text))) for text in texts)
    return total_tokens

# Calculate total tokens
total_tokens = count_tokens(df["combined_text"].dropna().tolist())
print(f"Total tokens in the dataset: {total_tokens}")

Nous utilisons Tiktoken pour la tokenisation comme suit :

• Initialiser le tokenizer :  Utilisez le tokenizer cl100k_base de Tiktoken, optimisé pour les modèles Gemini et GPT.
• Sélectionnez les colonnes de texte pertinentes: Identifiez les colonnes clés (industrie, produit, ventes, quantité, remise, bénéfice) pour l'analyse AI.
• Combinez les colonnes sélectionnées dans un seul champ de texte : Convertissez les colonnes en chaînes de caractères pour éviter les incompatibilités de type et fusionnez-les dans combined_text en utilisant " | " comme séparateur.
• Définissez une fonction pour compter les jetons : Tokenisez chaque ligne sur combined_text et calculez le nombre total de tokens sur toutes les lignes.
• Calculez le nombre total de tokens dans l'ensemble de données: Supprimez les valeurs NaN, appliquez la fonction de comptage des jetons et imprimez le nombre total de jetons pour garantir la conformité avec la limite de 1 million de jetons de Gemini 2.0 Flash.

Étape 6 : Résumer les tendances des ventes

Nous pouvons maintenant travailler sur les parties de la démo consacrées aux analystes. Cette fonction génère un résumé des ventes basé sur le secteur et le produit sélectionnés. 

def summarize_sales(industry, product):
    filtered_data = df.copy()

    if industry != "All Industries":
        filtered_data = filtered_data[filtered_data["industry"] == industry]
    if product != "All Products":
        filtered_data = filtered_data[filtered_data["product"] == product]

    if filtered_data.empty:
        return "No sales data available for the selected industry and product."

    # Create sales report
    total_sales = filtered_data["sales"].sum()
    total_quantity = filtered_data["quantity"].sum()
    total_profit = filtered_data["profit"].sum()
    avg_discount = filtered_data["discount"].mean()

    sales_text = f"""
    Sales Data for {industry} - {product}:
    - Total Sales: ${total_sales:,.2f}
    - Total Quantity Sold: {total_quantity}
    - Total Profit: ${total_profit:,.2f}
    - Average Discount: {avg_discount:.2f}%
    """

    # Generate summary using Gemini 2.0 Flash
    response = model.generate_content(sales_text, stream=True)
    response_text = "".join(chunk.text for chunk in response)

    return response_text

La fonction summarize_sales() filtre l'ensemble des données en fonction du secteur et du produit sélectionnés, calcule des indicateurs de vente clés tels que le chiffre d'affaires total, la quantité vendue, le bénéfice et la remise moyenne, et met en forme les données dans un message structuré. Cette invite est ensuite transmise au modèle Gemini 2.0 Flash pour générer un résumé concis des ventes.

Étape 7 : Effectuer une analyse du sentiment de vente

De même, nous définissons une autre fonction qui effectue une analyse des sentiments sur la base du bénéfice total. 

def analyze_sales_sentiment(industry, product):
    filtered_data = dataset_df.copy()

    if industry != "All Industries":
        filtered_data = filtered_data[filtered_data["industry"] == industry]
    if product != "All Products":
        filtered_data = filtered_data[filtered_data["product"] == product]

    if filtered_data.empty:
        return "No sales data available for sentiment analysis."

    total_sales = filtered_data["sales"].sum()
    total_profit = filtered_data["profit"].sum()

    # Define sentiment labels based on profit margins
    if total_profit > 500000:
        sentiment_label = "Positive"
    elif total_profit > 100000:
        sentiment_label = "Neutral"
    else:
        sentiment_label = "Negative"

    sentiment_text = f"""
    The total sales for {industry} - {product} is ${total_sales:,.2f}, 
    with a total profit of ${total_profit:,.2f}.
    Based on market trends, this performance is considered {sentiment_label}.
    Analyze the sentiment of sales performance for this product.
    """

    # Generate sentiment analysis using Gemini Flash 2.0
    response = model.generate_content(sentiment_text, stream=True)

    # Collect response text
    response_text = "".join(chunk.text for chunk in response)

    return response_text

La fonction analyze_sales_sentiment() analyse le sentiment de vente en filtrant l'ensemble des données en fonction de l'industrie et du produit sélectionnés, en calculant le total des ventes et le total des bénéfices, et en générant une analyse du sentiment alimentée par l'IA à l'aide de Gemini 2.0 Flash. Le modèle est ensuite invité à présenter un résumé structuré des performances de vente, ce qui lui permet d'évaluer le sentiment de manière dynamique au lieu de s'appuyer uniquement sur des seuils de profit fixes.

Étape 8 : Construire l'interface Gradio

Toutes les fonctions logiques clés sont désormais en place. Ensuite, nous travaillerons sur la construction d'une interface utilisateur interactive avec Gradio.

with gr.Blocks() as demo:
    gr.Markdown("# AI-Powered SaaS Sales Analysis")
    industry_dropdown = gr.Dropdown(choices=unique_industries, label="Select an Industry")
    product_dropdown = gr.Dropdown(choices=unique_products, label="Select a Product")
    summarize_btn = gr.Button("Summarize Sales Trends")
    summary_output = gr.Textbox(label="Sales Trend Summary")
    summarize_btn.click(summarize_sales, inputs=[industry_dropdown, product_dropdown], outputs=summary_output)
    demo.launch(debug=True)

Ce code crée une interface utilisateur interactive Gradio pour l'analyse des ventes SaaS alimentée par l'IA, où les utilisateurs peuvent sélectionner un secteur et un produit dans des menus déroulants et cliquer sur un bouton pour générer un résumé des ventes. Les entrées sélectionnées sont transmises à la fonction summarize_sales(), qui traite les données et renvoie des informations, affichées dans une zone de texte. L'application Gradio est alors lancée pour une interaction en temps réel.

Voici les résultats d'un test rapide que j'ai effectué. J'ai choisi tous les secteurs et tous les produits, puis j'ai demandé au modèle de produire un résumé des ventes et d'effectuer une analyse des sentiments sur la base des paramètres choisis.

Conclusion

Dans ce tutoriel, nous avons construit un outil d'analyse des ventes SaaS alimenté par l'IA à l'aide de Gemini 2.0 Flash, permettant l'analyse en temps réel des données de ventes SaaS. Nous avons utilisé la grande fenêtre contextuelle de Gemini 2.0 Flash pour traiter des données structurées sans RAG et avons intégré une interface interactive basée sur Gradio pour faciliter l'interaction avec l'utilisateur.

Je vous encourage à adapter ce tutoriel à votre propre cas d'utilisation. Pour en savoir plus sur la création d'applications avec Gemini 2.0, je vous recommande ces tutoriels :

• Construire une application d'IA multimodale avec Gemini 2.0 Pro
• Gemini 2.0 Flash : Tutoriel étape par étape avec projet de démonstration