Update app.py

app.py

@@ -2,9 +2,10 @@
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
+import matplotlib.patches as patches
 import seaborn as sns
 from scipy import stats
-from sklearn.preprocessing import StandardScaler
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import classification_report, roc_auc_score
@@ -22,7 +23,7 @@ class EnhancedAIvsRealGazeAnalyzer:
     """
     A comprehensive class to load, process, and analyze eye-tracking data.
     It supports statistical analysis (RQ1), predictive modeling (RQ2),
-    and deep-dive exploration of individual trials.
+    and an innovative deep-dive AOI Focus Dashboard.
     """
     def __init__(self):
         self.questions = ['Q1', 'Q2', 'Q3', 'Q4', 'Q5', 'Q6']
@@ -33,57 +34,43 @@ class EnhancedAIvsRealGazeAnalyzer:
         self.scaler = None
         self.feature_names = []
         self.group_means = None
-        self.et_id_col = 'Participant name' # Default participant ID column name
+        self.et_id_col = 'Participant name'
 
     def load_and_process_data(self, base_path, response_file):
-        """Loads all data from files and preprocesses it for analysis."""
         print("Loading and processing data...")
         self.response_data = pd.read_excel(response_file) if response_file.endswith('.xlsx') else pd.read_csv(response_file)
         self.response_data.columns = self.response_data.columns.str.strip()
-        
         all_data = {}
-        for question in self.questions:
-            file_path = f"{base_path}/Filtered_GenAI_Metrics_cleaned_{question}.xlsx"
+        for q in self.questions:
+            file_path = f"{base_path}/Filtered_GenAI_Metrics_cleaned_{q}.xlsx"
             if os.path.exists(file_path):
-                xls = pd.ExcelFile(file_path)
-                all_data[question] = {sheet_name: pd.read_excel(xls, sheet_name) for sheet_name in xls.sheet_names}
-        
+                all_data[q] = {s: pd.read_excel(file_path, s) for s in pd.ExcelFile(file_path).sheet_names}
         all_dfs = [df.copy().assign(Question=q, Metric_Type=m) for q, qd in all_data.items() for m, df in qd.items()]
         if not all_dfs: raise ValueError("No eye-tracking data files were found.")
-        
         self.combined_data = pd.concat(all_dfs, ignore_index=True)
         self.combined_data.columns = self.combined_data.columns.str.strip()
-        
         self.et_id_col = next((c for c in self.combined_data.columns if 'participant' in c.lower()), 'Participant name')
         resp_id_col = next((c for c in self.response_data.columns if 'participant' in c.lower()), 'Participant name')
-
-        for pair, correct_answer in self.correct_answers.items():
+        for pair, ans in self.correct_answers.items():
             if pair in self.response_data.columns:
-                self.response_data[f'{pair}_Correct'] = (self.response_data[pair].astype(str).str.strip().str.upper() == correct_answer)
-
-        response_long = self.response_data.melt(id_vars=[resp_id_col], value_vars=self.correct_answers.keys(), var_name='Pair', value_name='Response')
+                self.response_data[f'{pair}_Correct'] = (self.response_data[pair].astype(str).str.strip().str.upper() == ans)
+        response_long = self.response_data.melt(id_vars=[resp_id_col], value_vars=self.correct_answers.keys(), var_name='Pair')
         correctness_long = self.response_data.melt(id_vars=[resp_id_col], value_vars=[f'{p}_Correct' for p in self.correct_answers.keys()], var_name='Pair_Correct_Col', value_name='Correct')
         correctness_long['Pair'] = correctness_long['Pair_Correct_Col'].str.replace('_Correct', '')
         response_long = response_long.merge(correctness_long[[resp_id_col, 'Pair', 'Correct']], on=[resp_id_col, 'Pair'])
-        
         q_to_pair = {f'Q{i+1}': f'Pair{i+1}' for i in range(6)}
         self.combined_data['Pair'] = self.combined_data['Question'].map(q_to_pair)
         self.combined_data = self.combined_data.merge(response_long, left_on=[self.et_id_col, 'Pair'], right_on=[resp_id_col, 'Pair'], how='left')
         self.combined_data['Answer_Correctness'] = self.combined_data['Correct'].map({True: 'Correct', False: 'Incorrect'})
