Update app.py

app.py

@@ -6,36 +6,30 @@ import random
 import os
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 
-# --- 1. LOAD ARTIFACTS ---
+# --- 1. CONFIGURATION & LOAD ---
 PKG_PATH = "neuro_semantic_package.pt"
 
-print("🚀 System Startup: Loading Artifacts...")
+# Fallback for local/Colab testing
 if not os.path.exists(PKG_PATH):
-    # Fallback for local testing if file isn't in root
-    POSSIBLE_PATHS = [
+    # Try looking in common paths
+    possible_paths = [
         "neuro_semantic_package.pt",
         "/content/drive/MyDrive/Brain2Text_Project/demo_research_v2/neuro_semantic_package.pt"
     ]
-    for p in POSSIBLE_PATHS:
+    for p in possible_paths:
         if os.path.exists(p):
             PKG_PATH = p
             break
-    
-    if not os.path.exists(PKG_PATH):
-        raise FileNotFoundError(f"CRITICAL: '{PKG_PATH}' missing. Please upload the .pt file.")
+            
+if not os.path.exists(PKG_PATH):
+    raise FileNotFoundError("CRITICAL: 'neuro_semantic_package.pt' missing.")
 
-# Load the "Black Box" package
-# map_location='cpu' ensures it runs on basic HF spaces without GPU if needed
-PKG = torch.load(PKG_PATH, map_location="cpu", weights_only=False) 
+print("🚀 Loading Neuro-Semantic Engine...")
+PKG = torch.load(PKG_PATH, map_location="cpu", weights_only=False)
 DATA = PKG['data']
-MODELS = PKG['models']       # The Projectors
-MATRIX = PKG['matrix']       # Pre-calculated Accuracy Table
-MAPPING = PKG['mapping_key'] # Secret Mapping
+MODELS = PKG['models']       
+MAPPING = PKG['mapping_key'] 
 
-# Inverse mapping (Alias -> Real Sub)
-ALIAS_TO_REAL = {v: k for k, v in MAPPING.items()}
-
-# Load Decoder
 print("🤖 Loading RoBERTa-GoEmotions...")
 MODEL_NAME = "SamLowe/roberta-base-go_emotions"
 tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
@@ -43,110 +37,107 @@ classifier = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME)
 classifier.eval()
 id2label = classifier.config.id2label
 
-# --- 2. LOGIC FUNCTIONS ---
+# --- 2. HISTORICAL ACCURACY LOOKUP ---
+# Based on the "Grand Benchmark" results we calculated
+ENSEMBLE_ACCURACY = {
+    "ZAB": "49.0%", "ZDM": "45.7%", "ZDN": "48.3%",
+    "ZJS": "61.3%", "ZGW": "42.9%", "ZJN": "53.3%",
+    "ZKH": "58.3%", "ZKB": "48.9%", "ZPH": "45.2%",
+    "ZMG": "56.6%"
+}
 
-def get_sentence_options(subject_name):
-    # Return available sentences for the selected subject
-    choices = DATA[subject_name]['Text']
-    # Pick a random one as default to encourage exploration
-    default = random.choice(choices)
-    return gr.Dropdown(choices=choices, value=default)
+# --- 3. LOGIC FUNCTIONS ---
 
-def get_warning_status(subject, projector_alias):
-    """Checks for Data Leakage"""
-    clean_alias = projector_alias.split(" ")[1]
-    source_subject = ALIAS_TO_REAL.get(clean_alias)
-    
-    if source_subject == subject:
-        return (
-            "⚠️ **WARNING: DATA LEAKAGE DETECTED**\n\n"
-            f"The selected Projector ({projector_alias}) includes data from Subject {subject} in its training set.\n"
-            "Results will be artificially high (Self-Test). For valid research verification, please select a different Projector."
-        )
-    else:
-        return "✅ **VALID ZERO-SHOT CONFIGURATION**\n\nTarget Subject was NOT seen during Projector training."
-
-def get_historical_accuracy(subject, projector_alias):
-    """Retrieves pre-calculated accuracy"""
-    try:
-        acc = MATRIX.loc[projector_alias, subject]
-        return f"**Historical Compatibility:** {acc}"
-    except:
-        return "**Historical Compatibility:** N/A"
+def get_status_info(subject):
+    acc = ENSEMBLE_ACCURACY.get(subject, "Unknown")
+    return f"**General Model Accuracy on this Subject:** {acc}\n(Baseline Random Chance: ~7.1%)"
 
-def decode_neuro_semantics(subject, projector_alias, text):
+def decode_neuro_semantics(subject, text):
     # 1. Fetch Data
     try:
         idx = DATA[subject]['Text'].index(text)
         eeg_input = DATA[subject]['X'][idx].reshape(1, -1)
     except ValueError:
-        return pd.DataFrame(), "Error: Data point not found."
+        return pd.DataFrame(), "Error"
 
