Gemini 2.0 Flash: come elaborare documenti di grandi dimensioni senza RAG

Perché usare Gemini 2.0 Flash invece di RAG?

Gemini 2.0 Flash ha una finestra di contesto di 1.000.000 token, che consente l'elaborazione dell'intero dataset senza bisogno di suddivisione in chunk o meccanismi di retrieval. Inoltre, è conveniente in termini di costi rispetto a modelli più grandi come Gemini Ultra.

Molte applicazioni usano la retrieval-augmented generation (RAG) per l'analisi di dati strutturati, ma Gemini 2.0 Flash elimina la necessità di RAG perché:

• Il suo ampio limite di token consente l'elaborazione dell'intero dataset in una singola richiesta.
• Permette l'analisi diretta di dati strutturati, eliminando la complessità del retrieval.
• Offre un'elaborazione più rapida e conveniente rispetto agli approcci basati su RAG.

Se vuoi usare Gemini 2.0 Flash Lite per ottimizzare i costi, puoi farlo, ma tieni presente che al momento della pubblicazione di questo articolo è limitato a 60 query al minuto ed è disponibile solo nella regione us-central1.

Panoramica: strumento di insight sulle vendite SaaS con Gemini 2.0 Flash

Vediamo i passaggi principali che seguiremo:

• Si parte caricando e preparando il dataset AWS SaaS Sales da Kaggle.
• Poi inizializzeremo Google Cloud Vertex AI e Gemini 2.0 Flash per l'elaborazione AI.
• Successivamente, estrarremo i settori e i prodotti unici per la selezione da parte dell'utente.
• Useremo Tiktoken per gestire la dimensione del dataset entro il limite di token.
• I filtri scelti dall'utente attiveranno il calcolo delle metriche chiave di vendita e insight generati dall'AI.
• L'analisi del sentiment classificherà le performance e una funzione di Q&A fornirà insight legati alle vendite.
• Infine, integreremo lo strumento in Gradio per un'interazione dinamica e un'esplorazione in tempo reale.

Passaggio 1: Prerequisiti

Prima di iniziare, assicurati di avere installati i seguenti strumenti e librerie:

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

Esegui i seguenti comandi per installare le dipendenze necessarie:

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

Una volta installate le dipendenze, esegui i seguenti comandi di import:

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

Passaggio 2: Carica il dataset

Useremo il dataset AWS SAAS Sales per questo progetto, disponibile su Kaggle. Inizia configurando le credenziali di Kaggle e passando rispettivamente l'autore e il nome del dataset.

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

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

Ora che il dataset è stato scaricato nel nostro ambiente, possiamo iniziare a lavorarci. Useremo la libreria pandas per caricare e leggere il dataset dal percorso.

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

Questo dataset contiene 9.994 transazioni con colonne quali:

• Industry: categoria del settore dell'azienda.
• Product: il prodotto SaaS venduto.
• Sales: ricavo della transazione.
• Quantity: numero di licenze vendute.
• Profit: profitto della transazione.
• Discount: eventuali sconti applicati.

Passaggio 3: Configurare Google Cloud Vertex AI

Per usare Gemini 2.0 Flash, dobbiamo effettuare l'autenticazione con Google Cloud.

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

Per inizializzare Vertex AI, cerca la Vertex AI API e abilitala (assicurati che la fatturazione sia abilitata sul tuo account).

Salva l'ID e la località del progetto per riferimento futuro. L'esecuzione di Gemini 2.0 Flash per questo progetto è costata circa $0,07 per circa cinque chiamate 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")

Per saperne di più su Vertex AI, dai un'occhiata a questo tutorial introduttivo su Vertex AI.

Passaggio 4: Preprocessing dei dati

Per garantire una corretta gestione dei dati, normalizza i nomi delle colonne ed estrai le categorie chiave. Troviamo i settori e i prodotti unici che fungono da sorgente per il nostro markdown nella demo. Se stai usando un dataset diverso, scegli le tue categorie di conseguenza.

