Update app.py

app.py

@@ -19,109 +19,169 @@ plt.style.use('default')
 sns.set_palette("husl")
 
 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.
+    """
     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.response_data = None
-        self.numeric_cols = []
-        self.time_metrics = []
+        self.participant_list = []
+        self.model = None
+        self.scaler = None
+        self.feature_names = []
+        self.group_means = None
+        self.et_id_col = 'Participant name' # Default participant ID column 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()
-        for pair, correct_answer 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)
+        
         all_data = {}
         for question in self.questions:
             file_path = f"{base_path}/Filtered_GenAI_Metrics_cleaned_{question}.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_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 or loaded.")
+        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()
-        et_id_col = next((c for c in self.combined_data.columns if 'participant' in c.lower()), None)
-        resp_id_col = next((c for c in self.response_data.columns if 'participant' in c.lower()), None)
+        
+        # Dynamically find participant ID columns
+        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():
+            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')
         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=[et_id_col, 'Pair'], right_on=[resp_id_col, 'Pair'], how='left')
+        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'])]
+        self.participant_list = sorted(self.combined_data[self.et_id_col].unique().tolist())
+        
+        # Pre-calculate group means for the explorer tab
+        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):
-        if metric not in self.combined_data.columns: return None, "Metric not found."
+        """Analyzes a single metric for RQ1."""
+        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()
         t_stat, p_val = stats.ttest_ind(incorrect, correct, equal_var=False, nan_policy='omit')
-        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 between the groups (p < 0.05).' if p_val < 0.05 else 'There is **no statistically significant** difference between the groups (p >= 0.05).'}"""
+        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 run_prediction_model(self, test_size, n_estimators):
-        leaky_features = ['Total_Correct', 'Overall_Accuracy', 'Correct']
-        features_to_use = [col for col in self.numeric_cols if col not in leaky_features]
-        features = self.combined_data[features_to_use].copy()
+        """Trains and evaluates the RandomForest model for RQ2."""
+        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()
         target = self.combined_data['Answer_Correctness'].map({'Correct': 1, 'Incorrect': 0})
         valid_indices = target.notna()
         features, target = features[valid_indices], target[valid_indices]
         features = features.fillna(features.median()).fillna(0)
-        if len(target.unique()) < 2: return "Not enough classes to train.", None, None
         X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=test_size, random_state=42, stratify=target)
-        scaler = StandardScaler()
-        X_train_scaled, X_test_scaled = scaler.fit_transform(X_train), scaler.transform(X_test)
-        model = RandomForestClassifier(n_estimators=n_estimators, random_state=42, class_weight='balanced')
-        model.fit(X_train_scaled, y_train)
-        y_pred = model.predict(X_test_scaled)
-        report = classification_report(y_test, y_pred, target_names=['Incorrect', 'Correct'], output_dict=True)
-        auc_score = roc_auc_score(y_test, model.predict_proba(X_test_scaled)[:, 1])
+        self.scaler = StandardScaler().fit(X_train)
+        X_train_scaled, X_test_scaled = self.scaler.transform(X_train), self.scaler.transform(X_test)
+        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])
+        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):
+        """Generates a detailed report for a single participant-question trial."""
+        if not participant or not question:
+            return "Please select a participant and a question.", None, None
+
+        trial_data = self.combined_data[(self.combined_data[self.et_id_col] == participant) & (self.combined_data['Question'] == question)]
+        if trial_data.empty:
+            return f"No data found for {participant} on {question}.", None, None
         
-        # --- THIS IS THE KEY FIX ---
-        # 1. Create the summary text separately.
+        trial_data = trial_data.iloc[0]
+        actual_answer = trial_data['Answer_Correctness']
+
+        # Model Prediction for this specific trial
+        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]
+        predicted_answer = "Correct" if prediction_prob[1] > 0.5 else "Incorrect"
+
+        # Summary Text
         summary_md = f"""
-        ### Model Performance
-        - **AUC Score:** **{auc_score:.4f}**
-        - **Overall Accuracy:** {report['accuracy']:.3f}
+        ### Trial Breakdown: **{participant}** on **{question}**
+        - **Actual Answer:** `{actual_answer}`
+        - **Model Prediction:** `{predicted_answer}` (Confidence: {max(prediction_prob)*100:.1f}%)
         """
