fine tuning changes

app.py

@@ -1,23 +1,33 @@
 import streamlit as st
 import pandas as pd
 from db import insert_data_if_empty, get_mongo_client
-from chatbot import chatbot_response  # Import chatbot functionality
+from chatbot import chatbot_response  # Updated chatbot functionality using the fine-tuned model
 
-# 1. Ensure the sentiment140 dataset is inserted into MongoDB
+# 1. Ensure historical data is loaded into MongoDB
 insert_data_if_empty()
 
-# 2. MongoDB Connection
+# 2. Connect to MongoDB collection (for potential historical data display)
 collection = get_mongo_client()
 
-st.subheader("💬 Chatbot with Sentiment & Topic Analysis")
-
-# User input for chatbot
+# Optional: Display historical data from the dataset (uncomment if needed)
+# st.title("📊 Historical Data and Chatbot Analysis")
+# st.subheader("Historical Data from MongoDB")
+# data = list(collection.find({}, {"_id": 0}).limit(5))
+# if data:
+#     st.write(pd.DataFrame(data))
+# else:
+#     st.warning("No data found in MongoDB. Please try refreshing.")
+#
+# if st.button("Show Complete Data"):
+#     all_data = list(collection.find({}, {"_id": 0}))
+#     st.write(pd.DataFrame(all_data))
+
+# 3. Chatbot interface
+st.subheader("💬 Chatbot with Fine-Tuned Sentiment & Topic Analysis")
 user_prompt = st.text_area("Ask me something:")
 
 if st.button("Get AI Response"):
-    # Generate real-time AI response, sentiment, and topic extraction
     ai_response, sentiment_label, sentiment_confidence, topic_label, topic_confidence = chatbot_response(user_prompt)
-
     if ai_response:
         st.write("### AI Response:")
         st.write(ai_response)
@@ -25,25 +35,7 @@ if st.button("Get AI Response"):
         st.write("### Sentiment Analysis:")
         st.write(f"**Sentiment:** {sentiment_label} ({sentiment_confidence:.2f} confidence)")
 
-        st.write("### Category Extraction:")
+        st.write("### Topic Extraction:")
         st.write(f"**Detected Category:** {topic_label} ({topic_confidence:.2f} confidence)")
-
-        # 3. Historical Insight: Compare with historical data from sentiment140.csv
-        historical_data = list(collection.find({}, {"_id": 0}))
-        if historical_data:
-            df = pd.DataFrame(historical_data)
-            # Assume the CSV has a 'sentiment' column with numeric labels: 
-            # 0: Negative, 2: Neutral, 4: Positive.
-            if 'sentiment' in df.columns:
-                sentiment_map = {0: "Negative", 2: "Neutral", 4: "Positive"}
-                # Ensure the sentiment column is numeric and map it to readable labels
-                df['sentiment_label'] = df['sentiment'].astype(int).map(sentiment_map)
-                matching_count = df[df['sentiment_label'] == sentiment_label].shape[0]
-                st.write("### Historical Insights:")
-                st.info(f"There are {matching_count} tweets in our dataset with a {sentiment_label} sentiment.")
-            else:
-                st.warning("Historical data does not contain a sentiment field.")
-        else:
-            st.warning("No historical data available.")
     else:
-        st.warning("⚠️ Please enter a question or text for analysis.")
+        st.warning("Please enter some text for analysis.")

chatbot.py

@@ -1,28 +1,94 @@
 import os
 import streamlit as st
 import google.generativeai as genai
-from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
-
-# Disable HF transfer mechanism to avoid rate limiting errors
-os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0"
+from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments
+from datasets import load_dataset
 
 # 🔑 Fetch API key from Hugging Face Secrets
 GEMINI_API_KEY = os.getenv("gemini_api")
-
 if GEMINI_API_KEY:
     genai.configure(api_key=GEMINI_API_KEY)
 else:
     st.error("⚠️ Google API key is missing! Set it in Hugging Face Secrets.")
 
