Update app.py

app.py

@@ -1,125 +1,209 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
-import time
-import random
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
 from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.ensemble import RandomForestClassifier
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+from sklearn.linear_model import LogisticRegression
 from sklearn.svm import SVC
 from sklearn.naive_bayes import MultinomialNB
+from sklearn.preprocessing import LabelEncoder
+from sklearn.utils import Bunch
+import kagglehub
+import time
+import random
+import threading
 
-# 1. SETUP DATA AND MAPPINGS (From your Notebook)
-SENT_MAP = {'❤️':'Pos', '👍':'Pos', '😂':'Pos', '💯':'Pos', '😢':'Neg', '😭':'Neg', '😮':'Neu'}
-INTENT_MAP = {'❤️':'Emotion', '👍':'Agreement', '😂':'Emotion', '😮':'Surprise'}
+# --- 1. CORE MODEL LOGIC (Ported from your script) ---
 
-def get_sent(emoji): return SENT_MAP.get(emoji, 'Neutral')
-def get_intent(emoji): return INTENT_MAP.get(emoji, 'Other')
+class EpisodicMemory:
+    def __init__(self, capacity=2000):
+        self.memory_x, self.memory_y = [], []
+        self.capacity = capacity
+    def store(self, x, y):
+        curr_x, curr_y = x.detach().cpu(), y.detach().cpu()
+        for i in range(curr_x.size(0)):
+            if len(self.memory_x) >= self.capacity:
+                self.memory_x.pop(0); self.memory_y.pop(0)
+            self.memory_x.append(curr_x[i]); self.memory_y.append(curr_y[i])
+    def retrieve(self, query_x, k=5):
+        if len(self.memory_x) < k: return None
+        mem_tensor = torch.stack(self.memory_x).to(query_x.device)
+        distances = torch.cdist(query_x, mem_tensor)
+        top_k_indices = torch.topk(distances, k, largest=False).indices
+        retrieved_y = [torch.stack([self.memory_y[idx] for idx in sample_indices]) for sample_indices in top_k_indices]
+        return torch.stack(retrieved_y).to(query_x.device)
 
-# Mock Data for training (As the CSV isn't provided, we use a small seed set)
-# In your Space, you can replace this by loading your actual CSV
-data = {
-    'content': ["I love this!", "That is so sad", "Wow really?", "I agree with you", "LMAO", "I am angry"],
-    'emoji': ["❤️", "😢", "😮", "👍", "😂", "😢"]
-}
-df = pd.DataFrame(data)
-df['sentiment'] = df['emoji'].apply(get_sent)
-df['intent'] = df['emoji'].apply(get_intent)
+class ExecutiveCore(nn.Module):
+    def __init__(self, input_dim, hidden_dim):
+        super().__init__()
+        self.net = nn.Sequential(nn.Linear(input_dim, hidden_dim), nn.LayerNorm(hidden_dim), nn.GELU(), nn.Dropout(0.2), nn.Linear(hidden_dim, hidden_dim), nn.GELU())
+    def forward(self, x): return self.net(x)
+
+class MotorPolicy(nn.Module):
+    def __init__(self, hidden_dim, output_dim):
+        super().__init__()
+        self.fc = nn.Linear(hidden_dim, output_dim)
+    def forward(self, x): return self.fc(x)
+
+class H3MOS(nn.Module):
+    def __init__(self, input_dim, hidden_dim, output_dim):
+        super().__init__()
+        self.executive = ExecutiveCore(input_dim, hidden_dim)
+        self.motor = MotorPolicy(hidden_dim, output_dim)
+        self.hippocampus = EpisodicMemory()
+    def forward(self, x, training_mode=False):
+        z = self.executive(x)
+        if training_mode or len(self.hippocampus.memory_x) < 10: return self.motor(z)
+        past_labels = self.hippocampus.retrieve(x, k=5)
+        raw_logits = self.motor(z)
+        mem_votes = torch.zeros_like(raw_logits)
+        for i in range(x.size(0)):
+            votes = torch.bincount(past_labels[i], minlength=raw_logits.size(1)).float()
+            mem_votes[i] = votes
+        return (0.8 * raw_logits) + (0.2 * F.softmax(mem_votes, dim=1) * 5.0)
 
