Update app.py

app.py

@@ -29,85 +29,80 @@ class EnhancedAIvsRealGazeAnalyzer:
         self.model = None
         self.scaler = None
         self.feature_names = []
-        self.et_id_col = 'Participant name'
 
-    def load_and_process_data(self, base_path, response_file):
-        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()
+    def _find_and_standardize_participant_col(self, df, filename):
+        """Finds, renames, and type-converts the participant ID column."""
+        participant_col = next((c for c in df.columns if 'participant' in str(c).lower()), None)
+        if not participant_col:
+            raise ValueError(f"Could not find a 'participant' column in the file: {filename}")
+        df.rename(columns={participant_col: 'participant_id'}, inplace=True)
+        df['participant_id'] = df['participant_id'].astype(str)
+        return df
+
+    def load_and_process_data(self, base_path, response_file_path):
+        print("--- Starting Robust Data Loading ---")
+        # 1. Load and Standardize Response Data
+        print("Loading response sheet...")
+        response_df = pd.read_excel(response_file_path)
+        response_df = self._find_and_standardize_participant_col(response_df, "GenAI Response.xlsx")
+        for pair, ans in self.correct_answers.items():
+            if pair in response_df.columns:
+                response_df[f'{pair}_Correct'] = (response_df[pair].astype(str).str.strip().str.upper() == ans)
         
+        response_long = response_df.melt(id_vars=['participant_id'], value_vars=self.correct_answers.keys(), var_name='Pair')
+        correctness_long = response_df.melt(id_vars=['participant_id'], 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[['participant_id', 'Pair', 'Correct']], on=['participant_id', 'Pair'])
+
+        # 2. Load and Standardize Metrics & Fixation 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"
+            print(f"Processing {file_path}...")
             if os.path.exists(file_path):
                 xls = pd.ExcelFile(file_path)
+                
+                # Metrics Data
                 metrics_df = pd.read_excel(xls, 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)
                 
+                # Fixation Data
                 if 'Fixation-based AOI' in xls.sheet_names:
                     fix_df = pd.read_excel(xls, sheet_name='Fixation-based AOI')
-                    fix_df['Question'] = q
+                    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)
-                    # Use a local variable here to avoid confusion
-                    fix_et_id_col = next((c for c in fix_df.columns if 'participant' in c.lower()), None)
-                    if fix_et_id_col:
-                        for participant, group in fix_df.groupby(fix_et_id_col):
-                            self.fixation_data[(str(participant), q)] = group.reset_index(drop=True)
-        
+                    fix_df['Question'] = q
+                    for participant, group in fix_df.groupby('participant_id'):
+                        self.fixation_data[(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()
-        
-        # --- THIS IS THE KEY FIX ---
-        # 1. Dynamically find the participant ID column in the COMBINED metrics data.
-        self.et_id_col = next((c for c in self.combined_data.columns if 'participant' in c.lower()), None)
-        if not self.et_id_col: raise KeyError("Could not find a 'participant' column in the aggregated metrics data.")
-
-        # 2. Dynamically find the participant ID column in the RESPONSE data.
-        resp_id_col = next((c for c in self.response_data.columns if 'participant' in c.lower()), None)
-        if not resp_id_col: raise KeyError("Could not find a 'participant' column in the response sheet.")
-        # --- END OF FIX ---
-
-        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', '')
-        response_long = response_long.merge(correctness_long[[resp_id_col, 'Pair', 'Correct']], on=[resp_id_col, 'Pair'])
+        # 3. Merge with Confidence
+        print("Merging all data sources...")
         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)
-        
-        # 3. Perform the merge using the correctly identified column names.
-        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 = self.combined_data.merge(response_long, on=['participant_id', 'Pair'], how='left')
         self.combined_data['Answer_Correctness'] = self.combined_data['Correct'].map({True: 'Correct', False: 'Incorrect'})
         
+        # 4. Finalize class attributes
         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([str(p) for p in self.combined_data[self.et_id_col].unique()])
-        print("Data loading complete.")
+        self.participant_list = sorted(self.combined_data['participant_id'].unique().tolist())
+        print("--- Data Loading Successful ---")
         return self
 
-    def analyze_rq1_metric(self, metric):
-        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 (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', self.et_id_col]
+        leaky_features = ['Total_Correct', 'Overall_Accuracy', 'Correct', 'participant_id']
         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 data to train model.", None, None
         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 = self.scaler.transform(X_train)
@@ -119,7 +114,7 @@ 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 _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)
@@ -163,9 +158,20 @@ class EnhancedAIvsRealGazeAnalyzer:
         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])
-        trial_info = self.combined_data[(self.combined_data[self.et_id_col].astype(str) == str(participant)) & (self.combined_data['Question'] == question)].iloc[0]
+        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)
+    
+    def analyze_rq1_metric(self, metric): # Added this back just in case
+        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()
+        incorrect = self.combined_data.loc[self.combined_data['Answer_Correctness'] == 'Incorrect', metric].dropna()
+        if len(correct) < 2 or len(incorrect) < 2: return None, "Not enough data for both groups to compare."
+        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 (p < 0.05).' if p_val < 0.05 else 'There is **no statistically significant** difference (p >= 0.05).'}"""
+        return fig, summary
+
 
 # --- DATA SETUP & GRADIO APP ---
 def setup_and_load_data():
@@ -174,8 +180,8 @@ def setup_and_load_data():
     if not os.path.exists(repo_dir): git.Repo.clone_from(repo_url, repo_dir)
     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)
+    response_file_path = os.path.join(repo_dir, "GenAI Response.xlsx")
+    analyzer = EnhancedAIvsRealGazeAnalyzer().load_and_process_data(base_path, response_file_path)
     return analyzer
 
 analyzer = setup_and_load_data()