mona's implementation

app.py

@@ -1,124 +1,143 @@
+#imorting libraries and utulities
+import psutil
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForCausalLM
+import pandas as pd
 import torch
 import gradio as gr
-import pandas as pd
-from datetime import datetime
-
-# Replace with your own pixabay API key
-# Intentionally hidden when deployed on HuggingFace Space
-API_Key = "censored-for-security-reason"
+from joblib import Parallel, delayed
+import matplotlib.pyplot as plt
+import seaborn as sns
+import random
 
-# Load emotion model and tokenizer
+# Load emotion detection
 emotion_tokenizer = AutoTokenizer.from_pretrained("mrm8488/t5-base-finetuned-emotion")
 emotion_model = AutoModelForSeq2SeqLM.from_pretrained("mrm8488/t5-base-finetuned-emotion")
 
-# Load text generation model and tokenizer
-import os
-token=os.getenv('hftoken')
-text_tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-2b-it", token=token)
-text_model = AutoModelForCausalLM.from_pretrained("google/gemma-2-2b-it", token=token)
+#Load quote generation models
+text_tokenizer = AutoTokenizer.from_pretrained("gpt2")
+text_model = AutoModelForCausalLM.from_pretrained("gpt2")
 
-# Set device to CUDA
 device = torch.device('cpu')
 emotion_model.to(device)
 text_model.to(device)
 
-# Initialize CSV file
-csv_file = 'diary_entries.csv'
-try:
-    # Try to load the existing file
-    df = pd.read_csv(csv_file)
-except FileNotFoundError:
-    # If it doesn't exist, create an empty DataFrame
-    df = pd.DataFrame(columns=["Date", "Diary Text", "Emotion", "Quote 1", "Quote 2"])
+# Hardcoded fallback quotes for each emotion
+fallback_quotes = {
+    "sadness": ["Keep going, tough times don't last.", "This too shall pass."],
+    "joy": ["Happiness is here to stay.", "Enjoy this moment."],
+    "love": ["Love is a beautiful journey.", "Cherish every moment of love."],
+    "anger": ["Take a deep breath, you'll get through this.", "Channel your anger into something positive."],
+    "fear": ["Courage is not the absence of fear.", "Face your fears, and they will disappear."],
+    "surprise": ["Embrace the unexpected.", "Life is full of pleasant surprises."]
+}
 
-
-# Function to predict emotion
+# Function to detect emotion from the user's input text
 def get_emotion(text):
     input_ids = emotion_tokenizer.encode(text + '</s>', return_tensors='pt').to(device)
     output = emotion_model.generate(input_ids=input_ids, max_length=2)
-    dec = [emotion_tokenizer.decode(ids, skip_special_tokens=True) for ids in output]
-    label = dec[0].strip()
-    return label
-
-
-# Function to generate two distinct inspirational quotes based on emotion and original text
-def generate_quotes(original_text, emotion):
-    # First quote generation
-    input_text_1 = f"Text: {original_text}\nEmotion: {emotion}\nInspirational Quote 1:"
-    input_ids_1 = text_tokenizer(input_text_1, return_tensors="pt").to(device)
-    outputs_1 = text_model.generate(**input_ids_1, max_new_tokens=70, do_sample=True, temperature=0.7)
-    generated_text_1 = text_tokenizer.decode(outputs_1[0], skip_special_tokens=True)
-    
-    if "Inspirational Quote 1:" in generated_text_1:
-        quote1 = generated_text_1.split("Inspirational Quote 1:")[1].strip().split("\n")[0]
-    else:
-        quote1 = generated_text_1.strip()
-    
-    # Second quote generation
-    input_text_2 = f"Text: {original_text}\nEmotion: {emotion}\nInspirational Quote 2:"
-    input_ids_2 = text_tokenizer(input_text_2, return_tensors="pt").to(device)
-    outputs_2 = text_model.generate(**input_ids_2, max_new_tokens=70, do_sample=True, temperature=0.7)
-    generated_text_2 = text_tokenizer.decode(outputs_2[0], skip_special_tokens=True)
-    
-    if "Inspirational Quote 2:" in generated_text_2:
-        quote2 = generated_text_2.split("Inspirational Quote 2:")[1].strip().split("\n")[0]
+    emotion = emotion_tokenizer.decode(output[0], skip_special_tokens=True).strip()
+    return emotion
+
+
+# Function to generate a motivational quote based on the detected emotion
+def generate_quote(original_text, emotion):
+    input_text = f"Generate an inspiring quote based on the following emotion:\nEmotion: {emotion}\nText: {original_text}\nQuote:"
+    input_ids = text_tokenizer(input_text, return_tensors="pt").to(device)
+
+    try:
+        outputs = text_model.generate(
+            **input_ids,
+            max_length=100,
+            do_sample=True,
+            top_k=50,  # Randomness control
+            top_p=0.95,  # Probability control for better diversity
+            temperature=0.7
+        )
+        generated_text = text_tokenizer.decode(outputs[0], skip_special_tokens=True)
+        if "Quote:" in generated_text:
+            quote = generated_text.split("Quote:")[1].strip().split("\n")[0]
+        else:
+            quote = generated_text.strip()
+        return quote
+    except:
+        return random.choice(fallback_quotes.get(emotion, ["Stay positive.", "Keep pushing forward."]))
+
+
+#For file input
+def load_and_process_data(file_path):
+    df = pd.read_csv(file_path)
+    if 'Answer' in df.columns:
+        df = df[['Answer']]
+        df['Emotion'] = df['Answer'].apply(get_emotion)
     else:
