Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Final_similarity_matrix.csv filter=lfs diff=lfs merge=lfs -text
+Final_similarity_matrix2.csv filter=lfs diff=lfs merge=lfs -text
+overall_database.csv filter=lfs diff=lfs merge=lfs -text

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

Final_similarity_matrix.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ff83586ea8a37e91968eb0b73f23edebd61fdd88f815bef34a0f727c6d5ef35
+size 39820273

Final_similarity_matrix2.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cdd2d60df4ebd8de7533d82f7df5d4f8733d06134c641795d2f014c5de561b2
+size 64812304

README.md

@@ -1,12 +1,6 @@
 ---
-title: Similarity Analysis
-emoji: 🔥
-colorFrom: green
-colorTo: pink
-sdk: gradio
-sdk_version: 5.46.0
+title: similarity_analysis
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 5.45.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,323 @@
+# ==================== main.py ====================
+"""Main application orchestrator"""
+
+import sys
+import os
+
+# Add project root to path for imports
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from data.data_loader import DataLoader
+from brain.roi_analyzer import ROIAnalyzer
+from visualization.plot_generator import PlotGenerator
+from visualization.image_viewer import ImageViewer
+from gui.gradio_interface import GradioInterface
+from typing import Tuple, Optional, Union, Dict, Any
+import pandas as pd
+
+class SimilarityApp:
+    """Main application class that orchestrates all components"""
+    
+    def __init__(self, csv_path: str):
+        # Initialize all components
+        self.data_loader = DataLoader()
+        self.plot_generator = PlotGenerator(self.data_loader)
+        self.image_viewer = ImageViewer()
+        self.roi_analyzer = ROIAnalyzer()
+        self.gui = GradioInterface(self)
+        
+        # Load data
+        if not self.data_loader.load_csv(csv_path):
+            raise ValueError("Failed to load data")
+    
+    def update_plots(self, brain_measure: str, ml_model_selection: Union[str, int]) -> Tuple[Optional[Any], Optional[Any]]:
+        """Update both 3D and 2D plots"""
+        try:
+            # Get model data and name
+            ml_data, ml_name = self.plot_generator.get_model_data(ml_model_selection)
+            
+            # Store current model for image viewer
+            self.set_current_model(ml_model_selection, ml_name)
+            
+            fig_3d = self.plot_generator.create_3d_plot(brain_measure, ml_model_selection)
+            fig_2d = self.plot_generator.create_2d_plots(brain_measure, ml_model_selection)
+            return fig_3d, fig_2d
+        except Exception as e:
+            print(f"Error updating plots: {e}")
+            return None, None
+    
+    def get_correlations(self, brain_measure: str, ml_model_selection: Union[str, int]) -> str:
+        """Get correlation statistics with min/max ranges"""
+        try:
+            data = self.data_loader.data
+            ml_data, ml_name = self.plot_generator.get_model_data(ml_model_selection)
+            
+            corr_hb = data['human_judgement'].corr(data[brain_measure])
+            corr_hm = data['human_judgement'].corr(ml_data)
+            corr_bm = data[brain_measure].corr(ml_data)
+            
+            brain_name = brain_measure.replace('cosine_similarity_roi_values_', '').replace('pearson_correlation_roi_values_', '').title()
+            measure_type = "Cosine" if "cosine" in brain_measure else "Pearson"
+            
+            # Calculate min/max correlations across all models for comparison
+            all_human_ml_corrs = []
+            all_brain_ml_corrs = []
+            for model_col in self.data_loader.ml_models:
+                human_ml_corr = data['human_judgement'].corr(data[model_col])
+                brain_ml_corr = data[brain_measure].corr(data[model_col])
+                all_human_ml_corrs.append(human_ml_corr)
+                all_brain_ml_corrs.append(brain_ml_corr)
+            
+            min_human_ml = min(all_human_ml_corrs)
+            max_human_ml = max(all_human_ml_corrs)
+            min_brain_ml = min(all_brain_ml_corrs)
+            max_brain_ml = max(all_brain_ml_corrs)
+            
+            stats_text = f"""## Current Analysis
+
+### Correlation Results
+| Comparison | Correlation |
+|------------|-------------|
+| Human ↔ Brain ({measure_type}) | **{corr_hb:.3f}** |
+| Human ↔ ML Model | **{corr_hm:.3f}** |  
+| Brain ({measure_type}) ↔ ML Model | **{corr_bm:.3f}** |
+
+### Dataset Correlation Ranges
+| Comparison | Min | Max |
+|------------|-----|-----|
+| Human ↔ All ML Models | {min_human_ml:.3f} | {max_human_ml:.3f} |
+| Brain ({measure_type}) ↔ All ML Models | {min_brain_ml:.3f} | {max_brain_ml:.3f} |
+
+### Dataset Information
+- **Total Image Pairs:** {len(data):,}
+- **Available ML Models:** {len(self.data_loader.ml_models)}
+- **Brain Measure:** {measure_type} {brain_name}
+            """
+            return stats_text
+        except Exception as e:
+            return f"**Error:** {e}"
+    
+    def get_model_rankings_for_pair(self, row_index: int) -> Dict[str, Dict[str, list]]:
+        """Get top 3 best and worst models for each category for a specific image pair"""
+        try:
+            data = self.data_loader.data
+            if row_index >= len(data):
+                return {}
+            
+            row = data.iloc[row_index]
+            rankings = {}
+            
+            # Get rankings for each category
+            for category in ['vision', 'language', 'semantic']:
+                if not self.data_loader.model_categories[category]:
+                    continue
+                
+                # Get all models in this category with their scores
+                category_models = [model[0] for model in self.data_loader.model_categories[category]]
+                model_scores = [(model, row[model]) for model in category_models]
+                
+                # Sort by score (highest first)
+                model_scores.sort(key=lambda x: x[1], reverse=True)
+                
+                # Get top 3 and bottom 3
+                top_3 = model_scores[:3]
+                bottom_3 = model_scores[-3:]
+                
+                rankings[category] = {
+                    'best': top_3,
+                    'worst': bottom_3
+                }
+            
+            return rankings
+        except Exception as e:
+            print(f"Error getting model rankings: {e}")
+            return {}
+    
+    def show_image_pair(self, row_index: int) -> Tuple[Optional[Any], Optional[Any], str, Optional[Any]]:
+        """Show specific image pair with details, captions, and model rankings"""
+        try:
+            data = self.data_loader.data
+            if row_index >= len(data):
+                return None, None, "Invalid row index", None
+            
+            row = data.iloc[row_index]
+            img1, img2 = self.image_viewer.get_image_pair(data, row_index)
+            
+            # Calculate model averages if not already present
+            if 'avg_vision' not in data.columns:
+                vision_models = [col for col in data.columns if 'BOLD5000_timm_' in col]
+                language_models = [col for col in data.columns if 'bert-' in col or 'deberta-' in col or 'sup-simcse' in col]
+                semantic_models = [col for col in data.columns if any(x in col for x in ["bm25", "rouge", "tf-idf", "co-occurrence"])]
+                
+                # Normalize each model to 0-1 scale before averaging
+                def normalize_models(model_list):
+                    if not model_list:
+                        return pd.Series([0] * len(data))
+                    
+                    normalized_data = []
+                    for model in model_list:
+                        if model in data.columns:
+                            model_data = data[model]
+                            # Normalize to 0-1 scale: (x - min) / (max - min)
+                            normalized = (model_data - model_data.min()) / (model_data.max() - model_data.min())
+                            normalized_data.append(normalized)
+                    
+                    if normalized_data:
+                        return pd.concat(normalized_data, axis=1).mean(axis=1)
+                    else:
+                        return pd.Series([0] * len(data))
+                
+                data['avg_vision'] = normalize_models(vision_models)
+                data['avg_language'] = normalize_models(language_models) 
+                data['avg_semantic'] = normalize_models(semantic_models)
+            
+            # Get model rankings for this specific pair
+            rankings = self.get_model_rankings_for_pair(row_index)
+            
+            # Get captions
+            caption1 = row.get('image_1_description', 'No caption available')
+            caption2 = row.get('image_2_description', 'No caption available')
+            
+            # Get current ML model selection if available
+            current_ml_model = getattr(self, '_current_ml_model', None)
+            current_ml_name = getattr(self, '_current_ml_name', 'No model selected')
+            current_ml_score = 'N/A'
+            
+            if current_ml_model is not None:
+                try:
+                    if isinstance(current_ml_model, int) and current_ml_model < len(self.data_loader.ml_models):
+                        ml_column = self.data_loader.ml_models[current_ml_model]
+                        current_ml_score = f"{row[ml_column]:.3f}"
+                    elif isinstance(current_ml_model, str) and current_ml_model.startswith('avg_'):
+                        # Handle average models
+                        current_ml_score = f"{row[current_ml_model]:.3f}"
+                except Exception:
+                    pass
+            
+            info_text = f"""## Image Pair #{row_index}
+            
+**Images:** `{row['image_1']}` vs `{row['image_2']}`
+
+### Image Captions
+**Image 1:** {caption1}
+
+**Image 2:** {caption2}
+
+### Similarity Scores
+
+<div style="display: flex; gap: 20px;">
+
+<div style="flex: 1;">
+
+**Human & Brain Measures**
+| Measure | Score |
+|---------|-------|
+| Human Rating | {row['human_judgement']:.3f}/6 |
+| Brain (Cosine Common) | {row.get('cosine_similarity_roi_values_common', 0):.3f} |
+| Brain (Cosine Early) | {row.get('cosine_similarity_roi_values_early', 0):.3f} |
+| Brain (Cosine Late) | {row.get('cosine_similarity_roi_values_late', 0):.3f} |
+
+</div>
+
+<div style="flex: 1;">
+
+**Brain Correlations & ML Models**
+| Measure | Score |
+|---------|-------|
+| Brain (Pearson Common) | {row.get('pearson_correlation_roi_values_common', 0):.3f} |
+| Brain (Pearson Early) | {row.get('pearson_correlation_roi_values_early', 0):.3f} |
+| Brain (Pearson Late) | {row.get('pearson_correlation_roi_values_late', 0):.3f} |
+| **Current ML Model** | **{current_ml_score}** |
+
+</div>
+
+</div>
+
+### Model Category Averages
+<div style="display: flex; gap: 20px;">
+
+<div style="flex: 1;">
+
+**Average Similarities**
+| Model Category | Score |
+|----------------|-------|
+| Vision Models | {row.get('avg_vision', 0):.3f} |
+| Language Models | {row.get('avg_language', 0):.3f} |
+| Semantic Models | {row.get('avg_semantic', 0):.3f} |
+
+</div>
+
+<div style="flex: 1;">
+
+**Model Information**
+- **Current Selection:** {current_ml_name}
+- **Total Vision Models:** {len([col for col in data.columns if 'BOLD5000_timm_' in col])}
+- **Total Language Models:** {len([col for col in data.columns if 'bert-' in col or 'deberta-' in col or 'sup-simcse' in col])}
+- **Total Semantic Models:** {len([col for col in data.columns if any(x in col for x in ["bm25", "rouge", "tf-idf", "co-occurrence"])])}
+
+</div>
+
+</div>
+
+"""
+            
+            # Add model rankings for each category in a more compact format
+            for category in ['vision', 'language', 'semantic']:
+                if category in rankings:
+                    category_name = category.title()
+                    info_text += f"### {category_name} Models\n"
+                    info_text += "<div style='display: flex; gap: 20px;'>\n"
+                    
+                    # Best models column
+                    info_text += "<div style='flex: 1;'>\n**Top 3 Best:**\n"
+                    for i, (model, score) in enumerate(rankings[category]['best'], 1):
+                        clean_name = model.replace('BOLD5000_timm_', '').replace('_sim_partial', '') if 'BOLD5000_timm_' in model else model
+                        info_text += f"{i}. {clean_name}: {score:.3f}\n"
+                    info_text += "</div>\n"
+                    
+                    # Worst models column
+                    info_text += "<div style='flex: 1;'>\n**Top 3 Worst:**\n"
+                    for i, (model, score) in enumerate(rankings[category]['worst'], 1):
+                        clean_name = model.replace('BOLD5000_timm_', '').replace('_sim_partial', '') if 'BOLD5000_timm_' in model else model
+                        info_text += f"{i}. {clean_name}: {score:.3f}\n"
+                    info_text += "</div>\n"
+                    
+                    info_text += "</div>\n\n"
+            
+            # Create ROI comparison plot
+            roi_plot = self.roi_analyzer.create_roi_comparison_plot(data, row_index)
+            
+            return img1, img2, info_text, roi_plot
+            
+        except Exception as e:
+            return None, None, f"**Error:** {e}", None
+    
+    def set_current_model(self, ml_model_selection, ml_name):
+        """Store the current ML model selection for display in image viewer"""
+        self._current_ml_model = ml_model_selection
+        self._current_ml_name = ml_name
+    
+    def launch(self, **kwargs):
+        """Launch the Gradio interface"""
+        interface = self.gui.create_interface()
+        interface.launch(**kwargs)
+
+
+def main():
+    """Main function to run the application"""
+    try:
+        # Create and launch the app
+        app = SimilarityApp('overall_database.csv')
+        app.launch(
+            server_name="localhost",
+            server_port=7860,
+            share=True,
+            debug=True
+        )
+        
+    except Exception as e:
+        print(f"Error starting application: {e}")
+
+
+if __name__ == "__main__":
+    main()

