Gemini 2.0 Flash: Grote documenten verwerken zonder RAG

Waarom Gemini 2.0 Flash gebruiken in plaats van RAG?

Gemini 2.0 Flash heeft een contextvenster van 1.000.000 tokens, waardoor je volledige datasets kunt verwerken zonder te hoeven chunken of retrievalmechanismen te gebruiken. Daarnaast is het kostenefficiënt vergeleken met grotere modellen zoals Gemini Ultra.

Veel applicaties gebruiken retrieval-augmented generation (RAG) voor analyse van gestructureerde data, maar Gemini 2.0 Flash maakt RAG overbodig omdat:

• De hoge tokenlimiet volledige datasetverwerking in één request mogelijk maakt.
• Het directe analyse van gestructureerde data toestaat, waardoor retrievalcomplexiteit vervalt.
• Het sneller en kostenefficiënter is dan RAG-gebaseerde aanpakken.

Als je Gemini 2.0 Flash Lite wilt gebruiken om kosten te optimaliseren, kan dat, maar houd er rekening mee dat het op het moment van publicatie beperkt is tot 60 queries per minuut en alleen beschikbaar is in de regio us-central1.

Overzicht: SaaS-tool voor verkoopinzichten met Gemini 2.0 Flash

Laten we de belangrijkste stappen schetsen die we gaan nemen:

• We beginnen met het laden en voorbereiden van de AWS SaaS Sales-dataset van Kaggle.
• Daarna initialiseren we Google Cloud Vertex AI en Gemini 2.0 Flash voor AI-verwerking.
• Vervolgens extraheren we unieke sectoren en producten voor gebruikersselectie.
• We gebruiken Tiktoken om de omvang van de dataset binnen de tokenlimiet te houden.
• Door de gebruiker gekozen filters starten de berekening van kerncijfers en AI-gestuurde inzichten.
• Sentimentanalyse classificeert de prestaties, en een Vraag-&-Antwoord-functie geeft verkoopgerelateerde inzichten.
• Tot slot integreren we de tool in Gradio voor dynamische interactie en realtime verkenning.

Stap 1: Vereisten

Voordat we beginnen, zorgen we dat de volgende tools en libraries zijn geïnstalleerd:

• Python 3.8+
• Kaggle
• Google-genai
• Datasets
• Tiktoken
• Gradio

Voer de volgende commando's uit om de benodigde dependencies te installeren:

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

Zodra de bovenstaande dependencies zijn geïnstalleerd, voer je deze import-commando's uit:

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

Stap 2: Laad de dataset

We gebruiken de AWS SAAS Sales-dataset voor dit project, die beschikbaar is op Kaggle. Begin met het instellen van Kaggle-credentials en geef respectievelijk de auteur en datasetnaam door.

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

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

Nu de dataset in onze omgeving is gedownload, kunnen we ermee aan de slag. We gebruiken de pandas-library om de dataset vanaf het pad te laden en te lezen.

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

Deze dataset bevat 9.994 transacties met kolommen zoals:

• Industry: sectorcategorie van het bedrijf.
• Product: het verkochte SaaS-product.
• Sales: omzet uit de transactie.
• Quantity: aantal verkochte licenties.
• Profit: winst uit de transactie.
• Discount: toegepaste kortingen.

Stap 3: Google Cloud Vertex AI instellen

Om Gemini 2.0 Flash te gebruiken, moeten we ons authenticeren bij Google Cloud.

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

Om Vertex AI te initialiseren, zoek je naar de Vertex AI API en schakel je die in (zorg dat facturatie is ingeschakeld op je account).

Sla de project-ID en locatie op voor later gebruik. Het draaien van Gemini 2.0 Flash voor dit project kostte ongeveer $0,07 voor circa vijf API-calls.

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

Wil je meer leren over Vertex AI, bekijk dan deze introductietutorial over Vertex AI.

Stap 4: Voorbewerking van data

Om de data goed te verwerken, normaliseer je kolomnamen en extraheer je belangrijke categorieën. We zoeken unieke sectoren en producten die dienen als bron voor onze markdown in de demo. Gebruik je een andere dataset, kies dan je categorieën dienovereenkomstig.

# 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

