Gemini 2.0 Flash: RAG के बिना बड़े दस्तावेज़ कैसे प्रोसेस करें

RAG की बजाय Gemini  2.0 Flash क्यों उपयोग करें?

Gemini 2.0 Flash की कॉन्टेक्स्ट विंडो 1,000,000 टोकन की है, जो बिना चंकिंग या रिट्रीवल मैकेनिज्म के पूरे डेटासेट को प्रोसेस करने की अनुमति देती है। साथ ही, यह Gemini Ultra जैसे बड़े मॉडलों की तुलना में किफायती है।

कई एप्लिकेशन retrieval-augmented generation (RAG) का उपयोग स्ट्रक्चर्ड डेटा विश्लेषण के लिए करते हैं, लेकिन Gemini 2.0 Flash RAG की आवश्यकता समाप्त कर देता है क्योंकि:

• इसकी बड़ी टोकन सीमा एक ही रिक्वेस्ट में पूरे डेटासेट को प्रोसेस करने देती है।
• यह सीधे स्ट्रक्चर्ड डेटा विश्लेषण की अनुमति देता है, जिससे रिट्रीवल की जटिलता समाप्त हो जाती है।
• यह RAG-आधारित तरीकों की तुलना में तेज़ और अधिक किफायती प्रोसेसिंग प्रदान करता है।

यदि आप लागत अनुकूलन के लिए Gemini 2.0 Flash Lite का उपयोग करना चाहते हैं, तो आप कर सकते हैं, लेकिन इस लेख के प्रकाशित होने के समय यह 60 क्वेरी प्रति मिनट तक रेट-लिमिटेड है और केवल us-central1 क्षेत्र में उपलब्ध है।

ओवरव्यू: Gemini 2.0 Flash के साथ SaaS सेल्स इनसाइट्स टूल

आइए मुख्य चरणों की रूपरेखा देखें जिन्हें हम अपनाएंगे:

• प्रक्रिया Kaggle से AWS SaaS Sales डेटासेट को लोड और तैयार करने से शुरू होती है।
• फिर हम AI प्रोसेसिंग के लिए Google Cloud Vertex AI और Gemini 2.0 Flash को इनिशियलाइज़ करेंगे।
• इसके बाद, हम उपयोगकर्ता चयन के लिए अद्वितीय उद्योग और उत्पाद निकालेंगे।
• टोकन सीमा के भीतर डेटासेट के आकार को प्रबंधित करने के लिए हम Tiktoken का उपयोग करेंगे।
• उपयोगकर्ता द्वारा चुने गए फ़िल्टर प्रमुख सेल्स मेट्रिक्स की गणना और AI-आधारित इनसाइट्स को ट्रिगर करेंगे।
• सेंटिमेंट विश्लेषण प्रदर्शन को वर्गीकृत करेगा, और Q&A फ़ीचर बिक्री से संबंधित इनसाइट्स प्रदान करेगा।
• अंत में, हम टूल को Gradio में इंटीग्रेट करेंगे ताकि डायनेमिक उपयोगकर्ता इंटरैक्शन और रियल-टाइम एक्सप्लोरेशन संभव हो।

चरण 1: पूर्वापेक्षाएँ

शुरू करने से पहले, सुनिश्चित करें कि निम्नलिखित टूल और लाइब्रेरी इंस्टॉल हैं:

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

आवश्यक डिपेंडेंसी इंस्टॉल करने के लिए निम्न कमांड चलाएँ:

!pip install gradio -q
!pip install --upgrade --quiet google-genai
!pip install datasets -q
!pip install tiktoken -q
!pip install kaggle -qसंचालित द्वारा

ऊपर दी गई डिपेंडेंसियाँ इंस्टॉल होने के बाद, निम्न इम्पोर्ट कमांड चलाएँ:

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संचालित द्वारा

चरण 2: डेटासेट लोड करें

हम इस प्रोजेक्ट के लिए AWS SAAS Sales डेटासेट का उपयोग करेंगे, जो Kaggle पर उपलब्ध है। Kaggle क्रेडेंशियल सेटअप से शुरू करें और क्रमशः ऑथर और डेटासेट का नाम पास करें।

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

# Download dataset
!kaggle datasets download -d nnthanh101/aws-saas-sales --unzipसंचालित द्वारा