brain/roi_analyzer.py

@@ -0,0 +1,111 @@
+# brain/roi_analyzer.py
+"""Brain ROI analysis and visualization"""
+
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from typing import Optional, Tuple
+import sys
+import os
+
+# Add parent directory to path for config imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from config.roi_config import ROIConfig
+
+class ROIAnalyzer:
+    """Handles ROI data analysis and visualization"""
+    
+    @staticmethod
+    def parse_roi_values(roi_string) -> Optional[np.ndarray]:
+        """Parse ROI values from string format"""
+        try:
+            if pd.isna(roi_string) or roi_string == '':
+                return None
+            # Remove brackets and split by spaces or commas
+            roi_string = roi_string.strip('[]')
+            values = [float(x) for x in roi_string.replace(',', ' ').split() if x.strip()]
+            return np.array(values)
+        except Exception as e:
+            print(f"Error parsing ROI values: {e}")
+            return None
+    
+    @staticmethod
+    def calculate_roi_similarities(roi1: np.ndarray, roi2: np.ndarray) -> Tuple[float, float]:
+        """Calculate cosine and Pearson similarities between ROI vectors"""
+        cosine_sim = np.dot(roi1, roi2) / (np.linalg.norm(roi1) * np.linalg.norm(roi2))
+        pearson_sim = np.corrcoef(roi1, roi2)[0, 1]
+        return cosine_sim, pearson_sim
+    
+    def create_roi_comparison_plot(self, data: pd.DataFrame, row_index: int) -> Optional[go.Figure]:
+        """Create side-by-side bar plots comparing ROI values"""
+        try:
+            if row_index >= len(data):
+                return None
+            
+            row = data.iloc[row_index]
+            
+            # Parse ROI values for both images
+            roi1 = self.parse_roi_values(row.get('image_1_roi_values', ''))
+            roi2 = self.parse_roi_values(row.get('image_2_roi_values', ''))
+            
+            if roi1 is None or roi2 is None:
+                return None
+            
+            # Ensure both arrays have the same length
+            min_len = min(len(roi1), len(roi2))
+            roi1 = roi1[:min_len]
+            roi2 = roi2[:min_len]
+            
+            # Get proper ROI labels
+            roi_labels = ROIConfig.COMMON_ROIS[:min_len]
+            
+            # Create subplot
+            fig = make_subplots(
+                rows=1, cols=2,
+                subplot_titles=[f'Image 1: {row["image_1"]}', f'Image 2: {row["image_2"]}']
+            )
+            
+            # Add bar plots
+            fig.add_trace(
+                go.Bar(
+                    x=roi_labels,
+                    y=roi1,
+                    name='Image 1',
+                    marker_color='lightblue',
+                    showlegend=False
+                ),
+                row=1, col=1
+            )
+            
+            fig.add_trace(
+                go.Bar(
+                    x=roi_labels,
+                    y=roi2,
+                    name='Image 2',
+                    marker_color='lightcoral',
+                    showlegend=False
+                ),
+                row=1, col=2
+            )
+            
+            # Calculate similarities
+            cosine_sim, pearson_sim = self.calculate_roi_similarities(roi1, roi2)
+            
+            # Update layout
+            fig.update_layout(
+                title=f'ROI Comparison - Pair #{row_index}<br>Cosine: {cosine_sim:.3f}, Pearson: {pearson_sim:.3f}',
+                height=500,
+                width=1000,
+                showlegend=False
+            )
+            
+            # Update x-axis labels
+            fig.update_xaxes(tickangle=45)
+            fig.update_yaxes(title_text="Activation Level")
+            
+            return fig
+            
+        except Exception as e:
+            print(f"Error creating ROI plot: {e}")
+            return None

config/roi_config.py

@@ -0,0 +1,44 @@
+# ==================== config/roi_config.py ====================
+"""ROI configuration and constants"""
+
+class ROIConfig:
+    """Configuration for brain regions of interest"""
+    
+    # All ROIs in order
+    COMMON_ROIS = [
+        'OFA', 'FFA1', 'FFA2', 'EBA', 'FBA2', 'OPA', 'PPA', 'RSC', 
+        'OWFA', 'VWFA1', 'VWFA2', 'mfs words', 'V1v', 'V1d', 'V2v', 
+        'V2d', 'V3v', 'V3d', 'hV4'
+    ]
+    
+    # Early/low-level regions (visual processing)
+    EARLY_ROIS = ['V1v', 'V1d', 'V2v', 'V2d', 'V3v', 'V3d', 'hV4']
+    
+    # Late/high-level regions (semantic and categorical processing)
+    LATE_ROIS = [
+        'OFA', 'FFA1', 'FFA2', 'EBA', 'FBA2', 'OPA', 'PPA', 'RSC', 
+        'OWFA', 'VWFA1', 'VWFA2', 'mfs words'
+    ]
+    
+    @classmethod
+    def get_roi_labels(cls, roi_type='common'):
+        """Get ROI labels for a specific type"""
+        if roi_type == 'common':
+            return cls.COMMON_ROIS
+        elif roi_type == 'early':
+            return cls.EARLY_ROIS
+        elif roi_type == 'late':
+            return cls.LATE_ROIS
+        else:
+            return cls.COMMON_ROIS
+    
+    @classmethod
+    def get_roi_type_from_measure(cls, brain_measure):
+        """Extract ROI type from brain measure name"""
+        if 'common' in brain_measure:
+            return 'common'
+        elif 'early' in brain_measure:
+            return 'early'
+        elif 'late' in brain_measure:
+            return 'late'
+        return 'common'

data/data_loader.py

@@ -0,0 +1,112 @@
+# ==================== data/data_loader.py ====================
+"""Data loading and preprocessing functionality"""
+
+import pandas as pd
+from typing import List, Dict, Tuple, Optional
+
+class DataLoader:
+    """Handles loading and parsing of similarity data"""
+    
+    def __init__(self):
+        self.data: Optional[pd.DataFrame] = None
+        self.ml_models: List[str] = []
+        self.brain_measures: List[str] = []
+        self.model_categories: Dict[str, List[Tuple[str, int]]] = {
+            'vision': [], 'language': [], 'semantic': [], 'other': []
+        }
+    
+    def get_model_type(self, model_name: str) -> str:
+        """Categorize model types"""
+        if any(x in model_name for x in ["bm25", "rouge", "tf-idf", "co-occurrence"]):
+            return "semantic"
+        elif any(x in model_name for x in ["bert", "deberta", "simcse"]):
+            return "language"
+        elif "timm_" in model_name:
+            return "vision"
+        else:
+            return "other"
+    
+    def load_csv(self, csv_path: str) -> bool:
+        """Load similarity data from CSV file"""
+        try:
+            self.data = pd.read_csv(csv_path)
+            self._extract_ml_models()
+            self._categorize_models()
+            self._extract_brain_measures()
+            self._print_summary()
+            return True
+        except Exception as e:
+            print(f"Error loading data: {e}")
+            return False
+    
+    def _extract_ml_models(self):
+        """Extract ML model columns"""
+        self.ml_models = [col for col in self.data.columns if 
+                        'BOLD5000_timm_' in col or 
+                        'bert-' in col or 
+                        'deberta-' in col or 
+                        'sup-simcse' in col or
+                        col in ['bm25S_captions', 'co-occurrence-rep_tags', 'co-occurrence_captions', 
+                               'bm25S_tags', 'co-occurrence_tags', 'rouge_captions', 
+                               'tf-idf-cosine_captions', 'rouge_tags', 'tf-idf-cosine_tags']]
+    
+    def _categorize_models(self):
+        """Categorize models by type"""
+        self.model_categories = {'vision': [], 'language': [], 'semantic': [], 'other': []}
+        for i, model in enumerate(self.ml_models):
+            category = self.get_model_type(model)
+            self.model_categories[category].append((model, i))
+    
+    def _extract_brain_measures(self):
+        """Extract brain response columns"""
+        self.brain_measures = []
+        for measure_type in ['cosine_similarity', 'pearson_correlation']:
+            for roi_type in ['common', 'early', 'late']:
+                col_name = f'{measure_type}_roi_values_{roi_type}'
+                if col_name in self.data.columns:
+                    self.brain_measures.append(col_name)
+    
+    def _print_summary(self):
+        """Print data loading summary"""
+        print(f"Loaded {len(self.data)} image pairs")
+        print(f"Found {len(self.ml_models)} ML models total:")
+        for category, models in self.model_categories.items():
+            print(f"  {category.title()}: {len(models)}")
+        print(f"Brain measures: {self.brain_measures}")
+    
+    def get_ml_model_options(self) -> List[Tuple[str, any]]:
+        """Get ML model options with averages and complete names"""
+        options = []
+        
+        # Add category averages first
+        for category in ['vision', 'language', 'semantic']:
+            if self.model_categories[category]:
+                options.append((f"AVERAGE - {category.title()} Models", f"avg_{category}"))
+        
+        # Add separator
+        if any(self.model_categories.values()):
+            options.append(("────────────────────────────", "separator"))
+        
+        # Add individual models
+        for i, model_name in enumerate(self.ml_models):
+            options.append((model_name, i))
+        
+        return options
+    
+    def get_brain_measure_options(self) -> List[Tuple[str, str]]:
+        """Get brain measure options with clean names"""
+        options = []
+        for measure in self.brain_measures:
+            if 'cosine_similarity' in measure and 'common' in measure:
+                options.append(("Cosine - Common", measure))
+            elif 'cosine_similarity' in measure and 'early' in measure:
+                options.append(("Cosine - Early", measure))
+            elif 'cosine_similarity' in measure and 'late' in measure:
+                options.append(("Cosine - Late", measure))
+            elif 'pearson_correlation' in measure and 'common' in measure:
+                options.append(("Pearson - Common", measure))
+            elif 'pearson_correlation' in measure and 'early' in measure:
+                options.append(("Pearson - Early", measure))
+            elif 'pearson_correlation' in measure and 'late' in measure:
+                options.append(("Pearson - Late", measure))
+        return options

gui/gradio_interface.py