-        
         self.numeric_cols = self.combined_data.select_dtypes(include=np.number).columns.tolist()
         self.time_metrics = [c for c in self.numeric_cols if any(k in c.lower() for k in ['time', 'duration', 'fixation'])]
-        
-        # --- THIS IS THE CORRECTED LINE ---
-        # Convert all participant IDs to strings before sorting to handle mixed types.
         self.participant_list = sorted([str(p) for p in self.combined_data[self.et_id_col].unique()])
-        # --- END OF CORRECTION ---
-        
         self.group_means = self.combined_data.groupby('Answer_Correctness')[self.numeric_cols].mean()
         print("Data loading complete.")
         return self
 
     def analyze_rq1_metric(self, metric):
+        # (Unchanged)
         if not metric: return None, "Metric not found."
         correct = self.combined_data.loc[self.combined_data['Answer_Correctness'] == 'Correct', metric].dropna()
         incorrect = self.combined_data.loc[self.combined_data['Answer_Correctness'] == 'Incorrect', metric].dropna()
@@ -93,6 +80,7 @@ class EnhancedAIvsRealGazeAnalyzer:
         return fig, summary
 
     def run_prediction_model(self, test_size, n_estimators):
+        # (Unchanged)
         leaky_features = ['Total_Correct', 'Overall_Accuracy', 'Correct', self.et_id_col]
         self.feature_names = [col for col in self.numeric_cols if col not in leaky_features and col in self.combined_data.columns]
         features = self.combined_data[self.feature_names].copy()
@@ -102,64 +90,96 @@ class EnhancedAIvsRealGazeAnalyzer:
         features = features.fillna(features.median()).fillna(0)
         X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=test_size, random_state=42, stratify=target)
         self.scaler = StandardScaler().fit(X_train)
-        X_train_scaled, X_test_scaled = self.scaler.transform(X_train), self.scaler.transform(X_test)
+        X_train_scaled = self.scaler.transform(X_train)
         self.model = RandomForestClassifier(n_estimators=n_estimators, random_state=42, class_weight='balanced').fit(X_train_scaled, y_train)
-        report = classification_report(y_test, self.model.predict(X_test_scaled), target_names=['Incorrect', 'Correct'], output_dict=True)
-        auc_score = roc_auc_score(y_test, self.model.predict_proba(X_test_scaled)[:, 1])
+        report = classification_report(y_test, self.model.predict(self.scaler.transform(X_test)), target_names=['Incorrect', 'Correct'], output_dict=True)
+        auc_score = roc_auc_score(y_test, self.model.predict_proba(self.scaler.transform(X_test))[:, 1])
         summary_md = f"### Model Performance\n- **AUC Score:** **{auc_score:.4f}**\n- **Overall Accuracy:** {report['accuracy']:.3f}"
         report_df = pd.DataFrame(report).transpose().round(3)
         feature_importance = pd.DataFrame({'Feature': self.feature_names, 'Importance': self.model.feature_importances_}).sort_values('Importance', ascending=False).head(15)
         fig, ax = plt.subplots(figsize=(10, 8)); sns.barplot(data=feature_importance, x='Importance', y='Feature', ax=ax, palette='viridis'); ax.set_title(f'Top 15 Predictive Features (n_estimators={n_estimators})', fontsize=14); plt.tight_layout()
         return summary_md, report_df, fig
 
-    def analyze_individual_trial(self, participant, question):
+    def generate_aoi_focus_dashboard(self, participant, question):
+        # --- NEW INNOVATIVE ANALYSIS FUNCTION ---
         if not participant or not question:
-            return "Please select a participant and a question.", None, None
+            return "Please select a participant and a question.", None
 
-        # Convert participant ID to string for matching, as the list is now all strings
-        trial_data = self.combined_data[(self.combined_data[self.et_id_col].astype(str) == str(participant)) & (self.combined_data['Question'] == question)]
-        if trial_data.empty:
-            return f"No data found for {participant} on {question}.", None, None
+        trial_data_row = self.combined_data[(self.combined_data[self.et_id_col].astype(str) == str(participant)) & (self.combined_data['Question'] == question)]
+        if trial_data_row.empty:
+            return f"No data found for {participant} on {question}.", None
         