-    # 2. Project (EEG -> Vector)
-    proj_model = MODELS[projector_alias]
-    predicted_vector = proj_model.predict(eeg_input)
-    tensor_vec = torch.tensor(predicted_vector).float()
-
-    # 3. Decode (Vector -> Emotions)
-    with torch.no_grad():
-        # Brain Path
-        x = classifier.classifier.dense(tensor_vec.unsqueeze(1))
-        x = torch.tanh(x)
-        logits_b = classifier.classifier.out_proj(x)
-        probs_brain = torch.sigmoid(logits_b).squeeze().numpy()
+    # 2. DYNAMIC ENSEMBLE CONSTRUCTION
+    # Identify the projector belonging to this subject to EXCLUDE it
+    target_alias = MAPPING[subject] # e.g. "A"
+    target_proj_name = f"Projector {target_alias}"
+    
+    # Committee = All models EXCEPT the one trained on this subject
+    committee_names = [name for name in MODELS.keys() if name != target_proj_name]
+    
+    all_probs = []
+    
+    # 3. Ensemble Prediction Loop
+    for proj_name in committee_names:
+        proj_model = MODELS[proj_name]
         
-        # Text Path (Ground Truth)
+        # A. Project (EEG -> Vector)
+        vec_np = proj_model.predict(eeg_input)
+        tensor_vec = torch.tensor(vec_np).float()
+        
+        # B. Decode (Vector -> Probs)
+        with torch.no_grad():
+            x = classifier.classifier.dense(tensor_vec.unsqueeze(1))
+            x = torch.tanh(x)
+            logits = classifier.classifier.out_proj(x)
+            probs = torch.sigmoid(logits).squeeze().numpy()
+            all_probs.append(probs)
+    
+    # 4. Soft Voting (Average Probabilities)
+    avg_probs = np.mean(all_probs, axis=0)
+    
+    # 5. Get Ground Truth (Text -> Probs)
+    with torch.no_grad():
         inputs = tokenizer(text, return_tensors="pt")
         logits_t = classifier(**inputs).logits
         probs_text = torch.sigmoid(logits_t).squeeze().numpy()
 
-    # 4. Rank & Format
-    top3_b = np.argsort(probs_brain)[::-1][:3]
+    # 6. Rank & Format
+    top3_b = np.argsort(avg_probs)[::-1][:3]
     top2_t = np.argsort(probs_text)[::-1][:2]
     
-    # Check Match (Top-1 Brain vs Top-2 Text)
     brain_top1 = id2label[top3_b[0]]
     text_top2 = [id2label[i] for i in top2_t]
     
     match_icon = "✅" if brain_top1 in text_top2 else "❌"
 
-    # Build Result Table for ONE sentence
-    # We display the probabilities nicely
-    brain_str = ", ".join([f"{id2label[i]} ({probs_brain[i]:.2f})" for i in top3_b])
+    brain_str = ", ".join([f"{id2label[i]} ({avg_probs[i]:.2f})" for i in top3_b])
     text_str = ", ".join([f"{id2label[i]} ({probs_text[i]:.2f})" for i in top2_t])
     
-    df = pd.DataFrame([{
+    return {
         "Sentence Stimulus": text,
         "Text Ground Truth (Top 2)": text_str,
         "Brain Decoding (Top 3)": brain_str,
         "Match": match_icon
-    }])
-    
-    return df
+    }, match_icon
 
-def run_batch_analysis(subject, projector_alias):
-    # Runs 5 random samples for robust demo
+def run_analysis(subject):
+    # Runs 5 random samples
     subject_data = DATA[subject]
     total_indices = list(range(len(subject_data['Text'])))
-    # Sample up to 5 sentences
-    selected_indices = random.sample(total_indices, min(5, len(total_indices)))
     
-    results = []
+    # Ensure we don't crash if < 5 samples
+    count = min(5, len(total_indices))
+    selected_indices = random.sample(total_indices, count)
+    
+    rows = []
+    matches = 0
     
     for idx in selected_indices:
         txt = subject_data['Text'][idx]
-        df = decode_neuro_semantics(subject, projector_alias, txt)
-        results.append(df)
+        row_data, icon = decode_neuro_semantics(subject, txt)
+        rows.append(row_data)
+        if icon == "✅": matches += 1
         
-    final_df = pd.concat(results)
+    df = pd.DataFrame(rows)
+    batch_acc = (matches / count) * 100
     
-    # Calculate Batch Accuracy
-    acc = (final_df["Match"] == "✅").mean() * 100
-    return final_df, f"**Batch Accuracy:** {acc:.1f}%"
-
-# --- 3. UI LAYOUT ---
+    return df, f"**Current Batch Accuracy:** {batch_acc:.1f}%"
 