@@ -0,0 +1,189 @@
+# ==================== gui/gradio_interface.py ====================
+"""Gradio interface components and layout"""
+
+import gradio as gr
+from typing import TYPE_CHECKING, Tuple, Optional, Any
+
+if TYPE_CHECKING:
+    from main import SimilarityApp
+
+class GradioInterface:
+    """Handles the Gradio interface creation and event management"""
+    
+    def __init__(self, app: 'SimilarityApp'):
+        self.app = app
+    
+    def create_interface(self) -> gr.Blocks:
+        """Create the main Gradio interface"""
+        brain_options = self.app.data_loader.get_brain_measure_options()
+        ml_options = self.app.data_loader.get_ml_model_options()
+        
+        with gr.Blocks(title="Enhanced Image Similarity Analysis", theme=gr.themes.Soft()) as interface:
+            # Header
+            self._create_header()
+            
+            # Main analysis section
+            with gr.Row():
+                # Controls panel
+                with gr.Column(scale=1):
+                    controls_components = self._create_controls_panel(brain_options, ml_options)
+                
+                # 3D visualization
+                with gr.Column(scale=2):
+                    plot_3d = self._create_3d_section()
+            
+            # 2D plots section
+            plot_2d = self._create_2d_section()
+            
+            # Image viewer section
+            image_components = self._create_image_viewer_section()
+            
+            # ROI visualization section
+            roi_plot = self._create_roi_section()
+            
+            # Connect all event handlers
+            self._connect_events(controls_components, plot_3d, plot_2d, image_components, roi_plot)
+        
+        return interface
+    
+    def _create_header(self):
+        """Create the header section"""
+        gr.Markdown("# Enhanced Image Similarity Analysis")
+        gr.Markdown("Compare human judgments, brain responses (Cosine & Pearson), and ML model similarities with captions and ROI visualization")
+    
+    def _create_controls_panel(self, brain_options, ml_options) -> dict:
+        """Create the controls panel"""
+        gr.Markdown("### Controls")
+        
+        brain_dropdown = gr.Dropdown(
+            choices=brain_options,
+            value=brain_options[0][1] if brain_options else None,
+            label="Brain Response Type",
+            info="Choose between Cosine similarity and Pearson correlation"
+        )
+        
+        ml_dropdown = gr.Dropdown(
+            choices=ml_options,
+            value=ml_options[0][1] if ml_options else None,
+            label="ML Model",
+            info="Individual models or category averages"
+        )
+        
+        update_btn = gr.Button("Update Plots", variant="primary")
+        stats_display = gr.Markdown("Select parameters and click 'Update Plots'")
+        
+        return {
+            'brain_dropdown': brain_dropdown,
+            'ml_dropdown': ml_dropdown,
+            'update_btn': update_btn,
+            'stats_display': stats_display
+        }
+    
+    def _create_3d_section(self) -> gr.Plot:
+        """Create the 3D visualization section"""
+        gr.Markdown("### 3D Visualization")
+        return gr.Plot(label="3D Scatter Plot")
+    
+    def _create_2d_section(self) -> gr.Plot:
+        """Create the 2D plots section"""
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 2D Pairwise Comparisons")
+                return gr.Plot(label="2D Scatter Plots", show_label=False)
+    
+    def _create_image_viewer_section(self) -> dict:
+        """Create the image viewer section"""
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### Image Pair Viewer")
+                
+                with gr.Row():
+                    row_input = gr.Number(
+                        value=0, 
+                        label="Image Pair Index", 
+                        info=f"Enter 0 to {len(self.app.data_loader.data)-1}",
+                        precision=0
+                    )
+                    show_btn = gr.Button("Show Images & ROI", variant="secondary", size="sm")
+                
+                image_info = gr.Markdown("Enter an index and click 'Show Images & ROI' to see details")
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### Image 1")
+                image1_display = gr.Image(label="Image 1", height=200)
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### Image 2") 
+                image2_display = gr.Image(label="Image 2", height=200)
+        
+        return {
+            'row_input': row_input,
+            'show_btn': show_btn,
+            'image_info': image_info,
+            'image1_display': image1_display,
+            'image2_display': image2_display
+        }
+    
+    def _create_roi_section(self) -> gr.Plot:
+        """Create the ROI visualization section"""
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### ROI Brain Activation Comparison")
+                return gr.Plot(label="Side-by-Side ROI Values", show_label=False)
+    
+    def _connect_events(self, controls, plot_3d, plot_2d, image_components, roi_plot):
+        """Connect all event handlers"""
+        
+        def update_all(brain_measure, ml_model_selection):
+            if ml_model_selection == "separator":
+                return None, None, "Please select a valid model or average option"
+            
+            fig_3d, fig_2d = self.app.update_plots(brain_measure, ml_model_selection)
+            stats = self.app.get_correlations(brain_measure, ml_model_selection)
+            return fig_3d, fig_2d, stats
+        
+        def show_images_and_roi(row_idx):
+            img1, img2, info, roi_fig = self.app.show_image_pair(int(row_idx) if row_idx is not None else 0)
+            return img1, img2, info, roi_fig
+        
+        # Connect main plot updates
+        controls['update_btn'].click(
+            fn=update_all,
+            inputs=[controls['brain_dropdown'], controls['ml_dropdown']],
+            outputs=[plot_3d, plot_2d, controls['stats_display']]
+        )
+        
+        controls['brain_dropdown'].change(
+            fn=update_all,
+            inputs=[controls['brain_dropdown'], controls['ml_dropdown']],
+            outputs=[plot_3d, plot_2d, controls['stats_display']]
+        )
+        
+        controls['ml_dropdown'].change(
+            fn=update_all,
+            inputs=[controls['brain_dropdown'], controls['ml_dropdown']],
+            outputs=[plot_3d, plot_2d, controls['stats_display']]
+        )
+        
+        # Connect image viewer
+        image_components['show_btn'].click(
+            fn=show_images_and_roi,
+            inputs=[image_components['row_input']],
+            outputs=[
+                image_components['image1_display'], 
+                image_components['image2_display'], 
+                image_components['image_info'], 
+                roi_plot
+            ]
+        )
+        
+        image_components['row_input'].change(
+            fn=show_images_and_roi,
+            inputs=[image_components['row_input']],
+            outputs=[
+                image_components['image1_display'], 
+                image_components['image2_display'], 
+                image_components['image_info'], 
+                roi_plot
+            ]
+        )

overall_database.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:08b27836f940efc44631b48b31964c02ae9ae0b7ef0c35ec4b33f1181e9e5480
+size 44624446

requirements.txt