-        # 2. Create the report DataFrame.
-        report_df = pd.DataFrame(report).transpose().round(3)
+
+        # A vs B Gaze Bias Plot
+        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])
         
-        # 3. Create the feature importance plot.
-        feature_importance = pd.DataFrame({'Feature': features.columns, 'Importance': model.feature_importances_})
-        feature_importance = feature_importance.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)
+        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()
+
+        # Feature Report Card
+        top_features = self.model.feature_importances_.argsort()[-5:][::-1]
+        top_feature_names = [self.feature_names[i] for i in top_features]
         
-        # 4. Return the three items separately.
-        return summary_md, report_df, fig
-        # --- END OF FIX ---
+        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
 
-# --- DATA SETUP ---
+# --- DATA SETUP (RUNS ONCE AT STARTUP) ---
 def setup_and_load_data():
+    """Clones the repo if not present and loads 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. Skipping clone.")
+        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)
@@ -133,26 +193,26 @@ 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 from the dropdown."
+    if not metric_choice: return None, "Please select a metric."
     plot, summary = analyzer.analyze_rq1_metric(metric_choice)
     return plot, summary
 
 def update_rq2_model(test_size, n_estimators):
     n_estimators = int(n_estimators)
-    # The function now returns three items
     summary, report_df, plot = analyzer.run_prediction_model(test_size, n_estimators)
     return summary, report_df, plot
 
-# --- GRADIO INTERFACE DEFINITION ---
-description = """
-# Interactive Dashboard: AI vs. Real Gaze Analysis
-Explore the eye-tracking dataset by interacting with the controls below. The data is automatically loaded from the public GitHub repository.
-"""
+def update_explorer_view(participant, question):
+    summary, plot, report_card = analyzer.analyze_individual_trial(participant, question)
+    return summary, plot, report_card
 
+# --- GRADIO INTERFACE DEFINITION ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown(description)
+    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.")
+    
     with gr.Tabs():
-        with gr.TabItem("RQ1: Viewing Time vs. Correctness"):
+        # --- TAB 1: RQ1 ---
+        with gr.TabItem("📊 RQ1: Viewing Time vs. Correctness"):
             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)
@@ -160,34 +220,48 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                 with gr.Column(scale=2):
                     rq1_plot_output = gr.Plot(label="Metric Comparison")
         
-        with gr.TabItem("RQ2: Predicting Correctness from Gaze"):
+        # --- TAB 2: RQ2 ---
+        with gr.TabItem("🤖 RQ2: Predicting Correctness from Gaze"):
             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)")
-                
-                # --- THIS IS THE KEY UI FIX ---
                 with gr.Column(scale=2):
-                    # 1. A Markdown component for the summary text.
                     rq2_summary_output = gr.Markdown(label="Model Performance Summary")
-                    # 2. A Dataframe component for the table.
                     rq2_table_output = gr.Dataframe(label="Classification Report", interactive=False)
-                    # 3. A Plot component for the chart.
                     rq2_plot_output = gr.Plot(label="Feature Importance")
-                # --- END OF UI FIX ---
-
-    # --- THIS IS THE KEY WIRING FIX ---
-    # The outputs list now has 3 items to match the 3 components
-    outputs_rq2 = [rq2_summary_output, rq2_table_output, rq2_plot_output]
+        
+        # --- TAB 3: INNOVATIVE EXPLORER ---
+        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.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)")
     
+    # --- WIRING FOR ALL TABS ---
+    outputs_rq2 = [rq2_summary_output, rq2_table_output, rq2_plot_output]
+    outputs_explorer = [explorer_summary, explorer_plot, explorer_report_card]
+
+    # Wiring for Tab 1
     rq1_metric_dropdown.change(fn=update_rq1_visuals, inputs=[rq1_metric_dropdown], outputs=[rq1_plot_output, rq1_summary_output])
+    
+    # Wiring for Tab 2
     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)
     
+    # Wiring for Tab 3
+    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)
+
+    # Load initial state for all tabs when the app starts
     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)
-    # --- END OF WIRING FIX ---
 
 if __name__ == "__main__":
     demo.launch()