debug

app.py

@@ -38,6 +38,103 @@ from src.submission.submit import add_new_eval
 
 
 
+
+
+
+
+
+
+
+
+
+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 explicit column grouping.
+    """
+    def __init__(
+        self,
+        column_groups: Optional[Dict[str, List[str]]] = None,
+        column_mapping: Optional[Dict[str, str]] = None,
+        initial_selected: Optional[List[str]] = None,
+        **kwargs
+    ):
+        """
+        Initialize SmartSelectColumns with enhanced functionality.
+        
+        Args:
+            column_groups: Dict mapping group names to lists of columns in that group
+            column_mapping: Dict mapping actual column names to display names
+            initial_selected: List of columns to show initially
+        """
+        super().__init__(**kwargs)
+        self.column_groups = column_groups 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 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
+            
+            # Convert column groups to use display names
+            filtered_cols = {}
+            for group_name, columns in self.column_groups.items():
+                filtered_cols[group_name] = [
+                    self.column_mapping.get(col, col) 
+                    for col in columns 
+                    if col in value.columns
+                ]
+            
+            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)
+
+
+
+
+
+
+
+
+
+
+
+
+
 def restart_space():
     API.restart_space(repo_id=REPO_ID)
 
@@ -128,122 +225,58 @@ from src.about import TasksMib_Subgraph
 
 
 
-def init_leaderboard_mib_subgraph(dataframe, track):
-    """Initialize the subgraph leaderboard with grouped column selection by benchmark."""
-    if dataframe is None or dataframe.empty:
-        raise ValueError("Leaderboard DataFrame is empty or None.")
-
-    print("\nDebugging DataFrame columns:", dataframe.columns.tolist())
-    
-    # Create groups of columns by benchmark
-    benchmark_groups = []
-    
-    # For each benchmark in our TasksMib_Subgraph enum...
-    for task in TasksMib_Subgraph:
-        benchmark = task.value.benchmark
-        # Get all valid columns for this benchmark's models
-        benchmark_cols = [
-            f"{benchmark}_{model}"
-            for model in task.value.models
-            if f"{benchmark}_{model}" in dataframe.columns
-        ]
-        if benchmark_cols:  # Only add if we have valid columns
-            benchmark_groups.append(benchmark_cols)
-            print(f"\nBenchmark group for {benchmark}:", benchmark_cols)
-
-    # Create model groups as well
-    model_groups = []
-    all_models = list(set(model for task in TasksMib_Subgraph for model in task.value.models))
-    
-    # For each unique model...
-    for model in all_models:
-        # Get all valid columns for this model across benchmarks
-        model_cols = [
-            f"{task.value.benchmark}_{model}"
-            for task in TasksMib_Subgraph
-            if model in task.value.models
-            and f"{task.value.benchmark}_{model}" in dataframe.columns
-        ]
-        if model_cols:  # Only add if we have valid columns
-            model_groups.append(model_cols)
-            print(f"\nModel group for {model}:", model_cols)
-
-    # Combine all groups
-    all_groups = benchmark_groups + model_groups
-    
-    # Flatten groups for default selection (show everything initially)
-    all_columns = [col for group in all_groups for col in group]
-    print("\nAll available columns:", all_columns)
-
-    return Leaderboard(
-        value=dataframe,
-        datatype=[c.type for c in fields(AutoEvalColumn_mib_subgraph)],
-        select_columns=SelectColumns(
-            default_selection=all_columns,  # Show all columns initially
-            label="Select Results:"
-        ),
-        search_columns=["Method"],
-        hide_columns=[],
-        interactive=False,
-    )
-
-
 # def init_leaderboard_mib_subgraph(dataframe, track):
-#     """Initialize the subgraph leaderboard with display names for better readability."""
+#     """Initialize the subgraph leaderboard with grouped column selection by benchmark."""
 #     if dataframe is None or dataframe.empty:
 #         raise ValueError("Leaderboard DataFrame is empty or None.")
 
 #     print("\nDebugging DataFrame columns:", dataframe.columns.tolist())
     
-#     # First, create our display name mapping
-#     # This is like creating a translation dictionary between internal names and display names
-#     display_mapping = {}
-#     for task in TasksMib_Subgraph:
-#         for model in task.value.models:
-#             field_name = f"{task.value.benchmark}_{model}"
-#             display_name = f"{task.value.benchmark}({model})"
-#             display_mapping[field_name] = display_name
-
-#     # Now when creating benchmark groups, we'll use display names
+#     # Create groups of columns by benchmark
 #     benchmark_groups = []
+    
+#     # For each benchmark in our TasksMib_Subgraph enum...
 #     for task in TasksMib_Subgraph:
 #         benchmark = task.value.benchmark
+#         # Get all valid columns for this benchmark's models
 #         benchmark_cols = [
-#             display_mapping[f"{benchmark}_{model}"]  # Use display name from our mapping
+#             f"{benchmark}_{model}"
 #             for model in task.value.models
 #             if f"{benchmark}_{model}" in dataframe.columns
 #         ]
-#         if benchmark_cols:
+#         if benchmark_cols:  # Only add if we have valid columns
 #             benchmark_groups.append(benchmark_cols)
 #             print(f"\nBenchmark group for {benchmark}:", benchmark_cols)
 
-#     # Similarly for model groups
+#     # Create model groups as well
 #     model_groups = []
 #     all_models = list(set(model for task in TasksMib_Subgraph for model in task.value.models))
     
+#     # For each unique model...
 #     for model in all_models:
+#         # Get all valid columns for this model across benchmarks
 #         model_cols = [
-#             display_mapping[f"{task.value.benchmark}_{model}"]  # Use display name
+#             f"{task.value.benchmark}_{model}"
 #             for task in TasksMib_Subgraph
 #             if model in task.value.models
 #             and f"{task.value.benchmark}_{model}" in dataframe.columns
 #         ]
-#         if model_cols:
+#         if model_cols:  # Only add if we have valid columns
 #             model_groups.append(model_cols)
 #             print(f"\nModel group for {model}:", model_cols)
 
-#     # Combine all groups using display names
+#     # Combine all groups
 #     all_groups = benchmark_groups + model_groups
+    
+#     # Flatten groups for default selection (show everything initially)
 #     all_columns = [col for group in all_groups for col in group]
-
-#     # Important: We need to rename our DataFrame columns to match display names
-#     renamed_df = dataframe.rename(columns=display_mapping)
+#     print("\nAll available columns:", all_columns)
 
 #     return Leaderboard(
-#         value=renamed_df,  # Use DataFrame with display names
+#         value=dataframe,
 #         datatype=[c.type for c in fields(AutoEvalColumn_mib_subgraph)],
 #         select_columns=SelectColumns(
-#             default_selection=all_columns,  # Now contains display names
+#             default_selection=all_columns,  # Show all columns initially
 #             label="Select Results:"
 #         ),
 #         search_columns=["Method"],
@@ -252,152 +285,132 @@ def init_leaderboard_mib_subgraph(dataframe, track):
 #     )
 
 
+def init_leaderboard_mib_subgraph(dataframe, track):
+    """Initialize the subgraph leaderboard with display names for better readability."""
+    if dataframe is None or dataframe.empty:
+        raise ValueError("Leaderboard DataFrame is empty or None.")
 
-
-    class SmartSelectColumns(gr.SelectColumns):
-        """
-        Enhanced SelectColumns component for Gradio Leaderboard with smart filtering and mapping capabilities.
-        """
-        def __init__(
-            self,
-            column_filters: Optional[Dict[str, List[str]]] = None,
-            column_mapping: Optional[Dict[str, str]] = None,
-            initial_selected: Optional[List[str]] = None,
-            *args,
-            **kwargs
-        ):
-            """
-            Initialize SmartSelectColumns with enhanced functionality.
-            
-            Args:
-                column_filters: Dict mapping filter names to lists of substrings to match
-                column_mapping: Dict mapping actual column names to display names
-                initial_selected: List of column names to be initially selected
-                *args, **kwargs: Additional arguments passed to parent SelectColumns
-            """
-            super().__init__(*args, **kwargs)
-            self.column_filters = column_filters 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(self, x: List[str]) -> List[str]:
-            """
-            Transform selected display names back to actual column names.
-            
-            Args:
-                x: List of selected display names
-                
-            Returns:
-                List of actual column names
-            """
-            return [self.reverse_mapping.get(col, col) for col in x]
-        
-        def postprocess(self, y: List[str]) -> List[str]:
-            """
-            Transform actual column names to display names.
-            
-            Args:
-                y: List of actual column names
-                
-            Returns:
-                List of display names
-            """
-            return [self.column_mapping.get(col, col) for col in y]
-        
-        def get_filtered_columns(self, df: pd.DataFrame) -> Dict[str, List[str]]:
-            """
-            Get columns filtered by substring matches.
-            
-            Args:
-                df: Input DataFrame
-                
-            Returns:
-                Dict mapping filter names to lists of matching display names
-            """
-            filtered_cols = {}
-            
-            for filter_name, substrings in self.column_filters.items():
-                matching_cols = []
-                for col in df.columns:
-                    if any(substr.lower() in col.lower() for substr in substrings):
-                        display_name = self.column_mapping.get(col, col)
-                        matching_cols.append(display_name)
-                filtered_cols[filter_name] = matching_cols
-                
-            return filtered_cols
-
-        def update(
-            self, 
-            value: Union[pd.DataFrame, Dict[str, List[str]], Any], 
-            interactive: Optional[bool] = None
-        ) -> Dict:
-            """
-            Update component with new values, supporting DataFrame fields.
-            
-            Args:
-                value: DataFrame, dict of columns, or fields object
-                interactive: Whether component should be interactive
-                
-            Returns:
-                Dict containing update configuration
-            """
-            if isinstance(value, pd.DataFrame):
-                filtered_cols = self.get_filtered_columns(value)
-                choices = [self.column_mapping.get(col, col) for col in value.columns]
-                
-                # Set initial selection if provided
-                value = self.initial_selected if self.initial_selected else choices
-                
-                return {
-                    "choices": choices,
-                    "value": value,
-                    "filtered_cols": filtered_cols,
-                    "interactive": interactive if interactive is not None else self.interactive
-                }
-            
-            # Handle fields object (e.g., from dataclass)
-            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,
-                    "interactive": interactive if interactive is not None else self.interactive
-                }
-                
-            return super().update(value, interactive)
+    print("\nDebugging DataFrame columns:", dataframe.columns.tolist())
     
+    # First, create our display name mapping
+    # This is like creating a translation dictionary between internal names and display names
+    display_mapping = {}
+    for task in TasksMib_Subgraph:
+        for model in task.value.models:
+            field_name = f"{task.value.benchmark}_{model}"
+            display_name = f"{task.value.benchmark}({model})"
+            display_mapping[field_name] = display_name
 
-    # Define filters and mappings
-    filters = {
-        "IOI Metrics": ["ioi"],
-        "Performance Metrics": ["performance"]
-    }
-    
-    mappings = {
-        "ioi_score_1": "IOI Score (Type 1)",
-        "ioi_score_2": "IOI Score (Type 2)",
-        "other_metric": "Other Metric",
-        "performance_1": "Performance Metric 1"
-    }
+    # Now when creating benchmark groups, we'll use display names
+    benchmark_groups = []
+    for task in TasksMib_Subgraph:
+        benchmark = task.value.benchmark
+        benchmark_cols = [
+            display_mapping[f"{benchmark}_{model}"]  # Use display name from our mapping
+            for model in task.value.models
+            if f"{benchmark}_{model}" in dataframe.columns
+        ]
+        if benchmark_cols:
+            benchmark_groups.append(benchmark_cols)
+            print(f"\nBenchmark group for {benchmark}:", benchmark_cols)
+
+    # Similarly for model groups
+    model_groups = []
+    all_models = list(set(model for task in TasksMib_Subgraph for model in task.value.models))
     
-    column_filters = filters
-    column_mapping = mappings
-    initial_columns = renamed_df
+    for model in all_models:
+        model_cols = [
+            display_mapping[f"{task.value.benchmark}_{model}"]  # Use display name
+            for task in TasksMib_Subgraph
+            if model in task.value.models
+            and f"{task.value.benchmark}_{model}" in dataframe.columns
+        ]
+        if model_cols:
+            model_groups.append(model_cols)
+            print(f"\nModel group for {model}:", model_cols)
 
+    # Combine all groups using display names
+    all_groups = benchmark_groups + model_groups
+    all_columns = [col for group in all_groups for col in group]
+
+    # Important: We need to rename our DataFrame columns to match display names
+    renamed_df = dataframe.rename(columns=display_mapping)
+
+    # return Leaderboard(
+    #     value=renamed_df,  # Use DataFrame with display names
+    #     datatype=[c.type for c in fields(AutoEvalColumn_mib_subgraph)],
+    #     select_columns=SelectColumns(
+    #         default_selection=all_columns,  # Now contains display names
+    #         label="Select Results:"
+    #     ),
+    #     search_columns=["Method"],
+    #     hide_columns=[],
+    #     interactive=False,
+    # )
+        # Complete column groups for both benchmarks and models
+    column_groups = {
+        # Benchmark groups
+        "Benchmark group for ioi": ["ioi_gpt2", "ioi_qwen2_5", "ioi_gemma2", "ioi_llama3"],
+        "Benchmark group for mcqa": ["mcqa_qwen2_5", "mcqa_gemma2", "mcqa_llama3"],
+        "Benchmark group for arithmetic_addition": ["arithmetic_addition_llama3"],
+        "Benchmark group for arithmetic_subtraction": ["arithmetic_subtraction_llama3"],
+        "Benchmark group for arc_easy": ["arc_easy_gemma2", "arc_easy_llama3"],
+        "Benchmark group for arc_challenge": ["arc_challenge_llama3"],
+        
+        # Model groups
+        "Model group for qwen2_5": ["ioi_qwen2_5", "mcqa_qwen2_5"],
+        "Model group for gpt2": ["ioi_gpt2"],
+        "Model group for gemma2": ["ioi_gemma2", "mcqa_gemma2", "arc_easy_gemma2"],
+        "Model group for llama3": [
+            "ioi_llama3", 
+            "mcqa_llama3", 
+            "arithmetic_addition_llama3", 
+            "arithmetic_subtraction_llama3", 
+            "arc_easy_llama3", 
+            "arc_challenge_llama3"
+        ]
+    }
 
-    # Initialize SmartSelectColumns
+    # # Complete mappings for more readable display names
+    # mappings = {
+    #     # IOI benchmark mappings
+    #     "ioi_llama3": "IOI (LLaMA-3)",
+    #     "ioi_qwen2_5": "IOI (Qwen-2.5)",
+    #     "ioi_gpt2": "IOI (GPT-2)",
+    #     "ioi_gemma2": "IOI (Gemma-2)",
+        
+    #     # MCQA benchmark mappings
+    #     "mcqa_llama3": "MCQA (LLaMA-3)",
+    #     "mcqa_qwen2_5": "MCQA (Qwen-2.5)",
+    #     "mcqa_gemma2": "MCQA (Gemma-2)",
+        
+    #     # Arithmetic benchmark mappings
+    #     "arithmetic_addition_llama3": "Arithmetic Addition (LLaMA-3)",
+    #     "arithmetic_subtraction_llama3": "Arithmetic Subtraction (LLaMA-3)",
+        
+    #     # ARC benchmark mappings
+    #     "arc_easy_llama3": "ARC Easy (LLaMA-3)",
+    #     "arc_easy_gemma2": "ARC Easy (Gemma-2)",
+    #     "arc_challenge_llama3": "ARC Challenge (LLaMA-3)",
+        
+    #     # Other columns
+    #     "eval_name": "Evaluation Name",
+    #     "Method": "Method",
+    #     "Average": "Average Score"
+    # }
+    mappings = {}
+
+    # Create SmartSelectColumns instance
     smart_columns = SmartSelectColumns(
-        column_filters=filters,
+        column_groups=column_groups,
         column_mapping=mappings,
-        initial_selected=initial_columns,
-        multiselect=True
+        initial_selected=["Method", "Average"]
     )
 
-    return gr.Leaderboard(
+    # Create Leaderboard directly
+    leaderboard = Leaderboard(
         value=renamed_df,
-        datatype=[c.type for c in fields(column_class)],
+        datatype=[c.type for c in fields(AutoEvalColumn_mib_subgraph)],
         select_columns=smart_columns,
         search_columns=["Method"],
         hide_columns=[],
@@ -405,6 +418,10 @@ def init_leaderboard_mib_subgraph(dataframe, track):
     )
 
 
+
+
+
+
 # def init_leaderboard_mib_subgraph(dataframe, track):
 #     """Initialize the subgraph leaderboard with group-based column selection."""
 #     if dataframe is None or dataframe.empty:

custom-select-columns.py

@@ -287,25 +287,21 @@ def initialize_leaderboard(df: pd.DataFrame, column_class: Any,
     Returns:
         Configured Leaderboard instance
     """