@@ -0,0 +1,465 @@
+absl-py==2.0.0
+accelerate==0.33.0
+aiobotocore @ file:///C:/b/abs_1c1a_vjay2/croot/aiobotocore_1682537737724/work
+aiofiles @ file:///C:/b/abs_9ex6mi6b56/croot/aiofiles_1683773603390/work
+aiohttp @ file:///C:/b/abs_b78zt6vo64/croot/aiohttp_1694181126607/work
+aioitertools @ file:///tmp/build/80754af9/aioitertools_1607109665762/work
+aiosignal @ file:///tmp/build/80754af9/aiosignal_1637843061372/work
+aiosqlite @ file:///C:/b/abs_9djc_0pyi3/croot/aiosqlite_1683773915844/work
+alabaster @ file:///home/ktietz/src/ci/alabaster_1611921544520/work
+anaconda-anon-usage @ file:///C:/b/abs_f4tsjyl9va/croot/anaconda-anon-usage_1695310457827/work
+anaconda-catalogs @ file:///C:/b/abs_8btyy0o8s8/croot/anaconda-catalogs_1685727315626/work
+anaconda-client @ file:///C:/b/abs_80wttmgui4/croot/anaconda-client_1694625288614/work
+anaconda-cloud-auth @ file:///C:/b/abs_5cjpnu6wjb/croot/anaconda-cloud-auth_1694462130037/work
+anaconda-navigator @ file:///C:/b/abs_ab00e0_u7e/croot/anaconda-navigator_1695238210954/work
+anaconda-project @ file:///C:/ci_311/anaconda-project_1676458365912/work
+annotated-types==0.7.0
+antlr4-python3-runtime==4.9.3
+anyio==4.10.0
+appdirs==1.4.4
+argon2-cffi @ file:///opt/conda/conda-bld/argon2-cffi_1645000214183/work
+argon2-cffi-bindings @ file:///C:/ci_311/argon2-cffi-bindings_1676424443321/work
+arrow @ file:///C:/ci_311/arrow_1678249767083/work
+astroid @ file:///C:/ci_311/astroid_1678740610167/work
+astropy @ file:///C:/ci_311_rebuilds/astropy_1678996071858/work
+asttokens @ file:///opt/conda/conda-bld/asttokens_1646925590279/work
+astunparse==1.6.3
+async-timeout @ file:///C:/ci_311/async-timeout_1676431518331/work
+atomicwrites==1.4.0
+attrs @ file:///C:/ci_311/attrs_1676422272484/work
+audioread==3.0.1
+Automat @ file:///tmp/build/80754af9/automat_1600298431173/work
+autopep8 @ file:///opt/conda/conda-bld/autopep8_1650463822033/work
+autoreject==0.4.2
+Babel @ file:///C:/ci_311/babel_1676427169844/work
+backcall @ file:///home/ktietz/src/ci/backcall_1611930011877/work
+backports.functools-lru-cache @ file:///tmp/build/80754af9/backports.functools_lru_cache_1618170165463/work
+backports.tempfile @ file:///home/linux1/recipes/ci/backports.tempfile_1610991236607/work
+backports.weakref==1.0.post1
+bcrypt @ file:///C:/ci_311/bcrypt_1676435170049/work
+beautifulsoup4 @ file:///C:/b/abs_0agyz1wsr4/croot/beautifulsoup4-split_1681493048687/work
+binaryornot @ file:///tmp/build/80754af9/binaryornot_1617751525010/work
+black @ file:///C:/b/abs_620t6ndje8/croot/black_1680737261963/work
+bleach @ file:///opt/conda/conda-bld/bleach_1641577558959/work
+bokeh @ file:///C:/b/abs_e5qs_0dl2w/croot/bokeh_1690546119144/work
+boltons @ file:///C:/ci_311/boltons_1677729932371/work
+boto3==1.35.21
+botocore==1.35.21
+Bottleneck @ file:///C:/ci_311/bottleneck_1676500016583/work
+Brotli==1.1.0
+brotlipy==0.7.0
+cachetools==5.3.2
+certifi @ file:///home/conda/feedstock_root/build_artifacts/certifi_1700303426725/work/certifi
+cffi @ file:///C:/ci_311/cffi_1676423759166/work
+cftime==1.6.3
+chardet @ file:///C:/ci_311/chardet_1676436134885/work
+charset-normalizer @ file:///tmp/build/80754af9/charset-normalizer_1630003229654/work
+click @ file:///C:/ci_311/click_1676433091657/work
+cloudpickle @ file:///C:/b/abs_3796yxesic/croot/cloudpickle_1683040098851/work
+clyent==1.2.2
+colorama @ file:///C:/ci_311/colorama_1676422310965/work
+colorcet @ file:///C:/ci_311/colorcet_1676440389947/work
+coloredlogs==15.0.1
+comm @ file:///C:/ci_311/comm_1678376562840/work
+conda @ file:///C:/b/abs_3eb7ewgq2c/croot/conda_1694545461647/work
+conda-build @ file:///C:/b/abs_8di4gx5nj5/croot/conda-build_1692366837286/work
+conda-content-trust @ file:///C:/b/abs_e3bcpyv7sw/croot/conda-content-trust_1693490654398/work
+conda-libmamba-solver @ file:///C:/b/abs_016p0csqp7/croot/conda-libmamba-solver_1691418958509/work/src
+conda-pack @ file:///tmp/build/80754af9/conda-pack_1611163042455/work
+conda-package-handling @ file:///C:/b/abs_b9wp3lr1gn/croot/conda-package-handling_1691008700066/work
+conda-repo-cli==1.0.75
+conda-token @ file:///Users/paulyim/miniconda3/envs/c3i/conda-bld/conda-token_1662660369760/work
+conda-verify==3.4.2
+conda_index @ file:///C:/b/abs_50towt3zan/croot/conda-index_1695311135992/work
+conda_package_streaming @ file:///C:/b/abs_6c28n38aaj/croot/conda-package-streaming_1690988019210/work
+constantly==15.1.0
+contourpy @ file:///C:/ci_311/contourpy_1676431756017/work
+cookiecutter @ file:///opt/conda/conda-bld/cookiecutter_1649151442564/work
+cryptography @ file:///C:/b/abs_f4do8t8jfs/croot/cryptography_1694444424531/work
+cssselect==1.1.0
+cvxopt==1.3.2
+cycler @ file:///tmp/build/80754af9/cycler_1637851556182/work
+cytoolz @ file:///C:/ci_311/cytoolz_1676436342770/work
+daal4py==2023.1.1
+dask @ file:///C:/b/abs_23lvfodys3/croot/dask-core_1686782960052/work
+datasets @ file:///C:/b/abs_a3jy4vrfuo/croot/datasets_1684484478038/work
+datashader @ file:///C:/b/abs_8323862uxi/croot/datashader_1692372298149/work
+datashape==0.5.4
+debugpy @ file:///C:/b/abs_c0y1fjipt2/croot/debugpy_1690906864587/work
+decorator @ file:///opt/conda/conda-bld/decorator_1643638310831/work
+defusedxml @ file:///tmp/build/80754af9/defusedxml_1615228127516/work
+dgl==1.1.2
+diff-match-patch @ file:///Users/ktietz/demo/mc3/conda-bld/diff-match-patch_1630511840874/work
+diffusers==0.31.0
+dill @ file:///C:/ci_311/dill_1676433323862/work
+distributed @ file:///C:/b/abs_7509xfv227/croot/distributed_1686866088894/work
+distro==1.9.0
+docstring-to-markdown @ file:///C:/ci_311/docstring-to-markdown_1677742566583/work
+docutils @ file:///C:/ci_311/docutils_1676428078664/work
+eeglabio==0.0.2.post4
+entrypoints @ file:///C:/ci_311/entrypoints_1676423328987/work
+et-xmlfile==1.1.0
+executing @ file:///opt/conda/conda-bld/executing_1646925071911/work
+fastapi==0.116.1
+fastjsonschema @ file:///C:/ci_311/python-fastjsonschema_1679500568724/work
+ffmpy==0.6.1
+filelock @ file:///C:/ci_311/filelock_1676427284139/work
+flake8 @ file:///C:/ci_311/flake8_1678376624746/work
+Flask @ file:///C:/ci_311/flask_1676436667658/work
+flatbuffers==23.5.26
+fonttools==4.25.0
+frozenlist @ file:///C:/ci_311/frozenlist_1676428131576/work
+fsspec==2024.6.1
+future @ file:///C:/ci_311_rebuilds/future_1678998246262/work
+gast==0.5.4
+gensim @ file:///C:/ci_311/gensim_1677743037820/work
+glob2 @ file:///home/linux1/recipes/ci/glob2_1610991677669/work
+google-auth==2.25.2
+google-auth-oauthlib==1.0.0
+google-pasta==0.2.0
+gradio==5.45.0
+gradio_client==1.13.0
+greenlet @ file:///C:/ci_311/greenlet_1676436788118/work
+groovy==0.1.2
+grpcio==1.60.0
+h11==0.14.0
+h5io==0.1.9
+h5py @ file:///C:/b/abs_17fav01gwy/croot/h5py_1691589733413/work
+HeapDict @ file:///Users/ktietz/demo/mc3/conda-bld/heapdict_1630598515714/work
+holoviews @ file:///C:/b/abs_fa7afixkhc/croot/holoviews_1693378101313/work
+httpcore==1.0.7
+httpx==0.28.1
+huggingface-hub==0.34.4
+humanfriendly==10.0
+hvplot @ file:///C:/b/abs_2b13wifauw/croot/hvplot_1685998632349/work
+hyperlink @ file:///tmp/build/80754af9/hyperlink_1610130746837/work
+idna @ file:///C:/ci_311/idna_1676424932545/work
+imagecodecs @ file:///C:/b/abs_e2g5zbs1q0/croot/imagecodecs_1695065012000/work
+ImageHash==4.3.1
+imageio @ file:///C:/ci_311/imageio_1678373794394/work
+imagesize @ file:///C:/ci_311/imagesize_1676431905616/work
+imbalanced-learn @ file:///C:/b/abs_275a0acaq2/croot/imbalanced-learn_1685025644593/work
+importlib-metadata @ file:///C:/b/abs_20ndzb2j6v/croot/importlib-metadata_1678997085534/work
+incremental @ file:///tmp/build/80754af9/incremental_1636629750599/work
+inflection==0.5.1
+iniconfig @ file:///home/linux1/recipes/ci/iniconfig_1610983019677/work
+innvestigate==2.1.2
+intake @ file:///C:/ci_311_rebuilds/intake_1678999914269/work
+intervaltree @ file:///Users/ktietz/demo/mc3/conda-bld/intervaltree_1630511889664/work
+ipykernel @ file:///C:/b/abs_07rkft_vaz/croot/ipykernel_1691121700587/work
+ipython @ file:///C:/b/abs_e5729i179y/croot/ipython_1694181400005/work
+ipython-genutils @ file:///tmp/build/80754af9/ipython_genutils_1606773439826/work
+ipywidgets @ file:///C:/b/abs_5awapknmz_/croot/ipywidgets_1679394824767/work
+isort @ file:///tmp/build/80754af9/isort_1628603791788/work
+itemadapter @ file:///tmp/build/80754af9/itemadapter_1626442940632/work
+itemloaders @ file:///opt/conda/conda-bld/itemloaders_1646805235997/work
+itsdangerous @ file:///tmp/build/80754af9/itsdangerous_1621432558163/work
+jaraco.classes @ file:///tmp/build/80754af9/jaraco.classes_1620983179379/work
+jedi @ file:///C:/ci_311/jedi_1679427407646/work
+jellyfish @ file:///C:/b/abs_50kgvtnrbj/croot/jellyfish_1695193564091/work
+Jinja2 @ file:///C:/ci_311/jinja2_1676424968965/work
+jinja2-time @ file:///opt/conda/conda-bld/jinja2-time_1649251842261/work
+jiter==0.8.2
+jmespath @ file:///Users/ktietz/demo/mc3/conda-bld/jmespath_1630583964805/work
+joblib @ file:///C:/b/abs_1anqjntpan/croot/joblib_1685113317150/work
+json5 @ file:///tmp/build/80754af9/json5_1624432770122/work
+jsonpatch @ file:///tmp/build/80754af9/jsonpatch_1615747632069/work
+jsonpointer==2.1
+jsonschema @ file:///C:/b/abs_d40z05b6r1/croot/jsonschema_1678983446576/work
+jupyter @ file:///C:/ci_311/jupyter_1678249952587/work
+jupyter-console @ file:///C:/b/abs_82xaa6i2y4/croot/jupyter_console_1680000189372/work
+jupyter-events @ file:///C:/b/abs_4cak_28ewz/croot/jupyter_events_1684268050893/work
+jupyter-server @ file:///C:/ci_311/jupyter_server_1678228762759/work
+jupyter-ydoc @ file:///C:/b/abs_e7m6nh5lao/croot/jupyter_ydoc_1683747253535/work
+jupyter_client @ file:///C:/ci_311/jupyter_client_1676424009414/work
+jupyter_core @ file:///C:/b/abs_9d0ttho3bs/croot/jupyter_core_1679906581955/work
+jupyter_server_fileid @ file:///C:/b/abs_f1yjnmiq_6/croot/jupyter_server_fileid_1684273602142/work
+jupyter_server_ydoc @ file:///C:/b/abs_8ai39bligw/croot/jupyter_server_ydoc_1686767445888/work
+jupyterlab @ file:///C:/b/abs_c1msr8zz3y/croot/jupyterlab_1686179674844/work
+jupyterlab-pygments @ file:///tmp/build/80754af9/jupyterlab_pygments_1601490720602/work
+jupyterlab-widgets @ file:///C:/b/abs_38ad427jkz/croot/jupyterlab_widgets_1679055289211/work
+jupyterlab_server @ file:///C:/b/abs_e0qqsihjvl/croot/jupyterlab_server_1680792526136/work
+kaleido @ file:///C:/b/abs_60smvjz1os/croot/python-kaleido_1689927138239/work
+keras==2.14.0
+keyring @ file:///C:/b/abs_dbjc7g0dh2/croot/keyring_1678999228878/work
+kiwisolver @ file:///C:/ci_311/kiwisolver_1676431979301/work
+kneed==0.8.5
+lazy-object-proxy @ file:///C:/ci_311/lazy-object-proxy_1676432050939/work
+lazy_loader @ file:///C:/b/abs_c9jlw06oq1/croot/lazy_loader_1687266162676/work
+libarchive-c @ file:///tmp/build/80754af9/python-libarchive-c_1617780486945/work
+libclang==16.0.6
+libmambapy @ file:///C:/b/abs_71g8gec0dd/croot/mamba-split_1694187821755/work/libmambapy
+librosa==0.10.1
+linkify-it-py @ file:///C:/ci_311/linkify-it-py_1676474436187/work
+llvmlite @ file:///C:/b/abs_a8i9keuf6p/croot/llvmlite_1683555140340/work
+lmdb @ file:///C:/b/abs_556ronuvb2/croot/python-lmdb_1682522366268/work
+locket @ file:///C:/ci_311/locket_1676428325082/work
+lxml @ file:///C:/b/abs_9e7tpg2vv9/croot/lxml_1695058219431/work
+lz4 @ file:///C:/b/abs_064u6aszy3/croot/lz4_1686057967376/work
+Markdown @ file:///C:/ci_311/markdown_1676437912393/work
+markdown-it-py @ file:///C:/b/abs_a5bfngz6fu/croot/markdown-it-py_1684279915556/work
+MarkupSafe @ file:///C:/ci_311/markupsafe_1676424152318/work
+matplotlib @ file:///C:/b/abs_085jhivdha/croot/matplotlib-suite_1693812524572/work
+matplotlib-inline @ file:///C:/ci_311/matplotlib-inline_1676425798036/work
+mccabe @ file:///opt/conda/conda-bld/mccabe_1644221741721/work
+mdit-py-plugins @ file:///C:/ci_311/mdit-py-plugins_1676481827414/work
+mdurl @ file:///C:/ci_311/mdurl_1676442676678/work
+meegkit==0.1.3
+menuinst @ file:///C:/ci_311/menuinst_1678730372782/work
+mistune @ file:///C:/ci_311/mistune_1676425149302/work
+mkl-fft @ file:///C:/b/abs_19i1y8ykas/croot/mkl_fft_1695058226480/work
+mkl-random @ file:///C:/b/abs_edwkj1_o69/croot/mkl_random_1695059866750/work
+mkl-service==2.4.0
+ml-dtypes==0.2.0
+mne==1.5.1
+mne-connectivity==0.5.0
+mne-icalabel==0.5.1
+more-itertools @ file:///tmp/build/80754af9/more-itertools_1637733554872/work
+mpld3==0.5.10
+mpmath @ file:///C:/b/abs_7833jrbiox/croot/mpmath_1690848321154/work
+msgpack @ file:///C:/ci_311/msgpack-python_1676427482892/work
+multidict @ file:///C:/ci_311/multidict_1676428396308/work
+multipledispatch @ file:///C:/ci_311/multipledispatch_1676442767760/work
+multiprocess @ file:///C:/ci_311/multiprocess_1676442808395/work
+munkres==1.1.4
+mypy-extensions @ file:///C:/b/abs_8f7xiidjya/croot/mypy_extensions_1695131051147/work
+navigator-updater @ file:///C:/b/abs_895otdwmo9/croot/navigator-updater_1695210220239/work
+nbclassic @ file:///C:/b/abs_c8_rs7b3zw/croot/nbclassic_1681756186106/work
+nbclient @ file:///C:/ci_311/nbclient_1676425195918/work
+nbconvert @ file:///C:/ci_311/nbconvert_1676425836196/work
+nbformat @ file:///C:/b/abs_5a2nea1iu2/croot/nbformat_1694616866197/work
+nest-asyncio @ file:///C:/ci_311/nest-asyncio_1676423519896/work
+netCDF4==1.6.5
+networkx @ file:///C:/b/abs_e6gi1go5op/croot/networkx_1690562046966/work
+nibabel==5.2.1
+nltk @ file:///C:/b/abs_a638z6l1z0/croot/nltk_1688114186909/work
+notebook @ file:///C:/b/abs_e2qn6c85jb/croot/notebook_1690985290943/work
+notebook_shim @ file:///C:/ci_311/notebook-shim_1678144850856/work
+numba @ file:///C:/b/abs_00f2z7znbq/croot/numba_1690878309825/work
+numexpr @ file:///C:/b/abs_afm0oewmmt/croot/numexpr_1683221839116/work
+numpy @ file:///C:/Users/dev-admin/mkl/numpy_and_numpy_base_1682982345978/work
+numpydoc @ file:///C:/ci_311/numpydoc_1676453412027/work
+oauthlib==3.2.2
+omegaconf==2.3.0
+onnxruntime==1.16.2
+openai==1.60.2
+opencv-python==4.8.1.78
+openpyxl==3.0.10
+opt-einsum==3.3.0
+orjson==3.11.3
+packaging @ file:///C:/b/abs_28t5mcoltc/croot/packaging_1693575224052/work
+pandas @ file:///C:/miniconda3/conda-bld/pandas_1692298018988/work
+pandocfilters @ file:///opt/conda/conda-bld/pandocfilters_1643405455980/work
+panel @ file:///C:/b/abs_a4rd7zrkc6/croot/panel_1695145945642/work
+param @ file:///C:/b/abs_f5xzp6ism6/croot/param_1684915326009/work
+paramiko @ file:///opt/conda/conda-bld/paramiko_1640109032755/work
+parsel @ file:///C:/ci_311/parsel_1676443327188/work
+parso @ file:///opt/conda/conda-bld/parso_1641458642106/work
+partd @ file:///C:/b/abs_4e2m_ds81n/croot/partd_1693937921136/work
+pathlib @ file:///Users/ktietz/demo/mc3/conda-bld/pathlib_1629713961906/work
+pathspec @ file:///C:/ci_311/pathspec_1679427644142/work
+patsy==0.5.3
+pep8==1.7.1
+pexpect @ file:///tmp/build/80754af9/pexpect_1605563209008/work
+pickleshare @ file:///tmp/build/80754af9/pickleshare_1606932040724/work
+Pillow @ file:///C:/b/abs_153xikw91n/croot/pillow_1695134603563/work
+pkce @ file:///C:/b/abs_d0z4444tb0/croot/pkce_1690384879799/work
+pkginfo @ file:///C:/b/abs_d18srtr68x/croot/pkginfo_1679431192239/work
+platformdirs @ file:///C:/b/abs_b6z_yqw_ii/croot/platformdirs_1692205479426/work
+plotly @ file:///C:/ci_311/plotly_1676443558683/work
+pluggy @ file:///C:/ci_311/pluggy_1676422178143/work
+ply==3.11
+pooch==1.8.0
+poyo @ file:///tmp/build/80754af9/poyo_1617751526755/work
+praat-parselmouth==0.4.3
+prometheus-client @ file:///C:/ci_311/prometheus_client_1679591942558/work
+prompt-toolkit @ file:///C:/ci_311/prompt-toolkit_1676425940920/work
+Protego @ file:///tmp/build/80754af9/protego_1598657180827/work
+protobuf==4.23.4
+psutil @ file:///C:/ci_311_rebuilds/psutil_1679005906571/work
+ptyprocess @ file:///tmp/build/80754af9/ptyprocess_1609355006118/work/dist/ptyprocess-0.7.0-py2.py3-none-any.whl
+pure-eval @ file:///opt/conda/conda-bld/pure_eval_1646925070566/work
+py-cpuinfo @ file:///Users/ktietz/demo/mc3/conda-bld/py-cpuinfo_1629480366017/work
+pyarrow==11.0.0
+pyasn1 @ file:///Users/ktietz/demo/mc3/conda-bld/pyasn1_1629708007385/work
+pyasn1-modules==0.2.8
+pycodestyle @ file:///C:/ci_311/pycodestyle_1678376707834/work
+pycosat @ file:///C:/ci_311/pycosat_1676438455539/work
+pycparser @ file:///tmp/build/80754af9/pycparser_1636541352034/work
+pyct @ file:///C:/ci_311/pyct_1676438538057/work
+pycurl==7.45.2
+pydantic==2.11.7
+pydantic_core==2.33.2
+PyDispatcher==2.0.5
+pydocstyle @ file:///C:/ci_311/pydocstyle_1678402028085/work
+pydub==0.25.1
+pyEDFlib==0.1.37
+pyerfa @ file:///C:/ci_311/pyerfa_1676503994641/work
+pyflakes @ file:///C:/ci_311/pyflakes_1678402101687/work
+Pygments @ file:///C:/b/abs_fay9dpq4n_/croot/pygments_1684279990574/work
+PyJWT @ file:///C:/ci_311/pyjwt_1676438890509/work
+pylint @ file:///C:/ci_311/pylint_1678740302984/work
+pylint-venv @ file:///C:/ci_311/pylint-venv_1678402170638/work
+pyls-spyder==0.4.0
+pymatreader==0.0.32
+PyNaCl @ file:///C:/ci_311/pynacl_1676445861112/work
+pyodbc @ file:///C:/ci_311/pyodbc_1676489976744/work
+pyOpenSSL @ file:///C:/b/abs_08f38zyck4/croot/pyopenssl_1690225407403/work
+pyparsing @ file:///C:/ci_311/pyparsing_1678502182533/work
+PyQt5==5.15.7
+PyQt5-sip @ file:///C:/ci_311/pyqt-split_1676428895938/work/pyqt_sip
+PyQtWebEngine==5.15.4
+pyreadline3==3.4.1
+pyriemann==0.5
+pyrsistent @ file:///C:/ci_311/pyrsistent_1676422695500/work
+PySocks @ file:///C:/ci_311/pysocks_1676425991111/work
+pytest @ file:///C:/b/abs_48heoo_k8y/croot/pytest_1690475385915/work
+python-dateutil @ file:///tmp/build/80754af9/python-dateutil_1626374649649/work
+python-dotenv @ file:///C:/ci_311/python-dotenv_1676455170580/work
+python-json-logger @ file:///C:/b/abs_cblnsm6puj/croot/python-json-logger_1683824130469/work
+python-lsp-black @ file:///C:/ci_311/python-lsp-black_1678721855627/work
+python-lsp-jsonrpc==1.0.0
+python-lsp-server @ file:///C:/b/abs_catecj7fv1/croot/python-lsp-server_1681930405912/work
+python-multipart==0.0.20
+python-slugify @ file:///tmp/build/80754af9/python-slugify_1620405669636/work
+python-snappy @ file:///C:/ci_311/python-snappy_1676446060182/work
+pytoolconfig @ file:///C:/ci_311/pytoolconfig_1678402262175/work
+pytorch-pretrained-biggan==0.1.1
+pytz @ file:///C:/b/abs_19q3ljkez4/croot/pytz_1695131651401/work
+pyviz-comms @ file:///C:/b/abs_6cq38vhwa5/croot/pyviz_comms_1685030740344/work
+PyWavelets @ file:///C:/ci_311/pywavelets_1676504105729/work
+pywin32==305.1
+pywin32-ctypes @ file:///C:/ci_311/pywin32-ctypes_1676427747089/work
+pywinpty @ file:///C:/ci_311/pywinpty_1677707791185/work/target/wheels/pywinpty-2.0.10-cp311-none-win_amd64.whl
+PyYAML @ file:///C:/ci_311/pyyaml_1676432488822/work
+pyzmq @ file:///C:/ci_311/pyzmq_1676423601304/work
+QDarkStyle @ file:///tmp/build/80754af9/qdarkstyle_1617386714626/work
+qstylizer @ file:///C:/ci_311/qstylizer_1678502012152/work/dist/qstylizer-0.2.2-py2.py3-none-any.whl
+QtAwesome @ file:///C:/ci_311/qtawesome_1678402331535/work
+qtconsole @ file:///C:/b/abs_eb4u9jg07y/croot/qtconsole_1681402843494/work
+QtPy @ file:///C:/ci_311/qtpy_1676432558504/work
+queuelib==1.5.0
+regex @ file:///C:/ci_311_rebuilds/regex_1679006156792/work
+requests @ file:///C:/b/abs_316c2inijk/croot/requests_1690400295842/work
+requests-file @ file:///Users/ktietz/demo/mc3/conda-bld/requests-file_1629455781986/work
+requests-oauthlib==1.3.1
+requests-toolbelt @ file:///C:/b/abs_2fsmts66wp/croot/requests-toolbelt_1690874051210/work
+responses @ file:///tmp/build/80754af9/responses_1619800270522/work
+rfc3339-validator @ file:///C:/b/abs_ddfmseb_vm/croot/rfc3339-validator_1683077054906/work
+rfc3986-validator @ file:///C:/b/abs_6e9azihr8o/croot/rfc3986-validator_1683059049737/work
+rich==14.1.0
+rope @ file:///C:/ci_311/rope_1678402524346/work
+rsa==4.9
+Rtree @ file:///C:/ci_311/rtree_1676455758391/work
+ruamel-yaml-conda @ file:///C:/ci_311/ruamel_yaml_1676455799258/work
+ruamel.yaml @ file:///C:/ci_311/ruamel.yaml_1676439214109/work
+ruff==0.13.0
+s3fs @ file:///C:/b/abs_adfhcfx438/croot/s3fs_1682551489845/work
+s3transfer==0.10.2
+safehttpx==0.1.6
+safetensors==0.5.2
+scikit-image @ file:///C:/b/abs_2075zg1pia/croot/scikit-image_1682528361447/work
+scikit-learn @ file:///C:/b/abs_55olq_4gzc/croot/scikit-learn_1690978955123/work
+scikit-learn-intelex==20230426.121932
+scipy==1.11.1
+Scrapy @ file:///C:/ci_311/scrapy_1678502587780/work
+seaborn @ file:///C:/ci_311/seaborn_1676446547861/work
+semantic-version==2.10.0
+Send2Trash @ file:///tmp/build/80754af9/send2trash_1632406701022/work
+service-identity @ file:///Users/ktietz/demo/mc3/conda-bld/service_identity_1629460757137/work
+shellingham==1.5.4
+sip @ file:///C:/ci_311/sip_1676427825172/work
+six @ file:///tmp/build/80754af9/six_1644875935023/work
+smart-open @ file:///C:/ci_311/smart_open_1676439339434/work
+sniffio @ file:///C:/ci_311/sniffio_1676425339093/work
+snowballstemmer @ file:///tmp/build/80754af9/snowballstemmer_1637937080595/work
+sortedcontainers @ file:///tmp/build/80754af9/sortedcontainers_1623949099177/work
+soundfile==0.12.1
+soupsieve @ file:///C:/b/abs_a989exj3q6/croot/soupsieve_1680518492466/work
+sox==1.5.0
+soxr==0.3.7
+Sphinx @ file:///C:/ci_311/sphinx_1676434546244/work
+sphinxcontrib-applehelp @ file:///home/ktietz/src/ci/sphinxcontrib-applehelp_1611920841464/work
+sphinxcontrib-devhelp @ file:///home/ktietz/src/ci/sphinxcontrib-devhelp_1611920923094/work
+sphinxcontrib-htmlhelp @ file:///tmp/build/80754af9/sphinxcontrib-htmlhelp_1623945626792/work
+sphinxcontrib-jsmath @ file:///home/ktietz/src/ci/sphinxcontrib-jsmath_1611920942228/work
+sphinxcontrib-qthelp @ file:///home/ktietz/src/ci/sphinxcontrib-qthelp_1611921055322/work
+sphinxcontrib-serializinghtml @ file:///tmp/build/80754af9/sphinxcontrib-serializinghtml_1624451540180/work
+spyder @ file:///C:/b/abs_e99kl7d8t0/croot/spyder_1681934304813/work
+spyder-kernels @ file:///C:/b/abs_e788a8_4y9/croot/spyder-kernels_1691599588437/work
+SQLAlchemy @ file:///C:/ci_311/sqlalchemy_1676446707912/work
+stack-data @ file:///opt/conda/conda-bld/stack_data_1646927590127/work
+starlette==0.47.3
+statsmodels @ file:///C:/b/abs_7bth810rna/croot/statsmodels_1689937298619/work
+sympy @ file:///C:/ci_311_rebuilds/sympy_1679009400182/work
+tables @ file:///C:/b/abs_0626auep9v/croot/pytables_1691623892917/work
+tabulate @ file:///C:/ci_311/tabulate_1676494503192/work
+TBB==0.2
+tblib @ file:///Users/ktietz/demo/mc3/conda-bld/tblib_1629402031467/work
+tenacity @ file:///C:/b/abs_ddkoa9nju6/croot/tenacity_1682972298929/work
+tensorboard==2.14.1
+tensorboard-data-server==0.7.2
+tensorflow==2.14.1
+tensorflow-estimator==2.14.0
+tensorflow-intel==2.14.1
+tensorflow-io-gcs-filesystem==0.31.0
+termcolor==2.4.0
+terminado @ file:///C:/ci_311/terminado_1678228513830/work
+text-unidecode @ file:///Users/ktietz/demo/mc3/conda-bld/text-unidecode_1629401354553/work
+textdistance @ file:///tmp/build/80754af9/textdistance_1612461398012/work
+tf-explain==0.3.1
+threadpoolctl @ file:///Users/ktietz/demo/mc3/conda-bld/threadpoolctl_1629802263681/work
+three-merge @ file:///tmp/build/80754af9/three-merge_1607553261110/work
+tifffile @ file:///C:/b/abs_45o5chuqwt/croot/tifffile_1695107511025/work
+tinycss2 @ file:///C:/ci_311/tinycss2_1676425376744/work
+tldextract @ file:///opt/conda/conda-bld/tldextract_1646638314385/work
+tokenizers==0.21.0
+toml @ file:///tmp/build/80754af9/toml_1616166611790/work
+tomlkit==0.13.3
+toolz @ file:///C:/ci_311/toolz_1676431406517/work
+torch==2.1.0+cu118
+torch_geometric==2.4.0
+torchaudio==2.1.0+cu118
+torchvision==0.16.0+cu118
+tornado @ file:///C:/b/abs_61jhmrrua1/croot/tornado_1690848767317/work
+tqdm @ file:///C:/b/abs_f76j9hg7pv/croot/tqdm_1679561871187/work
+traitlets @ file:///C:/ci_311/traitlets_1676423290727/work
+transformers==4.48.1
+Twisted @ file:///C:/b/abs_f1pc_rieoy/croot/twisted_1683796899561/work
+twisted-iocpsupport @ file:///C:/ci_311/twisted-iocpsupport_1676447612160/work
+typer==0.17.4
+typing-inspection==0.4.1
+typing_extensions==4.12.2
+tzdata @ file:///croot/python-tzdata_1690578112552/work
+uc-micro-py @ file:///C:/ci_311/uc-micro-py_1676457695423/work
+ujson @ file:///C:/ci_311/ujson_1676434714224/work
+umap==0.1.1
+Unidecode @ file:///tmp/build/80754af9/unidecode_1614712377438/work
+urllib3 @ file:///C:/b/abs_889_loyqv4/croot/urllib3_1686163174463/work
+uvicorn==0.35.0
+w3lib @ file:///Users/ktietz/demo/mc3/conda-bld/w3lib_1629359764703/work
+watchdog @ file:///C:/ci_311/watchdog_1676457923624/work
+wcwidth @ file:///Users/ktietz/demo/mc3/conda-bld/wcwidth_1629357192024/work
+webencodings==0.5.1
+webrtcvad==2.0.10
+websocket-client @ file:///C:/ci_311/websocket-client_1676426063281/work
+websockets==15.0.1
+Werkzeug @ file:///C:/b/abs_8578rs2ra_/croot/werkzeug_1679489759009/work
+whatthepatch @ file:///C:/ci_311/whatthepatch_1678402578113/work
+widgetsnbextension @ file:///C:/b/abs_882k4_4kdf/croot/widgetsnbextension_1679313880295/work
+win-inet-pton @ file:///C:/ci_311/win_inet_pton_1676425458225/work
+wrapt @ file:///C:/ci_311/wrapt_1676432805090/work
+xarray @ file:///C:/b/abs_5bkjiynp4e/croot/xarray_1689041498548/work
+XlsxWriter==3.1.9
+xlwings @ file:///C:/ci_311_rebuilds/xlwings_1679013429160/work
+xmltodict==0.13.0
+xxhash @ file:///C:/ci_311/python-xxhash_1676446168786/work
+xyzservices @ file:///C:/ci_311/xyzservices_1676434829315/work
+y-py @ file:///C:/b/abs_b7f5go6r0j/croot/y-py_1683662173571/work
+yapf @ file:///tmp/build/80754af9/yapf_1615749224965/work
+yarl @ file:///C:/ci_311/yarl_1676432870023/work
+ypy-websocket @ file:///C:/b/abs_4e65ywlnv8/croot/ypy-websocket_1684172103529/work
+zict @ file:///C:/b/abs_fc7elavmem/croot/zict_1682698759288/work
+zipp @ file:///C:/ci_311/zipp_1676426100491/work
+zope.interface @ file:///C:/ci_311/zope.interface_1676439868776/work
+zstandard==0.19.0