# 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

Passaggio 5: conteggio dei token nel dataset

Ora che abbiamo elaborato il nostro dataset, conteremo i token. Poiché Gemini 2.0 Flash ha un limite di 1.000.000 di token, è importante calcolare il numero di token nel dataset prima di passarlo al modello. Questo dataset ha  805447 token.

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

Usiamo Tiktoken per la tokenizzazione come segue:

• Inizializza il tokenizer: usa il tokenizer cl100k_base di Tiktoken, ottimizzato per i modelli Gemini e GPT.
• Seleziona le colonne di testo rilevanti: identifica le colonne chiave (industry, product, sales, quantity, discount, profit) per l'analisi AI.
• Combina le colonne selezionate in un unico campo testuale: converti le colonne in stringhe per evitare incongruenze di tipo e uniscile in combined_text usando " | " come separatore.
• Definisci una funzione per contare i token: tokenizza ogni riga in combined_text e calcola il numero totale di token su tutte le righe.
• Calcola i token totali nel dataset: rimuovi i valori NaN, applica la funzione di conteggio dei token e stampa il totale dei token per assicurarti di rispettare il limite di 1M token di Gemini 2.0 Flash.

Passaggio 6: riassumere le tendenze di vendita

Ora possiamo lavorare sulla parte di analisi della demo. Questa funzione genera un riepilogo delle vendite in base al settore e al prodotto selezionati. 

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 funzione summarize_sales() filtra il dataset in base al settore e al prodotto selezionati, calcola le metriche chiave come vendite totali, quantità venduta, profitto e sconto medio, e formatta i dati in un prompt strutturato. Questo prompt viene quindi passato al modello Gemini 2.0 Flash per generare un riepilogo conciso delle vendite.

Passaggio 7: eseguire l'analisi del sentiment sulle vendite

In modo analogo, definiamo un'altra funzione che esegue l'analisi del sentiment in base al profitto totale. 

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 funzione analyze_sales_sentiment() analizza il sentiment delle vendite filtrando il dataset in base al settore e al prodotto selezionati, calcolando vendite totali e profitto totale e generando un'analisi del sentiment con Gemini 2.0 Flash. Il modello viene quindi istruito con un riepilogo strutturato delle performance di vendita, permettendogli di valutare il sentiment in modo dinamico invece di basarsi solo su soglie fisse di profitto.

Passaggio 8: creare l'interfaccia Gradio

Ora abbiamo tutte le funzioni logiche chiave. Procediamo con la costruzione di un'interfaccia interattiva con 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)

Questo codice crea un'interfaccia Gradio interattiva per l'analisi AI delle vendite SaaS, in cui l'utente può selezionare un settore e un prodotto dai menu a tendina e fare clic su un pulsante per generare un riepilogo delle vendite. Gli input selezionati vengono passati alla funzione summarize_sales(), che elabora i dati e restituisce insight visualizzati in una casella di testo. L'app Gradio viene quindi avviata per l'interazione in tempo reale.

Ecco gli output di un rapido test che ho eseguito. Ho scelto tutti i settori e prodotti, poi ho chiesto al modello di produrre un riepilogo delle vendite e di fare l'analisi del sentiment sui parametri scelti.

Conclusione

In questo tutorial, abbiamo creato uno strumento AI per insight sulle vendite SaaS usando Gemini 2.0 Flash, abilitando l'analisi in tempo reale dei dati di vendita SaaS. Abbiamo sfruttato l'ampia finestra di contesto di Gemini 2.0 Flash per elaborare dati strutturati senza RAG e integrato un'interfaccia interattiva basata su Gradio per un'interazione semplice.

Ti invito ad adattare questo tutorial al tuo caso d'uso. Per saperne di più sulla creazione di app con Gemini 2.0, ti consiglio questi tutorial:

• Creare applicazioni AI multimodali con Gemini 2.0 Pro
• Gemini 2.0 Flash: tutorial passo passo con progetto demo