Update app.py

app.py

@@ -1,11 +1,11 @@
-# app.py 
+# app.py (Gaze Playback & Real-Time Prediction)
 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, MinMaxScaler
+from sklearn.preprocessing import StandardScaler
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import classification_report, roc_auc_score
@@ -23,37 +23,56 @@ class EnhancedAIvsRealGazeAnalyzer:
     """
     A comprehensive class to load, process, and analyze eye-tracking data.
     It supports statistical analysis (RQ1), predictive modeling (RQ2),
-    and an innovative deep-dive AOI Focus Dashboard.
+    and an innovative "Gaze Playback" dashboard.
     """
     def __init__(self):
         self.questions = ['Q1', 'Q2', 'Q3', 'Q4', 'Q5', 'Q6']
         self.correct_answers = {'Pair1': 'B', 'Pair2': 'B', 'Pair3': 'B', 'Pair4': 'B', 'Pair5': 'B', 'Pair6': 'B'}
         self.combined_data = None
+        self.fixation_data = {}  # To store raw fixation data for each trial
         self.participant_list = []
         self.model = None
         self.scaler = None
         self.feature_names = []
-        self.group_means = None
         self.et_id_col = 'Participant name'
 
     def load_and_process_data(self, base_path, response_file):
-        print("Loading and processing data...")
+        """Loads aggregated metrics and raw fixation data, handling NaNs."""
+        print("Loading and processing aggregated and raw fixation 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 = {}
+        
+        all_metrics_dfs = []
+        # Load both aggregated metrics and raw fixations
         for q in self.questions:
             file_path = f"{base_path}/Filtered_GenAI_Metrics_cleaned_{q}.xlsx"
             if os.path.exists(file_path):
-                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)
+                xls = pd.ExcelFile(file_path)
+                # Load aggregated metrics (assuming it's the first sheet)
+                metrics_df = pd.read_excel(xls, sheet_name=0)
+                metrics_df['Question'] = q
+                all_metrics_dfs.append(metrics_df)
+                
+                # Load raw fixation data if the sheet exists
+                if 'Fixation-based AOI' in xls.sheet_names:
+                    fix_df = pd.read_excel(xls, sheet_name='Fixation-based AOI')
+                    fix_df['Question'] = q
+                    # ENSURE NO NULLS: Drop rows with invalid data crucial for playback
+                    fix_df.dropna(subset=['Fixation point X', 'Fixation point Y', 'Gaze event duration (ms)'], inplace=True)
+                    self.et_id_col = next((c for c in fix_df.columns if 'participant' in c.lower()), 'Participant name')
+                    for participant, group in fix_df.groupby(self.et_id_col):
+                        self.fixation_data[(str(participant), q)] = group.reset_index(drop=True)
+        
+        if not all_metrics_dfs: raise ValueError("No aggregated metrics files were found.")
+        self.combined_data = pd.concat(all_metrics_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')
+        
+        # Merge response data with aggregated metrics
         resp_id_col = next((c for c in self.response_data.columns if 'participant' in c.lower()), 'Participant name')
         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() == 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', '')
@@ -62,15 +81,15 @@ class EnhancedAIvsRealGazeAnalyzer:
         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'])]
+        # Convert all participant IDs to strings to prevent sorting errors
         self.participant_list = sorted([str(p) for p in self.combined_data[self.et_id_col].unique()])
-        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()
@@ -80,7 +99,6 @@ 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()
@@ -99,158 +117,133 @@ class EnhancedAIvsRealGazeAnalyzer:
         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 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
-
-        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
+    
+    def _recalculate_features_from_fixations(self, fixations_df):
+        """Helper to dynamically create a feature vector from a list of fixations."""
+        feature_vector = pd.Series(0.0, index=self.feature_names)
+        if fixations_df.empty:
+            return feature_vector.values.reshape(1, -1)
         
-        trial_data = trial_data_row.iloc[0]
-        actual_answer = trial_data['Answer_Correctness']
-        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}%)"
-
-        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)
+        # Recalculate duration-based features
+        if 'AOI name' in fixations_df.columns:
+            for aoi_name, group in fixations_df.groupby('AOI name'):
+                col_name = f'Total fixation duration on {aoi_name}'
+                if col_name in feature_vector.index:
+                    feature_vector[col_name] = group['Gaze event duration (ms)'].sum()
+        
+        feature_vector['Total Recording Duration'] = fixations_df['Gaze event duration (ms)'].sum()
         
