Simplify leaderboard controls and labels

README.md

@@ -8,7 +8,7 @@ app_port: 7860
 
 Interactive dashboard for the Tang Lab neural model benchmark.
 
-The dashboard compares 23 methods across five datasets, with sortable task
+The dashboard compares 23 methods across five datasets, with sortable decoding
 performance, robustness, cross-session alignment, neuron and trial influence,
 compute cost, and 3D latent-space views.
 

app.py

@@ -104,8 +104,8 @@ TABLE_LABELS = {
     "method": "Method",
     "family": "Family",
     "hardware": "Hardware",
-    "task_score": "Task performance",
-    "score": "Task performance",
+    "task_score": "Decoding score",
+    "score": "Decoding score",
     "robustness_auc": "Robustness AUC",
     "alignment_score": "Cross-session alignment",
     "training_time_sec": "Training time (s)",
@@ -430,6 +430,24 @@ def metric_text(value: object) -> str:
     return str(value)
 
 
+def decoding_label(metric: object) -> str:
+    text = metric_text(metric)
+    if text.lower() == "r2":
+        return "Decoding R2"
+    if text.lower() == "accuracy":
+        return "Decoding accuracy"
+    return f"Decoding {text}"
+
+
+def leaderboard_columns(columns: Iterable[str], metric: object) -> list[dict]:
+    defs = column_defs(columns)
+    label = decoding_label(metric)
+    for item in defs:
+        if item["id"] == "task_score":
+            item["name"] = label
+    return defs
+
+
 def value_text(value: object, digits: int = 3) -> str:
     if value is None or pd.isna(value):
         return "Not available"
@@ -623,7 +641,7 @@ def leaderboard_summary(dataset: str, table_df: pd.DataFrame) -> list[html.Div]:
 def performance_heatmap(dataset: str, models: list[str] | None) -> go.Figure:
     df = filter_models(prediction, models)
     if df.empty:
-        return empty_figure("No task performance results are available.")
+        return empty_figure("No decoding results are available.")
     df = add_method_columns(df)
     df["score"] = pd.to_numeric(df["score"], errors="coerce")
     df["dataset_label"] = df["dataset"].map(DATASET_LABELS).fillna(df["dataset"])
@@ -659,15 +677,16 @@ def performance_heatmap(dataset: str, models: list[str] | None) -> go.Figure:
             hovertemplate="Method=%{y}<br>Dataset=%{x}<br>Score=%{z:.4f}<extra></extra>",
         )
     )
-    fig.update_layout(title=f"Task performance matrix, sorted by {selected_label}")
+    fig.update_layout(title=f"Decoding score matrix, sorted by {selected_label}")
     return fig_layout(fig, height=max(430, 26 * len(pivot.index) + 150))
 
 
 def ranking_figure(dataset: str, table_df: pd.DataFrame) -> go.Figure:
     rank_df = table_df.dropna(subset=["task_score"]).sort_values("task_score", ascending=True)
     if rank_df.empty:
-        return empty_figure(f"No task performance results are available for {DATASET_LABELS.get(dataset, dataset)}.")
+        return empty_figure(f"No decoding results are available for {DATASET_LABELS.get(dataset, dataset)}.")
     metric = metric_text(rank_df["metric"].dropna().iloc[0]) if rank_df["metric"].notna().any() else "score"
+    label = decoding_label(metric)
     fig = go.Figure(
         go.Bar(
             x=rank_df["task_score"],
@@ -677,8 +696,8 @@ def ranking_figure(dataset: str, table_df: pd.DataFrame) -> go.Figure:
             hovertemplate="Method=%{y}<br>Score=%{x:.4f}<extra></extra>",
         )
     )
-    fig.update_layout(title=f"{DATASET_LABELS.get(dataset, dataset)} ranking")
-    fig.update_xaxes(title=metric)
+    fig.update_layout(title=f"{DATASET_LABELS.get(dataset, dataset)} {label} ranking")
+    fig.update_xaxes(title=label)
     fig.update_yaxes(title="")
     return fig_layout(fig, height=max(420, 25 * len(rank_df) + 150))
 
@@ -983,31 +1002,44 @@ def latent_space_figure(dataset: str, model: str | None) -> go.Figure:
     return fig
 
 
-def robustness_figure(dataset: str, models: list[str] | None) -> go.Figure:
+def robustness_figure(dataset: str, models: list[str] | None, hover_data: dict | None = None) -> go.Figure:
     df = filter_models(present_rows(robustness), models)
     df = df[df["dataset"].astype(str) == str(dataset)].copy() if not df.empty else df
     if df.empty:
         return empty_figure("No robustness results are available for this selection.")
     df = add_method_columns(df).sort_values("model_order")
+    highlighted_trace = None
+    if hover_data and hover_data.get("points"):
+        highlighted_trace = hover_data["points"][0].get("curveNumber")
+
     fig = go.Figure()