अब जबकि डेटासेट हमारे वातावरण में डाउनलोड हो चुका है, हम इस पर काम शुरू कर सकते हैं। हम पांडा लाइब्रेरी का उपयोग करके पाथ से डेटासेट लोड और रीड करेंगे।

dataset_path = "path_to_your_data.csv"  # Load dataset from specified path
dataset_df = pd.read_csv(dataset_path)  संचालित द्वारा

इस डेटासेट में 9,994 ट्रांज़ैक्शन हैं, जिनमें निम्न कॉलम शामिल हैं:

• Industry: कंपनी का उद्योग श्रेणी।
• Product: बेचा गया SaaS उत्पाद।
• Sales: ट्रांज़ैक्शन से प्राप्त राजस्व।
• Quantity: बेचे गए लाइसेंसों की संख्या।
• Profit: ट्रांज़ैक्शन से प्राप्त लाभ।
• Discount: लागू किया गया कोई भी डिस्काउंट।

चरण 3: Google Cloud Vertex AI सेटअप करना

Gemini 2.0 Flash का उपयोग करने के लिए, हमें Google Cloud के साथ ऑथेंटिकेट करना होगा।

if "google.colab" in sys.modules:
    from google.colab import auth
    auth.authenticate_user()संचालित द्वारा

Vertex AI को इनिशियलाइज़ करने के लिए, Vertex AI API खोजें और उसे सक्षम करें (सुनिश्चित करें कि आपके अकाउंट पर बिलिंग सक्षम है)।

प्रोजेक्ट का ID और लोकेशन आगे के लिए सहेज कर रखें। इस प्रोजेक्ट के लिए Gemini 2.0 Flash चलाने में लगभग पाँच API कॉल के लिए करीब $0.07 का खर्च आया।

# 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")संचालित द्वारा

Vertex AI के बारे में अधिक जानने के लिए, Vertex AI पर यह परिचयात्मक ट्यूटोरियल देखें।

चरण 4: डेटा प्री-प्रोसेसिंग

उचित डेटा हैंडलिंग सुनिश्चित करने के लिए, कॉलम नामों को सामान्यीकृत करें और प्रमुख श्रेणियाँ निकालें। हम डेमो में अपने मार्कडाउन के लिए स्रोत के रूप में काम करने वाले अद्वितीय उद्योगों और उत्पादों को पाते हैं। यदि आप कोई अलग डेटासेट उपयोग कर रहे हैं, तो अपनी श्रेणियाँ उसी के अनुसार चुनें।

# 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संचालित द्वारा

चरण 5: डेटासेट में टोकन गिनना

अब जब हमने अपना डेटासेट प्रोसेस कर लिया है, तो हम टोकन गिनेंगे। चूँकि Gemini 2.0 Flash में 1,000,000 टोकन की सीमा है, इसलिए मॉडल को पास करने से पहले डेटासेट में टोकन की संख्या की गणना करना महत्वपूर्ण है। इस डेटासेट में  805447 टोकन हैं।

# 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}")संचालित द्वारा

हम टोकनाइज़ेशन के लिए Tiktoken का उपयोग इस प्रकार करते हैं:

• Tokenizer इनिशियलाइज़ करें: Gemini और GPT मॉडलों के लिए अनुकूलित Tiktoken के cl100k_base टोकनाइज़र का उपयोग करें।
• प्रासंगिक टेक्स्ट कॉलम चुनें: AI विश्लेषण के लिए मुख्य कॉलम (industry, product, sales, quantity, discount, profit) की पहचान करें।
• चुने गए कॉलम को एकल टेक्स्ट फ़ील्ड में संयोजित करें: टाइप मिसमैच से बचने के लिए कॉलम को स्ट्रिंग में बदलें और उन्हें " | " सेपरेटर के साथ combined_text में मर्ज करें।
• टोकन गिनने के लिए फ़ंक्शन परिभाषित करें: combined_text की प्रत्येक पंक्ति को टोकनाइज़ करें और सभी पंक्तियों में कुल टोकन की गणना करें।
• डेटासेट में कुल टोकन की गणना करें: NaN मान हटाएँ, टोकन गिनने वाले फ़ंक्शन को लागू करें, और Gemini 2.0 Flash की 1M टोकन सीमा के अनुपालन की पुष्टि के लिए कुल टोकन प्रिंट करें।

चरण 6: बिक्री रुझानों का सारांश