-# Formatted Report Text
+# --- 4. REPORT TEXT ---
 REPORT_TEXT = """
 ### 1. Abstract
 This interface demonstrates a **Brain-Computer Interface (BCI)** capable of decoding high-level semantic information directly from non-invasive EEG signals. By aligning biological neural activity with the latent space of Large Language Models (LLMs), we show that it is possible to reconstruct the **emotional sentiment** of a sentence a user is reading, even if the model has **never seen that user's brain data before**.
@@ -163,8 +154,8 @@ Instead of training a simple classifier to predict "Positive" or "Negative" from
 
 ### 4. Experimental Setup: Strict Zero-Shot Evaluation
 To ensure scientific rigor, this demo adheres to a **Strict Leave-One-Group-Out** protocol.
-*   **Disjoint Training:** The "Projectors" available in this demo were trained on a subset of subjects and validated on **completely different subjects**.
-*   **No Calibration:** The model does not receive any calibration data from the target subject. It must rely on universal neural patterns shared across humans.
+*   **Disjoint Training:** The decoding is performed by an **Ensemble** of projectors trained on *other* subjects. The target subject's data is strictly excluded from the training set of the active models.
+*   **No Calibration:** The model does not receive any calibration data from the target subject. It relies on universal neural patterns shared across humans.
 
 ### 5. Interpretation of Results
 The demo compares two probability distributions for every sentence:
@@ -174,49 +165,35 @@ The demo compares two probability distributions for every sentence:
 **Accuracy Metric:** A prediction is considered correct if the **Top-1 Emotion** predicted from the Brain Signal matches either the **#1 or #2 Emotion** predicted from the Text.
 """
 
+# --- 5. UI LAYOUT ---
 with gr.Blocks(theme=gr.themes.Soft(), title="Neuro-Semantic Decoder") as demo:
     gr.Markdown("# 🧠 Neuro-Semantic Alignment: Zero-Shot Decoding")
     
     with gr.Tabs():
-        # --- TAB 1: INTERACTIVE DEMO ---
+        # --- TAB 1: DEMO ---
         with gr.TabItem("🔮 Interactive Demo"):
             with gr.Row():
                 with gr.Column(scale=1):
                     gr.Markdown("### ⚙️ Configuration")
                     
-                    # Selectors
-                    sub_dropdown = gr.Dropdown(choices=list(DATA.keys()), value="ZKB", label="Select Target Subject (Data Source)")
-                    proj_dropdown = gr.Dropdown(choices=list(MODELS.keys()), value="Projector A", label="Select Projector (Decoding Model)")
+                    sub_dropdown = gr.Dropdown(choices=list(DATA.keys()), value="ZKB", label="Select Human Subject")
                     
-                    # Dynamic Info Boxes
-                    warning_box = gr.Markdown("✅ **VALID ZERO-SHOT CONFIGURATION**\n\nTarget Subject was NOT seen during Projector training.")
-                    history_box = gr.Markdown("**Historical Compatibility:** 40.0%")
+                    # Info Box
+                    info_box = gr.Markdown(get_status_info("ZKB"))
                     
-                    btn = gr.Button("🔮 Run Batch Analysis (5 Samples)", variant="primary")
+                    btn = gr.Button("🔮 Decode Brain Signals", variant="primary")
                     
                 with gr.Column(scale=2):
-                    gr.Markdown("### 📊 Decoding Results")
-                    
-                    # Output Table
+                    gr.Markdown("### 📊 Decoding Results (5 Random Samples)")
                     result_table = gr.Dataframe(
                         headers=["Sentence Stimulus", "Text Ground Truth (Top 2)", "Brain Decoding (Top 3)", "Match"],
                         wrap=True
                     )
-                    batch_accuracy_box = gr.Markdown("**Batch Accuracy:** -")
+                    batch_acc_box = gr.Markdown("**Current Batch Accuracy:** -")
 
-            # Interactivity
-            sub_dropdown.change(fn=get_warning_status, inputs=[sub_dropdown, proj_dropdown], outputs=warning_box)
-            sub_dropdown.change(fn=get_historical_accuracy, inputs=[sub_dropdown, proj_dropdown], outputs=history_box)
-            
-            proj_dropdown.change(fn=get_warning_status, inputs=[sub_dropdown, proj_dropdown], outputs=warning_box)
-            proj_dropdown.change(fn=get_historical_accuracy, inputs=[sub_dropdown, proj_dropdown], outputs=history_box)
-            
-            # Run
-            btn.click(
-                fn=run_batch_analysis,
-                inputs=[sub_dropdown, proj_dropdown],
-                outputs=[result_table, batch_accuracy_box]
-            )
+            # Events
+            sub_dropdown.change(fn=get_status_info, inputs=sub_dropdown, outputs=info_box)
+            btn.click(run_analysis, inputs=sub_dropdown, outputs=[result_table, batch_acc_box])
 
         # --- TAB 2: REPORT ---
         with gr.TabItem("📘 Project Report"):