test.py

@@ -0,0 +1,722 @@
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import gradio as gr
+import numpy as np
+from PIL import Image
+import requests
+from io import BytesIO
+import json
+
+class DataLoader:
+    """Handles loading and parsing of similarity data"""
+    
+    def __init__(self):
+        self.data = None
+        self.ml_models = []
+        self.brain_measures = []
+        self.model_categories = {'vision': [], 'language': [], 'semantic': [], 'other': []}
+    
+    def get_model_type(self, model_name):
+        """Categorize model types"""
+        if any(x in model_name for x in ["bm25", "rouge", "tf-idf", "co-occurrence"]):
+            return "semantic"
+        elif any(x in model_name for x in ["bert", "deberta", "simcse"]):
+            return "language"
+        elif "timm_" in model_name:
+            return "vision"
+        else:
+            return "other"
+    
+    def load_csv(self, csv_path):
+        """Load similarity data from CSV file"""
+        try:
+            self.data = pd.read_csv(csv_path)
+            
+            # Get ALL ML model columns from your data
+            self.ml_models = [col for col in self.data.columns if 
+                            'BOLD5000_timm_' in col or 
+                            'bert-' in col or 
+                            'deberta-' in col or 
+                            'sup-simcse' in col or
+                            col in ['bm25S_captions', 'co-occurrence-rep_tags', 'co-occurrence_captions', 
+                                   'bm25S_tags', 'co-occurrence_tags', 'rouge_captions', 
+                                   'tf-idf-cosine_captions', 'rouge_tags', 'tf-idf-cosine_tags']]
+            
+            # Categorize models
+            self.model_categories = {'vision': [], 'language': [], 'semantic': [], 'other': []}
+            for i, model in enumerate(self.ml_models):
+                category = self.get_model_type(model)
+                self.model_categories[category].append((model, i))
+            
+            # Get brain response columns - both cosine and pearson
+            self.brain_measures = []
+            for measure_type in ['cosine_similarity', 'pearson_correlation']:
+                for roi_type in ['common', 'early', 'late']:
+                    col_name = f'{measure_type}_roi_values_{roi_type}'
+                    if col_name in self.data.columns:
+                        self.brain_measures.append(col_name)
+            
+            print(f"Loaded {len(self.data)} image pairs")
+            print(f"Found {len(self.ml_models)} ML models total:")
+            print(f"  Vision: {len(self.model_categories['vision'])}")
+            print(f"  Language: {len(self.model_categories['language'])}")
+            print(f"  Semantic: {len(self.model_categories['semantic'])}")
+            print(f"  Other: {len(self.model_categories['other'])}")
+            print(f"Brain measures: {self.brain_measures}")
+            
+            return True
+        except Exception as e:
+            print(f"Error loading data: {e}")
+            return False
+    
+    def get_ml_model_options(self):
+        """Get ML model options with averages and complete names"""
+        options = []
+        
+        # Add category averages first
+        if self.model_categories['vision']:
+            options.append(("AVERAGE - Vision Models", "avg_vision"))
+        if self.model_categories['language']:
+            options.append(("AVERAGE - Language Models", "avg_language"))
+        if self.model_categories['semantic']:
+            options.append(("AVERAGE - Semantic Models", "avg_semantic"))
+        
+        # Add separator
+        if any(self.model_categories.values()):
+            options.append(("────────────────────────────", "separator"))
+        
+        # Add all individual models with their EXACT column names
+        for i, model_name in enumerate(self.ml_models):
+            options.append((model_name, i))
+        
+        return options
+    
+    def get_brain_measure_options(self):
+        """Get brain measure options with clean names"""
+        options = []
+        for measure in self.brain_measures:
+            # Parse measure name for display
+            if 'cosine_similarity' in measure and 'common' in measure:
+                options.append(("Cosine - Common", measure))
+            elif 'cosine_similarity' in measure and 'early' in measure:
+                options.append(("Cosine - Early", measure))
+            elif 'cosine_similarity' in measure and 'late' in measure:
+                options.append(("Cosine - Late", measure))
+            elif 'pearson_correlation' in measure and 'common' in measure:
+                options.append(("Pearson - Common", measure))
+            elif 'pearson_correlation' in measure and 'early' in measure:
+                options.append(("Pearson - Early", measure))
+            elif 'pearson_correlation' in measure and 'late' in measure:
+                options.append(("Pearson - Late", measure))
+        return options
+
+class ROIVisualizer:
+    """Handles ROI data visualization"""
+    
+    @staticmethod
+    def parse_roi_values(roi_string):
+        """Parse ROI values from string format"""
+        try:
+            if pd.isna(roi_string) or roi_string == '':
+                return None
+            # Remove brackets and split by spaces or commas
+            roi_string = roi_string.strip('[]')
+            values = [float(x) for x in roi_string.replace(',', ' ').split() if x.strip()]
+            return np.array(values)
+        except Exception as e:
+            print(f"Error parsing ROI values: {e}")
+            return None
+    
+    @staticmethod
+    def create_roi_comparison_plot(data, row_index):
+        """Create side-by-side bar plots comparing ROI values"""
+        try:
+            if row_index >= len(data):
+                return None
+            
+            row = data.iloc[row_index]
+            
+            # Parse ROI values for both images
+            roi1 = ROIVisualizer.parse_roi_values(row.get('image_1_roi_values', ''))
+            roi2 = ROIVisualizer.parse_roi_values(row.get('image_2_roi_values', ''))
+            
+            if roi1 is None or roi2 is None:
+                return None
+            
+            # Ensure both arrays have the same length
+            min_len = min(len(roi1), len(roi2))
+            roi1 = roi1[:min_len]
+            roi2 = roi2[:min_len]
+            
+            # Create ROI region labels
+            roi_labels = [f'ROI_{i+1}' for i in range(min_len)]
+            
+            # Create subplot
+            fig = make_subplots(
+                rows=1, cols=2,
+                subplot_titles=[f'Image 1: {row["image_1"]}', f'Image 2: {row["image_2"]}']
+            )
+            
+            # Add bar plots
+            fig.add_trace(
+                go.Bar(
+                    x=roi_labels,
+                    y=roi1,
+                    name='Image 1',
+                    marker_color='lightblue',
+                    showlegend=False
+                ),
+                row=1, col=1
+            )
+            
+            fig.add_trace(
+                go.Bar(
+                    x=roi_labels,
+                    y=roi2,
+                    name='Image 2',
+                    marker_color='lightcoral',
+                    showlegend=False
+                ),
+                row=1, col=2
+            )
+            
+            # Calculate similarities
+            cosine_sim = np.dot(roi1, roi2) / (np.linalg.norm(roi1) * np.linalg.norm(roi2))
+            pearson_sim = np.corrcoef(roi1, roi2)[0, 1]
+            
+            # Update layout
+            fig.update_layout(
+                title=f'ROI Comparison - Pair #{row_index}<br>Cosine: {cosine_sim:.3f}, Pearson: {pearson_sim:.3f}',
+                height=500,
+                width=1000,
+                showlegend=False
+            )
+            
+            # Update x-axis labels
+            fig.update_xaxes(tickangle=45)
+            fig.update_yaxes(title_text="Activation Level")
+            
+            return fig
+            
+        except Exception as e:
+            print(f"Error creating ROI plot: {e}")
+            return None
+
+class PlotGenerator:
+    """Handles creation of plotly visualizations"""
+    
+    def __init__(self, data_loader):
+        self.data_loader = data_loader
+    
+    def get_model_data(self, ml_model_selection):
+        """Get model data - either individual model or category average"""
+        data = self.data_loader.data
+        
+        # Handle category averages
+        if ml_model_selection == "avg_vision":
+            vision_models = [model[0] for model in self.data_loader.model_categories['vision']]
+            if vision_models:
+                avg_data = data[vision_models].mean(axis=1)
+                return avg_data, "Vision Models (Average)"
+            else:
+                raise ValueError("No vision models available")
+                
+        elif ml_model_selection == "avg_language":
+            language_models = [model[0] for model in self.data_loader.model_categories['language']]
+            if language_models:
+                avg_data = data[language_models].mean(axis=1)
+                return avg_data, "Language Models (Average)"
+            else:
+                raise ValueError("No language models available")
+                
+        elif ml_model_selection == "avg_semantic":
+            semantic_models = [model[0] for model in self.data_loader.model_categories['semantic']]
+            if semantic_models:
+                avg_data = data[semantic_models].mean(axis=1)
+                return avg_data, "Semantic Models (Average)"
+            else:
+                raise ValueError("No semantic models available")
+        
+        # Handle individual models
+        elif isinstance(ml_model_selection, int):
+            ml_column = self.data_loader.ml_models[ml_model_selection]
+            return data[ml_column], ml_column
+        
+        else:
+            raise ValueError(f"Invalid model selection: {ml_model_selection}")
+    
+    def create_3d_plot(self, brain_measure, ml_model_selection):
+        """Create 3D scatter plot"""
+        data = self.data_loader.data
+        
+        try:
+            ml_data, ml_name = self.get_model_data(ml_model_selection)
+        except ValueError as e:
+            print(f"Error getting model data: {e}")
+            return None
+        
+        # Create hover text
+        hover_text = []
+        for idx, row in data.iterrows():
+            text = f"Pair #{idx}<br>"
+            text += f"Images: {row['image_1']} vs {row['image_2']}<br>"
+            text += f"Human: {row['human_judgement']:.3f}<br>"
+            text += f"Brain: {row[brain_measure]:.3f}<br>"
+            text += f"ML: {ml_data.iloc[idx]:.3f}"
+            hover_text.append(text)
+        
+        fig = go.Figure(data=go.Scatter3d(
+            x=data['human_judgement'],
+            y=data[brain_measure],
+            z=ml_data,
+            mode='markers',
+            marker=dict(
+                size=6,
+                color=data['human_judgement'],
+                colorscale='Viridis',
+                opacity=0.7,
+                colorbar=dict(title="Human Rating")
+            ),
+            text=hover_text,
+            hovertemplate='%{text}<extra></extra>',
+            customdata=data[['image_1', 'image_2', 'stim_1', 'stim_2']].values
+        ))
+        
+        brain_name = brain_measure.replace('cosine_similarity_roi_values_', '').replace('pearson_correlation_roi_values_', '').title()
+        measure_type = "Cosine" if "cosine" in brain_measure else "Pearson"
+        
+        fig.update_layout(
+            title=f'3D Analysis: Human vs {measure_type} {brain_name} Brain vs {ml_name}',
+            scene=dict(
+                xaxis_title='Human Rating (0-5)',
+                yaxis_title=f'Brain Similarity ({measure_type} {brain_name})',
+                zaxis_title=f'ML Model: {ml_name}',
+                camera=dict(eye=dict(x=1.5, y=1.5, z=1.5))
+            ),
+            width=800,
+            height=600
+        )
+        
+        return fig
+    
+    def create_2d_plots(self, brain_measure, ml_model_selection):
+        """Create three 2D scatter plots"""
+        data = self.data_loader.data
+        
+        try:
+            ml_data, ml_name = self.get_model_data(ml_model_selection)
+        except ValueError as e:
+            print(f"Error getting model data: {e}")
+            return None
+        
+        # Calculate correlations
+        corr_hb = data['human_judgement'].corr(data[brain_measure])
+        corr_hm = data['human_judgement'].corr(ml_data)
+        corr_bm = data[brain_measure].corr(ml_data)
+        
+        brain_name = brain_measure.replace('cosine_similarity_roi_values_', '').replace('pearson_correlation_roi_values_', '').title()
+        measure_type = "Cosine" if "cosine" in brain_measure else "Pearson"
+        
+        # Create subplot
+        fig = make_subplots(
+            rows=1, cols=3,
+            subplot_titles=[
+                f'Human vs Brain (r={corr_hb:.3f})', 
+                f'Human vs ML (r={corr_hm:.3f})', 
+                f'Brain vs ML (r={corr_bm:.3f})'
+            ],
+            horizontal_spacing=0.1
+        )
+        
+        # Custom data for hover - include row index
+        customdata = [[idx, row['image_1'], row['image_2']] for idx, row in data.iterrows()]
+        
+        # Plot 1: Human vs Brain
+        fig.add_trace(
+            go.Scatter(
+                x=data['human_judgement'],
+                y=data[brain_measure],
+                mode='markers',
+                marker=dict(color='blue', opacity=0.6, size=3),
+                hovertemplate='Pair #%{customdata[0]}<br>Human: %{x:.3f}<br>Brain: %{y:.3f}<br>%{customdata[1]} vs %{customdata[2]}<extra></extra>',
+                customdata=customdata,
+                showlegend=False
+            ),
+            row=1, col=1
+        )
+        
+        # Plot 2: Human vs ML
+        fig.add_trace(
+            go.Scatter(
+                x=data['human_judgement'],
+                y=ml_data,
+                mode='markers',
+                marker=dict(color='red', opacity=0.6, size=3),
+                hovertemplate='Pair #%{customdata[0]}<br>Human: %{x:.3f}<br>ML: %{y:.3f}<br>%{customdata[1]} vs %{customdata[2]}<extra></extra>',
+                customdata=customdata,
+                showlegend=False
+            ),
+            row=1, col=2
+        )
+        
+        # Plot 3: Brain vs ML
+        fig.add_trace(
+            go.Scatter(
+                x=data[brain_measure],
+                y=ml_data,
+                mode='markers',
+                marker=dict(color='green', opacity=0.6, size=3),
+                hovertemplate='Pair #%{customdata[0]}<br>Brain: %{x:.3f}<br>ML: %{y:.3f}<br>%{customdata[1]} vs %{customdata[2]}<extra></extra>',
+                customdata=customdata,
+                showlegend=False
+            ),
+            row=1, col=3
+        )
+        
+        # Update layout
+        fig.update_layout(
+            title=f'2D Comparisons: {measure_type} {brain_name} Brain vs {ml_name}',
+            width=1300,
+            height=500,
+            margin=dict(l=60, r=60, t=80, b=80)
+        )
+        
+        return fig
+
+class ImageViewer:
+    """Handles image loading and display"""
+    
+    @staticmethod
+    def load_image_from_url(url, max_size=(200, 200)):
+        """Load and resize image from URL"""
+        try:
+            response = requests.get(url, timeout=10)
+            img = Image.open(BytesIO(response.content))
+            img.thumbnail(max_size, Image.Resampling.LANCZOS)
+            return img
+        except Exception as e:
+            print(f"Error loading image {url}: {e}")
+            placeholder = Image.new('RGB', (200, 200), color='gray')
+            return placeholder
+    
+    @staticmethod
+    def get_image_pair(data, row_index):
+        """Get image pair for a specific row"""
+        if row_index >= len(data):
+            return None, None
+        
+        row = data.iloc[row_index]
+        img1_url = row.get('stim_1', '')
+        img2_url = row.get('stim_2', '')
+        
+        img1 = ImageViewer.load_image_from_url(img1_url) if img1_url else None
+        img2 = ImageViewer.load_image_from_url(img2_url) if img2_url else None
+        
+        return img1, img2
+
+class SimilarityApp:
+    """Main application class"""
+    
+    def __init__(self, csv_path):
+        self.data_loader = DataLoader()
+        self.plot_generator = PlotGenerator(self.data_loader)
+        self.image_viewer = ImageViewer()
+        self.roi_visualizer = ROIVisualizer()
+        
+        if not self.data_loader.load_csv(csv_path):
+            raise ValueError("Failed to load data")
+    
+    def update_plots(self, brain_measure, ml_model_selection):
+        """Update both 3D and 2D plots"""
+        try:
+            fig_3d = self.plot_generator.create_3d_plot(brain_measure, ml_model_selection)
+            fig_2d = self.plot_generator.create_2d_plots(brain_measure, ml_model_selection)
+            return fig_3d, fig_2d
+        except Exception as e:
+            print(f"Error updating plots: {e}")
+            return None, None
+    
+    def get_correlations(self, brain_measure, ml_model_selection):
+        """Get correlation statistics with min/max ranges"""
+        try:
+            data = self.data_loader.data
+            ml_data, ml_name = self.plot_generator.get_model_data(ml_model_selection)
+            
+            corr_hb = data['human_judgement'].corr(data[brain_measure])
+            corr_hm = data['human_judgement'].corr(ml_data)
+            corr_bm = data[brain_measure].corr(ml_data)
+            
+            brain_name = brain_measure.replace('cosine_similarity_roi_values_', '').replace('pearson_correlation_roi_values_', '').title()
+            measure_type = "Cosine" if "cosine" in brain_measure else "Pearson"
+            
+            # Calculate min/max correlations across all models for comparison
+            all_human_ml_corrs = []
+            all_brain_ml_corrs = []
+            for model_col in self.data_loader.ml_models:
+                human_ml_corr = data['human_judgement'].corr(data[model_col])
+                brain_ml_corr = data[brain_measure].corr(data[model_col])
+                all_human_ml_corrs.append(human_ml_corr)
+                all_brain_ml_corrs.append(brain_ml_corr)
+            
+            min_human_ml = min(all_human_ml_corrs)
+            max_human_ml = max(all_human_ml_corrs)
+            min_brain_ml = min(all_brain_ml_corrs)
+            max_brain_ml = max(all_brain_ml_corrs)
+            
+            stats_text = f"""## Current Analysis
+
+### Correlation Results
+| Comparison | Correlation |
+|------------|-------------|
+| Human ↔ Brain ({measure_type}) | **{corr_hb:.3f}** |
+| Human ↔ ML Model | **{corr_hm:.3f}** |  
+| Brain ({measure_type}) ↔ ML Model | **{corr_bm:.3f}** |
+
+### Dataset Correlation Ranges
+| Comparison | Min | Max |
+|------------|-----|-----|
+| Human ↔ All ML Models | {min_human_ml:.3f} | {max_human_ml:.3f} |
+| Brain ({measure_type}) ↔ All ML Models | {min_brain_ml:.3f} | {max_brain_ml:.3f} |
+
+### Dataset Information
+- **Total Image Pairs:** {len(data):,}
+- **Available ML Models:** {len(self.data_loader.ml_models)}
+- **Brain Measure:** {measure_type} {brain_name}
+            """
+            return stats_text
+        except Exception as e:
+            return f"**Error:** {e}"
+    
+    def get_model_rankings_for_pair(self, row_index):
+        """Get top 3 best and worst models for each category for a specific image pair"""
+        try:
+            data = self.data_loader.data
+            if row_index >= len(data):
+                return {}
+            
+            row = data.iloc[row_index]
+            rankings = {}
+            
+            # Get rankings for each category
+            for category in ['vision', 'language', 'semantic']:
+                if not self.data_loader.model_categories[category]:
+                    continue
+                
+                # Get all models in this category with their scores
+                category_models = [model[0] for model in self.data_loader.model_categories[category]]
+                model_scores = [(model, row[model]) for model in category_models]
+                
+                # Sort by score (highest first)
+                model_scores.sort(key=lambda x: x[1], reverse=True)
+                
+                # Get top 3 and bottom 3
+                top_3 = model_scores[:3]
+                bottom_3 = model_scores[-3:]
+                
+                rankings[category] = {
+                    'best': top_3,
+                    'worst': bottom_3
+                }
+            
+            return rankings
+        except Exception as e:
+            print(f"Error getting model rankings: {e}")
+            return {}
+    
+    def show_image_pair(self, row_index):
+        """Show specific image pair with details, captions, and model rankings"""
+        try:
+            data = self.data_loader.data
+            if row_index >= len(data):
+                return None, None, "Invalid row index", None
+            
+            row = data.iloc[row_index]
+            img1, img2 = self.image_viewer.get_image_pair(data, row_index)
+            
+            # Get model rankings for this specific pair
+            rankings = self.get_model_rankings_for_pair(row_index)
+            
+            # Get captions
+            caption1 = row.get('image_1_description', 'No caption available')
+            caption2 = row.get('image_2_description', 'No caption available')
+            
+            info_text = f"""## Image Pair #{row_index}
+            
+**Images:** `{row['image_1']}` vs `{row['image_2']}`
+
+### Image Captions
+**Image 1:** {caption1}
+
+**Image 2:** {caption2}
+
+### Similarity Scores
+| Measure | Score |
+|---------|-------|
+| Human Rating | {row['human_judgement']:.3f}/6 |
+| Brain (Cosine Common) | {row.get('cosine_similarity_roi_values_common', 0):.3f} |
+| Brain (Cosine Early) | {row.get('cosine_similarity_roi_values_early', 0):.3f} |
+| Brain (Cosine Late) | {row.get('cosine_similarity_roi_values_late', 0):.3f} |
+| Brain (Pearson Common) | {row.get('pearson_correlation_roi_values_common', 0):.3f} |
+| Brain (Pearson Early) | {row.get('pearson_correlation_roi_values_early', 0):.3f} |
+| Brain (Pearson Late) | {row.get('pearson_correlation_roi_values_late', 0):.3f} |
+
+"""
+            
+            # Add model rankings for each category
+            for category in ['vision', 'language', 'semantic']:
+                if category in rankings:
+                    category_name = category.title()
+                    info_text += f"### Top 3 Best {category_name} Models\n"
+                    for i, (model, score) in enumerate(rankings[category]['best'], 1):
+                        clean_name = model.replace('BOLD5000_timm_', '').replace('_sim_partial', '') if 'BOLD5000_timm_' in model else model
+                        info_text += f"{i}. {clean_name}: {score:.3f}\n"
+                    
+                    info_text += f"\n### Top 3 Worst {category_name} Models\n"
+                    for i, (model, score) in enumerate(rankings[category]['worst'], 1):
+                        clean_name = model.replace('BOLD5000_timm_', '').replace('_sim_partial', '') if 'BOLD5000_timm_' in model else model
+                        info_text += f"{i}. {clean_name}: {score:.3f}\n"
+                    info_text += "\n"
+            
+            # Create ROI comparison plot
+            roi_plot = self.roi_visualizer.create_roi_comparison_plot(data, row_index)
+            
+            return img1, img2, info_text, roi_plot
+            
+        except Exception as e:
+            return None, None, f"**Error:** {e}", None
+    
+    def create_interface(self):
+        """Create the Gradio interface"""
+        brain_options = self.data_loader.get_brain_measure_options()
+        ml_options = self.data_loader.get_ml_model_options()
+        
+        with gr.Blocks(title="Enhanced Image Similarity Analysis", theme=gr.themes.Soft()) as interface:
+            gr.Markdown("# Enhanced Image Similarity Analysis")
+            gr.Markdown("Compare human judgments, brain responses (Cosine & Pearson), and ML model similarities with captions and ROI visualization")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Controls")
+                    
+                    brain_dropdown = gr.Dropdown(
+                        choices=brain_options,
+                        value=brain_options[0][1] if brain_options else None,
+                        label="Brain Response Type",
+                        info="Choose between Cosine similarity and Pearson correlation"
+                    )
+                    
+                    ml_dropdown = gr.Dropdown(
+                        choices=ml_options,
+                        value=ml_options[0][1] if ml_options else None,
+                        label="ML Model",
+                        info="Individual models or category averages"
+                    )
+                    
+                    update_btn = gr.Button("Update Plots", variant="primary")
+                    stats_display = gr.Markdown("Select parameters and click 'Update Plots'")
+                
+                with gr.Column(scale=2):
+                    gr.Markdown("### 3D Visualization")
+                    plot_3d = gr.Plot(label="3D Scatter Plot")
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 2D Pairwise Comparisons")
+                    plot_2d = gr.Plot(label="2D Scatter Plots", show_label=False)
+            
+            # Enhanced image viewer section with captions and ROI visualization
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Image Pair Viewer")
+                    
+                    with gr.Row():
+                        row_input = gr.Number(
+                            value=0, 
+                            label="Image Pair Index", 
+                            info=f"Enter 0 to {len(self.data_loader.data)-1}",
+                            precision=0
+                        )
+                        show_btn = gr.Button("Show Images & ROI", variant="secondary", size="sm")
+                    
+                    image_info = gr.Markdown("Enter an index and click 'Show Images & ROI' to see details")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### Image 1")
+                    image1_display = gr.Image(label="Image 1", height=200)
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### Image 2") 
+                    image2_display = gr.Image(label="Image 2", height=200)
+            
+            # ROI visualization section
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### ROI Brain Activation Comparison")
+                    roi_plot = gr.Plot(label="Side-by-Side ROI Values", show_label=False)
+            
+            # Event handlers
+            def update_all(brain_measure, ml_model_selection):
+                # Filter out non-selectable options
+                if ml_model_selection == "separator":
+                    return None, None, "Please select a valid model or average option"
+                
+                fig_3d, fig_2d = self.update_plots(brain_measure, ml_model_selection)
+                stats = self.get_correlations(brain_measure, ml_model_selection)
+                return fig_3d, fig_2d, stats
+            
+            def show_images_and_roi(row_idx):
+                img1, img2, info, roi_fig = self.show_image_pair(int(row_idx) if row_idx is not None else 0)
+                return img1, img2, info, roi_fig
+            
+            # Connect events
+            update_btn.click(
+                fn=update_all,
+                inputs=[brain_dropdown, ml_dropdown],
+                outputs=[plot_3d, plot_2d, stats_display]
+            )
+            
+            brain_dropdown.change(
+                fn=update_all,
+                inputs=[brain_dropdown, ml_dropdown],
+                outputs=[plot_3d, plot_2d, stats_display]
+            )
+            
+            ml_dropdown.change(
+                fn=update_all,
+                inputs=[brain_dropdown, ml_dropdown],
+                outputs=[plot_3d, plot_2d, stats_display]
+            )
+            
+            show_btn.click(
+                fn=show_images_and_roi,
+                inputs=[row_input],
+                outputs=[image1_display, image2_display, image_info, roi_plot]
+            )
+            
+            row_input.change(
+                fn=show_images_and_roi,
+                inputs=[row_input],
+                outputs=[image1_display, image2_display, image_info, roi_plot]
+            )
+        
+        return interface
+
+def main():
+    """Main function to run the application"""
+    try:
+        # Update this to use your new CSV file
+        app = SimilarityApp('overall_database.csv')
+        interface = app.create_interface()
+        interface.launch(
+            server_name="localhost",
+            server_port=7860,
+            share=False,
+            debug=True
+        )
+        
+    except Exception as e:
+        print(f"Error starting application: {e}")
+
+if __name__ == "__main__":
+    main()

