Tighten leaderboard sorting and colors

app.py

@@ -104,7 +104,6 @@ TABLE_LABELS = {
     "method": "Method",
     "family": "Family",
     "hardware": "Hardware",
-    "metric": "Metric",
     "task_score": "Task performance",
     "score": "Task performance",
     "robustness_auc": "Robustness AUC",
@@ -128,7 +127,6 @@ TABLE_LABELS = {
     "n_train_trials": "Training trials",
     "n_test_trials": "Test trials",
     "n_neurons": "Neurons",
-    "notes": "Notes",
 }
 
 NUMERIC_COLUMNS = {
@@ -158,20 +156,57 @@ NUMERIC_COLUMNS = {
 }
 RIGHT_ALIGNED_COLUMNS = NUMERIC_COLUMNS | {"rank"}
 
-SCORE_SCALE = [[0.0, "#9f3a38"], [0.5, "#f3efe4"], [1.0, "#006d77"]]
+# Shared figure colors copied from the paper plotting scripts.
+TASK_COLOR = "#1565C0"
+ROBUSTNESS_COLOR = "#2E7D32"
+COMPUTE_COLOR = "#E65100"
+INFLUENCE_COLOR = "#CC79A7"
+ALIGNMENT_COLOR = "#0072B2"
+SCORE_SCALE = [[0.0, "#EFF6FF"], [1.0, TASK_COLOR]]
+ALIGNMENT_SCALE = [[0.0, "#F7FBF7"], [1.0, ROBUSTNESS_COLOR]]
+DATASET_COLORS = {
+    "monkey": "#0072B2",
+    "allen_neuropixels": "#E69F00",
+    "speech": "#009E73",
+    "mc_pacman": "#CC79A7",
+    "ratinabox": "#D55E00",
+}
 CATEGORICAL_PALETTE = [
-    "#0072B2",
     "#E69F00",
-    "#009E73",
-    "#CC79A7",
-    "#D55E00",
     "#56B4E9",
+    "#009E73",
     "#F0E442",
-    "#6A3D9A",
-    "#8C564B",
-    "#4E79A7",
-    "#59A14F",
-    "#AF7AA1",
+    "#0072B2",
+    "#D55E00",
+    "#CC79A7",
+    "#000000",
+]
+DIRECTION_PALETTE = [
+    "#B23AEE",
+    "#3B1C54",
+    "#2DD4F6",
+    "#289285",
+    "#E3D724",
+    "#00A65A",
+    "#5B8FF9",
+    "#F97316",
+]
+SPEECH_PALETTE = {
+    "3": "#E69F00",
+    "2": "#56B4E9",
+    "4": "#009E73",
+    "7": "#999933",
+    "6": "#0072B2",
+    "1": "#D55E00",
+    "5": "#CC79A7",
+    "0": "#000000",
+}
+RATINABOX_SCALE = [
+    [0.0, "#440154"],
+    [0.25, "#3B528B"],
+    [0.5, "#21918C"],
+    [0.75, "#5EC962"],
+    [1.0, "#FDE725"],
 ]
 
 
@@ -354,6 +389,26 @@ def round_numeric(df: pd.DataFrame, columns: Iterable[str], digits: int = 3) ->
     return out
 
 
+def sort_table(df: pd.DataFrame, sort_by: list[dict] | None, default: list[tuple[str, bool]]) -> pd.DataFrame:
+    if sort_by:
+        sort_spec = []
+        for item in sort_by:
+            col = item.get("column_id")
+            if col in df.columns:
+                sort_spec.append((col, item.get("direction") == "asc"))
+        if sort_spec:
+            return df.sort_values(
+                [col for col, _ in sort_spec],
+                ascending=[ascending for _, ascending in sort_spec],
+                na_position="last",
+            )
+    return df.sort_values(
+        [col for col, _ in default],
+        ascending=[ascending for _, ascending in default],
+        na_position="last",
+    )
+
+
 def records(df: pd.DataFrame) -> list[dict]:
     clean = df.astype(object).where(pd.notna(df), None)
     return clean.to_dict("records")
@@ -435,13 +490,15 @@ def dataframe_table(
     *,
     page_size: int = 8,
     max_height: str = "520px",
+    sort_action: str = "native",
 ) -> dash_table.DataTable:
     return dash_table.DataTable(
         id=table_id,
         columns=[],
         data=[],
         page_size=page_size,
-        sort_action="native",
+        sort_action=sort_action,
+        sort_mode="single",
         cell_selectable=True,
         style_as_list_view=True,
         fixed_rows={"headers": True},
@@ -531,8 +588,6 @@ def leaderboard_frame(dataset: str, models: list[str] | None) -> pd.DataFrame:
     df = df.merge(rob, on="model", how="left")
     df = df.merge(cons, on="model", how="left")
     df = df.merge(scale, on="model", how="left")
-    df["notes"] = np.where(df["task_score"].isna(), "Not available", "")
-
     available = df["task_score"].notna()
     order = df.loc[available].sort_values(
         ["task_score", "model_order"], ascending=[False, True]
@@ -541,9 +596,6 @@ def leaderboard_frame(dataset: str, models: list[str] | None) -> pd.DataFrame:
     for rank, idx in enumerate(order, start=1):
         df.at[idx, "rank"] = rank
 
-    df = df.sort_values(
-        ["task_score", "model_order"], ascending=[False, True], na_position="last"
-    )
     df["id"] = df["model"]
     return round_numeric(df, NUMERIC_COLUMNS)
 
@@ -551,7 +603,9 @@ def leaderboard_frame(dataset: str, models: list[str] | None) -> pd.DataFrame:
 def leaderboard_summary(dataset: str, table_df: pd.DataFrame) -> list[html.Div]:
     label = DATASET_LABELS.get(dataset, dataset)
     metric = metric_text(table_df["metric"].dropna().iloc[0]) if table_df["metric"].notna().any() else "score"
-    available = table_df.dropna(subset=["task_score"]).head(3)
+    available = sort_table(
+        table_df, None, [("task_score", False), ("model_order", True)]
+    ).dropna(subset=["task_score"]).head(3)
     cards = [metric_card("Dataset", label, f"Primary metric: {metric}")]
     for _, row in available.iterrows():
         cards.append(
@@ -578,7 +632,11 @@ def performance_heatmap(dataset: str, models: list[str] | None) -> go.Figure:
     )
 
     selected_label = DATASET_LABELS.get(dataset, dataset)
-    order_df = leaderboard_frame(dataset, models)
+    order_df = sort_table(
+        leaderboard_frame(dataset, models),
+        None,
+        [("task_score", False), ("model_order", True)],
+    )
     method_order = [m for m in order_df["method"] if m in set(pivot.index)]
     pivot = pivot.reindex(method_order)
     dataset_order = [DATASET_LABELS.get(ds, ds) for ds in DATASETS]
@@ -615,7 +673,7 @@ def ranking_figure(dataset: str, table_df: pd.DataFrame) -> go.Figure:
             x=rank_df["task_score"],
             y=rank_df["method"],
             orientation="h",
-            marker=dict(color="#006d77"),
+            marker=dict(color=TASK_COLOR),
             hovertemplate="Method=%{y}<br>Score=%{x:.4f}<extra></extra>",
         )
     )
@@ -637,7 +695,6 @@ def consistency_frame(dataset: str, models: list[str] | None) -> pd.DataFrame:
     cons = cons.rename(columns={"mean_r2": "alignment_score"})
 
     df = base.merge(cons, on="model", how="left")
-    df["notes"] = np.where(df["alignment_score"].isna(), "Not available", "")
     available = df["alignment_score"].notna()
     order = df.loc[available].sort_values(
         ["alignment_score", "model_order"], ascending=[False, True]
@@ -645,9 +702,6 @@ def consistency_frame(dataset: str, models: list[str] | None) -> pd.DataFrame:
     df["rank"] = None
     for rank, idx in enumerate(order, start=1):
         df.at[idx, "rank"] = rank
-    df = df.sort_values(
-        ["alignment_score", "model_order"], ascending=[False, True], na_position="last"
-    )
     df["id"] = df["model"]
     return round_numeric(df, NUMERIC_COLUMNS)
 
@@ -655,7 +709,9 @@ def consistency_frame(dataset: str, models: list[str] | None) -> pd.DataFrame:
 def selected_consistency_model(df: pd.DataFrame, active_cell: dict | None) -> str | None:
     if active_cell and active_cell.get("row_id") in set(df["model"]):
         return str(active_cell["row_id"])
-    available = df.dropna(subset=["alignment_score"])
+    available = sort_table(
+        df, None, [("alignment_score", False), ("model_order", True)]
+    ).dropna(subset=["alignment_score"])
     if available.empty:
         return None
     return str(available.iloc[0]["model"])
@@ -670,7 +726,7 @@ def consistency_bar_figure(dataset: str, df: pd.DataFrame) -> go.Figure:
             x=bar_df["alignment_score"],
             y=bar_df["method"],
             orientation="h",
-            marker=dict(color="#4c908b"),
+            marker=dict(color=ALIGNMENT_COLOR),
             hovertemplate="Method=%{y}<br>Alignment=%{x:.4f}<extra></extra>",
         )
     )
@@ -698,7 +754,7 @@ def consistency_heatmap(models: list[str] | None) -> go.Figure:
             y=list(pivot.index),
             text=text.values if not pivot.empty else [[]],
             texttemplate="%{text}",
-            colorscale=SCORE_SCALE,
+            colorscale=ALIGNMENT_SCALE,
             colorbar=dict(title="Score", thickness=12),
             hovertemplate="Method=%{y}<br>Dataset=%{x}<br>Alignment=%{z:.4f}<extra></extra>",
         )