-    # Create renamed DataFrame with display names
-    renamed_df = df.rename(columns=mappings)
-    
-    # Initialize SmartSelectColumns
-    smart_columns = SmartSelectColumns(
-        column_filters=filters,
-        column_mapping=mappings,
-        initial_selected=initial_columns,
-        multiselect=True
-    )
+
+    # Define filters and mappings
+    filters = {
+        "IOI Metrics": ["ioi"],
+        "Performance Metrics": ["performance"]
+    }
     
-    return gr.Leaderboard(
-        value=renamed_df,
-        datatype=[c.type for c in fields(column_class)],
-        select_columns=smart_columns,
-        search_columns=["Method"],
-        hide_columns=[],
-        interactive=False
-    )
+    mappings = {
+        "ioi_score_1": "IOI Score (Type 1)",
+        "ioi_score_2": "IOI Score (Type 2)",
+        "other_metric": "Other Metric",
+        "performance_1": "Performance Metric 1"
+    }
+
+
 
 # Example usage
 if __name__ == "__main__":
@@ -321,7 +317,7 @@ if __name__ == "__main__":
     # Define filters and mappings
     filters = {
         "IOI Metrics": ["ioi"],
-        "Performance Metrics": ["performance"]
+        "gemma2.5": ["gemma2_5`"]
     }
     
     mappings = {
@@ -341,5 +337,289 @@ if __name__ == "__main__":
             mappings=mappings,
             initial_columns=["Method", "IOI Score (Type 1)"]
         )