visualization/image_viewer.py

@@ -0,0 +1,39 @@
+# ==================== visualization/image_viewer.py ====================
+"""Image loading and display functionality"""
+
+import pandas as pd
+from PIL import Image
+import requests
+from io import BytesIO
+from typing import Optional, Tuple
+
+class ImageViewer:
+    """Handles image loading and display"""
+    
+    @staticmethod
+    def load_image_from_url(url: str, max_size: Tuple[int, int] = (200, 200)) -> Optional[Image.Image]:
+        """Load and resize image from URL"""
+        try:
+            response = requests.get(url, timeout=10)
+            img = Image.open(BytesIO(response.content))
+            img.thumbnail(max_size, Image.Resampling.LANCZOS)
+            return img
+        except Exception as e:
+            print(f"Error loading image {url}: {e}")
+            placeholder = Image.new('RGB', (200, 200), color='gray')
+            return placeholder
+    
+    @staticmethod
+    def get_image_pair(data: pd.DataFrame, row_index: int) -> Tuple[Optional[Image.Image], Optional[Image.Image]]:
+        """Get image pair for a specific row"""
+        if row_index >= len(data):
+            return None, None
+        
+        row = data.iloc[row_index]
+        img1_url = row.get('stim_1', '')
+        img2_url = row.get('stim_2', '')
+        
+        img1 = ImageViewer.load_image_from_url(img1_url) if img1_url else None
+        img2 = ImageViewer.load_image_from_url(img2_url) if img2_url else None
+        
+        return img1, img2