-        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
+        return feature_vector.fillna(0).values.reshape(1, -1)
 
-        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')
+    def generate_gaze_playback(self, participant, question, fixation_num):
+        """Generates the gaze playback and real-time prediction dashboard."""
+        trial_key = (str(participant), question)
+        if not participant or not question or trial_key not in self.fixation_data:
+            return "Please select a valid trial with fixation data.", None, gr.Slider(interactive=False)
 
-        # --- 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]
+        all_fixations = self.fixation_data[trial_key]
+        fixation_num = int(fixation_num)
         
-        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)
+        slider_max = len(all_fixations)
+        if fixation_num > slider_max: fixation_num = slider_max
+        current_fixations = all_fixations.iloc[:fixation_num]
         
-        angles = np.linspace(0, 2*np.pi, len(labels), endpoint=False).tolist()
-        angles += angles[:1]
+        partial_features = self._recalculate_features_from_fixations(current_fixations)
+        prediction_prob = self.model.predict_proba(self.scaler.transform(partial_features))[0]
+        prob_correct = prediction_prob[1]
+
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8), gridspec_kw={'height_ratios': [4, 1]})
+        fig.suptitle(f"Gaze Playback for {participant} - {question}", fontsize=16, weight='bold')
+
+        ax1.set_title(f"Displaying Fixations 1 through {fixation_num}/{slider_max}")
+        ax1.set_xlim(0, 1920); ax1.set_ylim(1080, 0)
+        ax1.set_aspect('equal'); ax1.tick_params(left=False, right=False, bottom=False, top=False, labelleft=False, labelbottom=False)
+        ax1.add_patch(patches.Rectangle((0, 0), 1920/2, 1080, facecolor='black', alpha=0.05))
+        ax1.add_patch(patches.Rectangle((1920/2, 0), 1920/2, 1080, facecolor='blue', alpha=0.05))
+        ax1.text(1920*0.25, 50, "Image A", ha='center', fontsize=14, alpha=0.5)
+        ax1.text(1920*0.75, 50, "Image B", ha='center', fontsize=14, alpha=0.5)
+
+        if not current_fixations.empty:
+            points = current_fixations[['Fixation point X', 'Fixation point Y']]
+            ax1.plot(points['Fixation point X'], points['Fixation point Y'], marker='o', color='grey', alpha=0.5, linestyle='-')
+            ax1.scatter(points.iloc[-1]['Fixation point X'], points.iloc[-1]['Fixation point Y'], s=150, c='red', zorder=10, edgecolors='black')
+
+        ax2.set_xlim(0, 1); ax2.set_yticks([])
+        ax2.set_title("Live Prediction Confidence (Answer is 'Correct')")
+        bar_color = 'green' if prob_correct > 0.5 else 'red'
+        ax2.barh([0], [prob_correct], color=bar_color, height=0.5)
+        ax2.axvline(0.5, color='black', linestyle='--', linewidth=1)
+        ax2.text(prob_correct, 0, f" {prob_correct:.1%} ", va='center', ha='left' if prob_correct < 0.9 else 'right', color='white', weight='bold')
+
+        plt.tight_layout(rect=[0, 0, 1, 0.95])
         
-        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')
+        trial_info = self.combined_data[(self.combined_data[self.et_id_col].astype(str) == str(participant)) & (self.combined_data['Question'] == question)].iloc[0]
+        summary_text = f"**Actual Answer:** `{trial_info['Answer_Correctness']}`"
         
-        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
+        return summary_text, fig, gr.Slider(maximum=slider_max, value=fixation_num, interactive=True)
 
-# --- DATA SETUP ---
+# --- DATA SETUP & GRADIO APP ---
 def setup_and_load_data():
     repo_url = "https://github.com/RextonRZ/GenAIEyeTrackingCleanedDataset"
     repo_dir = "GenAIEyeTrackingCleanedDataset"
     if not os.path.exists(repo_dir): git.Repo.clone_from(repo_url, repo_dir)