-        trial_data = trial_data.iloc[0]
+        trial_data = trial_data_row.iloc[0]
         actual_answer = trial_data['Answer_Correctness']
-        trial_features = trial_data[self.feature_names].values.reshape(1, -1)
-        trial_features_scaled = self.scaler.transform(trial_features)
-        prediction_prob = self.model.predict_proba(trial_features_scaled)[0]
+        prediction_prob = self.model.predict_proba(self.scaler.transform(trial_data[self.feature_names].values.reshape(1, -1)))[0]
         predicted_answer = "Correct" if prediction_prob[1] > 0.5 else "Incorrect"
-        summary_md = f"""### Trial Breakdown: **{participant}** on **{question}**\n- **Actual Answer:** `{actual_answer}`\n- **Model Prediction:** `{predicted_answer}` (Confidence: {max(prediction_prob)*100:.1f}%)"""
-        aoi_cols = [c for c in self.feature_names if ' A' in c or ' B' in c]
-        a_cols = sorted([c for c in aoi_cols if ' A' in c])
-        b_cols = sorted([c for c in aoi_cols if ' B' in c])
-        plot_data = []
-        for a_col, b_col in zip(a_cols, b_cols):
-            base_name = a_col.replace(' A', '')
-            plot_data.append({'AOI': base_name, 'Image': 'A', 'Value': trial_data[a_col]})
-            plot_data.append({'AOI': base_name, 'Image': 'B', 'Value': trial_data[b_col]})
-        fig, ax = plt.subplots(figsize=(10, 6))
-        if plot_data:
-            sns.barplot(data=pd.DataFrame(plot_data), x='Value', y='AOI', hue='Image', ax=ax, palette={'A': '#66b3ff', 'B': '#ff9999'})
-            ax.set_title(f'Gaze Bias: Image A vs. Image B for {question}')
-        else:
-            ax.text(0.5, 0.5, 'No A/B Area of Interest data for this question.', ha='center')
-        plt.tight_layout()
-        top_features = self.model.feature_importances_.argsort()[-5:][::-1]
-        top_feature_names = [self.feature_names[i] for i in top_features]
-        report_card_data = []
-        for feature in top_feature_names:
-            report_card_data.append({'Top Feature': feature, 'This Trial Value': f"{trial_data[feature]:.2f}", 'Avg (Correct)': f"{self.group_means.loc['Correct', feature]:.2f}", 'Avg (Incorrect)': f"{self.group_means.loc['Incorrect', feature]:.2f}"})
-        report_card_df = pd.DataFrame(report_card_data)
-        return summary_md, fig, report_card_df
+        summary_md = f"### Trial Breakdown: **{participant}** on **{question}**\n- **Actual Answer:** `{actual_answer}`\n- **Model Prediction:** `{predicted_answer}` (Confidence: {max(prediction_prob)*100:.1f}%)"
+
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 7))
+        fig.suptitle(f'AOI Focus & Gaze Profile for {participant} - {question}', fontsize=18, weight='bold')
+
+        # --- Plot 1: Schematic Heatmap ---
+        ax1.set_title('Schematic AOI Heatmap (Fixation Duration)', fontsize=14)
+        ax1.set_xlim(0, 10); ax1.set_ylim(0, 10); ax1.set_aspect('equal')
+        ax1.tick_params(axis='both', which='both', bottom=False, top=False, left=False, right=False, labelbottom=False, labelleft=False)
+        
+        aoi_layout = {
+            '2 Face': (2.5, 7.5), '2 Hair': (2.5, 5), '1 Eyes': (7.5, 8.5), '2 Body': (7.5, 6),
+            '5 Sky': (2.5, 2.5), '5 Sea': (7.5, 3.5), '6 Background': (7.5, 1.5)
+        }
+        fixation_cols = [c for c in trial_data.index if 'Total fixation duration' in c]
+        aoi_values = {key.split('duration on ')[1]: trial_data[key] for key in fixation_cols if key.split('duration on ')[1] in aoi_layout}
+        max_val = max(aoi_values.values()) if aoi_values else 1.0
+
+        for name, pos in aoi_layout.items():
+            val_a = aoi_values.get(f'{name} A', 0); val_b = aoi_values.get(f'{name} B', 0)
+            color_a = plt.cm.viridis(val_a / max_val); color_b = plt.cm.viridis(val_b / max_val)
+            ax1.add_patch(patches.Rectangle((pos[0]-2, pos[1]-0.5), 2, 1, facecolor=color_a))
+            ax1.add_patch(patches.Rectangle((pos[0], pos[1]-0.5), 2, 1, facecolor=color_b))
+            ax1.text(pos[0]-1, pos[1], "A", ha='center', va='center', color='white', weight='bold')
+            ax1.text(pos[0]+1, pos[1], "B", ha='center', va='center', color='white', weight='bold')
+            ax1.text(pos[0], pos[1]+0.7, name, ha='center', va='center')
+
+        # --- Plot 2: Gaze Profile Radar Chart ---
+        top_features_indices = self.model.feature_importances_.argsort()[-5:][::-1]
+        labels = [self.feature_names[i].replace('Total fixation duration on ','') for i in top_features_indices]
+        
+        scaler_minmax = MinMaxScaler()
+        profiles = pd.concat([
+            self.group_means.loc['Correct', [self.feature_names[i] for i in top_features_indices]],
+            self.group_means.loc['Incorrect', [self.feature_names[i] for i in top_features_indices]],
+            trial_data[[self.feature_names[i] for i in top_features_indices]]
+        ], axis=1).T
+        profiles_scaled = scaler_minmax.fit_transform(profiles)
+        
+        angles = np.linspace(0, 2*np.pi, len(labels), endpoint=False).tolist()
+        angles += angles[:1]
+        
+        ax2 = plt.subplot(122, polar=True)
+        ax2.set_title('Gaze Profile Comparison', fontsize=14)
+
+        def add_to_radar(profile, color, label):
+            values = profile.tolist()
+            values += values[:1]
+            ax2.plot(angles, values, color=color, linewidth=2, linestyle='solid', label=label)
+            ax2.fill(angles, values, color=color, alpha=0.25)
+
+        add_to_radar(profiles_scaled[0,:], 'green', 'Avg. Correct Profile')
+        add_to_radar(profiles_scaled[1,:], 'red', 'Avg. Incorrect Profile')
+        add_to_radar(profiles_scaled[2,:], 'blue', 'This Trial Profile')
+        
+        ax2.set_thetagrids(np.degrees(angles[:-1]), labels)
+        ax2.legend(loc='upper right', bbox_to_anchor=(0.1, 0.1))
+
+        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+        return summary_md, fig
 
 # --- DATA SETUP ---
 def setup_and_load_data():
     repo_url = "https://github.com/RextonRZ/GenAIEyeTrackingCleanedDataset"
     repo_dir = "GenAIEyeTrackingCleanedDataset"
