Gemini 2.0 Flash: Cara Memproses Dokumen Besar Tanpa RAG

Mengapa Menggunakan Gemini 2.0 Flash Alih-alih RAG?

Gemini 2.0 Flash memiliki jendela konteks 1.000.000 token, yang memungkinkan pemrosesan seluruh dataset tanpa perlu chunking atau mekanisme retrieval. Selain itu, biayanya efisien dibandingkan model yang lebih besar seperti Gemini Ultra.

Banyak aplikasi menggunakan retrieval-augmented generation (RAG) untuk analisis data terstruktur, tetapi Gemini 2.0 Flash menghilangkan kebutuhan akan RAG karena:

• Batas token yang besar memungkinkan pemrosesan seluruh dataset dalam satu permintaan.
• Memungkinkan analisis data terstruktur secara langsung, menghilangkan kompleksitas retrieval.
• Memberikan pemrosesan yang lebih cepat dan lebih hemat biaya dibandingkan pendekatan berbasis RAG.

Jika Anda ingin menggunakan Gemini 2.0 Flash Lite untuk mengoptimalkan biaya, Anda bisa melakukannya, tetapi harap diketahui bahwa pada saat artikel ini diterbitkan, versi tersebut dibatasi hingga 60 kueri per menit dan hanya tersedia di region us-central1.

Gambaran Umum: Alat Wawasan Penjualan SaaS dengan Gemini 2.0 Flash

Mari kita garis bawahi langkah utama yang akan kita lakukan:

• Proses dimulai dengan memuat dan menyiapkan dataset AWS SaaS Sales dari Kaggle.
• Kemudian kita akan menginisialisasi Google Cloud Vertex AI dan Gemini 2.0 Flash untuk pemrosesan AI.
• Selanjutnya, kita akan mengekstrak industri dan produk unik untuk pilihan pengguna.
• Kita akan menggunakan Tiktoken untuk mengelola ukuran dataset dalam batas token.
• Filter yang dipilih pengguna akan memicu perhitungan metrik penjualan utama dan wawasan berbasis AI.
• Analisis sentimen akan mengklasifikasikan kinerja, dan fitur Tanya Jawab akan memberikan wawasan terkait penjualan.
• Terakhir, kita akan mengintegrasikan alat ini ke Gradio untuk interaksi pengguna yang dinamis dan eksplorasi waktu nyata.

Langkah 1: Prasyarat

Sebelum mulai, pastikan kita telah memasang alat dan pustaka berikut:

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

Jalankan perintah berikut untuk memasang dependensi yang diperlukan:

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

Setelah dependensi di atas terpasang, jalankan perintah impor berikut:

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

Langkah 2: Muat Dataset

Kita akan menggunakan dataset AWS SAAS Sales untuk proyek ini, yang tersedia di Kaggle. Mulailah dengan menyiapkan kredensial Kaggle dan meneruskan nama penulis dan dataset masing-masing.

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

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

Sekarang dataset telah diunduh ke lingkungan kita, kita dapat mulai mengolahnya. Kita akan menggunakan pustaka pandas untuk memuat dan membaca dataset dari path.

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

Dataset ini berisi 9.994 transaksi dengan kolom seperti:

• Industry: Kategori industri perusahaan.
• Product: Produk SaaS yang dijual.
• Sales: Pendapatan dari transaksi.
• Quantity: Jumlah lisensi yang terjual.
• Profit: Laba dari transaksi.
• Discount: Diskon yang diterapkan.

Langkah 3: Menyiapkan Google Cloud Vertex AI

Untuk menggunakan Gemini 2.0 Flash, kita perlu melakukan autentikasi dengan Google Cloud.

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

Untuk menginisialisasi Vertex AI, cari Vertex AI API dan aktifkan (pastikan penagihan di akun Anda sudah aktif).

Simpan ID proyek dan lokasinya untuk referensi mendatang. Menjalankan Gemini 2.0 Flash untuk proyek ini menelan biaya sekitar $0,07 untuk kurang lebih lima panggilan 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")

Untuk mempelajari lebih lanjut tentang Vertex AI, lihat tutorial pengantar ini tentang Vertex AI.

Langkah 4: Prapemrosesan Data

Untuk memastikan penanganan data yang tepat, normalisasi nama kolom dan ekstrak kategori kunci. Kita mencari industri dan produk unik yang menjadi sumber untuk markdown dalam demo. Jika Anda menggunakan dataset berbeda, pilih kategori Anda sesuai kebutuhan.