अब हम डेमो के विश्लेषक हिस्सों पर काम कर सकते हैं। यह फ़ंक्शन चुने गए उद्योग और उत्पाद के आधार पर सेल्स सारांश बनाता है। 

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संचालित द्वारा

summarize_sales() फ़ंक्शन चुने गए उद्योग और उत्पाद के आधार पर डेटासेट को फ़िल्टर करता है, कुल बिक्री, बेची गई मात्रा, लाभ और औसत डिस्काउंट जैसे प्रमुख सेल्स मेट्रिक्स की गणना करता है, और डेटा को एक संरचित प्रॉम्प्ट में फॉर्मेट करता है। यह प्रॉम्प्ट फिर Gemini 2.0 Flash मॉडल को पास किया जाता है ताकि संक्षिप्त सेल्स सारांश जेनरेट किया जा सके।

चरण 7: बिक्री सेंटिमेंट विश्लेषण करें

इसी तरह, हम एक और फ़ंक्शन परिभाषित करते हैं जो कुल लाभ के आधार पर सेंटिमेंट विश्लेषण करता है। 

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संचालित द्वारा

analyze_sales_sentiment() फ़ंक्शन चुने गए उद्योग और उत्पाद के आधार पर डेटासेट को फ़िल्टर करके कुल बिक्री और कुल लाभ की गणना करता है और Gemini 2.0 Flash का उपयोग करके AI-संचालित सेंटिमेंट विश्लेषण जेनरेट करता है। मॉडल को फिर बिक्री प्रदर्शन के एक संरचित सारांश से प्रॉम्प्ट किया जाता है, जिससे यह केवल फिक्स्ड लाभ थ्रेसहोल्ड पर निर्भर होने के बजाय गतिशील रूप से सेंटिमेंट का मूल्यांकन कर सके।

चरण 8: Gradio इंटरफ़ेस बनाएं

अब हमारे पास सभी प्रमुख लॉजिक फ़ंक्शन मौजूद हैं। अगला कदम Gradio के साथ इंटरैक्टिव UI बनाना है।

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)संचालित द्वारा

यह कोड AI-संचालित SaaS सेल्स विश्लेषण के लिए एक इंटरैक्टिव Gradio UI बनाता है, जहाँ उपयोगकर्ता ड्रॉपडाउन मेनू से किसी उद्योग और उत्पाद का चयन कर सकते हैं और एक बटन पर क्लिक कर सेल्स सारांश जेनरेट कर सकते हैं। चुने गए इनपुट्स summarize_sales() फ़ंक्शन को पास किए जाते हैं, जो डेटा को प्रोसेस करके इनसाइट्स लौटाता है, जिन्हें टेक्स्ट बॉक्स में प्रदर्शित किया जाता है। इसके बाद Gradio ऐप रियल-टाइम इंटरैक्शन के लिए लॉन्च किया जाता है।

यहाँ एक त्वरित परीक्षण के आउटपुट हैं जो मैंने चलाया। मैंने सभी उद्योग और उत्पाद चुने, फिर मॉडल से सेल्स सारांश बनाने और चुने गए पैरामीटर्स पर सेंटिमेंट विश्लेषण करने के लिए कहा।

निष्कर्ष

इस ट्यूटोरियल में, हमने Gemini 2.0 Flash का उपयोग करके एक AI-संचालित SaaS सेल्स इनसाइट्स टूल बनाया, जो SaaS बिक्री डेटा का रियल-टाइम विश्लेषण सक्षम करता है। हमने Gemini 2.0 Flash की बड़ी कॉन्टेक्स्ट विंडो का उपयोग करके स्ट्रक्चर्ड डेटा को बिना RAG के प्रोसेस किया और आसान उपयोगकर्ता इंटरैक्शन के लिए Gradio-आधारित इंटरैक्टिव इंटरफ़ेस इंटीग्रेट किया।

मैं आपको इस ट्यूटोरियल को अपने उपयोग के मामले के अनुसार अनुकूलित करने के लिए प्रोत्साहित करता/करती हूँ। Gemini 2.0 के साथ ऐप्स बनाने के बारे में अधिक जानने के लिए, मैं ये ट्यूटोरियल सुझाता/सुझाती हूँ:

• Gemini 2.0 Pro के साथ मल्टीमॉडल AI एप्लिकेशन बनाना
• Gemini 2.0 Flash: डेमो प्रोजेक्ट के साथ स्टेप-बाय-स्टेप ट्यूटोरियल