-    if not os.path.exists(repo_dir):
-        print(f"Cloning data repository from {repo_url}...")
-        git.Repo.clone_from(repo_url, repo_dir)
-    else:
-        print("Data repository already exists. Skipping clone.")
+    if not os.path.exists(repo_dir): git.Repo.clone_from(repo_url, repo_dir)
+    else: print("Data repository already exists. Skipping clone.")
     base_path = repo_dir 
     response_file = os.path.join(repo_dir, "GenAI Response.xlsx")
     analyzer = EnhancedAIvsRealGazeAnalyzer().load_and_process_data(base_path, response_file)
@@ -171,31 +191,29 @@ print("Application setup complete. Ready for interaction.")
 
 # --- GRADIO INTERACTIVE FUNCTIONS ---
 def update_rq1_visuals(metric_choice):
-    if not metric_choice: return None, "Please select a metric."
-    plot, summary = analyzer.analyze_rq1_metric(metric_choice)
-    return plot, summary
+    return analyzer.analyze_rq1_metric(metric_choice)
 
 def update_rq2_model(test_size, n_estimators):
-    n_estimators = int(n_estimators)
-    summary, report_df, plot = analyzer.run_prediction_model(test_size, n_estimators)
-    return summary, report_df, plot
+    return analyzer.run_prediction_model(int(test_size*100)/100, int(n_estimators))
 
 def update_explorer_view(participant, question):
-    summary, plot, report_card = analyzer.analyze_individual_trial(participant, question)
-    return summary, plot, report_card
+    return analyzer.generate_aoi_focus_dashboard(participant, question)
 
 # --- GRADIO INTERFACE DEFINITION ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Interactive Dashboard: AI vs. Real Gaze Analysis\nExplore the eye-tracking dataset by interacting with the controls below. The data is automatically loaded from the public GitHub repository.")
