updated dropdown

app.py

@@ -49,7 +49,8 @@ from src.load_results import (
     get_filter_options,
     get_model_metadata,
     create_model_metadata_display,
-    get_overall_summary
+    get_overall_summary,
+    sort_table_by_column
 )
 
 def restart_space():
@@ -68,48 +69,60 @@ def create_leaderboard_interface():
         # Get filter options
         filter_options = get_filter_options()
         
-        # Filters across the top with scrolling lists
+        # Compact filters across the top - narrower for better fit
         with gr.Row():
+            with gr.Column(scale=2):
+                model_search = gr.Textbox(
+                    label="🔍 Model",
+                    placeholder="Search...",
+                    scale=1
+                )
             with gr.Column(scale=1):
-                with gr.Accordion("🔍 Model Search", open=False):
-                    model_search = gr.Textbox(
-                        label="Model Search",
-                        placeholder="Search for a specific model...",
-                        info="Type part of a model name to filter"
-                    )
-            
-            with gr.Column(scale=1):
-                with gr.Accordion("📂 Category Filter", open=False):
-                    category_dropdown = gr.Dropdown(
-                        choices=filter_options["categories"],
-                        value="all",
-                        label="Category",
-                        info="Filter by category",
-                        allow_custom_value=False
-                    )
-            
+                category_dropdown = gr.Dropdown(
+                    choices=filter_options["categories"],
+                    value="all",
+                    label="📂 Category",
+                    allow_custom_value=False,
+                    scale=1
+                )
             with gr.Column(scale=1):
-                with gr.Accordion("🌐 Domain Filter", open=False):
-                    domain_dropdown = gr.Dropdown(
-                        choices=filter_options["domains"],
-                        value="all",
-                        label="Domain",
-                        info="Filter by domain",
-                        allow_custom_value=False
-                    )
-            
+                domain_dropdown = gr.Dropdown(
+                    choices=filter_options["domains"],
+                    value="all",
+                    label="🌐 Domain",
+                    allow_custom_value=False,
+                    scale=1
+                )
             with gr.Column(scale=1):
-                with gr.Accordion("📊 Dataset Filter", open=False):
-                    dataset_dropdown = gr.Dropdown(
-                        choices=filter_options["datasets"],
-                        value="all",
-                        label="Dataset",
-                        info="Filter by dataset",
-                        allow_custom_value=False
-                    )
-            
+                dataset_dropdown = gr.Dropdown(
+                    choices=filter_options["datasets"],
+                    value="all",
+                    label="📊 Dataset",
+                    allow_custom_value=False,
+                    scale=1
+                )
+            with gr.Column(scale=2):
+                sort_dropdown = gr.Dropdown(
+                    choices=[
+                        "Rank",
+                        "Model A-Z",
+                        "Organization A-Z",
+                        "Datasets ↑",
+                        "MAPE ↓",
+                        "Uni-MAPE ↓",
+                        "Uni-Multi-MAPE ↑",
+                        "MAE ↓",
+                        "RMSE ↓",
+                        "NMAE ↓",
+                        "Date ↑"
+                    ],
+                    value="Rank",
+                    label="🔄 Sort",
+                    allow_custom_value=False,
+                    scale=1
+                )
             with gr.Column(scale=1):
-                clear_filters_btn = gr.Button("🗑️ Clear All Filters", variant="secondary")
+                clear_filters_btn = gr.Button("🗑️ Clear", variant="secondary", scale=1)
         
         # Full width table
         gr.Markdown("### 📋 Model Rankings")