-# 2. TRAIN MODELS
-tfidf = TfidfVectorizer(max_features=1000)
+# --- 2. DATA & TRAINING SETUP ---
+
+print("Downloading dataset and training models...")
+path = kagglehub.dataset_download('dewanmukto/social-messages-and-emoji-reactions')
+df = pd.read_csv(path+"/messages_emojis.csv").dropna(subset=['content'])
+
+sent_map = {'❤️':'Pos', '👍':'Pos', '😂':'Pos', '💯':'Pos', '😢':'Neg', '😭':'Neg', '😮':'Neu'}
+intent_map = {'❤️':'Emotion', '👍':'Agreement', '😂':'Emotion', '😮':'Surprise'}
+tfidf = TfidfVectorizer(max_features=1000, stop_words='english')
 X = tfidf.fit_transform(df['content'])
 
-# Emoji Models
-model_rf_emoji = RandomForestClassifier().fit(X, df['emoji'])
-model_svm_emoji = SVC(probability=True).fit(X, df['emoji'])
-model_nb_emoji = MultinomialNB().fit(X, df['emoji'])
-
-# Sentiment & Intent Models (Using Random Forest as base)
-model_sent = RandomForestClassifier().fit(X, df['sentiment'])
-model_intent = RandomForestClassifier().fit(X, df['intent'])
-
-# 3. HELPER FUNCTIONS
-def get_avatar(name):
-    return f"https://api.dicebear.com/7.x/avataaars/svg?seed={name}"
-
-def predict_all(text):
-    vec = tfidf.transform([text])
-    return {
-        "Random Forest": model_rf_emoji.predict(vec)[0],
-        "SVM": model_svm_emoji.predict(vec)[0],
-        "Naive Bayes": model_nb_emoji.predict(vec)[0],
-        "Sentiment": model_sent.predict(vec)[0],
-        "Intent": model_intent.predict(vec)[0]
-    }
-
-# 4. CHAT LOGIC
-def chat_response(message, history):
-    preds = predict_all(message)
-    
-    # User's message with reactions
-    # We format reactions as a small row at the bottom
-    reactions_html = f"""
-    <div style='display: flex; gap: 5px; margin-top: 8px; font-size: 0.8em;'>
-        <span title='RF: {preds["Random Forest"]} | SVM: {preds["SVM"]} | NB: {preds["Naive Bayes"]}' 
-              style='background: #f0f2f5; padding: 2px 8px; border-radius: 12px; cursor: help;'>
-            {preds["Random Forest"]} {preds["SVM"]} {preds["Naive Bayes"]}
-        </span>
-    </div>
-    """
-    history.append({"role": "user", "content": message + reactions_html})
-    yield history
+targets = {
+    'emoji': df['emoji'].values,
+    'sentiment': df['emoji'].apply(lambda x: sent_map.get(x, 'Neutral')).values,
+    'intent': df['emoji'].apply(lambda x: intent_map.get(x, 'Other')).values
+}
+
+model_zoo = {}
+encoders = {}
+algs = {
+    "RandomForest": RandomForestClassifier(n_estimators=50),
+    "SVM": SVC(kernel='linear', probability=True),
+    "NaiveBayes": MultinomialNB(),
+    "LogReg": LogisticRegression(max_iter=500),
+    "DISTIL-H3MOS": "torch"
+}
 
-    # Simulate group chat replies
-    bots = [
-        {"name": "The Forester (RF)", "avatar": get_avatar("Forester")},
-        {"name": "The Maverick (SVM)", "avatar": get_avatar("Maverick")},
-        {"name": "The Sage (NB)", "avatar": get_avatar("Sage")}
-    ]
+for task, y in targets.items():
+    le = LabelEncoder()
+    y_enc = le.fit_transform(y)
+    encoders[task] = le
+    for name, clf in algs.items():
+        if name not in model_zoo: model_zoo[name] = {}
+        if name == "DISTIL-H3MOS":
+            model = H3MOS(X.shape[1], 64, len(le.classes_))
+            # (Simplified training for demo speed)
+            optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
+            X_t = torch.FloatTensor(X.toarray())
+            y_t = torch.LongTensor(y_enc)
+            for _ in range(20):
+                optimizer.zero_grad(); loss = F.cross_entropy(model(X_t, True), y_t); loss.backward(); optimizer.step()
+            model_zoo[name][task] = model
+        else:
+            clf.fit(X, y)
+            model_zoo[name][task] = clf
+
+# --- 3. GRADIO UI & CHAT LOGIC ---
+
+# Dicebear Avatars
+def get_avatar(seed):
+    return f"https://api.dicebear.com/7.x/adventurer/svg?seed={seed}"
+
+CSS = """
+.reaction-pill { 
+    background: rgba(255, 255, 255, 0.8); 
+    border-radius: 12px; 
+    padding: 2px 8px; 
+    font-size: 14px; 
+    margin-top: 5px; 
+    display: inline-block; 
+    border: 1px solid #ddd;
+    cursor: help;
+}
+.chat-window { border-radius: 15px; }
+"""
+
+def chat_interface(message, history):
+    if not message: return "", history
+    
+    # 1. Process Reactions for User Message
+    vec = tfidf.transform([message])
+    vec_t = torch.FloatTensor(vec.toarray())
     