+    gr.Markdown("# Interactive Dashboard: AI vs. Real Gaze Analysis\nExplore the eye-tracking dataset by interacting with the controls below.")
     with gr.Tabs():
         with gr.TabItem("📊 RQ1: Viewing Time vs. Correctness"):
+            # (UI Unchanged)
             with gr.Row():
                 with gr.Column(scale=1):
                     rq1_metric_dropdown = gr.Dropdown(choices=analyzer.time_metrics, label="Select a Time-Based Metric", value=analyzer.time_metrics[0] if analyzer.time_metrics else None)
                     rq1_summary_output = gr.Markdown(label="Statistical Summary")
                 with gr.Column(scale=2):
                     rq1_plot_output = gr.Plot(label="Metric Comparison")
+        
         with gr.TabItem("🤖 RQ2: Predicting Correctness from Gaze"):
+            # (UI Unchanged)
             with gr.Row():
                 with gr.Column(scale=1):
                     gr.Markdown("#### Tune Model Hyperparameters")
@@ -205,24 +223,32 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     rq2_summary_output = gr.Markdown(label="Model Performance Summary")
                     rq2_table_output = gr.Dataframe(label="Classification Report", interactive=False)
                     rq2_plot_output = gr.Plot(label="Feature Importance")
-        with gr.TabItem("🔬 Individual Trial Explorer"):
-            gr.Markdown("### Deep Dive into a Single Trial\nSelect a participant and a question to see a detailed breakdown of their gaze behavior.")
+        
+        with gr.TabItem("🔬 AOI Focus Dashboard"):
+            # --- NEW INNOVATIVE UI ---
+            gr.Markdown("### Deep Dive into a Single Trial\nSelect a participant and a question to visualize their unique gaze pattern.")
             with gr.Row():
                 with gr.Column(scale=1):
                     explorer_participant = gr.Dropdown(choices=analyzer.participant_list, label="Select Participant")
                     explorer_question = gr.Dropdown(choices=analyzer.questions, label="Select Question")
                     explorer_summary = gr.Markdown(label="Trial Summary")
-                    explorer_report_card = gr.Dataframe(label="Feature Report Card", interactive=False)
                 with gr.Column(scale=2):
-                    explorer_plot = gr.Plot(label="Gaze Bias (Image A vs. B)")
+                    explorer_plot = gr.Plot(label="Gaze Focus & Profile Analysis")
     
+    # --- WIRING FOR ALL TABS ---
     outputs_rq2 = [rq2_summary_output, rq2_table_output, rq2_plot_output]
-    outputs_explorer = [explorer_summary, explorer_plot, explorer_report_card]
+    outputs_explorer = [explorer_summary, explorer_plot]
+
     rq1_metric_dropdown.change(fn=update_rq1_visuals, inputs=[rq1_metric_dropdown], outputs=[rq1_plot_output, rq1_summary_output])
     rq2_test_size_slider.release(fn=update_rq2_model, inputs=[rq2_test_size_slider, rq2_estimators_slider], outputs=outputs_rq2)
     rq2_estimators_slider.release(fn=update_rq2_model, inputs=[rq2_test_size_slider, rq2_estimators_slider], outputs=outputs_rq2)
-    explorer_participant.change(fn=update_explorer_view, inputs=[explorer_participant, explorer_question], outputs=outputs_explorer)
-    explorer_question.change(fn=update_explorer_view, inputs=[explorer_participant, explorer_question], outputs=outputs_explorer)
+    
+    # Wiring for the new explorer tab
+    explorer_inputs = [explorer_participant, explorer_question]
+    explorer_participant.change(fn=update_explorer_view, inputs=explorer_inputs, outputs=outputs_explorer)
+    explorer_question.change(fn=update_explorer_view, inputs=explorer_inputs, outputs=outputs_explorer)
+
+    # Load initial state
     demo.load(fn=update_rq1_visuals, inputs=[rq1_metric_dropdown], outputs=[rq1_plot_output, rq1_summary_output])
     demo.load(fn=update_rq2_model, inputs=[rq2_test_size_slider, rq2_estimators_slider], outputs=outputs_rq2)