@@ -117,10 +130,10 @@ def create_leaderboard_interface():
         # Main results table
         results_table = gr.Dataframe(
             value=create_overall_table(),
-            headers=["Rank", "Model", "Organization", "Datasets", 
-                    "MAPE", "Uni-MAPE", "Uni-Multi-MAPE", "MAE", "RMSE", "NMAE", "Submission Date"],
-            datatype=["number", "str", "str", "number", 
-                    "str", "str", "str", "str", "str", "str", "str"],
+            headers=["Model", "Organization", "Datasets", 
+                    "MAPE", "Uni-MAPE", "Uni-Multi-MAPE", "MAE", "RMSE", "NMAE", "Submission Date", "Rank"],
+            datatype=["str", "str", "number", 
+                    "str", "str", "str", "str", "str", "str", "str", "number"],
             interactive=False,
             label="Overall Rankings",
             wrap=True,
@@ -187,43 +200,69 @@ def create_leaderboard_interface():
             else:
                 return gr.update(), gr.update()  # No change
         
-        # Connect filters to table updates with mutual exclusivity
+        def sort_by_dropdown(sort_option, domain, category, dataset, model):
+            """Sort table based on dropdown selection - independent of filters"""
+            # Map dropdown options to column names
+            sort_mapping = {
+                "Rank": "Rank",
+                "Model A-Z": "Model",
+                "Organization A-Z": "Organization",
+                "Datasets ↑": "Datasets",
+                "MAPE ↓": "MAPE",
+                "Uni-MAPE ↓": "Uni-MAPE",
+                "Uni-Multi-MAPE ↑": "Uni-Multi-MAPE",
+                "MAE ↓": "MAE",
+                "RMSE ↓": "RMSE",
+                "NMAE ↓": "NMAE",
+                "Date ↑": "Submission Date"
+            }
+            
+            column_name = sort_mapping.get(sort_option, "Rank")
+            df = create_overall_table(domain, category, dataset, model)
+            return sort_table_by_column(df, column_name)
+        
+        def update_table_with_sort(sort_option, domain, category, dataset, model):
+            """Update table with current filters and sorting"""
+            return sort_by_dropdown(sort_option, domain, category, dataset, model)
+        
+        
+        # Connect filters to table updates with mutual exclusivity and sorting
         domain_dropdown.change(
-            fn=lambda domain, category, dataset, model: (
-                update_table(domain, category, dataset, model),
+            fn=lambda domain, category, dataset, model, sort_option: (
+                update_table_with_sort(sort_option, domain, category, dataset, model),
                 *reset_other_filters(domain, "domain")
             ),
-            inputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search],
+            inputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search, sort_dropdown],
             outputs=[results_table, category_dropdown, dataset_dropdown]
         )
         
         category_dropdown.change(
-            fn=lambda domain, category, dataset, model: (
-                update_table(domain, category, dataset, model),
+            fn=lambda domain, category, dataset, model, sort_option: (
+                update_table_with_sort(sort_option, domain, category, dataset, model),
                 *reset_other_filters(category, "category")
             ),
-            inputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search],
+            inputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search, sort_dropdown],
             outputs=[results_table, domain_dropdown, dataset_dropdown]
         )
         
         dataset_dropdown.change(
-            fn=lambda domain, category, dataset, model: (
-                update_table(domain, category, dataset, model),
+            fn=lambda domain, category, dataset, model, sort_option: (
+                update_table_with_sort(sort_option, domain, category, dataset, model),
                 *reset_other_filters(dataset, "dataset")
             ),
-            inputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search],
+            inputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search, sort_dropdown],
             outputs=[results_table, category_dropdown, domain_dropdown]
         )
         
         model_search.change(
-            fn=update_table,
-            inputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search],
+            fn=update_table_with_sort,
+            inputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search, sort_dropdown],
             outputs=results_table
         )
         
         refresh_btn.click(
-            fn=update_table,
-            inputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search],
+            fn=update_table_with_sort,
+            inputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search, sort_dropdown],
             outputs=results_table
         )
         
@@ -232,6 +271,13 @@ def create_leaderboard_interface():
             outputs=[domain_dropdown, category_dropdown, dataset_dropdown, model_search]
         )
         
