Update app.py

app.py

@@ -1,8 +1,7 @@
-# app.py (Corrected and Ready to Run)
+# app.py 
 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
@@ -24,13 +23,11 @@ class EnhancedAIvsRealGazeAnalyzer:
         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 = {}
-        self.valid_playback_participants = []
-        self.valid_playback_trials = {}
         self.model = None
         self.scaler = None
         self.feature_names = []
-        self.time_metrics = [] # Initialize here
+        self.time_metrics = []
+        self.numeric_cols = []
 
     def _find_and_standardize_participant_col(self, df, filename):
         participant_col = next((c for c in df.columns if 'participant' in str(c).lower()), None)
@@ -57,25 +54,10 @@ class EnhancedAIvsRealGazeAnalyzer:
             file_path = f"{base_path}/Filtered_GenAI_Metrics_cleaned_{q}.xlsx"
             if os.path.exists(file_path):
                 print(f"Processing {file_path}...")
-                xls = pd.ExcelFile(file_path)
-                metrics_df = pd.read_excel(xls, sheet_name=0)
+                metrics_df = pd.read_excel(file_path, sheet_name=0)
                 metrics_df = self._find_and_standardize_participant_col(metrics_df, f"{q} Metrics")
                 metrics_df['Question'] = q
                 all_metrics_dfs.append(metrics_df)
-                
-                if len(xls.sheet_names) > 1:
-                    try:
-                        fix_df = pd.read_excel(xls, sheet_name=1)
-                        fix_df = self._find_and_standardize_participant_col(fix_df, f"{q} Fixations")
-                        fix_df.dropna(subset=['Fixation point X', 'Fixation point Y', 'Gaze event duration (ms)'], inplace=True)
-                        for participant_id, group in fix_df.groupby('participant_id'):
-                            self.fixation_data[(participant_id, q)] = group.reset_index(drop=True)
-                            if participant_id not in self.valid_playback_trials:
-                                self.valid_playback_trials[participant_id] = []
-                            self.valid_playback_trials[participant_id].append(q)
-                        print(f"  -> Successfully loaded {len(fix_df)} fixations for {q}.")
-                    except Exception as e:
-                        print(f"  -> WARNING: Could not load fixation sheet for {q}. Error: {e}")
 
         if not all_metrics_dfs: raise ValueError("No aggregated metrics files were found.")
         self.combined_data = pd.concat(all_metrics_dfs, ignore_index=True)
@@ -85,12 +67,9 @@ class EnhancedAIvsRealGazeAnalyzer:
         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()
-        
-        # <<< FIX: Removed the space in the variable name here >>>
         self.time_metrics = [c for c in self.numeric_cols if any(k in c.lower() for k in ['time', 'duration', 'fixation'])]
         
-        self.valid_playback_participants = sorted(list(self.valid_playback_trials.keys()))
-        print(f"--- Data Loading Successful. Found {len(self.valid_playback_participants)} participants with fixation data. ---")
+        print(f"--- Data Loading Successful ---")
         return self
 
     def run_prediction_model(self, test_size, n_estimators):
@@ -111,62 +90,10 @@ class EnhancedAIvsRealGazeAnalyzer:
         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={int(n_estimators)})', fontsize=14); plt.tight_layout()
-        return summary_md, report_df, fig, gr.Markdown("✅ **Model is ready!** You can now use the Gaze Playback tab.")
-
-    def _recalculate_features_from_fixations(self, fixations_df):
-        feature_vector = pd.Series(0.0, index=self.feature_names)
-        if fixations_df.empty: return feature_vector.fillna(0).values.reshape(1, -1)
-        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()
-        return feature_vector.fillna(0).values.reshape(1, -1)
-
-    def generate_gaze_playback(self, participant, question, fixation_num):
-        if self.model is None: return "Please train a model in Tab 2 first.", None, gr.Slider(interactive=False)
-        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.", None, gr.Slider(interactive=False, value=0)
-        
-        all_fixations = self.fixation_data[trial_key]
-        fixation_num = int(fixation_num)
-        slider_max = len(all_fixations)
-        if fixation_num > slider_max: fixation_num = slider_max
-        current_fixations = all_fixations.iloc[:fixation_num]
-        
-        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='#e0e0e0'))
-        ax1.add_patch(patches.Rectangle((1920/2, 0), 1920/2, 1080, facecolor='#f0f0f0'))
-        ax1.text(1920*0.25, 50, "Image A", ha='center', fontsize=14, alpha=0.7)
-        ax1.text(1920*0.75, 50, "Image B", ha='center', fontsize=14, alpha=0.7)
-        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=200, c='red', zorder=10, edgecolors='black', lw=2)
         