@@ -757,10 +813,21 @@ def latent_space_figure(dataset: str, model: str | None) -> go.Figure:
 
     condition_values = sorted(plot_df["condition"].astype(str).unique(), key=condition_sort_key)
     use_categorical = len(condition_values) <= 12
-    condition_colors = {
-        condition: CATEGORICAL_PALETTE[idx % len(CATEGORICAL_PALETTE)]
-        for idx, condition in enumerate(condition_values)
-    }
+    if dataset == "monkey":
+        condition_colors = {
+            condition: DIRECTION_PALETTE[int(float(condition)) % len(DIRECTION_PALETTE)]
+            for condition in condition_values
+        }
+    elif dataset == "speech":
+        condition_colors = {
+            condition: SPEECH_PALETTE.get(condition, CATEGORICAL_PALETTE[idx % len(CATEGORICAL_PALETTE)])
+            for idx, condition in enumerate(condition_values)
+        }
+    else:
+        condition_colors = {
+            condition: CATEGORICAL_PALETTE[idx % len(CATEGORICAL_PALETTE)]
+            for idx, condition in enumerate(condition_values)
+        }
     condition_name = condition_axis_label(dataset)
 
     for session_idx, session in enumerate(sessions):
@@ -847,7 +914,7 @@ def latent_space_figure(dataset: str, model: str | None) -> go.Figure:
                         size=2.8,
                         opacity=0.72,
                         color=session_df["condition_num"],