-# Model for Sentiment Analysis
-MODEL_NAME = "cardiffnlp/twitter-roberta-base-sentiment"
+# Define path for the fine-tuned model
+FINE_TUNED_MODEL_DIR = "fine-tuned-sentiment-model"
+
+# Function to fine-tune sentiment analysis model using sentiment140.csv
+def fine_tune_model():
+    st.info("Fine-tuning sentiment model. This may take a while...")
+
+    # Load the dataset from the local CSV file.
+    # Ensure that 'sentiment140.csv' is in your working directory.
+    try:
+        dataset = load_dataset('csv', data_files={'train': 'sentiment140.csv'}, encoding='ISO-8859-1')
+    except Exception as e:
+        st.error(f"❌ Error loading dataset: {e}")
+        return None, None
+
+    # Convert sentiment labels: sentiment140 labels are 0 (Negative), 2 (Neutral), 4 (Positive).
+    # We map them to 0,1,2 respectively.
+    def convert_labels(example):
+        mapping = {0: 0, 2: 1, 4: 2}
+        example["label"] = mapping[int(example["target"])]
+        return example
+
+    dataset = dataset.map(convert_labels)
+
+    # Base model name
+    base_model_name = "cardiffnlp/twitter-roberta-base-sentiment"
+
+    # Initialize tokenizer and model
+    tokenizer = AutoTokenizer.from_pretrained(base_model_name)
+    model = AutoModelForSequenceClassification.from_pretrained(base_model_name, num_labels=3)
+
+    # Tokenize the dataset; assuming the CSV has a column named "text"
+    def tokenize_function(examples):
+        return tokenizer(examples["text"], padding="max_length", truncation=True, max_length=128)
+    tokenized_dataset = dataset.map(tokenize_function, batched=True)
+
+    # Set training arguments (for demo purposes, we use 1 epoch; adjust as needed)
+    training_args = TrainingArguments(
+        output_dir="./results",
+        num_train_epochs=1,
+        per_device_train_batch_size=8,
+        logging_steps=10,
+        save_steps=50,
+        evaluation_strategy="no",
+        learning_rate=2e-5,
+        weight_decay=0.01,
+        logging_dir='./logs',
+        disable_tqdm=False
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_dataset["train"]
+    )
+
+    trainer.train()
+
+    # Save the fine-tuned model and tokenizer
+    model.save_pretrained(FINE_TUNED_MODEL_DIR)
+    tokenizer.save_pretrained(FINE_TUNED_MODEL_DIR)
+    st.success("✅ Fine-tuning complete and model saved.")
+    return model, tokenizer
+
+# Load (or fine-tune) the sentiment analysis model and tokenizer
+if not os.path.exists(FINE_TUNED_MODEL_DIR):
+    model, tokenizer = fine_tune_model()
+    if model is None or tokenizer is None:
+        st.error("❌ Failed to fine-tune the sentiment analysis model.")
+else:
+    tokenizer = AutoTokenizer.from_pretrained(FINE_TUNED_MODEL_DIR)
+    model = AutoModelForSequenceClassification.from_pretrained(FINE_TUNED_MODEL_DIR)
 
-# Load Sentiment Analysis Model
+# Initialize sentiment analysis pipeline using the fine-tuned model
 try:
-    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-    sentiment_pipeline = pipeline("sentiment-analysis", model=MODEL_NAME, tokenizer=tokenizer)
+    sentiment_pipeline = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
 except Exception as e:
-    st.error(f"❌ Error loading sentiment model: {e}")
+    st.error(f"❌ Error loading sentiment pipeline: {e}")
 
 # Load Topic Extraction Model
 try:
@@ -40,10 +106,10 @@ TOPIC_LABELS = [
 def analyze_sentiment(text):
     try:
         sentiment_result = sentiment_pipeline(text)[0]
-        label = sentiment_result['label']  # Extract sentiment label (POSITIVE, NEGATIVE, NEUTRAL)
-        score = sentiment_result['score']  # Extract confidence score
+        label = sentiment_result['label']  # e.g., "LABEL_0", "LABEL_1", "LABEL_2"
+        score = sentiment_result['score']  # Confidence score
 
-        # Convert labels to readable format
+        # Map model labels to human-readable format
         sentiment_mapping = {
             "LABEL_0": "Negative",
             "LABEL_1": "Neutral",
@@ -57,8 +123,8 @@ def analyze_sentiment(text):
 def extract_topic(text):
     try:
         topic_result = topic_pipeline(text, TOPIC_LABELS)
-        top_topic = topic_result["labels"][0]  # Get the highest confidence topic
-        confidence = topic_result["scores"][0]  # Confidence score for the topic
+        top_topic = topic_result["labels"][0]  # Highest confidence topic
+        confidence = topic_result["scores"][0]
         return top_topic, confidence
     except Exception as e:
         return f"Error extracting topic: {e}", None
@@ -69,14 +135,14 @@ def chatbot_response(user_prompt):
         return None, None, None, None, None
 
     try:
-        # AI Response from Gemini
-        model = genai.GenerativeModel("gemini-1.5-pro")
-        ai_response = model.generate_content(user_prompt)
+        # Generate AI Response using Gemini
+        model_gen = genai.GenerativeModel("gemini-1.5-pro")
+        ai_response = model_gen.generate_content(user_prompt)
 
-        # Sentiment Analysis
+        # Run Sentiment Analysis
         sentiment_label, sentiment_confidence = analyze_sentiment(user_prompt)
 
-        # Topic Extraction
+        # Run Topic Extraction
         topic_label, topic_confidence = extract_topic(user_prompt)
 
         return ai_response.text, sentiment_label, sentiment_confidence, topic_label, topic_confidence

db.py

@@ -3,27 +3,26 @@ import requests
 import io
 from pymongo import MongoClient
 
-# 1. MongoDB Connection
+# Function to establish MongoDB connection and return the collection
 def get_mongo_client():
     client = MongoClient("mongodb+srv://groupA:[email protected]/?retryWrites=true&w=majority&appName=SentimentCluster")
     db = client["sentiment_db"]
     return db["tweets"]
 
-# 2. Insert Data If Collection is Empty
+# Function to insert the dataset into MongoDB if the collection is empty
 def insert_data_if_empty():
     collection = get_mongo_client()
 
     if collection.count_documents({}) == 0:
-        print("🟢 No data found. Inserting dataset...")
-
+        print("🟢 No data found in MongoDB. Inserting dataset...")
         csv_url = "https://huggingface.co/spaces/sharangrav24/SentimentAnalysis/resolve/main/sentiment140.csv"
 
         try:
             response = requests.get(csv_url)
-            response.raise_for_status()  # Ensure request was successful
+            response.raise_for_status()  # Ensure the request was successful
             df = pd.read_csv(io.StringIO(response.text), encoding="ISO-8859-1")
 
-            # Insert into MongoDB
+            # Insert dataset records into MongoDB
             collection.insert_many(df.to_dict("records"))
             print("✅ Data Inserted into MongoDB!")
         except Exception as e: