debug

app.py

@@ -410,8 +410,10 @@ def init_leaderboard_mib_subgraph(dataframe, track):
         initial_selected=["Method", "Average"]
     )
 
+    print("\nDebugging DataFrame columns:", renamed_df.columns.tolist())
+
     # Create Leaderboard
-    return Leaderboard(
+    leaderboard = Leaderboard(
         value=renamed_df,
         datatype=[c.type for c in fields(AutoEvalColumn_mib_subgraph)],
         select_columns=smart_columns,
@@ -419,6 +421,9 @@ def init_leaderboard_mib_subgraph(dataframe, track):
         hide_columns=[],
         interactive=False
     )
+    print(f"Successfully created leaderboard.")
+    return leaderboard
+
 
 
 

custom-select-columns.py

@@ -579,6 +579,190 @@ if __name__ == "__main__":
 
 
 
+
+
+
+
+
+from gradio_leaderboard import SelectColumns, Leaderboard
+import pandas as pd
+from typing import List, Dict, Union, Optional, Any
+from dataclasses import fields
+
+class SmartSelectColumns(SelectColumns):
+    """
+    Enhanced SelectColumns component for gradio_leaderboard with dynamic column filtering.
+    """
+    def __init__(
+        self,
+        benchmark_keywords: Optional[List[str]] = None,
+        model_keywords: Optional[List[str]] = None,
+        column_mapping: Optional[Dict[str, str]] = None,
+        initial_selected: Optional[List[str]] = None,
+        **kwargs
+    ):
+        """
+        Initialize SmartSelectColumns with dynamic filtering.
+        
+        Args:
+            benchmark_keywords: List of benchmark names to filter by (e.g., ["ioi", "mcqa"])
+            model_keywords: List of model names to filter by (e.g., ["llama3", "qwen2_5"])
+            column_mapping: Dict mapping actual column names to display names
+            initial_selected: List of columns to show initially
+        """
+        super().__init__(**kwargs)
+        self.benchmark_keywords = benchmark_keywords or []
+        self.model_keywords = model_keywords or []
+        self.column_mapping = column_mapping or {}
+        self.reverse_mapping = {v: k for k, v in self.column_mapping.items()} if column_mapping else {}
+        self.initial_selected = initial_selected or []
+        
+    def preprocess_value(self, x: List[str]) -> List[str]:
+        """Transform selected display names back to actual column names."""
+        return [self.reverse_mapping.get(col, col) for col in x]
+    
+    def postprocess_value(self, y: List[str]) -> List[str]:
+        """Transform actual column names to display names."""
+        return [self.column_mapping.get(col, col) for col in y]
+
+    def get_filtered_groups(self, df: pd.DataFrame) -> Dict[str, List[str]]:
+        """
+        Dynamically create column groups based on keywords.
+        """
+        filtered_groups = {}
+        
+        # Create benchmark groups
+        for benchmark in self.benchmark_keywords:
+            matching_cols = [
+                col for col in df.columns 
+                if benchmark in col.lower()
+            ]
+            if matching_cols:
+                group_name = f"Benchmark group for {benchmark}"
+                filtered_groups[group_name] = [
+                    self.column_mapping.get(col, col) 
+                    for col in matching_cols
+                ]
+        
+        # Create model groups
+        for model in self.model_keywords:
+            matching_cols = [
+                col for col in df.columns 
+                if model in col.lower()
+            ]
+            if matching_cols:
+                group_name = f"Model group for {model}"
+                filtered_groups[group_name] = [
+                    self.column_mapping.get(col, col) 
+                    for col in matching_cols
+                ]
+        
+        return filtered_groups
+
+    def update(
+        self, 
+        value: Union[pd.DataFrame, Dict[str, List[str]], Any]
+    ) -> Dict:
+        """Update component with new values."""
+        if isinstance(value, pd.DataFrame):
+            # Get all column names and convert to display names
+            choices = [self.column_mapping.get(col, col) for col in value.columns]
+            
+            # Use initial selection or default columns
+            selected = self.initial_selected if self.initial_selected else choices
+            
+            # Get dynamically filtered groups
+            filtered_cols = self.get_filtered_groups(value)
+            
+            return {
+                "choices": choices,
+                "value": selected,
+                "filtered_cols": filtered_cols
+            }
+        
+        # Handle fields object
+        if hasattr(value, '__dataclass_fields__'):
+            field_names = [field.name for field in fields(value)]
+            choices = [self.column_mapping.get(name, name) for name in field_names]
+            return {
+                "choices": choices,
+                "value": self.initial_selected if self.initial_selected else choices
+            }
+            
+        return super().update(value)
+
+
+# Example usage
+if __name__ == "__main__":
+    # Sample DataFrame
+    df = pd.DataFrame({
+        "eval_name": ["test1", "test2", "test3"],
+        "Method": ["method1", "method2", "method3"],
+        "ioi_llama3": [0.1, 0.2, 0.3],
+        "ioi_qwen2_5": [0.4, 0.5, 0.6],
+        "ioi_gpt2": [0.7, 0.8, 0.9],
+        "mcqa_llama3": [0.2, 0.3, 0.4],
+        "Average": [0.35, 0.45, 0.55]
+    })
+
+    # Define keywords for filtering
+    benchmark_keywords = ["ioi", "mcqa", "arithmetic_addition", "arithmetic_subtraction", "arc_easy", "arc_challenge"]
+    model_keywords = ["qwen2_5", "gpt2", "gemma2", "llama3"]
+
+    # Optional: Define display names
+    mappings = {
+        "ioi_llama3": "IOI (LLaMA-3)",
+        "ioi_qwen2_5": "IOI (Qwen-2.5)",
+        "ioi_gpt2": "IOI (GPT-2)",
+        "ioi_gemma2": "IOI (Gemma-2)",
+        "mcqa_llama3": "MCQA (LLaMA-3)",
+        "mcqa_qwen2_5": "MCQA (Qwen-2.5)",
+        "mcqa_gemma2": "MCQA (Gemma-2)",
+        "arithmetic_addition_llama3": "Arithmetic Addition (LLaMA-3)",
+        "arithmetic_subtraction_llama3": "Arithmetic Subtraction (LLaMA-3)",
+        "arc_easy_llama3": "ARC Easy (LLaMA-3)",
+        "arc_easy_gemma2": "ARC Easy (Gemma-2)",
+        "arc_challenge_llama3": "ARC Challenge (LLaMA-3)",
+        "eval_name": "Evaluation Name",
+        "Method": "Method",
+        "Average": "Average Score"
+    }
+
+    # Create SmartSelectColumns instance
+    smart_columns = SmartSelectColumns(
+        benchmark_keywords=benchmark_keywords,
+        model_keywords=model_keywords,
+        column_mapping=mappings,
+        initial_selected=["Method", "Average"]
+    )
+
+    # Create Leaderboard
+    leaderboard = Leaderboard(
+        value=df,
+        datatype=[c.type for c in fields(AutoEvalColumn_mib_subgraph)],
+        select_columns=smart_columns,
+        search_columns=["Method"],
+        hide_columns=[],
+        interactive=False
+    )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+