-                        colorscale="Viridis",
+                        colorscale=RATINABOX_SCALE,
                         showscale=session_idx == 0,
                         colorbar=dict(title=condition_name, thickness=12),
                     ),
@@ -948,7 +1015,7 @@ def robustness_table_frame(dataset: str, models: list[str] | None) -> pd.DataFra
     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 pd.DataFrame(columns=["method", "metric", "reference_score", "highest_noise_score", "robustness_auc", "average_noisy_score"])
+        return pd.DataFrame(columns=["method", "reference_score", "highest_noise_score", "robustness_auc", "average_noisy_score"])
     df = add_method_columns(df)
     df = df.rename(
         columns={
@@ -958,7 +1025,7 @@ def robustness_table_frame(dataset: str, models: list[str] | None) -> pd.DataFra
             "mean_score": "average_noisy_score",
         }
     )
-    cols = ["method", "metric", "reference_score", "highest_noise_score", "robustness_auc", "average_noisy_score"]
+    cols = ["method", "reference_score", "highest_noise_score", "robustness_auc", "average_noisy_score"]
     return round_numeric(df[cols].sort_values("robustness_auc", ascending=False), NUMERIC_COLUMNS)
 
 
@@ -988,7 +1055,7 @@ def compute_figures(dataset: str, models: list[str] | None) -> tuple[go.Figure,
             text=df["method"],
             marker=dict(
                 size=np.clip(df["peak_ram_gb"].fillna(1.0) * 4, 8, 26),
-                color=df["hardware"].map({"CPU": "#8a6f2a", "GPU": "#006d77"}).fillna("#637381"),
+                color=df["hardware"].map({"CPU": "#E69F00", "GPU": TASK_COLOR}).fillna("#637381"),
                 opacity=0.82,
                 line=dict(color="#ffffff", width=1),
             ),
@@ -1035,7 +1102,7 @@ def influence_figures(dataset: str, models: list[str] | None) -> tuple[go.Figure
     nshap = nshap[nshap["dataset"].astype(str) == str(dataset)].copy() if not nshap.empty else nshap
     if nshap.empty:
         neuron_fig = empty_figure("No neuron-influence results are available for this dataset.")
-        table = pd.DataFrame(columns=["method", "metric", "baseline_score", "full_model_score", "neuron_influence_auc", "shap_mean_value", "shap_fraction_positive"])
+        table = pd.DataFrame(columns=["method", "baseline_score", "full_model_score", "neuron_influence_auc", "shap_mean_value", "shap_fraction_positive"])
     else:
         nshap = add_method_columns(nshap)
         nshap["auc"] = pd.to_numeric(nshap["auc"], errors="coerce")
@@ -1045,7 +1112,7 @@ def influence_figures(dataset: str, models: list[str] | None) -> tuple[go.Figure
                 x=bar_df["auc"],
                 y=bar_df["method"],
                 orientation="h",
-                marker=dict(color="#006d77"),
+                marker=dict(color=INFLUENCE_COLOR),
                 hovertemplate="Method=%{y}<br>AUC=%{x:.4f}<extra></extra>",
             )
         )
@@ -1055,7 +1122,7 @@ def influence_figures(dataset: str, models: list[str] | None) -> tuple[go.Figure
         fig_layout(neuron_fig, height=max(420, 25 * len(bar_df) + 150))
         table = nshap.rename(columns={"auc": "neuron_influence_auc"})
         table = table[
-            ["method", "metric", "baseline_score", "full_model_score", "neuron_influence_auc", "shap_mean_value", "shap_fraction_positive"]
+            ["method", "baseline_score", "full_model_score", "neuron_influence_auc", "shap_mean_value", "shap_fraction_positive"]
         ]
 
     tshap = filter_models(active_rows(trial_shapley), models)
@@ -1071,7 +1138,7 @@ def influence_figures(dataset: str, models: list[str] | None) -> tuple[go.Figure
                 x=trial_df["perturbation_auc"],
                 y=trial_df["method"],
                 orientation="h",
-                marker=dict(color="#8a6f2a"),
+                marker=dict(color="#009E73"),
                 hovertemplate="Method=%{y}<br>AUC=%{x:.4f}<extra></extra>",
             )
         )
@@ -1173,7 +1240,7 @@ app.layout = html.Div(
                             html.Div(
                                 [
                                     html.Div(
-                                        dataframe_table("leaderboard-table", page_size=23, max_height="680px"),
+                                        dataframe_table("leaderboard-table", page_size=23, max_height="680px", sort_action="custom"),
                                         className="leaderboard-table-wrap",
                                     ),
                                     dcc.Graph(id="dataset-ranking", config={"displayModeBar": False}),
@@ -1198,7 +1265,7 @@ app.layout = html.Div(
                                 [
                                     html.Div(
                                         [
-                                            dataframe_table("consistency-table", page_size=23, max_height="520px"),
+                                            dataframe_table("consistency-table", page_size=23, max_height="520px", sort_action="custom"),
                                             html.P("Click a method to update the 3D latent view.", className="table-hint"),
                                         ],
                                         className="consistency-table-wrap",
@@ -1312,21 +1379,21 @@ app.layout = html.Div(
     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):
+def update_leaderboard(dataset: str, models: list[str] | None, sort_by: list[dict] | None):
     df = leaderboard_frame(dataset, models)
     visible_cols = [
         "rank",
         "method",
         "task_score",
-        "metric",
         "robustness_auc",
         "alignment_score",
         "training_time_sec",
         "peak_ram_gb",
-        "notes",
     ]
-    table_df = df[[c for c in visible_cols + ["id", "model"] if c in df.columns]]
+    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]]
     return (
         leaderboard_summary(dataset, df),
         column_defs([c for c in visible_cols if c in table_df.columns]),
@@ -1345,12 +1412,14 @@ def update_leaderboard(dataset: str, models: list[str] | None):
     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):
+def update_consistency(dataset: str, models: list[str] | None, active_cell: dict | None, sort_by: list[dict] | None):
     df = consistency_frame(dataset, models)
     model = selected_consistency_model(df, active_cell)
-    visible_cols = ["rank", "method", "alignment_score", "n_sessions", "latent_dim", "n_pairwise", "notes"]
-    table_df = df[[c for c in visible_cols + ["id", "model"] if c in df.columns]]
+    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)])
+    table_df = sorted_df[[c for c in visible_cols + ["id", "model"] if c in sorted_df.columns]]
     return (
         column_defs([c for c in visible_cols if c in table_df.columns]),
         records(table_df),

assets/styles.css

@@ -163,7 +163,7 @@ h2 {
 
 .tab-selected {
   color: #12302f !important;
-  border-bottom-color: #006d77 !important;
+  border-bottom-color: #1565C0 !important;
   background: #ffffff !important;
 }