+        # Sort dropdown event handler - independent of filters
+        sort_dropdown.change(
+            fn=sort_by_dropdown,
+            inputs=[sort_dropdown, domain_dropdown, category_dropdown, dataset_dropdown, model_search],
+            outputs=results_table
+        )
+        
         # Model selector event handler
         model_selector.change(
             fn=create_model_metadata_display,

src/about.py

@@ -95,11 +95,11 @@ The leaderboard aggregates results across all datasets to provide overall model
 """
 
 CITATION_BUTTON_LABEL = "📋 Citation"
-CITATION_BUTTON_TEXT = """@article{mused-fm2024,
-    title={MUSED-FM: A Multivariate Time Series Evaluation Dataset for Foundation Models},
-    author={Synthefy Research Team},
-    journal={arXiv preprint},
-    year={2024}
+CITATION_BUTTON_TEXT = """@article{mused-fm2025,
+    title={MuSED-FM: A Benchmark for Evaluating Multivariate Time Series Foundation Models},
+    author={Synthefy Inc.},
+    journal={preprint},
+    year={2025}
 }"""
 
 EVALUATION_QUEUE_TEXT = """

src/load_results.py

@@ -152,16 +152,76 @@ def create_overall_table(domain_filter="all", category_filter="all", dataset_fil
             "MAE": f"{avg_mae:.3f}",
             "RMSE": f"{avg_rmse:.3f}",
             "NMAE": f"{avg_nmae:.3f}",
-            "Submission Date": stats["submission_date"]
+            "Submission Date": stats["submission_date"],
+            # Store raw values for ranking and sorting
+            "_mape_raw": avg_mape,
+            "_uni_mape_raw": avg_uni_mape,
+            "_uni_multi_mape_raw": avg_uni_multi_mape,
+            "_mae_raw": avg_mae,
+            "_rmse_raw": avg_rmse,
+            "_nmae_raw": avg_nmae
         }
         table_data.append(row)
     
-    # Sort by MAE and add ranks
-    table_data.sort(key=lambda x: float(x["MAE"]))
+    # Calculate rank based on max(MAPE, Uni-MAPE) - lower is better
+    for row in table_data:
+        max_error = max(row["_mape_raw"], row["_uni_mape_raw"])
+        row["_rank_score"] = max_error
+    
+    # Sort by rank score (lower is better) and assign ranks
+    table_data.sort(key=lambda x: x["_rank_score"])
     for i, row in enumerate(table_data):
         row["Rank"] = i + 1
     
-    return pd.DataFrame(table_data)
+    # Remove raw values from final output
+    for row in table_data:
+        del row["_mape_raw"]
+        del row["_uni_mape_raw"] 
+        del row["_uni_multi_mape_raw"]
+        del row["_mae_raw"]
+        del row["_rmse_raw"]
+        del row["_nmae_raw"]
+        del row["_rank_score"]
+    
+    # Create DataFrame and reorder columns to put Rank last
+    df = pd.DataFrame(table_data)
+    column_order = ["Model", "Organization", "Datasets", 
+                   "MAPE", "Uni-MAPE", "Uni-Multi-MAPE", "MAE", "RMSE", "NMAE", "Submission Date", "Rank"]
+    df = df[column_order]
+    
+    return df
+
+
+def sort_table_by_column(df, column_name, ascending=True):
+    """
+    Sort the table by a specific column.
+    For Uni-Multi-MAPE, higher values are better (ascending=False).
+    For all other metrics, lower values are better (ascending=True).
+    """
+    if column_name == "Uni-Multi-MAPE":
+        # Higher values are better for Uni-Multi-MAPE
+        ascending = False
+    else:
+        # Lower values are better for all other metrics
+        ascending = True
+    
+    # Convert percentage strings to float for proper sorting
+    if column_name in ["MAPE", "Uni-MAPE", "Uni-Multi-MAPE"]:
+        df_sorted = df.copy()
+        df_sorted[f"{column_name}_sort"] = df_sorted[column_name].str.replace('%', '').astype(float)
+        df_sorted = df_sorted.sort_values(f"{column_name}_sort", ascending=ascending)
+        df_sorted = df_sorted.drop(columns=[f"{column_name}_sort"])
+    elif column_name in ["MAE", "RMSE", "NMAE"]:
+        df_sorted = df.sort_values(column_name, ascending=ascending)
+    else:
+        # For non-metric columns, use default sorting
+        df_sorted = df.sort_values(column_name, ascending=ascending)
+    
+    # Reassign ranks after sorting
+    df_sorted = df_sorted.reset_index(drop=True)
+    df_sorted["Rank"] = range(1, len(df_sorted) + 1)
+    
+    return df_sorted
 
 
 def get_filter_options():