+    trace_idx = 0
     for idx, row in enumerate(df.itertuples()):
         xs = parse_float_list(row.noise_levels)
         ys = parse_float_list(row.scores)
         if xs and len(xs) == len(ys):
+            is_highlighted = highlighted_trace is None or highlighted_trace == trace_idx
             fig.add_trace(
                 go.Scatter(
                     x=xs,
                     y=ys,
                     mode="lines+markers",
                     name=row.method,
-                    line=dict(color=CATEGORICAL_PALETTE[idx % len(CATEGORICAL_PALETTE)], width=2),
-                    marker=dict(size=5),
+                    opacity=0.92 if is_highlighted else 0.16,
+                    line=dict(
+                        color=CATEGORICAL_PALETTE[idx % len(CATEGORICAL_PALETTE)],
+                        width=4 if highlighted_trace == trace_idx else 2,
+                    ),
+                    marker=dict(size=8 if highlighted_trace == trace_idx else 5),
                     hovertemplate="Noise=%{x:.2f}<br>Score=%{y:.4f}<extra></extra>",
                 )
             )
+            trace_idx += 1
     fig.update_layout(title=f"{DATASET_LABELS.get(dataset, dataset)} robustness curves")
+    fig.update_layout(hovermode="closest")
     fig.update_xaxes(title="Noise fraction")
-    fig.update_yaxes(title=metric_text(df["metric"].dropna().iloc[0]) if df["metric"].notna().any() else "score")
+    metric = metric_text(df["metric"].dropna().iloc[0]) if df["metric"].notna().any() else "score"
+    fig.update_yaxes(title=decoding_label(metric))
     return fig_layout(fig, height=520)
 
 
@@ -1177,7 +1209,7 @@ app.layout = html.Div(
                         html.Div("Tang Lab", className="eyebrow"),
                         html.H1("Neural Model Benchmark"),
                         html.P(
-                            "Explore task performance, robustness, latent alignment, neuron and trial influence, and compute cost across 23 benchmarked methods.",
+                            "Explore decoding performance, robustness, latent alignment, neuron and trial influence, and compute cost across 23 benchmarked methods.",
                             className="lede",
                         ),
                     ],
@@ -1186,7 +1218,7 @@ app.layout = html.Div(
                 html.Div(
                     [
                         metric_card("Methods", str(len(MODELS)), "Benchmarked in the paper"),
-                        metric_card("Datasets", str(len(DATASETS)), "Selectable below"),
+                        metric_card("Datasets", str(len(DATASETS)), "Select one below"),
                     ],
                     className="hero-metrics",
                 ),
@@ -1207,19 +1239,6 @@ app.layout = html.Div(
                     ],
                     className="control",
                 ),
-                html.Div(
-                    [
-                        html.Label("Method filter"),
-                        dcc.Dropdown(
-                            id="model-filter",
-                            options=[{"label": model_label(model), "value": model} for model in MODELS],
-                            value=[],
-                            multi=True,
-                            placeholder="All methods",
-                        ),
-                    ],
-                    className="control control-wide",
-                ),
             ],
             className="toolbar",
         ),
@@ -1248,7 +1267,7 @@ app.layout = html.Div(
                                 className="leaderboard-grid",
                             ),
                             dcc.Graph(id="performance-heatmap", config={"displayModeBar": False}),
-                            subtitle="Sorted by the selected dataset. Regression datasets use R2; classification datasets use accuracy. Higher is better.",
+                            subtitle="Sorted by the selected dataset. Regression datasets use decoding R2; classification datasets use decoding accuracy. Higher is better.",
                             className="leaderboard-panel",
                         )
                     ],
@@ -1305,9 +1324,9 @@ app.layout = html.Div(
                     children=[
                         panel(
                             "Robustness",
-                            dcc.Graph(id="robustness-curve", config={"displayModeBar": False}),
+                            dcc.Graph(id="robustness-curve", clear_on_unhover=True, config={"displayModeBar": False}),
                             details_table("View robustness rows", dataframe_table("robustness-table")),
-                            subtitle="Curves show how task performance changes as neural count noise increases.",
+                            subtitle="Hover a method to highlight its curve. Curves show how decoding performance changes as neural count noise increases.",
                         )
                     ],
                 ),
@@ -1378,11 +1397,10 @@ app.layout = html.Div(
     Output("dataset-ranking", "figure"),
     Output("performance-heatmap", "figure"),
     Input("dataset-filter", "value"),
-    Input("model-filter", "value"),
     Input("leaderboard-table", "sort_by"),
 )