+    
+    
+    # Create renamed DataFrame with display names
+    renamed_df = df.rename(columns=mappings)
+
+    initial_columns=["Method", "IOI Score (Type 1)"]
+    initial_columns=?
+    
+    # Initialize SmartSelectColumns
+    smart_columns = SmartSelectColumns(
+        column_filters=filters,
+        column_mapping=mappings,
+        initial_selected=initial_columns,
+        multiselect=True
+    )
+    column_class=None
+
+    return gr.Leaderboard(
+        value=renamed_df,
+        datatype=[c.type for c in fields(column_class)],
+        select_columns=smart_columns,
+        search_columns=["Method"],
+        hide_columns=[],
+        interactive=False
+    )
+        
+    demo.launch()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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 explicit column grouping.
+    """
+    def __init__(
+        self,
+        column_groups: Optional[Dict[str, List[str]]] = None,
+        column_mapping: Optional[Dict[str, str]] = None,
+        initial_selected: Optional[List[str]] = None,
+        **kwargs
+    ):
+        """
+        Initialize SmartSelectColumns with enhanced functionality.
+        
+        Args:
+            column_groups: Dict mapping group names to lists of columns in that group
+            column_mapping: Dict mapping actual column names to display names
+            initial_selected: List of columns to show initially
+        """
+        super().__init__(**kwargs)
+        self.column_groups = column_groups 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 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
+            
+            # Convert column groups to use display names
+            filtered_cols = {}
+            for group_name, columns in self.column_groups.items():
+                filtered_cols[group_name] = [
+                    self.column_mapping.get(col, col) 
+                    for col in columns 
+                    if col in value.columns
+                ]
+            
+            return {
+                "choices": choices,
+                "value": selected,
+                "filtered_cols": filtered_cols
+            }
         
-    demo.launch()
+        # 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]
+    # })
+
+    # Complete column groups for both benchmarks and models
+    column_groups = {
+        # Benchmark groups
+        "Benchmark group for ioi": ["ioi_gpt2", "ioi_qwen2_5", "ioi_gemma2", "ioi_llama3"],
+        "Benchmark group for mcqa": ["mcqa_qwen2_5", "mcqa_gemma2", "mcqa_llama3"],
+        "Benchmark group for arithmetic_addition": ["arithmetic_addition_llama3"],
+        "Benchmark group for arithmetic_subtraction": ["arithmetic_subtraction_llama3"],
+        "Benchmark group for arc_easy": ["arc_easy_gemma2", "arc_easy_llama3"],
+        "Benchmark group for arc_challenge": ["arc_challenge_llama3"],
+        
+        # Model groups
+        "Model group for qwen2_5": ["ioi_qwen2_5", "mcqa_qwen2_5"],
+        "Model group for gpt2": ["ioi_gpt2"],
+        "Model group for gemma2": ["ioi_gemma2", "mcqa_gemma2", "arc_easy_gemma2"],
+        "Model group for llama3": [
+            "ioi_llama3", 
+            "mcqa_llama3", 
+            "arithmetic_addition_llama3", 
+            "arithmetic_subtraction_llama3", 
+            "arc_easy_llama3", 
+            "arc_challenge_llama3"
+        ]
+    }
+
+    # Complete mappings for more readable display names
+    mappings = {
+        # IOI benchmark mappings
+        "ioi_llama3": "IOI (LLaMA-3)",
+        "ioi_qwen2_5": "IOI (Qwen-2.5)",
+        "ioi_gpt2": "IOI (GPT-2)",
+        "ioi_gemma2": "IOI (Gemma-2)",
+        
+        # MCQA benchmark mappings
+        "mcqa_llama3": "MCQA (LLaMA-3)",
+        "mcqa_qwen2_5": "MCQA (Qwen-2.5)",
+        "mcqa_gemma2": "MCQA (Gemma-2)",
+        
+        # Arithmetic benchmark mappings
+        "arithmetic_addition_llama3": "Arithmetic Addition (LLaMA-3)",
+        "arithmetic_subtraction_llama3": "Arithmetic Subtraction (LLaMA-3)",
+        
+        # ARC benchmark mappings
+        "arc_easy_llama3": "ARC Easy (LLaMA-3)",
+        "arc_easy_gemma2": "ARC Easy (Gemma-2)",
+        "arc_challenge_llama3": "ARC Challenge (LLaMA-3)",
+        
+        # Other columns
+        "eval_name": "Evaluation Name",
+        "Method": "Method",
+        "Average": "Average Score"
+    }
+
+    # Create SmartSelectColumns instance
+    smart_columns = SmartSelectColumns(
+        column_groups=column_groups,
+        column_mapping=mappings,
+        initial_selected=["Method", "Average"]
+    )
+
+    # Create Leaderboard directly
+    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
+    )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Debugging DataFrame columns: ['eval_name', 'Method', 'ioi_llama3', 'ioi_qwen2_5', 'ioi_gpt2', 'ioi_gemma2', 'mcqa_llama3', 'mcqa_qwen2_5', 'mcqa_gemma2', 'arithmetic_addition_llama3', 'arithmetic_subtraction_llama3', 'arc_easy_llama3', 'arc_easy_gemma2', 'arc_challenge_llama3', 'Average']
+
+Benchmark group for ioi: ['ioi_gpt2', 'ioi_qwen2_5', 'ioi_gemma2', 'ioi_llama3']
+
+Benchmark group for mcqa: ['mcqa_qwen2_5', 'mcqa_gemma2', 'mcqa_llama3']
+
+Benchmark group for arithmetic_addition: ['arithmetic_addition_llama3']
+
+Benchmark group for arithmetic_subtraction: ['arithmetic_subtraction_llama3']
+
+Benchmark group for arc_easy: ['arc_easy_gemma2', 'arc_easy_llama3']
+
+Benchmark group for arc_challenge: ['arc_challenge_llama3']
+
+Model group for qwen2_5: ['ioi_qwen2_5', 'mcqa_qwen2_5']
+
+Model group for gpt2: ['ioi_gpt2']
+
+Model group for gemma2: ['ioi_gemma2', 'mcqa_gemma2', 'arc_easy_gemma2']
+
+Model group for llama3: ['ioi_llama3', 'mcqa_llama3', 'arithmetic_addition_llama3', 'arithmetic_subtraction_llama3', 'arc_easy_llama3', 'arc_challenge_llama3']
+
+All available columns: ['ioi_gpt2', 'ioi_qwen2_5', 'ioi_gemma2', 'ioi_llama3', 'mcqa_qwen2_5', 'mcqa_gemma2', 'mcqa_llama3', 'arithmetic_addition_llama3', 'arithmetic_subtraction_llama3', 'arc_easy_gemma2', 'arc_easy_llama3', 'arc_challenge_llama3', 'ioi_qwen2_5', 'mcqa_qwen2_5', 'ioi_gpt2', 'ioi_gemma2', 'mcqa_gemma2', 'arc_easy_gemma2', 'ioi_llama3', 'mcqa_llama3', 'arithmetic_addition_llama3', 'arithmetic_subtraction_llama3', 'arc_easy_llama3', 'arc_challenge_llama3']
+* Running on local URL:  http://0.0.0.0:7860
+/usr/local/lib/python3.10/site-packages/gradio/blocks.py:2634: UserWarning: Setting share=True is not supported on Hugging Face Spaces
+  warnings.warn(
+
+To create a public link, set `share=True` in `launch()`.
+
+
+