Update app.py

app.py

@@ -6,30 +6,36 @@ import random
 import os
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 
-# --- 1. CONFIGURATION & LOAD ---
+# --- 1. LOAD ARTIFACTS ---
 PKG_PATH = "neuro_semantic_package.pt"
 
-# Fallback for local/Colab testing
+print("🚀 System Startup: Loading Artifacts...")
 if not os.path.exists(PKG_PATH):
-    # Try looking in common paths
-    possible_paths = [
+    # Fallback for local testing if file isn't in root
+    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("CRITICAL: 'neuro_semantic_package.pt' missing.")
+    
+    if not os.path.exists(PKG_PATH):
+        raise FileNotFoundError(f"CRITICAL: '{PKG_PATH}' missing. Please upload the .pt file.")
 
-print("🚀 Loading Neuro-Semantic Engine...")
-PKG = torch.load(PKG_PATH, map_location="cpu", weights_only=False)
+# 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) 
 DATA = PKG['data']
-MODELS = PKG['models']       
-MAPPING = PKG['mapping_key'] 
+MODELS = PKG['models']       # The Projectors
+MATRIX = PKG['matrix']       # Pre-calculated Accuracy Table
+MAPPING = PKG['mapping_key'] # Secret Mapping
 
+# 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)
@@ -37,107 +43,110 @@ classifier = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME)
 classifier.eval()
 id2label = classifier.config.id2label
 
-# --- 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%"
-}
+# --- 2. LOGIC FUNCTIONS ---
 
-# --- 3. LOGIC FUNCTIONS ---
+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)
 
-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 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 decode_neuro_semantics(subject, text):
+def decode_neuro_semantics(subject, projector_alias, 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"
+        return pd.DataFrame(), "Error: Data point not found."
 
-    # 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]
-        
-        # 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)
+    # 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()
+        
+        # Text Path (Ground Truth)
         inputs = tokenizer(text, return_tensors="pt")
         logits_t = classifier(**inputs).logits
         probs_text = torch.sigmoid(logits_t).squeeze().numpy()
 
-    # 6. Rank & Format
-    top3_b = np.argsort(avg_probs)[::-1][:3]
+    # 4. Rank & Format
+    top3_b = np.argsort(probs_brain)[::-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 "❌"
 
-    brain_str = ", ".join([f"{id2label[i]} ({avg_probs[i]:.2f})" for i in top3_b])
+    # 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])
     text_str = ", ".join([f"{id2label[i]} ({probs_text[i]:.2f})" for i in top2_t])
     
-    return {
+    df = pd.DataFrame([{
         "Sentence Stimulus": text,
         "Text Ground Truth (Top 2)": text_str,
         "Brain Decoding (Top 3)": brain_str,
         "Match": match_icon
-    }, match_icon
+    }])
+    
+    return df
 
-def run_analysis(subject):
-    # Runs 5 random samples
+def run_batch_analysis(subject, projector_alias):
+    # Runs 5 random samples for robust demo
     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)))
     
-    # Ensure we don't crash if < 5 samples
-    count = min(5, len(total_indices))
-    selected_indices = random.sample(total_indices, count)
-    
-    rows = []
-    matches = 0
+    results = []
     
     for idx in selected_indices:
         txt = subject_data['Text'][idx]
-        row_data, icon = decode_neuro_semantics(subject, txt)
-        rows.append(row_data)
-        if icon == "✅": matches += 1
+        df = decode_neuro_semantics(subject, projector_alias, txt)
+        results.append(df)
         
-    df = pd.DataFrame(rows)
-    batch_acc = (matches / count) * 100
+    final_df = pd.concat(results)
     
-    return df, f"**Current Batch Accuracy:** {batch_acc:.1f}%"
+    # Calculate Batch Accuracy
+    acc = (final_df["Match"] == "✅").mean() * 100
+    return final_df, f"**Batch Accuracy:** {acc:.1f}%"
+
+# --- 3. UI LAYOUT ---
 
-# --- 4. REPORT TEXT ---
+# Formatted 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**.
@@ -154,8 +163,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 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.
+*   **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.
 
 ### 5. Interpretation of Results
 The demo compares two probability distributions for every sentence:
@@ -165,35 +174,49 @@ 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: DEMO ---
+        # --- TAB 1: INTERACTIVE DEMO ---
         with gr.TabItem("🔮 Interactive Demo"):
             with gr.Row():
                 with gr.Column(scale=1):
                     gr.Markdown("### ⚙️ Configuration")
                     
-                    sub_dropdown = gr.Dropdown(choices=list(DATA.keys()), value="ZKB", label="Select Human Subject")
+                    # 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)")
                     
-                    # Info Box
-                    info_box = gr.Markdown(get_status_info("ZKB"))
+                    # 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%")
                     
-                    btn = gr.Button("🔮 Decode Brain Signals", variant="primary")
+                    btn = gr.Button("🔮 Run Batch Analysis (5 Samples)", variant="primary")
                     
                 with gr.Column(scale=2):
-                    gr.Markdown("### 📊 Decoding Results (5 Random Samples)")
+                    gr.Markdown("### 📊 Decoding Results")
+                    
+                    # Output Table
                     result_table = gr.Dataframe(
                         headers=["Sentence Stimulus", "Text Ground Truth (Top 2)", "Brain Decoding (Top 3)", "Match"],
                         wrap=True
                     )
-                    batch_acc_box = gr.Markdown("**Current Batch Accuracy:** -")
+                    batch_accuracy_box = gr.Markdown("**Batch Accuracy:** -")
 
-            # 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])
+            # 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]
+            )
 
         # --- TAB 2: REPORT ---
         with gr.TabItem("📘 Project Report"):