-        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, edgecolor='black')
-        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', fontsize=12)
-        plt.tight_layout(rect=[0, 0, 1, 0.95])
-        
-        trial_info = self.combined_data[(self.combined_data['participant_id'] == str(participant)) & (self.combined_data['Question'] == question)].iloc[0]
-        summary_text = f"**Actual Answer:** `{trial_info['Answer_Correctness']}`"
-        
-        return summary_text, fig, gr.Slider(maximum=slider_max, value=fixation_num, interactive=True, step=1, minimum=0)
-    
+        # <<< FIX: Updated status message >>>
+        return summary_md, report_df, fig, gr.Markdown("✅ **Model trained successfully.**")
+
     def analyze_rq1_metric(self, metric):
         if not metric or metric not in self.combined_data.columns: return None, "Metric not found."
         correct = self.combined_data.loc[self.combined_data['Answer_Correctness'] == 'Correct', metric].dropna()
@@ -176,18 +103,6 @@ class EnhancedAIvsRealGazeAnalyzer:
         fig, ax = plt.subplots(figsize=(8, 6)); sns.boxplot(data=self.combined_data, x='Answer_Correctness', y=metric, ax=ax, palette=['#66b3ff','#ff9999']); ax.set_title(f'Comparison of "{metric}" by Answer Correctness', fontsize=14); ax.set_xlabel("Answer Correctness"); ax.set_ylabel(metric); plt.tight_layout()
         summary = f"""### Analysis for: **{metric}**\n- **Mean (Correct Answers):** {correct.mean():.4f}\n- **Mean (Incorrect Answers):** {incorrect.mean():.4f}\n- **T-test p-value:** {p_val:.4f}\n\n**Conclusion:**\n- {'There is a **statistically significant** difference (p < 0.05).' if p_val < 0.05 else 'There is **no statistically significant** difference (p >= 0.05).'}"""
         return fig, summary
-    
-    def update_question_dropdown(self, participant):
-        """Dynamically updates the question dropdown based on the selected participant."""
-        valid_questions = self.valid_playback_trials.get(participant, [])
-        return gr.Dropdown(choices=sorted(valid_questions), interactive=True, value=None, label="2. Select a Question")
-
-    def handle_new_trial_selection(self, participant, question):
-        """Called when a new trial is selected. Resets the view to the first fixation."""
-        if not participant or not question:
-            return "Select a trial to begin.", None, gr.Slider(value=0, interactive=False)
-        initial_fixation_num = 1
-        return self.generate_gaze_playback(participant, question, initial_fixation_num)
 
 # --- DATA SETUP & GRADIO APP ---
 def setup_and_load_data():
@@ -222,60 +137,26 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     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")
-                    rq2_status = gr.Markdown("Train a model to enable the Gaze Playback tab.")
+                    # <<< FIX: Updated initial status message >>>
+                    rq2_status = gr.Markdown("Train a model to see performance metrics.")
                 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("👁️ Gaze Playback & Real-Time Prediction"):
-            gr.Markdown("### See the Prediction Evolve with Every Glance!")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    playback_participant=gr.Dropdown(choices=analyzer.valid_playback_participants, label="1. Select a Participant")
-                    playback_question=gr.Dropdown(choices=[], label="2. Select a Question", interactive=False)
-                    gr.Markdown("3. 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):
-                    playback_plot=gr.Plot(label="Gaze Playback & Live Prediction")
-
     # --- WIRING FOR ALL TABS ---
     outputs_rq2 = [rq2_summary_output, rq2_table_output, rq2_plot_output, rq2_status]
-    outputs_playback = [playback_summary, playback_plot, playback_slider]
     
     rq1_metric_dropdown.change(fn=analyzer.analyze_rq1_metric, inputs=rq1_metric_dropdown, outputs=[rq1_plot_output, rq1_summary_output])
     
-    train_event = rq2_test_size_slider.release(fn=analyzer.run_prediction_model, inputs=[rq2_test_size_slider, rq2_estimators_slider], outputs=outputs_rq2)
+    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_participant.change(
-        fn=analyzer.update_question_dropdown, 
-        inputs=playback_participant, 
-        outputs=playback_question
-    )
-
-    playback_question.change(
-        fn=analyzer.handle_new_trial_selection, 
-        inputs=[playback_participant, playback_question], 
-        outputs=outputs_playback
-    )
-    
-    playback_slider.release(
-        fn=analyzer.generate_gaze_playback, 
-        inputs=[playback_participant, playback_question, playback_slider], 
-        outputs=outputs_playback
-    )
 
     # Pre-load the initial state of the dashboard
     def initial_load():
-        # Load the first tab's content
         rq1_fig, rq1_summary = analyzer.analyze_rq1_metric(analyzer.time_metrics[0] if analyzer.time_metrics else None)
-        
-        # Train the initial model for the second tab
         model_summary, report_df, feature_fig, status_md = analyzer.run_prediction_model(0.3, 100)
         
-        # Return all the values needed to populate the outputs on load
         return {
             rq1_plot_output: rq1_fig,
             rq1_summary_output: rq1_summary,