-        quote2 = generated_text_2.strip()
-    
-    return quote1, quote2
-
-# Function to map emotions to weather search terms
-def map_emotion_to_weather(emotion):
-    mapping = {
-        "anger": "fire",
-        "joy": "sunshine",
-        "sadness": "lonely",
-        "love": "rose",
-        "fear": "ghost",
-        "surprise":"gift",
-    }
-    return mapping.get(emotion, "nature")  # Default to "nature" if not found
-
-# Function to handle emotion detection, quotes generation, and image display
+        raise ValueError("The expected column 'Answer' is not present in the dataset.")
+    return df
+
+# Function to generate synthetic journal data for testing
+def generate_synthetic_data(num_entries=100):
+    emotions = ["sadness", "joy", "love", "anger", "fear", "surprise"]
+    entries = []
+    for _ in range(num_entries):
+        emotion = random.choice(emotions)
+        text = f"This is a synthetic entry expressing {emotion}."
+        entries.append({"Answer": text, "Emotion": emotion})
+    return pd.DataFrame(entries)
+
+# Function to process data in chunks (for parallel processing)
+def process_chunk(chunk):
+    chunk['Inspirational Quote'] = chunk.apply(lambda row: generate_quote(row['Answer'], row['Emotion']), axis=1)
+    return chunk
+
+def process_in_chunks(df, chunk_size=10):
+    results = Parallel(n_jobs=-1, backend="multiprocessing")(
+        delayed(process_chunk)(df[start:start + chunk_size]) for start in range(0, len(df), chunk_size)
+    )
+    return pd.concat(results, ignore_index=True)
+
+# Function to plot the emotion distribution graph
+def plot_emotion_distribution(df):
+    emotion_count = df['Emotion'].value_counts()
+    plt.figure(figsize=(10,6))
+    sns.barplot(x=emotion_count.index, y=emotion_count.values, palette='viridis')
+    plt.title('Sum of Each Emotion')
+    plt.xlabel('Emotion')
+    plt.ylabel('Count')
+    plt.show()
+
+# Function to detect emotion and generate a quote for a journal entry
 def journal_interface(Diary):
-    try:
-        # Step 1: Detect Emotion
-        emotion = get_emotion(Diary)
-        
-        # Step 2: Generate Inspirational Quotes
-        quote1, quote2 = generate_quotes(Diary, emotion)
-        
-        # Step 3: Get image URL based on the emotion
-        # image_url = get_image_url(emotion)
-
-        # Step 4: Save to CSV
-        date_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        new_entry = pd.DataFrame([[date_time, Diary, emotion, quote1, quote2]], columns=["Date", "Diary Text", "Emotion", "Quote 1", "Quote 2"])
-        global df
-        df = pd.concat([df, new_entry], ignore_index=True)
-        df.to_csv(csv_file, index=False)
-        
-        return emotion, quote1, quote2, #image_url
-    except Exception as e:
-        # Return the error message to the interface for debugging
-        print(f"Error encountered: {str(e)}")
-        return f"Error: {str(e)}", "", "" #None  # Last output is for the image
-
-# Create the Gradio interface
+    emotion = get_emotion(Diary)
+    quote = generate_quote(Diary, emotion)
+    return emotion, quote
+
+# Function to track CPU utilization during processing
+def get_cpu_utilization():
+    return f"Current CPU Usage: {psutil.cpu_percent()}%"
+
+# Main function to load the data, process it in chunks, and generate a graph
+def main(file_path):
+    df = load_and_process_data(file_path)
+    print(file_path)
+    processed_df = process_in_chunks(df)
+    plot_emotion_distribution(processed_df)
+    print(get_cpu_utilization())
+    return processed_df
+
+# Gradio interface for inputting thoughts and generating emotion/quote
 interface = gr.Interface(
     fn=journal_interface,
     inputs=gr.Textbox(lines=5, placeholder="Enter your thoughts here..."),
     outputs=[
         gr.Textbox(label="Detected Emotion"),
-        gr.Textbox(label="Generated Quote 1"),
-        gr.Textbox(label="Generated Quote 2"),
-        #gr.Image(label="Emotion Image", visible=True, width="100%")  # Show image based on emotion
+        gr.Textbox(label="Generated Quote")
     ],
     title="AI-Powered Personal Journal",
-    description="Enter your thoughts, and the AI will detect the emotion and generate two inspirational quotes based on it.",
-    theme=gr.themes.Soft()  # Apply the Soft theme here
+    description="Enter your thoughts, and the AI will detect the emotion and generate an inspirational quote based on it.",
+    theme=gr.themes.Soft()
 )
+# Button to generate the graph and display CPU usage
+def graph_button(file_path):
+    processed_df = main(file_path)
+    return get_cpu_utilization()
 
-# Launch the Gradio app
-interface.launch(share=True)
+interface.launch(share=True)

requirements.txt

@@ -1,6 +1,7 @@
-transformers
+psutil 
+pandas 
 torch
 gradio
-pandas
-datetime
-python-multipart
+joblib
+matplotlib
+seaborn