visualization/plot_generator.py

@@ -0,0 +1,189 @@
+# visualization/plot_generator.py
+"""Main plotting functionality for similarity analysis"""
+
+import pandas as pd
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from typing import Tuple, Optional, Union
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+class PlotGenerator:
+    """Handles creation of plotly visualizations"""
+    
+    def __init__(self, data_loader):
+        self.data_loader = data_loader
+    
+    def get_model_data(self, ml_model_selection: Union[str, int]) -> Tuple[pd.Series, str]:
+        """Get model data - either individual model or category average"""
+        data = self.data_loader.data
+        
+        # Handle category averages
+        if ml_model_selection == "avg_vision":
+            vision_models = [model[0] for model in self.data_loader.model_categories['vision']]
+            if vision_models:
+                avg_data = data[vision_models].mean(axis=1)
+                return avg_data, "Vision Models (Average)"
+            else:
+                raise ValueError("No vision models available")
+                
+        elif ml_model_selection == "avg_language":
+            language_models = [model[0] for model in self.data_loader.model_categories['language']]
+            if language_models:
+                avg_data = data[language_models].mean(axis=1)
+                return avg_data, "Language Models (Average)"
+            else:
+                raise ValueError("No language models available")
+                
+        elif ml_model_selection == "avg_semantic":
+            semantic_models = [model[0] for model in self.data_loader.model_categories['semantic']]
+            if semantic_models:
+                avg_data = data[semantic_models].mean(axis=1)
+                return avg_data, "Semantic Models (Average)"
+            else:
+                raise ValueError("No semantic models available")
+        
+        # Handle individual models
+        elif isinstance(ml_model_selection, int):
+            ml_column = self.data_loader.ml_models[ml_model_selection]
+            return data[ml_column], ml_column
+        
+        else:
+            raise ValueError(f"Invalid model selection: {ml_model_selection}")
+    
+    def create_3d_plot(self, brain_measure: str, ml_model_selection: Union[str, int]) -> Optional[go.Figure]:
+        """Create 3D scatter plot"""
+        data = self.data_loader.data
+        
+        try:
+            ml_data, ml_name = self.get_model_data(ml_model_selection)
+        except ValueError as e:
+            print(f"Error getting model data: {e}")
+            return None
+        
+        # Create hover text
+        hover_text = []
+        for idx, row in data.iterrows():
+            text = f"Pair #{idx}<br>"
+            text += f"Images: {row['image_1']} vs {row['image_2']}<br>"
+            text += f"Human: {row['human_judgement']:.3f}<br>"
+            text += f"Brain: {row[brain_measure]:.3f}<br>"
+            text += f"ML: {ml_data.iloc[idx]:.3f}"
+            hover_text.append(text)
+        
+        fig = go.Figure(data=go.Scatter3d(
+            x=data['human_judgement'],
+            y=data[brain_measure],
+            z=ml_data,
+            mode='markers',
+            marker=dict(
+                size=6,
+                color=data['human_judgement'],
+                colorscale='Viridis',
+                opacity=0.7,
+                colorbar=dict(title="Human Rating")
+            ),
+            text=hover_text,
+            hovertemplate='%{text}<extra></extra>',
+            customdata=data[['image_1', 'image_2', 'stim_1', 'stim_2']].values
+        ))
+        
+        brain_name = brain_measure.replace('cosine_similarity_roi_values_', '').replace('pearson_correlation_roi_values_', '').title()
+        measure_type = "Cosine" if "cosine" in brain_measure else "Pearson"
+        
+        fig.update_layout(
+            title=f'3D Analysis: Human vs {measure_type} {brain_name} Brain vs {ml_name}',
+            scene=dict(
+                xaxis_title='Human Rating (0-5)',
+                yaxis_title=f'Brain Similarity ({measure_type} {brain_name})',
+                zaxis_title=f'ML Model: {ml_name}',
+                camera=dict(eye=dict(x=1.5, y=1.5, z=1.5))
+            ),
+            width=800,
+            height=600
+        )
+        
+        return fig
+    
+    def create_2d_plots(self, brain_measure: str, ml_model_selection: Union[str, int]) -> Optional[go.Figure]:
+        """Create three 2D scatter plots"""
+        data = self.data_loader.data
+        
+        try:
+            ml_data, ml_name = self.get_model_data(ml_model_selection)
+        except ValueError as e:
+            print(f"Error getting model data: {e}")
+            return None
+        
+        # Calculate correlations
+        corr_hb = data['human_judgement'].corr(data[brain_measure])
+        corr_hm = data['human_judgement'].corr(ml_data)
+        corr_bm = data[brain_measure].corr(ml_data)
+        
+        brain_name = brain_measure.replace('cosine_similarity_roi_values_', '').replace('pearson_correlation_roi_values_', '').title()
+        measure_type = "Cosine" if "cosine" in brain_measure else "Pearson"
+        
+        # Create subplot
+        fig = make_subplots(
+            rows=1, cols=3,
+            subplot_titles=[
+                f'Human vs Brain (r={corr_hb:.3f})', 
+                f'Human vs ML (r={corr_hm:.3f})', 
+                f'Brain vs ML (r={corr_bm:.3f})'
+            ],
+            horizontal_spacing=0.1
+        )
+        
+        # Custom data for hover
+        customdata = [[idx, row['image_1'], row['image_2']] for idx, row in data.iterrows()]
+        
+        # Add scatter plots with proper labels
+        plot_configs = [
+            {
+                'x': data['human_judgement'], 
+                'y': data[brain_measure], 
+                'color': 'blue',
+                'x_label': 'Human',
+                'y_label': f'Brain ({measure_type})'
+            },
+            {
+                'x': data['human_judgement'], 
+                'y': ml_data, 
+                'color': 'red',
+                'x_label': 'Human',
+                'y_label': 'ML Model'
+            },
+            {
+                'x': data[brain_measure], 
+                'y': ml_data, 
+                'color': 'green',
+                'x_label': f'Brain ({measure_type})',
+                'y_label': 'ML Model'
+            }
+        ]
+        
+        for i, config in enumerate(plot_configs):
+            fig.add_trace(
+                go.Scatter(
+                    x=config['x'], 
+                    y=config['y'],
+                    mode='markers',
+                    marker=dict(color=config['color'], opacity=0.6, size=3),
+                    hovertemplate=f'Pair #%{{customdata[0]}}<br>{config["x_label"]}: %{{x:.3f}}<br>{config["y_label"]}: %{{y:.3f}}<br>%{{customdata[1]}} vs %{{customdata[2]}}<extra></extra>',
+                    customdata=customdata,
+                    showlegend=False
+                ),
+                row=1, col=i+1
+            )
+        
+        fig.update_layout(
+            title=f'2D Comparisons: {measure_type} {brain_name} Brain vs {ml_name}',
+            width=1300,
+            height=500,
+            margin=dict(l=60, r=60, t=80, b=80)
+        )
+        
+        return fig