-def update_leaderboard(dataset: str, models: list[str] | None, sort_by: list[dict] | None):
-    df = leaderboard_frame(dataset, models)
+def update_leaderboard(dataset: str, sort_by: list[dict] | None):
+    df = leaderboard_frame(dataset, None)
     visible_cols = [
         "rank",
         "method",
@@ -1391,15 +1409,17 @@ def update_leaderboard(dataset: str, models: list[str] | None, sort_by: list[dic
         "alignment_score",
         "training_time_sec",
         "peak_ram_gb",
+        "peak_vram_gb",
     ]
     sorted_df = sort_table(df, sort_by, [("task_score", False), ("model_order", True)])
     table_df = sorted_df[[c for c in visible_cols + ["id", "model"] if c in sorted_df.columns]]
+    metric = df["metric"].dropna().iloc[0] if df["metric"].notna().any() else "score"
     return (
         leaderboard_summary(dataset, df),
-        column_defs([c for c in visible_cols if c in table_df.columns]),
+        leaderboard_columns([c for c in visible_cols if c in table_df.columns], metric),
         records(table_df),
         ranking_figure(dataset, df),
-        performance_heatmap(dataset, models),
+        performance_heatmap(dataset, None),
     )
 
 
@@ -1410,12 +1430,11 @@ def update_leaderboard(dataset: str, models: list[str] | None, sort_by: list[dic
     Output("consistency-bars", "figure"),
     Output("consistency-heatmap", "figure"),
     Input("dataset-filter", "value"),
-    Input("model-filter", "value"),
     Input("consistency-table", "active_cell"),
     Input("consistency-table", "sort_by"),
 )
-def update_consistency(dataset: str, models: list[str] | None, active_cell: dict | None, sort_by: list[dict] | None):
-    df = consistency_frame(dataset, models)
+def update_consistency(dataset: str, active_cell: dict | None, sort_by: list[dict] | None):
+    df = consistency_frame(dataset, None)
     model = selected_consistency_model(df, active_cell)
     visible_cols = ["rank", "method", "alignment_score", "n_sessions", "latent_dim", "n_pairwise"]
     sorted_df = sort_table(df, sort_by, [("alignment_score", False), ("model_order", True)])
@@ -1425,7 +1444,7 @@ def update_consistency(dataset: str, models: list[str] | None, active_cell: dict
         records(table_df),
         latent_space_figure(dataset, model),
         consistency_bar_figure(dataset, df),
-        consistency_heatmap(models),
+        consistency_heatmap(None),
     )
 
 
@@ -1434,12 +1453,12 @@ def update_consistency(dataset: str, models: list[str] | None, active_cell: dict
     Output("robustness-table", "columns"),
     Output("robustness-table", "data"),
     Input("dataset-filter", "value"),
-    Input("model-filter", "value"),
+    Input("robustness-curve", "hoverData"),
 )
-def update_robustness(dataset: str, models: list[str] | None):
-    table = robustness_table_frame(dataset, models)
+def update_robustness(dataset: str, hover_data: dict | None):
+    table = robustness_table_frame(dataset, None)
     return (
-        robustness_figure(dataset, models),
+        robustness_figure(dataset, None, hover_data),
         column_defs(table.columns),
         records(table),
     )
@@ -1451,10 +1470,9 @@ def update_robustness(dataset: str, models: list[str] | None):
     Output("compute-table", "columns"),
     Output("compute-table", "data"),
     Input("dataset-filter", "value"),
-    Input("model-filter", "value"),
 )
-def update_compute(dataset: str, models: list[str] | None):
-    scatter, memory, table = compute_figures(dataset, models)
+def update_compute(dataset: str):
+    scatter, memory, table = compute_figures(dataset, None)
     return scatter, memory, column_defs(table.columns), records(table)
 
 
@@ -1464,20 +1482,19 @@ def update_compute(dataset: str, models: list[str] | None):
     Output("influence-table", "columns"),
     Output("influence-table", "data"),
     Input("dataset-filter", "value"),
-    Input("model-filter", "value"),
 )
-def update_influence(dataset: str, models: list[str] | None):
-    neuron_fig, trial_fig, table = influence_figures(dataset, models)
+def update_influence(dataset: str):
+    neuron_fig, trial_fig, table = influence_figures(dataset, None)
     return neuron_fig, trial_fig, column_defs(table.columns), records(table)
 
 
 @app.callback(
     Output("methods-table", "columns"),
     Output("methods-table", "data"),
-    Input("model-filter", "value"),
+    Input("dataset-filter", "value"),
 )
-def update_methods(models: list[str] | None):
-    table = methods_frame(models)
+def update_methods(_dataset: str):
+    table = methods_frame(None)
     return column_defs(table.columns), records(table)
 
 

assets/styles.css

@@ -116,7 +116,7 @@ h2 {
   top: 0;
   z-index: 10;
   display: grid;
-  grid-template-columns: minmax(230px, 310px) minmax(360px, 1fr);
+  grid-template-columns: minmax(230px, 310px);
   gap: 16px;
   margin-top: 14px;
   margin-bottom: 14px;
@@ -152,6 +152,10 @@ h2 {
 }
 
 .tab {
+  display: flex !important;
+  align-items: center !important;
+  justify-content: center !important;
+  min-height: 44px;
   padding: 11px 18px !important;
   border: 0 !important;
   border-bottom: 2px solid transparent !important;