-    random.shuffle(bots)
+    reactions = []
+    reaction_details = "Models reacted: "
+    for name in model_zoo.keys():
+        if name == "DISTIL-H3MOS":
+            with torch.no_grad():
+                res = torch.argmax(model_zoo[name]['emoji'](vec_t)).item()
+                emoji = encoders['emoji'].inverse_transform([res])[0]
+        else:
+            emoji = model_zoo[name]['emoji'].predict(vec)[0]
+        reactions.append(emoji)
+        reaction_details += f"{name} ({emoji}) "
+
+    # Most frequent emoji as primary reaction
+    primary_emoji = max(set(reactions), key=reactions.count)
+    reaction_html = f"<div class='reaction-pill' title='{reaction_details}'>{primary_emoji} {len(reactions)}</div>"
     
-    for bot in bots:
-        # Random delay for typing simulation
+    user_msg_formatted = f"{message}<br>{reaction_html}"
+    history.append({"role": "user", "content": user_msg_formatted})
+    yield history
+
+    # 2. Simulate Bot Responses
+    active_models = ["DISTIL-H3MOS", "RandomForest", "LogReg", "SVM"]
+    random.shuffle(active_models)
+
+    for bot in active_models:
+        # Simulate typing delay
         time.sleep(random.uniform(0.5, 1.5))
         
-        bot_msg = f"**Sentiment:** {preds['Sentiment']}  \n**Intent:** {preds['Intent']}"
+        # Predict Sentiment/Intent
+        if bot == "DISTIL-H3MOS":
+            with torch.no_grad():
+                s_idx = torch.argmax(model_zoo[bot]['sentiment'](vec_t)).item()
+                i_idx = torch.argmax(model_zoo[bot]['intent'](vec_t)).item()
+                sent = encoders['sentiment'].inverse_transform([s_idx])[0]
+                intent = encoders['intent'].inverse_transform([i_idx])[0]
+        else:
+            sent = model_zoo[bot]['sentiment'].predict(vec)[0]
+            intent = model_zoo[bot]['intent'].predict(vec)[0]
+
+        bot_content = f"**Sentiment:** {sent} | **Intent:** {intent}"
         history.append({
             "role": "assistant", 
-            "content": bot_msg, 
-            "metadata": {"title": bot["name"]},
-            "avatar": bot["avatar"]
+            "content": bot_content, 
+            "metadata": {"title": f"{bot}", "avatar": get_avatar(bot)}
         })
         yield history
 
-# 5. UI CONSTRUCTION
-custom_css = """
-.gradio-container { background-color: #e5ddd5; } /* WhatsApp Background */
-.message-row { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; }
-"""
-
-with gr.Blocks(css=custom_css) as demo:
-    gr.Markdown("# 📱 Multi-Model Emoji Group Chat")
-    gr.Markdown("Type a message to see how different models react and respond based on sentiment and intent.")
+with gr.Blocks(css=CSS) as demo:
+    gr.Markdown("# 🤖 Multitask Model Group Chat\n*A benchmark-turned-chat app featuring H3MOS, RF, and SVM.*")
     
     chatbot = gr.Chatbot(
-        bubble_full_width=False,
-        show_label=False,
+        elem_id="chat-window",
         type="messages",
-        avatar_images=(None, "https://api.dicebear.com/7.x/avataaars/svg?seed=User")
+        avatar_images=(None, "https://api.dicebear.com/7.x/bottts/svg?seed=User"),
+        bubble_full_width=False
     )
     
     with gr.Row():
         txt = gr.Textbox(
             show_label=False,
-            placeholder="Type a message...",
+            placeholder="Type a message to see how the models react...",
             scale=4
         )
-        submit_btn = gr.Button("Send", variant="primary")
+        submit_btn = gr.Button("Send", variant="primary", scale=1)
 
-    # Hooking up logic
-    txt.submit(chat_response, [txt, chatbot], [chatbot])
-    submit_btn.click(chat_response, [txt, chatbot], [chatbot])
-    txt.submit(lambda: "", None, [txt]) # Clear textbox
-    submit_btn.click(lambda: "", None, [txt])
+    txt.submit(chat_interface, [txt, chatbot], [txt, chatbot])
+    submit_btn.click(chat_interface, [txt, chatbot], [txt, chatbot])
 
 demo.launch()