Stap 5: Tokens in de dataset tellen

Nu we onze dataset hebben verwerkt, gaan we de tokens tellen. Omdat Gemini 2.0 Flash een limiet heeft van 1.000.000 tokens, is het belangrijk om het aantal tokens in de dataset te berekenen voordat je die aan het model doorgeeft. Deze dataset heeft  805447 tokens.

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

We gebruiken Tiktoken voor tokenisatie als volgt:

• Initialiseer de tokenizer: gebruik Tiktokens cl100k_base-tokenizer, geoptimaliseerd voor Gemini- en GPT-modellen.
• Selecteer relevante tekstkolommen: identificeer sleutelkolommen (industry, product, sales, quantity, discount, profit) voor AI-analyse.
• Combineer geselecteerde kolommen tot één tekstveld: converteer kolommen naar strings om typemismatches te voorkomen en voeg ze samen in combined_text met " | " als scheidingsteken.
• Definieer een functie om tokens te tellen: tokeniseer elke rij in combined_text en bereken het totale aantal tokens over alle rijen.
• Bereken het totale aantal tokens in de dataset: verwijder NaN-waarden, pas de token-telfunctie toe en print het totaal om te controleren of je binnen de 1M-tokenlimiet van Gemini 2.0 Flash blijft.

Stap 6: Verkooptrends samenvatten

Nu kunnen we aan het analytische deel van de demo werken. Deze functie genereert een verkoopsamenvatting op basis van de geselecteerde sector en het geselecteerde product. 

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

De functie summarize_sales() filtert de dataset op basis van de gekozen sector en product, berekent kerncijfers zoals totale omzet, verkocht aantal, winst en gemiddelde korting, en zet de data om in een gestructureerde prompt. Deze prompt wordt vervolgens doorgegeven aan het Gemini 2.0 Flash-model om een beknopte verkoopsamenvatting te genereren.

Stap 7: Sentimentanalyse op verkopen uitvoeren

Op dezelfde manier definiëren we een andere functie die sentimentanalyse uitvoert op basis van de totale winst. 

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

De functie analyze_sales_sentiment() analyseert het verkoopsentiment door de dataset te filteren op de gekozen sector en product, de totale omzet en totale winst te berekenen en een AI-gestuurde sentimentanalyse te genereren met Gemini 2.0 Flash. Het model krijgt een gestructureerde samenvatting van de verkoopprestaties, zodat het het sentiment dynamisch kan evalueren in plaats van uitsluitend op vaste winstgrenzen te vertrouwen.

Stap 8: De Gradio-interface bouwen

Nu hebben we alle kernfuncties op orde. Vervolgens bouwen we een interactieve UI met 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)

Deze code maakt een interactieve Gradio-UI voor AI-gestuurde SaaS-verkoopanalyse, waar gebruikers een sector en een product kunnen selecteren in dropdownmenu's en op een knop kunnen klikken om een verkoopsamenvatting te genereren. De gekozen inputs worden doorgegeven aan de functie summarize_sales(), die de data verwerkt en inzichten teruggeeft die in een tekstvak worden weergegeven. De Gradio-app wordt vervolgens gelanceerd voor realtime interactie.

Hier zijn de outputs van een snelle test die ik heb uitgevoerd. Ik koos alle sectoren en producten en vroeg het model vervolgens om een verkoopsamenvatting te maken en sentimentanalyse te doen op de gekozen parameters.

Conclusie

In deze tutorial hebben we een AI-gestuurde SaaS-tool voor verkoopinzichten gebouwd met Gemini 2.0 Flash, waarmee realtime analyse van SaaS-verkoopdata mogelijk is. We gebruikten het grote contextvenster van Gemini 2.0 Flash om gestructureerde data te verwerken zonder RAG en integreerden een interactieve interface op basis van Gradio voor eenvoudige gebruikersinteractie.

Ik moedig je aan om deze tutorial aan te passen aan je eigen use-case. Wil je meer leren over het bouwen van apps met Gemini 2.0, bekijk dan deze tutorials:

• Multimodale AI-toepassing bouwen met Gemini 2.0 Pro
• Gemini 2.0 Flash: stapsgewijze tutorial met demoproject