-    else: print("Data repository already exists. Skipping clone.")
+    else: print("Data repository already exists.")
     base_path = repo_dir 
     response_file = os.path.join(repo_dir, "GenAI Response.xlsx")
     analyzer = EnhancedAIvsRealGazeAnalyzer().load_and_process_data(base_path, response_file)
     return analyzer
 
-print("Starting application setup...")
 analyzer = setup_and_load_data()
-print("Application setup complete. Ready for interaction.")
-
-# --- GRADIO INTERACTIVE FUNCTIONS ---
-def update_rq1_visuals(metric_choice):
-    return analyzer.analyze_rq1_metric(metric_choice)
 
-def update_rq2_model(test_size, n_estimators):
-    return analyzer.run_prediction_model(int(test_size*100)/100, int(n_estimators))
-
-def update_explorer_view(participant, question):
-    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.")
+    gr.Markdown("# Interactive Dashboard: AI vs. Real Gaze Analysis")
     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")
+                    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")
+                    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")
-                    rq2_test_size_slider = gr.Slider(minimum=0.1, maximum=0.5, step=0.05, value=0.3, label="Test Set Size")
-                    rq2_estimators_slider = gr.Slider(minimum=10, maximum=200, step=10, value=100, label="Number of Trees (n_estimators)")
+                    rq2_test_size_slider=gr.Slider(minimum=0.1, maximum=0.5, step=0.05, value=0.3, label="Test Set Size")
+                    rq2_estimators_slider=gr.Slider(minimum=10, maximum=200, step=10, value=100, label="Number of Trees")
                 with gr.Column(scale=2):
-                    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("🔬 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.")
+                    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("👁️ Gaze Playback & Real-Time Prediction"):
+            gr.Markdown("### See the Prediction Evolve with Every Glance!")
             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")
+                    playback_participant=gr.Dropdown(choices=analyzer.participant_list, label="Select Participant")
+                    playback_question=gr.Dropdown(choices=analyzer.questions, label="Select Question")
+                    gr.Markdown("Use the slider to play back fixations one by one.")
+                    playback_slider=gr.Slider(minimum=0, maximum=1, step=1, value=0, label="Fixation Number", interactive=False)
+                    playback_summary=gr.Markdown(label="Trial Info")
                 with gr.Column(scale=2):
-                    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]
+                    playback_plot=gr.Plot(label="Gaze Playback & Live Prediction")
 
-    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)
+    outputs_rq2 = [rq2_summary_output, rq2_table_output, rq2_plot_output]
+    outputs_playback = [playback_summary, playback_plot, playback_slider]
     
-    # 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)
+    rq1_metric_dropdown.change(fn=analyzer.analyze_rq1_metric, inputs=rq1_metric_dropdown, outputs=[rq1_plot_output, rq1_summary_output])
+    rq2_test_size_slider.release(fn=analyzer.run_prediction_model, inputs=[rq2_test_size_slider, rq2_estimators_slider], outputs=outputs_rq2)
+    rq2_estimators_slider.release(fn=analyzer.run_prediction_model, inputs=[rq2_test_size_slider, rq2_estimators_slider], outputs=outputs_rq2)
+    
+    playback_inputs = [playback_participant, playback_question, playback_slider]
+    # Reset slider to 0 when a new trial is selected
+    playback_participant.change(lambda: 0, None, playback_slider).then(fn=analyzer.generate_gaze_playback, inputs=playback_inputs, outputs=outputs_playback)
+    playback_question.change(lambda: 0, None, playback_slider).then(fn=analyzer.generate_gaze_playback, inputs=playback_inputs, outputs=outputs_playback)
+    playback_slider.release(fn=analyzer.generate_gaze_playback, inputs=playback_inputs, outputs=outputs_playback)
+
+    demo.load(fn=analyzer.analyze_rq1_metric, inputs=rq1_metric_dropdown, outputs=[rq1_plot_output, rq1_summary_output])
+    demo.load(fn=analyzer.run_prediction_model, inputs=[rq2_test_size_slider, rq2_estimators_slider], outputs=outputs_rq2)
 
 if __name__ == "__main__":
     demo.launch()