Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py
+# app.py (Corrected Version)
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
@@ -16,13 +16,12 @@ import os
 import git
 
 # --- Main Class (Slightly Refactored for Interactivity) ---
-# The core logic remains, but we separate data loading from analysis functions.
 warnings.filterwarnings('ignore')
 plt.style.use('default')
 sns.set_palette("husl")
 
-
 class EnhancedAIvsRealGazeAnalyzer:
+    # ... (The entire class from before remains unchanged up to run_prediction_model) ...
     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'}
@@ -32,192 +31,128 @@ class EnhancedAIvsRealGazeAnalyzer:
         self.time_metrics = []
 
     def load_and_process_data(self, base_path, response_file):
-        """Loads all data and preprocesses it once."""
         print("Loading and processing data...")
-        # Load response data
-        self.response_data = pd.read_excel(response_file) if response_file.endswith('.xlsx') else pd.read_csv(
-            response_file)
+        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)
-
-        # Load eye-tracking data
+                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}
-
-        # Combine and merge
         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 or loaded.")
         self.combined_data = pd.concat(all_dfs, ignore_index=True)
         self.combined_data.columns = self.combined_data.columns.str.strip()
-
-        # Merge with responses
         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)
-
-        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')
+        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)}
+        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['Answer_Correctness'] = self.combined_data['Correct'].map(
-            {True: 'Correct', False: 'Incorrect'})
-
-        # Identify numeric and time columns for later use
+        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['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.time_metrics = [c for c in self.numeric_cols if any(k in c.lower() for k in ['time', 'duration', 'fixation'])]
         print("Data loading complete.")
-        return self  # Return self for chaining
+        return self
 
     def analyze_rq1_metric(self, metric):
-        """Analyzes a single metric for RQ1."""
-        if metric not in self.combined_data.columns:
-            return None, "Metric not found."
-
+        if 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()
-
-        # Perform t-test
         t_stat, p_val = stats.ttest_ind(incorrect, correct, equal_var=False, nan_policy='omit')
-
-        # Create plot
         fig, ax = plt.subplots(figsize=(8, 6))
-        sns.boxplot(data=self.combined_data, x='Answer_Correctness', y=metric, ax=ax, palette=['#66b3ff', '#ff9999'])
+        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()
-
-        # Create summary text
-        summary = f"""
-        ### Analysis for: **{metric}**
-        - **Mean (Correct Answers):** {correct.mean():.4f}
-        - **Mean (Incorrect Answers):** {incorrect.mean():.4f}
-        - **T-test p-value:** {p_val:.4f}
-
-        **Conclusion:**
-        - {'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).'}
-        """
+        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).'}"""
         return fig, summary
 
     def run_prediction_model(self, test_size, n_estimators):
         """Runs the RandomForest model with given parameters for RQ2."""
         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()
         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 the model.", None
-
-        X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=test_size, random_state=42,
-                                                            stratify=target)
+        if len(target.unique()) < 2: return "Not enough classes to train the model.", 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_proba = model.predict_proba(X_test_scaled)[:, 1]
         y_pred = model.predict(X_test_scaled)
-
-        # Generate results
         report = classification_report(y_test, y_pred, target_names=['Incorrect', 'Correct'], output_dict=True)
         auc_score = roc_auc_score(y_test, y_pred_proba)
-
+        
+        # --- CHANGE 1: Use tabulate to create a clean markdown table ---
         report_df = pd.DataFrame(report).transpose().round(3)
+        report_table = tabulate(report_df, headers='keys', tablefmt='pipe')
+
         report_md = f"""
         ### Model Performance
         - **AUC Score:** **{auc_score:.4f}**
         - **Overall Accuracy:** {report['accuracy']:.3f}
-
+        
         **Classification Report:**
-        {report_df.to_markdown()}
+        {report_table}
         """
 
-        # 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)
         plt.tight_layout()
-
         return report_md, fig
 
-
 # --- 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 exists.")
-        
-    # --- THIS IS THE CORRECTED PART ---
-    # The data files are in the main repo directory, not a subfolder
     base_path = repo_dir 
-    # The response file is also in the main directory and has a different name
     response_file = os.path.join(repo_dir, "GenAI Response.xlsx")
-    # --- END OF CORRECTION ---
-    
     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):
-    """Called by Gradio when the dropdown for RQ1 changes."""
-    if not metric_choice:
-        return None, "Please select a metric from the dropdown."
+    if not metric_choice: return None, "Please select a metric from the dropdown."
     plot, summary = analyzer.analyze_rq1_metric(metric_choice)
     return plot, summary
 
-
 def update_rq2_model(test_size, n_estimators):
-    """Called by Gradio when sliders for RQ2 change."""
-    n_estimators = int(n_estimators)  # Ensure it's an integer
+    n_estimators = int(n_estimators)
     report, plot = analyzer.run_prediction_model(test_size, n_estimators)
     return report, 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.
 """
 
+# --- CHANGE 2: Restructure the layout with columns ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown(description)
 
@@ -234,10 +169,11 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     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"):
             gr.Markdown("### Can we build a model to predict answer correctness from gaze patterns?")
             with gr.Row():
+                # --- LEFT COLUMN FOR CONTROLS ---
                 with gr.Column(scale=1):
                     gr.Markdown("#### Tune Model Hyperparameters")
                     rq2_test_size_slider = gr.Slider(
@@ -246,40 +182,19 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     rq2_estimators_slider = gr.Slider(
                         minimum=10, maximum=200, step=10, value=100, label="Number of Trees (n_estimators)"
                     )
-                    rq2_report_output = gr.Markdown(label="Model Performance Report")
+                # --- RIGHT COLUMN FOR OUTPUTS ---
                 with gr.Column(scale=2):
+                    rq2_report_output = gr.Markdown(label="Model Performance Report") # Use gr.Markdown
                     rq2_plot_output = gr.Plot(label="Feature Importance")
 
     # Wire up the interactive components
-    rq1_metric_dropdown.change(
-        fn=update_rq1_visuals,
-        inputs=[rq1_metric_dropdown],
-        outputs=[rq1_plot_output, rq1_summary_output]
-    )
-
-    # Use .release to only update when the user lets go of the slider
-    rq2_test_size_slider.release(
-        fn=update_rq2_model,
-        inputs=[rq2_test_size_slider, rq2_estimators_slider],
-        outputs=[rq2_report_output, rq2_plot_output]
-    )
-    rq2_estimators_slider.release(
-        fn=update_rq2_model,
-        inputs=[rq2_test_size_slider, rq2_estimators_slider],
-        outputs=[rq2_report_output, rq2_plot_output]
-    )
-
+    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=[rq2_report_output, rq2_plot_output])
+    rq2_estimators_slider.release(fn=update_rq2_model, inputs=[rq2_test_size_slider, rq2_estimators_slider], outputs=[rq2_report_output, rq2_plot_output])
+    
     # 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=[rq2_report_output, rq2_plot_output]
-    )
+    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=[rq2_report_output, rq2_plot_output])
 
 if __name__ == "__main__":
     demo.launch()