Visualization fixes

analytics.py

@@ -76,15 +76,18 @@ def _log_normalize(values: np.ndarray, *, inverse: bool) -> np.ndarray:
     return out
 
 
-# Axis spec: (label, primary column, fallback column when primary is fully empty, strength direction)
-# For "inverse" True, lower raw value is better (WER, memory); for False, higher is better (RTF).
-_RADAR_AXES: tuple[tuple[str, str, str | None, bool], ...] = (
-    ("Avg WER", "avg_wer", None, True),
-    ("High SNR", "wer_high_snr", "wer_clean", True),
-    ("Distance", "wer_distant", None, True),
-    ("High Reverb", "wer_highly_reverberant", "wer_reverberant", True),
-    ("RTF", "eval_rtf", None, False),
-    ("Memory", "model_size_mb", None, True),
+# Axis spec: (strength_label, primary col, fallback col, inverse, raw_display_name, raw_unit)
+# strength_label  : what the axis is called on the chart — always phrased so "farther = better".
+# inverse         : True if *lower* raw value is better (e.g. WER, memory); False if higher is better (RTF).
+# raw_display_name: human-readable name of the underlying metric, shown in the hover tooltip.
+# raw_unit        : optional unit suffix for the raw value in the tooltip.
+_RADAR_AXES: tuple[tuple[str, str, str | None, bool, str, str], ...] = (
+    ("Overall accuracy",    "avg_wer",                None,              True,  "Avg WER",           ""),
+    ("High-SNR accuracy",   "wer_high_snr",           "wer_clean",       True,  "High-SNR WER",      ""),
+    ("Distance robustness", "wer_distant",            None,              True,  "Distant WER",       ""),
+    ("Reverb robustness",   "wer_highly_reverberant", "wer_reverberant", True,  "Reverb WER",        ""),
+    ("Speed",               "eval_rtf",               None,              False, "RTF",               "× realtime"),
+    ("Compactness",         "model_size_mb",          None,              True,  "Model size",        " MB"),
 )
 
 
@@ -143,11 +146,13 @@ def _raw_to_analytics_df(raw: list[dict]) -> pd.DataFrame:
             df[k] = np.nan
         else:
             df[k] = pd.to_numeric(df[k], errors="coerce")
-    for k in ("eval_wall_time_s", "eval_rtf", "eval_audio_seconds"):
+    for k in ("eval_wall_time_s", "eval_rtf", "eval_audio_seconds", "num_params"):
         if k not in df.columns:
             df[k] = np.nan
         else:
             df[k] = pd.to_numeric(df[k], errors="coerce")
+    # Millions of parameters — small, easy to read.
+    df["num_params_m"] = df["num_params"] / 1e6
     live_cols = [c for c in LIVE_SCENARIO_KEYS if c in df.columns]
     df["avg_wer"] = df[live_cols].mean(axis=1, skipna=True) if live_cols else np.nan
     df["model_size_mb"] = df["model_id"].apply(_cached_model_size_mb)
@@ -169,26 +174,31 @@ def plot_robustness_radar(
     title: str = "Model robustness profile — log-normalized, farther from center = stronger",
 ) -> go.Figure:
     """
-    Fixed 6-axis radar: Avg WER, High SNR, Distance, High Reverb, RTF, Memory.
-
-    Axes show a 0-1 **strength** score (higher = better) computed per-axis across
-    **all** leaderboard rows using a log transform + global min/max. So a bigger
-    hexagon = better model overall; axes are directly comparable across models.
-
-    Fallbacks (when a planned column has zero data leaderboard-wide):
-      * High SNR → wer_clean   (labeled "High SNR*")
-      * High Reverb → wer_reverberant (labeled "High Reverb*")
-    Missing values plot as 0 on that axis (honestly empty).
+    Fixed 6-axis radar — **strength** view. Every axis is phrased so that farther
+    from the centre = better, regardless of the raw metric direction:
+
+        Overall accuracy   (lower Avg WER  → higher strength)
+        High-SNR accuracy  (lower High-SNR WER → higher strength; falls back to Clean WER)
+        Distance robustness (lower Distant WER → higher strength)
+        Reverb robustness  (lower Reverb WER → higher strength; falls back to reverb WER)
+        Speed              (higher RTF → higher strength)
+        Compactness        (smaller model size → higher strength)
+
+    Strength is a 0-1 score computed per-axis across **all** leaderboard rows with
+    a log transform + global min/max, so axes and hexagon areas are directly
+    comparable across models. Axes marked with `*` fall back to a live proxy when
+    the planned column is empty; missing values plot as 0 (honestly empty).
     """
     if df.empty:
         return _empty_fig("No leaderboard data yet.")
 
     d = df.copy().reset_index(drop=True)
 
-    axes: list[tuple[str, np.ndarray]] = []
-    for label, primary, fallback, inverse in _RADAR_AXES:
+    axes: list[tuple[str, np.ndarray, np.ndarray, str, bool, str, str, bool]] = []
+    for label, primary, fallback, inverse, raw_disp, raw_unit in _RADAR_AXES:
         col_label = label
         col_name = primary
+        using_fallback = False
         col = (
             pd.to_numeric(d[primary], errors="coerce")
             if primary in d.columns
@@ -198,8 +208,11 @@ def plot_robustness_radar(
             col = pd.to_numeric(d[fallback], errors="coerce")
             col_label = f"{label}*"
             col_name = fallback
+            using_fallback = True
         strength = _log_normalize(col.to_numpy(), inverse=inverse)
-        axes.append((col_label, strength, col.to_numpy(), col_name, inverse))
+        axes.append(
+            (col_label, strength, col.to_numpy(), col_name, inverse, raw_disp, raw_unit, using_fallback)
+        )
 
     labels = [a[0] for a in axes]
     labels_closed = labels + [labels[0]]
@@ -217,35 +230,35 @@ def plot_robustness_radar(
             continue
         idx = rows[0]
         r_vals: list[float] = []
-        raw_vals: list[float] = []
-        inv_flags: list[bool] = []
-        for _, strength, raw_series, _src, inv in axes:
+        raw_text: list[str] = []
+        for _lab, strength, raw_series, _src, inv, raw_disp, raw_unit, using_fb in axes:
             s = strength[idx]
             rv = raw_series[idx]
             r_vals.append(float(s) if np.isfinite(s) else 0.0)
-            raw_vals.append(float(rv) if np.isfinite(rv) else float("nan"))
-            inv_flags.append(bool(inv))
+            direction = "lower is better" if inv else "higher is better"
+            if not np.isfinite(rv):
+                raw_text.append(f"{raw_disp}: — ({direction})")
+            else:
+                raw_text.append(f"{raw_disp}: {rv:.4f}{raw_unit} ({direction})")
+
         r_closed = r_vals + [r_vals[0]]
-        raw_closed = raw_vals + [raw_vals[0]]
-        raw_text = [
-            ("—" if not np.isfinite(v) else f"{v:.4f}")
-            for v in raw_closed
-        ]
+        raw_closed = raw_text + [raw_text[0]]
 
         short = mid.split("/")[-1][:28]
         fig.add_trace(
             go.Scatterpolar(
                 r=r_closed,
                 theta=labels_closed,
-                customdata=raw_text,
+                customdata=raw_closed,
                 fill="toself",
                 name=short,
                 line=dict(width=2, color=palette[i % len(palette)]),
                 fillcolor=palette[i % len(palette)],
                 opacity=0.35,
                 hovertemplate=(
-                    f"<b>{short}</b><br>%{{theta}}<br>"
-                    "strength: %{r:.2f}<br>raw: %{customdata}<extra></extra>"
+                    f"<b>{short}</b><br>"
+                    "%{theta} strength: %{r:.2f}<br>"
+                    "%{customdata}<extra></extra>"
                 ),
             )
         )
@@ -282,55 +295,65 @@ def plot_compare_models_across_scenarios(
     df: pd.DataFrame,
     model_ids: Sequence[str],
     metric_keys: Sequence[str],
-    title: str = "WER by scenario — click legend to show/hide models",
+    title: str = "WER across models — one line per scenario (click legend to show/hide scenarios)",
 ) -> go.Figure:
     """
-    Line chart: x = scenario, y = WER, one trace per model. Interactive legend toggles models.
+    Line chart: x = model (sorted by Average WER), y = WER, one trace per scenario.
+
+    Scaling to more models now just extends the x axis instead of adding more traces,
+    which keeps the legend small (≤ #scenarios) and makes cross-scenario comparisons
+    for the same model trivial (read a vertical slice).
+
+    `model_ids` filters which models appear on the x axis; empty / None → all rows.
     """
     metric_keys = [k for k in metric_keys if k in df.columns]
-    model_ids = [m for m in model_ids if m]
     if df.empty or not metric_keys:
         return _empty_fig("Not enough data.")
 
-    sub = df[df["model_id"].isin(model_ids)].copy() if model_ids else df.copy()
+    selected = [m for m in (model_ids or []) if m]
+    sub = df[df["model_id"].isin(selected)].copy() if selected else df.copy()
     if sub.empty:
         return _empty_fig("No matching models.")
 
-    x_labels = [metric_by_key(k).short if metric_by_key(k) else k for k in metric_keys]
+    # Sort models by Average WER ascending so the x axis reads best → worst.
+    if "avg_wer" in sub.columns:
+        sub = sub.sort_values("avg_wer", ascending=True, na_position="last")
+    sub = sub.reset_index(drop=True)
+
+    x_labels = sub["model_id"].str.split("/").str[-1].str[:32].tolist()
+    full_ids = sub["model_id"].tolist()
+
     fig = go.Figure()
     palette = qualitative.Plotly * 3
 
-    ordered = [m for m in model_ids if m in set(sub["model_id"])]
-    if not ordered:
-        ordered = sub["model_id"].unique().tolist()[:15]
-    for i, mid in enumerate(ordered):
-        row = sub[sub["model_id"] == mid]
-        if row.empty:
-            continue
-        ys = []
-        for k in metric_keys:
-            v = row[k].iloc[0]
-            ys.append(float(v) if pd.notna(v) else None)
-        short = mid.split("/")[-1][:32]
+    for i, k in enumerate(metric_keys):
+        m = metric_by_key(k)
+        scen_label = m.short if m else k
+        ys = [float(v) if pd.notna(v) else None for v in sub[k].tolist()]
         fig.add_trace(
             go.Scatter(
                 x=x_labels,
                 y=ys,
                 mode="lines+markers",
-                name=short,
+                name=scen_label,
+                customdata=full_ids,
                 line=dict(width=2, color=palette[i % len(palette)]),
                 marker=dict(size=8),
-                hovertemplate=f"<b>{short}</b><br>%{{x}}: %{{y:.4f}}<extra></extra>",
+                hovertemplate=(
+                    f"<b>%{{customdata}}</b><br>{scen_label}: %{{y:.4f}}<extra></extra>"
+                ),
             )
         )
 
+    n_models = len(x_labels)
+    tickangle = -45 if n_models > 8 else -25
     fig.update_layout(
         title=dict(text=title, x=0.5, xanchor="center"),
-        xaxis=dict(title="Scenario", tickangle=-25),
+        xaxis=dict(title="Model (sorted by Average WER)", tickangle=tickangle, automargin=True),
         yaxis=dict(title="WER (lower is better)", rangemode="tozero"),
         template=_TEMPLATE,
         height=_FIG_HEIGHT,
-        margin=dict(l=60, r=120, t=60, b=100),
+        margin=dict(l=60, r=120, t=60, b=140),
         **_plotly_legend_config(),
     )
     return fig
@@ -416,11 +439,11 @@ def plot_latency_vs_wer(
 
     xm = metric_by_key(y_metric_key)
     y_label = (xm.short if xm else y_metric_key) + " WER"
-    x_title = (
-        "Total inference wall time (s)"
-        if x_key == "eval_wall_time_s"
-        else "RTF (audio seconds / inference seconds)"
-    )
+    x_title = {
+        "eval_wall_time_s": "Total inference wall time (s)",
+        "eval_rtf": "RTF (audio seconds / inference seconds)",
+        "num_params_m": "Parameters (millions)",
+    }.get(x_key, x_key)
 
     short = d["model_id"].str.split("/").str[-1].str[:28]
     fig = go.Figure(

app.py

@@ -164,6 +164,7 @@ _METRIC_CHOICES = [
 _LATENCY_X_CHOICES = [
     ("Total eval wall time (s)", "eval_wall_time_s"),
     ("RTF (audio sec ÷ inference sec)", "eval_rtf"),
+    ("Parameters (millions)", "num_params_m"),
 ]
 _LATENCY_Y_CHOICES = [
     (f"{m.short} WER", m.key)
@@ -182,7 +183,6 @@ def _analytics_initial():
     sel = ids[: min(5, len(ids))]
     fig_r = analytics.plot_robustness_radar(df, sel)
     fig_cmp = analytics.plot_compare_models_across_scenarios(df, sel, line_default)
-    fig_clean = analytics.plot_clean_vs_reverb_scatter(df)
     fig_lat = analytics.plot_latency_vs_wer(df, "eval_wall_time_s", "wer_reverberant")
     fig_b = analytics.plot_scenario_bar_summary(df, 8)
     return (
@@ -192,7 +192,6 @@ def _analytics_initial():
         gr.update(choices=_LATENCY_Y_CHOICES, value="wer_reverberant"),
         fig_r,
         fig_cmp,
-        fig_clean,
         fig_lat,
         fig_b,
     )
@@ -209,14 +208,13 @@ def _analytics_apply(models, line_keys, top_n, latency_x, latency_y):
     avail = analytics.available_metric_keys(df)
     if not lk:
         lk = avail
-    lx = latency_x if latency_x in ("eval_wall_time_s", "eval_rtf") else "eval_wall_time_s"
+    lx = latency_x if latency_x in ("eval_wall_time_s", "eval_rtf", "num_params_m") else "eval_wall_time_s"
     ly = latency_y if latency_y in [m.key for m in SCENARIO_METRICS] else "wer_reverberant"
     fig_r = analytics.plot_robustness_radar(df, valid_models)
     fig_cmp = analytics.plot_compare_models_across_scenarios(df, valid_models, lk)
-    fig_clean = analytics.plot_clean_vs_reverb_scatter(df)
     fig_lat = analytics.plot_latency_vs_wer(df, lx, ly)
     fig_b = analytics.plot_scenario_bar_summary(df, int(top_n))
-    return fig_r, fig_cmp, fig_clean, fig_lat, fig_b
+    return fig_r, fig_cmp, fig_lat, fig_b
 
 
 # ---------------------------------------------------------------------------
@@ -459,14 +457,20 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
             gr.Markdown(
                 "Charts are **interactive (Plotly)**: use the **legend** to show or hide traces "
                 "(single click toggles, double‑click isolates), drag to **zoom**, and **hover** for values. "
-                "**Robustness radar** plots each selected model on 6 fixed axes — **Avg WER**, **High SNR**, "
-                "**Distance**, **High Reverb**, **RTF**, **Memory** — as a 0–1 *strength* score (higher = better) "
-                "computed globally with a log transform, so a bigger hexagon is a better model. Axes marked "
-                "with `*` fall back to a live proxy when the planned column is empty (High SNR → Clean; "
-                "High Reverb → Reverberant). **Scenario lines** plot raw WER across selected scenarios "
-                "(one trace per model). **Clean vs reverb** compares dry vs reverberant WER (typically above the diagonal). "
-                "**Speed vs accuracy** uses total inference wall time or RTF on the x-axis and a chosen scenario WER on the y-axis "
-                "(timing appears after new evaluations that record `eval_wall_time_s` / `eval_rtf`). "
+                "**Robustness radar** plots each selected model on 6 fixed **strength** axes — "
+                "**Overall accuracy**, **High‑SNR accuracy**, **Distance robustness**, **Reverb robustness**, "
+                "**Speed**, **Compactness**. Every axis is phrased so that farther from the centre = better "
+                "(e.g. Overall accuracy inverts WER, Compactness inverts model size). Strength is a 0–1 score "
+                "computed globally across all leaderboard rows with a log transform, so axes and hexagons are "
+                "directly comparable. Axes marked with `*` fall back to a live proxy when the planned column is "
+                "empty (High‑SNR → Clean; Reverb → Reverberant). Hover any vertex to see the raw metric value "
+                "and its direction. **WER across models** plots one line per scenario with models on the x axis "
+                "(sorted by Average WER, best→worst). Adding more models extends the x axis instead of cluttering "
+                "the legend, and a vertical slice gives you that model's numbers at a glance. "
+                "**Speed vs accuracy** uses total inference wall time, RTF, or parameter count on the x axis and a "
+                "chosen scenario WER on the y axis "
+                "(timing appears after new evaluations that record `eval_wall_time_s` / `eval_rtf`, and parameter "
+                "counts after evaluations that record `num_params`). "
                 "**Bars** group core scenarios for the top models."
             )
             with gr.Row():
@@ -494,23 +498,20 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
             an_apply = gr.Button("Apply / refresh charts", variant="primary")
             with gr.Row():
                 an_plot_radar = gr.Plot(label="Robustness radar (6 axes, strength 0–1)")
-                an_plot_compare = gr.Plot(label="WER by scenario — compare models")
-            with gr.Tabs():
-                with gr.TabItem("Clean vs reverberant"):
-                    an_plot_clean = gr.Plot(label="Clean vs reverberant WER")
-                with gr.TabItem("Speed vs accuracy"):
-                    with gr.Row():
-                        an_latency_x = gr.Dropdown(
-                            label="X axis (speed)",
-                            choices=_LATENCY_X_CHOICES,
-                            value="eval_wall_time_s",
-                        )
-                        an_latency_y = gr.Dropdown(
-                            label="Y axis (WER scenario)",
-                            choices=_LATENCY_Y_CHOICES,
-                            value="wer_reverberant",
-                        )
-                    an_plot_latency = gr.Plot(label="Latency vs WER")
+                an_plot_compare = gr.Plot(label="WER across models — one line per scenario")
+            gr.Markdown("### Speed vs accuracy")
+            with gr.Row():
+                an_latency_x = gr.Dropdown(
+                    label="X axis (speed)",
+                    choices=_LATENCY_X_CHOICES,
+                    value="eval_wall_time_s",
+                )
+                an_latency_y = gr.Dropdown(
+                    label="Y axis (WER scenario)",
+                    choices=_LATENCY_Y_CHOICES,
+                    value="wer_reverberant",
+                )
+            an_plot_latency = gr.Plot(label="Speed vs WER")
             an_plot_bar = gr.Plot(label="Core scenarios — top models (grouped)")
 
             an_apply.click(
@@ -525,7 +526,6 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                 outputs=[
                     an_plot_radar,
                     an_plot_compare,
-                    an_plot_clean,
                     an_plot_latency,
                     an_plot_bar,
                 ],
@@ -571,7 +571,6 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
             an_latency_y,
             an_plot_radar,
             an_plot_compare,
-            an_plot_clean,
             an_plot_latency,
             an_plot_bar,
         ],

backends/_model_utils.py

@@ -0,0 +1,36 @@
+"""Model-introspection helpers shared across backends."""
+
+from __future__ import annotations
+
+
+def count_params(module) -> int:
+    """
+    Return the total number of parameters of a PyTorch `nn.Module`-like object.
+
+    Works for standard Transformers models (they are `nn.Module` subclasses) and for
+    SpeechBrain's `Pretrained` base class (also an `nn.Module` subclass). Returns 0 if
+    the object has no `.parameters()` method or counting fails for any reason — we
+    treat parameter counts as best-effort metadata, never a hard requirement.
+    """
+    if module is None:
+        return 0
+    params_fn = getattr(module, "parameters", None)
+    if not callable(params_fn):
+        return 0
+    try:
+        total = 0
+        for p in params_fn():
+            numel = getattr(p, "numel", None)
+            if callable(numel):
+                total += int(numel())
+        return total
+    except Exception:
+        return 0
+
+
+def attach_params(fn, module) -> None:
+    """Convenience: attach the param count of `module` to `fn._num_params`."""
+    try:
+        fn._num_params = count_params(module)
+    except Exception:
+        fn._num_params = 0

backends/granite_speech.py

@@ -14,6 +14,8 @@ import numpy as np
 import torch
 from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor
 
+from ._model_utils import attach_params
+
 _DEFAULT_PROMPT = "<|audio|>can you transcribe the speech into a written format?"
 
 
@@ -65,6 +67,8 @@ def build_transcriber(model_id: str, device_str: str) -> tuple[Callable[..., str
         )
         return str(output_text[0]).strip() if output_text else ""
 
+    attach_params(transcribe, model)
+
     def cleanup() -> None:
         nonlocal model, processor
         del model, processor

backends/speechbrain_asr.py

@@ -21,6 +21,8 @@ from collections.abc import Callable
 import numpy as np
 import torch
 
+from ._model_utils import attach_params
+
 
 def _load_model(model_id: str, device_str: str, savedir: str):
     """Try the two common SpeechBrain ASR interfaces."""
@@ -61,6 +63,8 @@ def build_transcriber(model_id: str, device_str: str) -> tuple[Callable[..., str
             preds, _tokens = model.transcribe_batch(wav, wav_lens)
         return str(preds[0]).strip() if preds else ""
 
+    attach_params(transcribe, model)
+
     def cleanup() -> None:
         nonlocal model
         del model

backends/transformers_ctc.py

@@ -10,6 +10,8 @@ import numpy as np
 import torch
 from transformers import AutoModelForCTC, AutoProcessor
 
+from ._model_utils import attach_params
+
 
 def build_transcriber(model_id: str, device_str: str) -> tuple[Callable[..., str], Callable[[], None]]:
     processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
@@ -30,6 +32,8 @@ def build_transcriber(model_id: str, device_str: str) -> tuple[Callable[..., str
         text = processor.batch_decode(pred_ids)[0]
         return text
 
+    attach_params(transcribe, model)
+
     def cleanup() -> None:
         nonlocal model, processor
         del model, processor

backends/transformers_pipeline.py

@@ -10,6 +10,7 @@ from typing import Any
 import numpy as np
 
 from ._audio_utils import safe_pad_audio
+from ._model_utils import attach_params
 
 
 def build_transcriber(model_id: str, device_int: int) -> tuple[Callable[..., str], Callable[[], None]]:
@@ -28,6 +29,8 @@ def build_transcriber(model_id: str, device_int: int) -> tuple[Callable[..., str
         out = pipe({"raw": padded, "sampling_rate": sampling_rate})
         return str(out["text"])
 
+    attach_params(transcribe, getattr(pipe, "model", None))
+
     def cleanup() -> None:
         nonlocal pipe
         del pipe

backends/universal.py

@@ -30,6 +30,7 @@ import torch
 from transformers import AutoModel, AutoModelForSpeechSeq2Seq, AutoProcessor
 
 from ._audio_utils import safe_pad_audio
+from ._model_utils import attach_params
 
 
 def _safe_max_new_tokens(model, env_override: int | None, default_cap: int = 256) -> int:
@@ -200,6 +201,8 @@ def build_transcriber(model_id: str, device_str: str) -> tuple[Callable[..., str
             outputs = _generate(model, batch, max_new, language)
         return _decode(processor, outputs, meta, language)
 
+    attach_params(transcribe, model)
+
     def cleanup() -> None:
         nonlocal model, processor
         del model, processor

constants.py

@@ -82,6 +82,7 @@ convention). That is why scores across models are directly comparable.
 | **WER Clean / Noisy / Reverberant** | WER per condition (lower is better). |
 | **Eval wall time (s)** | Total server‑side inference time for the full condition set. |
 | **RTF** | *Audio seconds ÷ inference seconds*. Higher is faster; >1 means faster than real time. |
+| **Params (M)** | Total trainable parameters in the loaded model, in millions. |
 
 Timing depends on the hardware this Space runs on, so treat RTF and wall time as **comparative between submissions**
 on this leaderboard, not as absolute hardware numbers.

evaluation/orchestrator.py

@@ -45,9 +45,13 @@ def run_evaluation(
 
     transcribe, cleanup = build_transcriber(family_id, model_id, device_str, device_int)
     try:
+        # Backends attach `transcribe._num_params` via `_model_utils.attach_params`; defaults to 0
+        # if the backend couldn't introspect a module.
+        num_params = int(getattr(transcribe, "_num_params", 0) or 0)
         results: dict = {
             "model_id": model_id,
             "eval_family": resolve_label(family_id),
+            "num_params": num_params,
         }
         total_samples = 0
         total_audio_s = 0.0

init.py

@@ -49,6 +49,7 @@ CSV_FIELDS = [
     "eval_audio_seconds",
     "eval_wall_time_s",
     "eval_rtf",
+    "num_params",
     "submission_notes",
     "submitted_at",
 ]
@@ -67,7 +68,7 @@ def leaderboard_row_from_eval_result(
         if key in result and result[key] is not None:
             row[key] = str(result[key])
     row["num_samples"] = str(result.get("num_samples", ""))
-    for k in ("eval_audio_seconds", "eval_wall_time_s", "eval_rtf"):
+    for k in ("eval_audio_seconds", "eval_wall_time_s", "eval_rtf", "num_params"):
         if k in result and result[k] is not None and result[k] != "":
             row[k] = str(result[k])
     row["submission_notes"] = (submission_notes or "").strip()[:4000]
@@ -203,6 +204,14 @@ def load_results() -> pd.DataFrame:
     else:
         display_df["RTF"] = "NA"
 
+    if "num_params" in raw_df.columns:
+        params = pd.to_numeric(raw_df["num_params"], errors="coerce")
+        display_df["Params (M)"] = params.apply(
+            lambda v: round(float(v) / 1e6, 2) if pd.notna(v) and float(v) > 0 else "NA"
+        )
+    else:
+        display_df["Params (M)"] = "NA"
+
     display_df["Submitted"] = raw_df["submitted_at"].apply(_format_timestamp)
 
     return display_df

utils_display.py

@@ -23,6 +23,7 @@ class AutoEvalColumn:
     wer_reverb = ColumnContent("WER Reverberant", "number")
     eval_wall_s = ColumnContent("Eval wall time (s)", "number")
     eval_rtf = ColumnContent("RTF", "number")
+    params_m = ColumnContent("Params (M)", "number")
     submitted = ColumnContent("Submitted", "str")