# 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

Langkah 5: Menghitung Token dalam Dataset

Sekarang setelah kita memproses dataset, kita akan menghitung token. Karena Gemini 2.0 Flash memiliki batas 1.000.000 token, penting untuk menghitung jumlah token dalam dataset sebelum meneruskannya ke model. Dataset ini memiliki  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}")

Kita menggunakan Tiktoken untuk tokenisasi sebagai berikut:

• Inisialisasi Tokenizer: Gunakan tokenizer cl100k_base milik Tiktoken, yang dioptimalkan untuk model Gemini dan GPT.
• Pilih kolom teks yang relevan: Identifikasi kolom kunci (industry, product, sales, quantity, discount, profit) untuk analisis AI.
• Gabungkan kolom terpilih menjadi satu field teks: Konversi kolom menjadi string untuk menghindari ketidaksesuaian tipe dan gabungkan menjadi combined_text menggunakan pemisah " | ".
• Definisikan fungsi untuk menghitung token: Tokenisasi setiap baris di combined_text dan hitung total jumlah token di seluruh baris.
• Hitung total token dalam dataset: Hapus nilai NaN, terapkan fungsi penghitung token, dan cetak total token untuk memastikan sesuai dengan batas 1 juta token Gemini 2.0 Flash.

Langkah 6: Merangkum Tren Penjualan

Sekarang, kita dapat mengerjakan bagian analis dalam demo. Fungsi ini menghasilkan ringkasan penjualan berdasarkan industri dan produk yang dipilih. 

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

Fungsi summarize_sales() memfilter dataset berdasarkan industri dan produk yang dipilih, menghitung metrik penjualan utama seperti total penjualan, jumlah terjual, laba, dan diskon rata-rata, serta memformat data menjadi prompt terstruktur. Prompt ini kemudian diteruskan ke model Gemini 2.0 Flash untuk menghasilkan ringkasan penjualan yang ringkas.

Langkah 7: Melakukan Analisis Sentimen Penjualan

Dengan cara serupa, kita mendefinisikan fungsi lain yang melakukan analisis sentimen berdasarkan total laba. 

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

Fungsi analyze_sales_sentiment() menganalisis sentimen penjualan dengan memfilter dataset berdasarkan industri dan produk yang dipilih, menghitung total penjualan dan total laba, serta menghasilkan analisis sentimen berbasis AI menggunakan Gemini 2.0 Flash. Model kemudian diprompt dengan ringkasan terstruktur dari kinerja penjualan, memungkinkannya mengevaluasi sentimen secara dinamis alih-alih hanya mengandalkan ambang laba tetap.

Langkah 8: Bangun Antarmuka Gradio

Sekarang, semua fungsi logika utama sudah siap. Selanjutnya, kita membangun UI interaktif dengan 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)

Kode ini membuat UI Gradio interaktif untuk analisis penjualan SaaS bertenaga AI, di mana pengguna dapat memilih industri dan produk dari menu tarik-turun lalu mengeklik tombol untuk menghasilkan ringkasan penjualan. Input terpilih diteruskan ke fungsi summarize_sales(), yang memproses data dan mengembalikan wawasan, ditampilkan dalam kotak teks. Aplikasi Gradio kemudian diluncurkan untuk interaksi waktu nyata.

Berikut keluaran dari uji cepat yang saya jalankan. Saya memilih semua industri dan produk, lalu meminta model membuat ringkasan penjualan dan melakukan analisis sentimen pada parameter yang dipilih.

Kesimpulan

Dalam tutorial ini, kita membangun alat wawasan penjualan SaaS bertenaga AI menggunakan Gemini 2.0 Flash, yang memungkinkan analisis data penjualan SaaS secara waktu nyata. Kita memanfaatkan jendela konteks besar Gemini 2.0 Flash untuk memproses data terstruktur tanpa RAG dan mengintegrasikan antarmuka interaktif berbasis Gradio untuk memudahkan interaksi pengguna.

Saya mendorong Anda untuk menyesuaikan tutorial ini dengan use case Anda sendiri. Untuk mempelajari lebih lanjut tentang membangun aplikasi dengan Gemini 2.0, saya merekomendasikan tutorial berikut:

• Membangun Aplikasi AI Multimodal dengan Gemini 2.0 Pro
• Gemini 2.0 Flash: Tutorial Langkah-demi-Langkah dengan Proyek Demo