new version with new metrics

analytics.py

@@ -17,6 +17,16 @@ from plotly.colors import qualitative
 
 from metrics_config import LIVE_SCENARIO_KEYS, SCENARIO_METRICS, metric_by_key
 
+# Far-field ranking weights (renormalized per model over metrics that have data).
+FAR_FIELD_WEIGHTS: dict[str, float] = {
+    "wer_anechoic_speech": 0.05,
+    "wer_lab_measured": 0.10,
+    "wer_lab_simulated": 0.10,
+    "wer_realistic_high_snr": 0.20,
+    "wer_realistic_low_snr": 0.35,
+    "wer_moving_sources": 0.20,
+}
+
 # Consistent height for Gradio Plot
 _FIG_HEIGHT = 460
 _TEMPLATE = "plotly_white"
@@ -50,9 +60,86 @@ def _cached_model_size_mb(model_id: str) -> float:
     return mb
 
 
-def _log_normalize(values: np.ndarray, *, inverse: bool) -> np.ndarray:
+def _coerce_positive_float(v) -> float | None:
+    if v is None or v == "":
+        return None
+    try:
+        x = float(v)
+        return x if np.isfinite(x) and x > 0 else None
+    except (TypeError, ValueError):
+        return None
+
+
+def compute_wer_log_bounds(rows: list[dict], keys: Sequence[str]) -> dict[str, tuple[float, float]]:
+    """Per-key log10(WER) bounds across leaderboard rows (WER > 0 only)."""
+    bounds: dict[str, tuple[float, float]] = {}
+    for k in keys:
+        vals: list[float] = []
+        for r in rows:
+            x = _coerce_positive_float(r.get(k))
+            if x is not None:
+                vals.append(float(np.log10(x)))
+        if vals:
+            bounds[k] = (float(min(vals)), float(max(vals)))
+        else:
+            bounds[k] = (0.0, 0.0)
+    return bounds
+
+
+def wer_quality_from_bounds(wer, lo: float, hi: float) -> float | None:
+    """Inverted log10 min-max quality in [0, 1]; lower WER -> higher quality."""
+    x = _coerce_positive_float(wer)
+    if x is None:
+        return None
+    lv = float(np.log10(x))
+    if hi - lo < 1e-9:
+        return 0.5
+    t = (lv - lo) / (hi - lo)
+    t = float(np.clip(t, 0.0, 1.0))
+    return 1.0 - t
+
+
+def far_field_score_for_row(
+    row: dict,
+    bounds: dict[str, tuple[float, float]],
+    metric_keys: Sequence[str] | None = None,
+) -> float | None:
+    """Composite score in [0, 100]; higher is better. Missing metrics drop out with weight renorm."""
+    keys = list(metric_keys) if metric_keys is not None else list(LIVE_SCENARIO_KEYS)
+    num = 0.0
+    den = 0.0
+    for k in keys:
+        w = FAR_FIELD_WEIGHTS.get(k)
+        if w is None:
+            continue
+        lo, hi = bounds.get(k, (0.0, 0.0))
+        q = wer_quality_from_bounds(row.get(k), lo, hi)
+        if q is None:
+            continue
+        num += w * q
+        den += w
+    if den <= 0:
+        return None
+    return round(100.0 * num / den, 2)
+
+
+def compute_far_field_score_map(rows: list[dict]) -> dict[str, float]:
+    """model_id -> score for sorting CSV rows."""
+    bounds = compute_wer_log_bounds(rows, LIVE_SCENARIO_KEYS)
+    out: dict[str, float] = {}
+    for r in rows:
+        mid = r.get("model_id")
+        if not mid:
+            continue
+        s = far_field_score_for_row(r, bounds)
+        if s is not None:
+            out[str(mid)] = float(s)
+    return out
+
+
+def _log_normalize(values: np.ndarray, *, inverse: bool, strength_floor: float = 0.1) -> np.ndarray:
     """
-    Log-normalize an array across all models to a 0-1 "strength" score.
+    Log10-normalize an array across all models to a "strength" score (default display floor 0.1).
 
     * `inverse=True`  -> lower raw value is better (WER, memory). Strength = 1 - norm.
     * `inverse=False` -> higher raw value is better (RTF). Strength = norm.
@@ -64,7 +151,7 @@ def _log_normalize(values: np.ndarray, *, inverse: bool) -> np.ndarray:
     mask = np.isfinite(v) & (v > 0)
     if not mask.any():
         return out
-    logv = np.log(v[mask])
+    logv = np.log10(np.maximum(v[mask], 1e-12))
     lo = float(np.min(logv))
     hi = float(np.max(logv))
     if hi - lo < 1e-9:
@@ -73,6 +160,8 @@ def _log_normalize(values: np.ndarray, *, inverse: bool) -> np.ndarray:
         out[mask] = (logv - lo) / (hi - lo)
         if inverse:
             out[mask] = 1.0 - out[mask]
+    fin = np.isfinite(out)
+    out[fin] = np.clip(np.maximum(out[fin], strength_floor), strength_floor, 1.0)
     return out
 
 
@@ -82,15 +171,15 @@ def _log_normalize(values: np.ndarray, *, inverse: bool) -> np.ndarray:
 # 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.
 #
-# Live conditions reflected: Anechoic, Noisy, Treble Eval, Real RIR, Difficult.
-# Plus Speed (RTF) and Compactness (weight-file size).
+# Live far-field scenario axes + Speed (RTF) + Compactness (parameters / Hub size).
 _RADAR_AXES: tuple[tuple[str, str, str | None, bool, str, str], ...] = (
-    ("Anechoic",     "wer_clean",       None, True,  "Anechoic WER",    ""),
-    ("Noisy",        "wer_noisy",       None, True,  "Noisy WER",       ""),
-    ("Treble Eval",  "wer_reverberant", None, True,  "Treble Eval WER", ""),
-    ("Real RIR",     "wer_real",        None, True,  "Real RIR WER",    ""),
-    ("Difficult",    "wer_difficult",   None, True,  "Difficult WER",   ""),
-    ("Speed",        "eval_rtf",        None, False, "RTF",             "× realtime"),
+    ("Anechoic speech", "wer_anechoic_speech", None, True, "Anechoic speech WER", ""),
+    ("Lab measured", "wer_lab_measured", None, True, "Lab measured WER", ""),
+    ("Lab simulated", "wer_lab_simulated", None, True, "Lab simulated WER", ""),
+    ("Realistic Hi SNR", "wer_realistic_high_snr", None, True, "Realistic high-SNR WER", ""),
+    ("Realistic Lo SNR", "wer_realistic_low_snr", None, True, "Realistic low-SNR WER", ""),
+    ("Moving sources", "wer_moving_sources", None, True, "Moving sources WER", ""),
+    ("Speed", "eval_rtf", None, False, "RTF", "× realtime"),
     # Compactness: smaller model -> more compact -> farther from centre.
     # `inverse=True` makes `_log_normalize` emit `1 - norm`, so the smallest
     # observed model maps to strength = 1.0 (radar edge) and the largest
@@ -154,13 +243,17 @@ def _raw_to_analytics_df(raw: list[dict]) -> pd.DataFrame:
     """
     Parse leaderboard rows; coerce scenario WER + timing columns to float (NaN if missing).
 
-    Also computes derived columns used by the robustness radar:
-      * `avg_wer` — mean of live scenario WERs present for that row.
-      * `model_size_mb` — total weight-file size fetched from the Hub (cached).
+    Computes:
+      * ``avg_wer`` — mean of live scenario WERs present for that row (reference).
+      * ``ff_score`` — far-field composite score (0–100, higher is better).
+      * ``model_size_mb`` — total weight-file size fetched from the Hub (cached).
     """
+    from init import normalize_legacy_csv_row
+
     if not raw:
         return pd.DataFrame()
-    df = pd.DataFrame(raw)
+    rows = [normalize_legacy_csv_row(dict(r)) for r in raw]
+    df = pd.DataFrame(rows)
     if "model_id" not in df.columns:
         return pd.DataFrame()
     for m in SCENARIO_METRICS:
@@ -178,6 +271,8 @@ def _raw_to_analytics_df(raw: list[dict]) -> pd.DataFrame:
     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
+    bounds = compute_wer_log_bounds(rows, LIVE_SCENARIO_KEYS)
+    df["ff_score"] = [far_field_score_for_row(r, bounds) for r in rows]
     df["model_size_mb"] = df["model_id"].apply(_cached_model_size_mb)
     return df
 
@@ -191,10 +286,61 @@ def available_metric_keys(df: pd.DataFrame) -> list[str]:
     return keys
 
 
+def plot_leaderboard_score_bars(
+    df: pd.DataFrame,
+    top_n: int = 40,
+    title: str | None = None,
+) -> go.Figure:
+    """
+    Ranked horizontal bar chart of ``ff_score`` (Artificial Analysis–style highlights).
+    """
+    if df.empty or "ff_score" not in df.columns:
+        return _empty_fig("No leaderboard scores yet.")
+    d = df[["model_id", "ff_score"]].dropna(subset=["ff_score"]).copy()
+    if d.empty:
+        return _empty_fig("No scores computed.")
+    n = max(1, int(top_n))
+    d = d.sort_values("ff_score", ascending=False, na_position="last").head(n)
+    labels = d["model_id"].str.split("/").str[-1].str[:42]
+    scores = d["ff_score"].astype(float)
+    fig = go.Figure(
+        go.Bar(
+            x=scores,
+            y=labels,
+            orientation="h",
+            marker=dict(
+                color=scores,
+                colorscale="Viridis",
+                cmid=50,
+                cmin=0,
+                cmax=100,
+                showscale=True,
+                colorbar=dict(title="Score"),
+            ),
+            text=[f"{s:.1f}" for s in scores],
+            textposition="outside",
+            hovertemplate="<b>%{y}</b><br>Score: %{x:.2f} / 100<extra></extra>",
+        )
+    )
+    fig.update_layout(
+        title=dict(
+            text=title or f"Far-field score (top {len(d)} models) · Higher is better",
+            x=0.5,
+            xanchor="center",
+        ),
+        xaxis=dict(title="Score (out of 100)", range=[0, min(110, float(scores.max()) * 1.15 + 5)]),
+        yaxis=dict(autorange="reversed"),
+        template=_TEMPLATE,
+        height=int(min(920, max(_FIG_HEIGHT, 100 + 22 * len(d)))),
+        margin=dict(l=200, r=100, t=60, b=50),
+    )
+    return fig
+
+
 def plot_robustness_radar(
     df: pd.DataFrame,
     model_ids: Sequence[str],
-    title: str = "Model robustness profile — strength 0–1, farther from centre is better",
+    title: str = "Robustness radar — log10-scaled strength (floor 0.1), farther from centre is better",
 ) -> go.Figure:
     """
     Fixed-axis robustness radar — **strength** view (lines only, no fill).
@@ -203,7 +349,7 @@ def plot_robustness_radar(
     size / parameter count are inverted before normalisation; RTF is not.
     Strength is a 0–1 score computed per-axis across **all** leaderboard rows
     with a log transform + global min/max, so axes are directly comparable
-    across models. Missing values plot as 0 on that axis (honestly empty).
+    across models. Missing or invalid raw values use strength **0.1** (display floor).
 
     The Compactness axis prefers `num_params_m` (recorded for every modern
     eval) and falls back to `model_size_mb` only when params are unavailable;
@@ -257,7 +403,10 @@ def plot_robustness_radar(
         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)
+            if np.isfinite(s):
+                r_vals.append(float(max(s, 0.1)))
+            else:
+                r_vals.append(0.1)
             direction = "lower is better" if inv else "higher is better"
             if not np.isfinite(rv):
                 raw_text.append(f"{raw_disp}: — ({direction})")
@@ -290,8 +439,11 @@ def plot_robustness_radar(
     fig.update_layout(
         polar=dict(
             radialaxis=dict(
-                visible=True, range=[0, 1], showticklabels=True, tickformat=".2f",
-                tickvals=[0.0, 0.25, 0.5, 0.75, 1.0],
+                visible=True,
+                range=[0.1, 1.0],
+                showticklabels=True,
+                tickformat=".2f",
+                tickvals=[0.1, 0.25, 0.5, 0.75, 1.0],
             ),
             angularaxis=dict(direction="clockwise", rotation=90),
         ),
@@ -322,7 +474,7 @@ def plot_compare_models_across_scenarios(
     title: str = "WER across models — one line per scenario (click legend to show/hide scenarios)",
 ) -> go.Figure:
     """
-    Line chart: x = model (sorted by Average WER), y = WER, one trace per scenario.
+    Line chart: x = model (sorted by far-field score), 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
@@ -339,8 +491,10 @@ def plot_compare_models_across_scenarios(
     if sub.empty:
         return _empty_fig("No matching models.")
 
-    # Sort models by Average WER ascending so the x axis reads best → worst.
-    if "avg_wer" in sub.columns:
+    # Sort models by far-field score (fallback: Average WER).
+    if "ff_score" in sub.columns:
+        sub = sub.sort_values("ff_score", ascending=False, na_position="last")
+    elif "avg_wer" in sub.columns:
         sub = sub.sort_values("avg_wer", ascending=True, na_position="last")
     sub = sub.reset_index(drop=True)
 
@@ -373,7 +527,7 @@ def plot_compare_models_across_scenarios(
     tickangle = -45 if n_models > 8 else -25
     fig.update_layout(
         title=dict(text=title, x=0.5, xanchor="center"),
-        xaxis=dict(title="Model (sorted by Average WER)", tickangle=tickangle, automargin=True),
+        xaxis=dict(title="Model (sorted by far-field score)", tickangle=tickangle, automargin=True),
         yaxis=dict(title="WER (lower is better)", rangemode="tozero"),
         template=_TEMPLATE,
         height=_FIG_HEIGHT,
@@ -400,7 +554,7 @@ def plot_scenario_heatmap(
       - and how the top of the leaderboard compares to the rest.
 
     `metric_keys` selects which scenario columns to show (in given order). Models
-    are sorted by Average WER ascending and capped at `top_n` rows so the chart
+    are sorted by far-field score (fallback: mean WER) and capped at `top_n` rows so the chart
     stays legible even with hundreds of leaderboard entries.
     """
     metric_keys = [k for k in metric_keys if k in df.columns]
@@ -408,7 +562,9 @@ def plot_scenario_heatmap(
         return _empty_fig("Not enough data for the heatmap.")
 
     d = df.copy()
-    if "avg_wer" in d.columns:
+    if "ff_score" in d.columns:
+        d = d.sort_values("ff_score", ascending=False, na_position="last")
+    elif "avg_wer" in d.columns:
         d = d.sort_values("avg_wer", ascending=True, na_position="last")
     d = d.head(max(1, int(top_n))).reset_index(drop=True)
 
@@ -465,12 +621,13 @@ def plot_scenario_heatmap(
     height = int(min(900, max(_FIG_HEIGHT, 80 + 18 * n_rows)))
     fig.update_layout(
         title=dict(
-            text=title or f"WER heatmap — top {n_rows} model(s) × {len(keep_keys)} scenario(s)",
+            text=title
+            or f"WER heatmap — top {n_rows} model(s) × {len(keep_keys)} scenario(s) (sorted by score)",
             x=0.5,
             xanchor="center",
         ),
         xaxis=dict(title="Scenario", tickangle=0, side="top", automargin=True),
-        yaxis=dict(title="Model (sorted by Average WER)", automargin=True, autorange="reversed"),
+        yaxis=dict(title="Model (sorted by far-field score)", automargin=True, autorange="reversed"),
         template=_TEMPLATE,
         height=height,
         margin=dict(l=80, r=40, t=80, b=40),
@@ -480,23 +637,24 @@ def plot_scenario_heatmap(
 
 def plot_clean_vs_reverb_scatter(
     df: pd.DataFrame,
-    title: str = "Clean vs reverberant WER — points above the diagonal degrade more under reverb",
+    title: str = "Anechoic vs lab-simulated WER — points above the diagonal degrade more under simulation",
 ) -> go.Figure:
     """
-    Scatter: x = WER clean, y = WER reverberant. Models typically sit above y=x (reverb harder).
+    Scatter: x = anechoic WER, y = lab-simulated WER. Models often sit above y=x when simulation is harder.
     """
-    if df.empty or "wer_clean" not in df.columns or "wer_reverberant" not in df.columns:
-        return _empty_fig("Need wer_clean and wer_reverberant in the leaderboard.")
-
-    d = df[["model_id", "wer_clean", "wer_reverberant"]].copy()
-    d["wer_clean"] = pd.to_numeric(d["wer_clean"], errors="coerce")
-    d["wer_reverberant"] = pd.to_numeric(d["wer_reverberant"], errors="coerce")
-    d = d.dropna(subset=["wer_clean", "wer_reverberant"])
+    c1, c2 = "wer_anechoic_speech", "wer_lab_simulated"
+    if df.empty or c1 not in df.columns or c2 not in df.columns:
+        return _empty_fig("Need anechoic and lab-simulated WER columns in the leaderboard.")
+
+    d = df[["model_id", c1, c2]].copy()
+    d[c1] = pd.to_numeric(d[c1], errors="coerce")
+    d[c2] = pd.to_numeric(d[c2], errors="coerce")
+    d = d.dropna(subset=[c1, c2])
     if d.empty:
-        return _empty_fig("No complete clean/reverb WER pairs yet.")
+        return _empty_fig("No complete anechoic / lab-simulated WER pairs yet.")
 
     fig = go.Figure()
-    mx = float(max(d["wer_clean"].max(), d["wer_reverberant"].max()))
+    mx = float(max(d[c1].max(), d[c2].max()))
     fig.add_trace(
         go.Scatter(
             x=[0, mx],
@@ -510,21 +668,21 @@ def plot_clean_vs_reverb_scatter(
     short = d["model_id"].str.split("/").str[-1].str[:28]
     fig.add_trace(
         go.Scatter(
-            x=d["wer_clean"],
-            y=d["wer_reverberant"],
+            x=d[c1],
+            y=d[c2],
             mode="markers",
             text=short,
             marker=dict(size=10, opacity=0.85),
             hovertemplate=(
-                "<b>%{text}</b><br>Clean WER: %{x:.4f}<br>Reverb WER: %{y:.4f}<extra></extra>"
+                "<b>%{text}</b><br>Anechoic WER: %{x:.4f}<br>Lab simulated WER: %{y:.4f}<extra></extra>"
             ),
         )
     )
 
     fig.update_layout(
         title=dict(text=title, x=0.5, xanchor="center"),
-        xaxis=dict(title="WER — clean (lower is better)", rangemode="tozero"),
-        yaxis=dict(title="WER — reverberant (lower is better)", rangemode="tozero"),
+        xaxis=dict(title="WER — anechoic speech (lower is better)", rangemode="tozero"),
+        yaxis=dict(title="WER — lab simulated (lower is better)", rangemode="tozero"),
         template=_TEMPLATE,
         height=_FIG_HEIGHT,
         margin=dict(l=60, r=40, t=60, b=60),
@@ -556,27 +714,64 @@ def plot_latency_vs_wer(
             "No rows with both timing and WER. Run new evaluations to populate eval_wall_time_s / RTF."
         )
 
-    xm = metric_by_key(y_metric_key)
-    y_label = (xm.short if xm else y_metric_key) + " WER"
+    m_met = metric_by_key(y_metric_key)
+    y_label = (m_met.short if m_met else y_metric_key) + " WER"
     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(
-        data=[
+    xs = d[x_key].to_numpy(dtype=float)
+    ys = d[y_metric_key].to_numpy(dtype=float)
+    mx_f = float(np.nanmedian(xs))
+    my_f = float(np.nanmedian(ys))
+
+    def _bucket(xv: float, yv: float) -> tuple[str, str]:
+        if x_key == "eval_rtf":
+            fast = xv >= mx_f
+        else:
+            fast = xv <= mx_f
+        accurate = yv <= my_f
+        if fast and accurate:
+            return "Fast · accurate", "#22c55e"
+        if fast and not accurate:
+            return "Fast · higher WER", "#3b82f6"
+        if not fast and accurate:
+            return "Slower · lower WER", "#f59e0b"
+        return "Slower · higher WER", "#ef4444"
+
+    buckets = [_bucket(float(a), float(b)) for a, b in zip(xs, ys)]
+    labels = [b[0] for b in buckets]
+
+    fig = go.Figure()
+    for lab, color in (
+        ("Fast · accurate", "#22c55e"),
+        ("Fast · higher WER", "#3b82f6"),
+        ("Slower · lower WER", "#f59e0b"),
+        ("Slower · higher WER", "#ef4444"),
+    ):
+        idx = [i for i, lb in enumerate(labels) if lb == lab]
+        if not idx:
+            continue
+        fig.add_trace(
             go.Scatter(
-                x=d[x_key],
-                y=d[y_metric_key],
+                x=d.iloc[idx][x_key],
+                y=d.iloc[idx][y_metric_key],
                 mode="markers",
-                text=short,
-                marker=dict(size=10, opacity=0.85),
-                hovertemplate=f"<b>%{{text}}</b><br>{x_title}: %{{x:.4f}}<br>{y_label}: %{{y:.4f}}<extra></extra>",
+                text=d.iloc[idx]["model_id"].str.split("/").str[-1].str[:28],
+                name=lab,
+                legendgroup=lab,
+                marker=dict(size=11, opacity=0.9, color=color, line=dict(width=0.6, color="white")),
+                hovertemplate=(
+                    f"<b>%{{text}}</b><br>{lab}<br>{x_title}: %{{x:.4f}}<br>"
+                    f"{y_label}: %{{y:.4f}}<extra></extra>"
+                ),
             )
-        ]
-    )
+        )
+
+    fig.add_vline(x=mx_f, line_dash="dot", line_color="rgba(0,0,0,0.25)")
+    fig.add_hline(y=my_f, line_dash="dot", line_color="rgba(0,0,0,0.25)")
     ttl = title or f"Speed vs accuracy — {y_label}"
     fig.update_layout(
         title=dict(text=ttl, x=0.5, xanchor="center"),
@@ -585,6 +780,8 @@ def plot_latency_vs_wer(
         template=_TEMPLATE,
         height=_FIG_HEIGHT,
         margin=dict(l=60, r=40, t=60, b=60),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        showlegend=True,
     )
     return fig
 
@@ -601,8 +798,11 @@ def plot_scenario_bar_summary(df: pd.DataFrame, top_n: int = 8) -> go.Figure:
         return _empty_fig("No core WER columns.")
 
     d = df.copy()
-    d["_avg"] = d[cols].mean(axis=1, skipna=True)
-    d = d.sort_values("_avg", ascending=True).head(top_n)
+    if "ff_score" in d.columns:
+        d = d.sort_values("ff_score", ascending=False, na_position="last").head(int(top_n))
+    else:
+        d["_avg"] = d[cols].mean(axis=1, skipna=True)
+        d = d.sort_values("_avg", ascending=True).head(int(top_n))
 
     scenarios = cols
     x_labels = [metric_by_key(c).short if metric_by_key(c) else c for c in scenarios]
@@ -625,7 +825,7 @@ def plot_scenario_bar_summary(df: pd.DataFrame, top_n: int = 8) -> go.Figure:
     fig.update_layout(
         barmode="group",
         title=dict(
-            text=f"Core scenarios — top {len(d)} models (click legend to hide/show)",
+            text=f"WER by scenario — top {len(d)} models by score (click legend to hide/show)",
             x=0.5,
             xanchor="center",
         ),

app.py

@@ -3,7 +3,6 @@ import time
 
 import gradio as gr
 import pandas as pd
-import numpy as np
 from constants import (
     ABOUT_TEXT,
     APP_TITLE,
@@ -16,17 +15,20 @@ from constants import (
 import analytics
 from backends import default_family_id
 import job_queue
-from metrics_config import SCENARIO_METRICS
+from metrics_config import LIVE_SCENARIO_KEYS, SCENARIO_METRICS
 
 from init import (
     is_model_on_hub,
     load_raw_results,
     load_results,
+    normalize_legacy_csv_row,
 )
 from utils_display import (
     AutoEvalColumn,
     SCENARIO_DISPLAY_COLS,
+    SCENARIO_DISPLAY_TO_KEY,
     fields,
+    model_id_from_leaderboard_cell,
     styled_error,
     styled_message,
     styled_warning,
@@ -38,7 +40,7 @@ from utils_display import (
 
 COLS = [c.name for c in fields(AutoEvalColumn)]
 TYPES = [c.type for c in fields(AutoEvalColumn)]
-AVG_COL = AutoEvalColumn.avg_wer.name  # "Average ⬇️"
+SCORE_COL = AutoEvalColumn.ff_score.name  # "Score (out of 100)"
 MODEL_COL = AutoEvalColumn.model.name  # "Model"
 
 # Load initial data
@@ -61,31 +63,43 @@ def filter_main_table(search_query, selected_columns):
             )
             filtered_df = filtered_df[mask]
 
-    # Hide toggleable columns that the user unchecked. Model + Average always visible.
-    all_toggleable = [c for c in COLS if c not in (MODEL_COL, AVG_COL)]
+    # Hide toggleable columns that the user unchecked. Model + Score stay visible.
+    all_toggleable = [c for c in COLS if c not in (MODEL_COL, SCORE_COL)]
     columns_to_hide = set(all_toggleable) - set(selected_columns)
     filtered_df = filtered_df[[c for c in filtered_df.columns if c not in columns_to_hide]]
 
-    # Recompute the Average column from whichever benchmark columns are visible.
-    visible_benchmarks = [
-        c for c in SCENARIO_DISPLAY_COLS if c in filtered_df.columns and c in selected_columns
+    raw_rows = load_raw_results()
+    for r in raw_rows:
+        normalize_legacy_csv_row(r)
+    bounds = analytics.compute_wer_log_bounds(raw_rows, LIVE_SCENARIO_KEYS)
+    raw_by_mid = {r["model_id"]: r for r in raw_rows}
+
+    visible_metric_keys = [
+        SCENARIO_DISPLAY_TO_KEY[c]
+        for c in SCENARIO_DISPLAY_COLS
+        if c in filtered_df.columns and c in selected_columns
     ]
-    if visible_benchmarks:
-        def compute_avg(row):
-            vals = [float(row[c]) for c in visible_benchmarks if row[c] != "NA"]
-            return round(np.mean(vals), 4) if vals else "NA"
-        filtered_df[AVG_COL] = filtered_df.apply(compute_avg, axis=1)
-    else:
-        filtered_df[AVG_COL] = "NA"
-
-    # Sort: numeric Average ascending, NA rows go last.
-    def _avg_key(v):
+    if not visible_metric_keys:
+        visible_metric_keys = list(LIVE_SCENARIO_KEYS)
+
+    def compute_score(row):
+        mid = model_id_from_leaderboard_cell(row[MODEL_COL])
+        rdict = raw_by_mid.get(mid)
+        if not rdict:
+            return "NA"
+        s = analytics.far_field_score_for_row(rdict, bounds, metric_keys=visible_metric_keys)
+        return round(float(s), 2) if s is not None else "NA"
+
+    filtered_df[SCORE_COL] = filtered_df.apply(compute_score, axis=1)
+
+    # Sort by Score descending; NA last.
+    def _score_key(v):
         try:
-            return (0, float(v))
+            return (0, -float(v))
         except Exception:
             return (1, 0.0)
 
-    filtered_df = filtered_df.assign(_sort=filtered_df[AVG_COL].apply(_avg_key))
+    filtered_df = filtered_df.assign(_sort=filtered_df[SCORE_COL].apply(_score_key))
     filtered_df = filtered_df.sort_values(by="_sort").drop(columns="_sort")
     return filtered_df
 
@@ -95,6 +109,14 @@ def filter_main_table(search_query, selected_columns):
 # ---------------------------------------------------------------------------
 
 
+def _wer_cell(row: dict, key: str) -> str:
+    normalize_legacy_csv_row(row)
+    v = row.get(key, "")
+    if v is None or (isinstance(v, str) and str(v).strip() == ""):
+        return "—"
+    return str(v).strip()
+
+
 def submit_model(model_id: str, submission_notes: str) -> str:
     """Validate and enqueue evaluation; a background worker runs jobs one at a time.
 
@@ -113,11 +135,12 @@ def submit_model(model_id: str, submission_notes: str) -> str:
         if row["model_id"] == model_id:
             return styled_message(
                 f"Model '{model_id}' has already been evaluated. "
-                f"Anechoic: {row.get('wer_clean', '—')} | "
-                f"Noisy: {row.get('wer_noisy', '—')} | "
-                f"Treble Eval: {row.get('wer_reverberant', '—')} | "
-                f"Real RIR: {row.get('wer_real', '—')} | "
-                f"Difficult: {row.get('wer_difficult', '—')}"
+                f"Anechoic speech: {_wer_cell(row, 'wer_anechoic_speech')} | "
+                f"Lab measured: {_wer_cell(row, 'wer_lab_measured')} | "
+                f"Lab simulated: {_wer_cell(row, 'wer_lab_simulated')} | "
+                f"Realistic High SNR: {_wer_cell(row, 'wer_realistic_high_snr')} | "
+                f"Realistic Low SNR: {_wer_cell(row, 'wer_realistic_low_snr')} | "
+                f"Moving sources: {_wer_cell(row, 'wer_moving_sources')}"
             )
 
     on_hub, err_msg = is_model_on_hub(model_id)
@@ -142,11 +165,12 @@ def submit_model(model_id: str, submission_notes: str) -> str:
             if row["model_id"] == model_id:
                 return styled_message(
                     f"Model '{model_id}' has already been evaluated. "
-                    f"Anechoic: {row.get('wer_clean', '—')} | "
-                    f"Noisy: {row.get('wer_noisy', '—')} | "
-                    f"Treble Eval: {row.get('wer_reverberant', '—')} | "
-                    f"Real RIR: {row.get('wer_real', '—')} | "
-                    f"Difficult: {row.get('wer_difficult', '—')}"
+                    f"Anechoic speech: {_wer_cell(row, 'wer_anechoic_speech')} | "
+                    f"Lab measured: {_wer_cell(row, 'wer_lab_measured')} | "
+                    f"Lab simulated: {_wer_cell(row, 'wer_lab_simulated')} | "
+                    f"Realistic High SNR: {_wer_cell(row, 'wer_realistic_high_snr')} | "
+                    f"Realistic Low SNR: {_wer_cell(row, 'wer_realistic_low_snr')} | "
+                    f"Moving sources: {_wer_cell(row, 'wer_moving_sources')}"
                 )
         return styled_error("Could not enqueue; please try again.")
     if err == "queue_full":
@@ -205,18 +229,21 @@ def _analytics_initial():
     live_keys = [m.key for m in SCENARIO_METRICS if m.status == "live"]
     line_default = [k for k in live_keys if k in avail] or list(avail)
     sel = ids[: min(5, len(ids))]
-    fig_r = analytics.plot_robustness_radar(df, sel)
-    fig_hm = analytics.plot_scenario_heatmap(df, line_default, top_n=40)
-    fig_lat = analytics.plot_latency_vs_wer(df, "eval_wall_time_s", "wer_reverberant")
+    tn = 40
+    fig_score = analytics.plot_leaderboard_score_bars(df, top_n=tn)
+    fig_hm = analytics.plot_scenario_heatmap(df, line_default, top_n=tn)
+    fig_lat = analytics.plot_latency_vs_wer(df, "eval_wall_time_s", "wer_lab_simulated")
+    fig_radar = analytics.plot_robustness_radar(df, sel)
     fig_b = analytics.plot_scenario_bar_summary(df, 8)
     return (
         gr.update(choices=ids, value=sel),
         gr.update(value=line_default),
         gr.update(choices=_LATENCY_X_CHOICES, value="eval_wall_time_s"),
-        gr.update(choices=_LATENCY_Y_CHOICES, value="wer_reverberant"),
-        fig_r,
+        gr.update(choices=_LATENCY_Y_CHOICES, value="wer_lab_simulated"),
+        fig_score,
         fig_hm,
         fig_lat,
+        fig_radar,
         fig_b,
     )
 
@@ -233,12 +260,14 @@ def _analytics_apply(models, line_keys, top_n, latency_x, latency_y):
     if not lk:
         lk = avail
     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_hm = analytics.plot_scenario_heatmap(df, lk, top_n=int(top_n) if top_n else 40)
+    ly = latency_y if latency_y in [m.key for m in SCENARIO_METRICS] else "wer_lab_simulated"
+    tn = int(top_n) if top_n else 40
+    fig_score = analytics.plot_leaderboard_score_bars(df, top_n=tn)
+    fig_hm = analytics.plot_scenario_heatmap(df, lk, top_n=tn)
     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_hm, fig_lat, fig_b
+    fig_radar = analytics.plot_robustness_radar(df, valid_models)
+    fig_b = analytics.plot_scenario_bar_summary(df, tn)
+    return fig_score, fig_hm, fig_lat, fig_radar, fig_b
 
 
 # ---------------------------------------------------------------------------
@@ -481,19 +510,16 @@ 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.\n\n"
-                "**Robustness radar** plots each selected model on fixed **strength** axes covering the "
-                "live conditions (**Anechoic**, **Noisy**, **Treble Eval**, **Real RIR**, **Difficult**) "
-                "plus **Speed** (RTF) and **Compactness** (model size). Axes are phrased so that farther from "
-                "the centre = better (WER and size are inverted; RTF is not). Strength is a 0–1 score "
-                "computed globally across all leaderboard rows with a log transform, so axes and shapes are "
-                "directly comparable. Hover any vertex for the raw metric value and its direction.\n\n"
-                "**WER heatmap** shows the top‑N models (sorted by Average WER) on the y axis and the chosen "
-                "scenarios on the x axis, with colour = WER (greener is better). This scales cleanly to "
-                "hundreds of models — every row is one model, every column is one condition.\n\n"
-                "**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 evaluations that record "
-                "`eval_wall_time_s` / `eval_rtf`, and parameter counts after evaluations that record `num_params`).\n\n"
-                "**Bars** group core scenarios for the top models."
+                "**Far-field score (bar)** ranks models by the same weighted **Score (out of 100)** as the "
+                "leaderboard (higher is better). **WER heatmap** shows the top‑N models (sorted by score) on "
+                "the y axis and chosen scenarios on the x axis — greener is lower WER.\n\n"
+                "**Speed vs accuracy** scatter uses median splits on the axes: points are **color-coded** "
+                "(green = faster-for-axis & lower WER, blue/orange/red = other quadrants). Dotted lines show "
+                "the medians used for those buckets.\n\n"
+                "**Robustness radar** plots selected models on **log₁₀‑scaled strength** axes for each live "
+                "scenario plus **RTF** and **compactness** (parameters / Hub size). Display strengths use a "
+                "**0.1 floor** so traces stay readable. Farther from the centre = better on every spoke.\n\n"
+                "**Grouped bars** compare raw WER across scenarios for the top models."
             )
             with gr.Row():
                 an_models = gr.Dropdown(
@@ -509,7 +535,7 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                     80,
                     value=30,
                     step=1,
-                    label="Top‑N models (heatmap & bar chart)",
+                    label="Top‑N models (score bars, heatmap & grouped WER)",
                     scale=1,
                 )
             an_line_metrics = gr.CheckboxGroup(
@@ -519,22 +545,24 @@ 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 — strength 0–1, lines only")
+                an_plot_score = gr.Plot(label="Far-field score — top N models · Higher is better")
                 an_plot_compare = gr.Plot(label="WER heatmap — models × scenarios (greener = better)")
             gr.Markdown("### Speed vs accuracy")
             with gr.Row():
                 an_latency_x = gr.Dropdown(
-                    label="X axis (speed)",
+                    label="X axis (speed / compute)",
                     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",
+                    value="wer_lab_simulated",
                 )
-            an_plot_latency = gr.Plot(label="Speed vs WER")
-            an_plot_bar = gr.Plot(label="Core scenarios — top models (grouped)")
+            an_plot_latency = gr.Plot(label="Speed vs accuracy — color-coded quadrants")
+            with gr.Row():
+                an_plot_radar = gr.Plot(label="Robustness radar — strength with 0.1 floor")
+                an_plot_bar = gr.Plot(label="WER by scenario — top models (grouped)")
 
             an_apply.click(
                 fn=_analytics_apply,
@@ -546,9 +574,10 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                     an_latency_y,
                 ],
                 outputs=[
-                    an_plot_radar,
+                    an_plot_score,
                     an_plot_compare,
                     an_plot_latency,
+                    an_plot_radar,
                     an_plot_bar,
                 ],
             )
@@ -591,9 +620,10 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
             an_line_metrics,
             an_latency_x,
             an_latency_y,
-            an_plot_radar,
+            an_plot_score,
             an_plot_compare,
             an_plot_latency,
+            an_plot_radar,
             an_plot_bar,
         ],
     )

constants.py

@@ -38,26 +38,26 @@ BANNER = (
     "<h1>FFASR</h1>"
     "<div class='ffasr-subtitle'>Far‑Field Automatic Speech Recognition — a multi‑condition leaderboard</div>"
     "<div class='ffasr-badges'>"
-    "<span class='ffasr-badge'>Anechoic</span>"
-    "<span class='ffasr-badge'>Noisy</span>"
-    "<span class='ffasr-badge'>Treble Eval</span>"
-    "<span class='ffasr-badge'>Real RIR</span>"
-    "<span class='ffasr-badge'>Difficult</span>"
+    "<span class='ffasr-badge'>Far-field score</span>"
+    "<span class='ffasr-badge'>Lab vs realistic</span>"
+    "<span class='ffasr-badge'>Moving sources</span>"
     "<span class='ffasr-badge'>WER · RTF</span>"
     "</div>"
     "</div>"
 )
 
 INTRODUCTION_TEXT = (
-    "**FFASR** benchmarks speech‑recognition models on the kind of audio they encounter outside the close‑mic "
-    "studio. Every model runs on the **same held‑out set** and the **same text normalization**, so numbers are "
-    "directly comparable.\n\n"
-    "Five core conditions are scored today: **Anechoic** (close‑mic, dry), **Noisy** (additive noise), "
-    "**Treble Eval Dataset** (simulated reverberation), **Real RIR Dataset** (real‑room impulse responses), "
-    "and **Difficult Conditions** (low SNR, strong reverb, distortion). Models are ranked by **Average** WER "
-    "across these conditions — lower is better.\n\n"
+    "**FFASR** benchmarks speech‑recognition models on audio closer to **far‑field** deployment — noisy rooms, "
+    "reverberation, and adverse SNRs — not just studio‑dry speech. Every model runs on the **same held‑out set** "
+    "and the **same text normalization**, so numbers are directly comparable.\n\n"
+    "Each submission reports **WER** across six scenario columns (**anechoic speech**, **lab measured**, "
+    "**lab simulated**, **realistic high / low SNR**, **moving sources**) plus **RTF** and **parameter count**. "
+    "**Moving sources** fills when that evaluation split is available (otherwise shown as NA). Models are ranked "
+    "by a far‑field‑weighted **Score (out of 100)** — **higher is better** — derived from per‑scenario WER vs "
+    "the rest of the leaderboard.\n\n"
     "Paste a Hugging Face model id in the **Submit** tab — scoring runs server‑side and your model never sees "
-    "the evaluation audio directly. Use the **Analysis** tab for robustness, heatmap, and speed‑vs‑accuracy views."
+    "the evaluation audio directly. Use the **Analysis** tab for ranked scores, heatmaps, radar robustness, and "
+    "color‑coded speed‑vs‑accuracy plots."
 )
 
 CITATION_TEXT = """@misc{ffasr_leaderboard_2026,
@@ -70,33 +70,56 @@ CITATION_TEXT = """@misc{ffasr_leaderboard_2026,
 ABOUT_TEXT = """
 ## About FFASR
 
-**FFASR** (Far‑Field Automatic Speech Recognition) is an evaluation leaderboard that stresses ASR models
-on the kinds of audio encountered beyond the close‑mic studio — real rooms, real distance, real noise.
+**FFASR** (Far‑Field Automatic Speech Recognition) is an evaluation leaderboard that stresses ASR models on audio
+beyond close‑mic studio conditions — realistic acoustics, difficult SNRs, and (when enabled in the eval harness)
+moving sources.
 
-Five core conditions are evaluated today:
+### Scenario columns (WER · lower is better)
 
-* **Anechoic** — close‑mic, dry speech; the "easy" baseline.
-* **Noisy** — speech mixed with additive background noise.
-* **Treble Eval Dataset** — speech with simulated reverberation from the Treble eval set.
-* **Real RIR Dataset** — speech convolved with real‑room impulse responses (non‑simulated).
-* **Difficult Conditions** — adversarial mixtures (low SNR, strong reverb, distortion).
+The leaderboard surfaces six complementary benchmarks:
+
+* **Anechoic speech** — dry close‑mic baseline (included but **down‑weighted** in the headline score so rankings emphasise harder realism).
+* **Lab measured** — controlled recordings / additive artifacts captured under measured lab conditions.
+* **Lab simulated** — simulated room acoustics (historically Treble‑style simulated reverberation).
+* **Realistic cond.: High SNR** — real‑world‑style mixtures at comparatively forgiving SNR.
+* **Realistic cond.: Low SNR** — hard mixtures (low SNR, strong reverb, distortion) weighted heavily toward deployment realism.
+* **Moving sources** — moving talkers / geometry shifts (**NA until that packed split ships** in the evaluation pipeline).
+
+WER measures word‑level accuracy; **lower WER is always better** for each scenario column individually.
 
 Every submission is evaluated on the **same private held‑out set**, using the **same reference transcripts** and the
 **same text normalization pipeline** (lowercasing + whitespace/punctuation normalization, following the Whisper
 convention). That is why scores across models are directly comparable.
 
+### Far-field score (out of 100 · higher is better)
+
+Instead of a flat average across every scenario, the headline **Score (out of 100)** combines scenarios with weights tuned for far‑field impact:
+
+| Scenario bucket | Role in the score |
+|---|---|
+| Anechoic speech | Sanity baseline — contributes only a little so rankings aren’t dominated by easy speech |
+| Lab measured / simulated | Important diagnostics — modest weights versus tougher realism |
+| Realistic high SNR | Medium weight |
+| Realistic low SNR | High weight |
+| Moving sources | Highest planned weight once populated |
+
+Technically, each populated scenario contributes an inverted **log₁₀(WER)** quality score relative to every other model on the leaderboard, then weighted components are summed and scaled to **0–100**. Missing scenarios drop out automatically with weights **renormalised** over what remains.
+
+You can **narrow which scenarios influence Score** by toggling benchmark columns on the Leaderboard tab — only checked scenarios participate in the recomputed headline score.
+
 ## What you see on the leaderboard
 
 | Column | Meaning |
 |---|---|
-| **Average ⬇️** | Mean WER across the visible benchmark columns — the primary ranking (lower is better). |
-| **Anechoic** | WER on close‑mic dry speech. |
-| **Noisy** | WER under additive background noise. |
-| **Treble Eval Dataset** | WER on the simulated‑reverberation eval split. |
-| **Real RIR Dataset** | WER on speech convolved with real‑room impulse responses. |
-| **Difficult Conditions** | WER on adversarial / hard‑condition mixtures. |
+| **Score (out of 100)** | Far‑field weighted composite ranking (**higher is better**). |
+| **Anechoic speech** | WER on dry close‑mic speech. |
+| **Lab measured** | WER on measured lab / controlled noisy conditions. |
+| **Lab simulated** | WER on simulated reverberation / lab simulations. |
+| **Realistic cond.: High SNR** | WER on realistic high‑SNR mixtures. |
+| **Realistic cond.: Low SNR** | WER on realistic low‑SNR / adversarial mixtures. |
+| **Moving sources** | WER when the moving‑source split is available (**NA** otherwise). |
 | **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. |
+| **# PARAMs** | Trainable parameters (millions). |
 
 Timing depends on the hardware this Space runs on, so treat RTF as a **comparison between submissions on this
 leaderboard**, not as an absolute hardware number.
@@ -156,8 +179,7 @@ WER = (S + I + D) / N = (1 + 0 + 1) / 6 ≈ 0.33
 ### Speed & memory
 
 * **RTF** (real‑time factor) is the primary speed metric: higher = faster model for the same audio.
-* **Memory** on the robustness radar reflects total weight‑file size reported by the Hub (safetensors/bin/gguf/…).
-  Smaller models are rewarded on that axis.
+* **Compactness** on the robustness radar prefers recorded parameter counts (millions) and falls back to Hub weight‑file sizes when needed — smaller models extend farther on that spoke.
 
 ## Privacy and integrity
 

evaluation/orchestrator.py

@@ -409,7 +409,7 @@ def run_evaluation(
     ``progress_cb(samples_done_across_all_conditions, samples_total_across_all_conditions, current_condition_key)``
     periodically during the run.
 
-    Returns wer_clean, wer_noisy, wer_reverberant, num_samples, model_id, eval_family, plus timing.
+    Returns wer_clean, wer_noisy, wer_reverberant, wer_real, wer_difficult, num_samples, model_id, eval_family, plus timing.
     """
     apply_cpu_thread_settings_once()
 

init.py

@@ -35,6 +35,7 @@ __all__ = [
     "list_audio_files",
     "load_audio_file",
     "load_transcript_file",
+    "normalize_legacy_csv_row",
 ]
 
 csv_lock = threading.Lock()
@@ -54,6 +55,34 @@ CSV_FIELDS = [
     "submitted_at",
 ]
 
+# Legacy CSV / evaluation wire-format keys -> canonical ``SCENARIO_KEYS`` column names.
+_LEGACY_WER_TO_CANONICAL: tuple[tuple[str, str], ...] = (
+    ("wer_clean", "wer_anechoic_speech"),
+    ("wer_noisy", "wer_lab_measured"),
+    ("wer_reverberant", "wer_lab_simulated"),
+    ("wer_real", "wer_realistic_high_snr"),
+    ("wer_difficult", "wer_realistic_low_snr"),
+)
+
+
+def _cell_empty(v) -> bool:
+    return v is None or (isinstance(v, str) and v.strip() == "")
+
+
+def normalize_legacy_csv_row(row: dict) -> dict:
+    """Fill canonical scenario columns from legacy leaderboard CSV keys when needed."""
+    for old, new in _LEGACY_WER_TO_CANONICAL:
+        ov = row.get(old)
+        nv = row.get(new)
+        if _cell_empty(nv) and not _cell_empty(ov):
+            row[new] = str(ov).strip() if not isinstance(ov, str) else ov.strip()
+    # Older CSVs used ``wer_high_snr`` as a standalone column.
+    hn = row.get("wer_high_snr")
+    rh = row.get("wer_realistic_high_snr")
+    if _cell_empty(rh) and not _cell_empty(hn):
+        row["wer_realistic_high_snr"] = str(hn).strip() if isinstance(hn, str) else str(hn)
+    return row
+
 
 def leaderboard_row_from_eval_result(
     result: dict,
@@ -64,9 +93,19 @@ def leaderboard_row_from_eval_result(
     row = {k: "" for k in CSV_FIELDS}
     row["model_id"] = str(result.get("model_id", ""))
     row["eval_family"] = str(result.get("eval_family", ""))
-    for key in SCENARIO_KEYS:
-        if key in result and result[key] is not None:
-            row[key] = str(result[key])
+    # Evaluation pipeline still emits legacy wer_* keys on the wire.
+    _EVAL_WIRE_TO_CANONICAL = {
+        "wer_anechoic_speech": "wer_clean",
+        "wer_lab_measured": "wer_noisy",
+        "wer_lab_simulated": "wer_reverberant",
+        "wer_realistic_high_snr": "wer_real",
+        "wer_realistic_low_snr": "wer_difficult",
+        "wer_moving_sources": "wer_moving_sources",
+    }
+    for canon_key, wire_key in _EVAL_WIRE_TO_CANONICAL.items():
+        v = result.get(wire_key)
+        if v is not None and v != "":
+            row[canon_key] = str(v)
     row["num_samples"] = str(result.get("num_samples", ""))
     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] != "":
@@ -136,6 +175,7 @@ def load_raw_results() -> list[dict]:
                     if not row.get("eval_family"):
                         row["eval_family"] = "—"
                     row.setdefault("submission_notes", "")
+                    normalize_legacy_csv_row(row)
                 return results
             return []
         except Exception:
@@ -169,6 +209,8 @@ def load_results() -> pd.DataFrame:
     those still live in the CSV (for moderators and analytics) but are hidden from the
     public table.
     """
+    import analytics
+
     raw_rows = load_raw_results()
 
     if not raw_rows:
@@ -176,13 +218,22 @@ def load_results() -> pd.DataFrame:
 
     raw_df = pd.DataFrame(raw_rows)
 
-    # Coerce live-condition columns to numeric so the average / sort behave sensibly.
+    # Coerce live-condition columns to numeric so scoring / sorting behave sensibly.
     live_cols = [c for c in LIVE_SCENARIO_KEYS if c in raw_df.columns]
     for c in live_cols:
         raw_df[c] = pd.to_numeric(raw_df[c], errors="coerce")
 
-    raw_df["avg_wer"] = raw_df[live_cols].mean(axis=1, skipna=True) if live_cols else pd.NA
-    raw_df = raw_df.sort_values("avg_wer", ascending=True).reset_index(drop=True)
+    bounds = analytics.compute_wer_log_bounds(raw_rows, LIVE_SCENARIO_KEYS)
+    raw_df["_ff_score"] = [
+        analytics.far_field_score_for_row(dict(r), bounds) for r in raw_rows
+    ]
+    # Tie-breaker: lower mean WER among populated scenarios is better when scores tie.
+    raw_df["_mean_wer"] = raw_df[live_cols].mean(axis=1, skipna=True) if live_cols else pd.NA
+    raw_df = raw_df.sort_values(
+        by=["_ff_score", "_mean_wer"],
+        ascending=[False, True],
+        na_position="last",
+    ).reset_index(drop=True)
 
     def _num_or_na(series, rnd=4):
         return series.apply(
@@ -191,17 +242,18 @@ def load_results() -> pd.DataFrame:
 
     display_df = pd.DataFrame()
     display_df[AutoEvalColumn.model.name] = raw_df["model_id"].apply(make_clickable_model)
-    display_df[AutoEvalColumn.avg_wer.name] = raw_df["avg_wer"].apply(
-        lambda x: round(float(x), 4) if pd.notna(x) else "NA"
+    display_df[AutoEvalColumn.ff_score.name] = raw_df["_ff_score"].apply(
+        lambda x: round(float(x), 2) if pd.notna(x) else "NA"
     )
 
     # Map: scenario CSV key -> display column name (defined in AutoEvalColumn).
     scenario_col_map = {
-        "wer_clean": AutoEvalColumn.wer_clean.name,
-        "wer_noisy": AutoEvalColumn.wer_noisy.name,
-        "wer_reverberant": AutoEvalColumn.wer_reverb.name,
-        "wer_real": AutoEvalColumn.wer_real.name,
-        "wer_difficult": AutoEvalColumn.wer_difficult.name,
+        "wer_anechoic_speech": AutoEvalColumn.wer_anechoic.name,
+        "wer_lab_measured": AutoEvalColumn.wer_lab_measured.name,
+        "wer_lab_simulated": AutoEvalColumn.wer_lab_simulated.name,
+        "wer_realistic_high_snr": AutoEvalColumn.wer_realistic_high_snr.name,
+        "wer_realistic_low_snr": AutoEvalColumn.wer_realistic_low_snr.name,
+        "wer_moving_sources": AutoEvalColumn.wer_moving_sources.name,
     }
     for csv_key, display_name in scenario_col_map.items():
         if csv_key in raw_df.columns:

job_queue.py

@@ -275,20 +275,12 @@ def _progress_update(job_id: str, done: int, total: int, condition: str) -> None
         j.progress_condition = condition or ""
 
 
-def _leaderboard_sort_key(row: dict) -> float:
-    """Mean WER across live scenario columns (matches init.load_results ordering)."""
-    from metrics_config import LIVE_SCENARIO_KEYS
-
-    vals: list[float] = []
-    for key in LIVE_SCENARIO_KEYS:
-        raw = row.get(key, "")
-        if raw == "" or raw is None:
-            continue
-        try:
-            vals.append(float(raw))
-        except (TypeError, ValueError):
-            continue
-    return sum(vals) / len(vals) if vals else float("inf")
+def _leaderboard_sort_rows_inplace(rows: list[dict]) -> None:
+    """Sort leaderboard CSV rows by far-field score (descending)."""
+    from analytics import compute_far_field_score_map
+
+    scores = compute_far_field_score_map(rows)
+    rows.sort(key=lambda r: (-scores.get(r.get("model_id", ""), 0.0), r.get("model_id") or ""))
 
 
 def _evaluate_single_job(job_id: str, mid: str, fid: str) -> dict:
@@ -436,7 +428,7 @@ def _worker_loop() -> None:
                             submission_notes=notes,
                         )
                     )
-                    rows.sort(key=_leaderboard_sort_key)
+                    _leaderboard_sort_rows_inplace(rows)
                     save_raw_results(rows)
 
                     with _jobs_lock:

metrics_config.py

@@ -1,8 +1,8 @@
 """
 Scenario metrics: CSV column keys, labels, and grouping for leaderboard + analytics.
 
-Core metrics are produced by the current evaluation pipeline. Additional keys are reserved
-for future packed test sets (same WER semantics: lower is better).
+Canonical scenario keys are far-field oriented. Legacy keys (wer_clean, …) are migrated
+on CSV load in ``init.normalize_legacy_csv_row``.
 """
 
 from __future__ import annotations
@@ -28,68 +28,52 @@ class ScenarioMetric:
 # Order defines CSV column order for scenario WER columns.
 SCENARIO_METRICS: tuple[ScenarioMetric, ...] = (
     ScenarioMetric(
-        key="wer_clean",
-        label="Anechoic (close-mic, dry)",
-        short="Anechoic",
-        description="Close-mic / anechoic dry speech — the easy baseline.",
+        key="wer_anechoic_speech",
+        label="Anechoic speech (close-mic, dry)",
+        short="Anechoic speech",
+        description="Close-mic / anechoic dry speech — easy baseline (downweighted for far-field ranking).",
         group="Core benchmarks",
         status="live",
     ),
     ScenarioMetric(
-        key="wer_noisy",
-        label="Noisy",
-        short="Noisy",
-        description="Speech mixed with additive background noise.",
+        key="wer_lab_measured",
+        label="Lab measured",
+        short="Lab measured",
+        description="Controlled lab recordings with measured acoustics / additive noise.",
         group="Core benchmarks",
         status="live",
     ),
     ScenarioMetric(
-        key="wer_reverberant",
-        label="Treble Eval Dataset",
-        short="Treble Eval",
-        description="Reverberant speech from the simulated Treble eval dataset.",
+        key="wer_lab_simulated",
+        label="Lab simulated",
+        short="Lab simulated",
+        description="Simulated acoustics (e.g. simulated room / Treble-style reverb).",
         group="Core benchmarks",
         status="live",
     ),
     ScenarioMetric(
-        key="wer_real",
-        label="Real RIR Dataset",
-        short="Real RIR",
-        description="Speech convolved with real-room impulse responses (non-simulated).",
-        group="Core benchmarks",
+        key="wer_realistic_high_snr",
+        label="Realistic conditions — High SNR",
+        short="Realistic · High SNR",
+        description="Realistic far-field / room conditions at relatively high SNR.",
+        group="Realistic conditions",
         status="live",
     ),
     ScenarioMetric(
-        key="wer_difficult",
-        label="Difficult Conditions",
-        short="Difficult",
-        description="Challenging acoustic mixtures (low SNR, strong reverb, distortion).",
-        group="Core benchmarks",
+        key="wer_realistic_low_snr",
+        label="Realistic conditions — Low SNR",
+        short="Realistic · Low SNR",
+        description="Hard realistic mixtures (low SNR, strong reverb, distortion).",
+        group="Realistic conditions",
         status="live",
     ),
     ScenarioMetric(
-        key="wer_high_snr",
-        label="High SNR scenario",
-        short="High SNR",
-        description="High signal-to-noise conditions (reserved for future packed split).",
-        group="Acoustic conditions",
-        status="planned",
-    ),
-    ScenarioMetric(
-        key="wer_distant",
-        label="Distant talker",
-        short="Distant",
-        description="Far-field / low direct-path energy (reserved).",
-        group="Acoustic conditions",
-        status="planned",
-    ),
-    ScenarioMetric(
-        key="wer_highly_reverberant",
-        label="Highly reverberant",
-        short="High reverb",
-        description="Strong late reflections / long RT60 (reserved).",
-        group="Acoustic conditions",
-        status="planned",
+        key="wer_moving_sources",
+        label="Moving sources",
+        short="Moving sources",
+        description="Moving talker / varying geometry (populated when the eval split is available).",
+        group="Realistic conditions",
+        status="live",
     ),
 )
 

scripts/run_eval.py

@@ -43,6 +43,8 @@ def main() -> None:
         print("wer_clean:", out["wer_clean"])
         print("wer_noisy:", out["wer_noisy"])
         print("wer_reverberant:", out["wer_reverberant"])
+        print("wer_real:", out.get("wer_real"))
+        print("wer_difficult:", out.get("wer_difficult"))
         print("num_samples:", out["num_samples"])
 
 

scripts/run_eval_and_publish.py

@@ -685,33 +685,24 @@ def _write_csv(path: str, fields: list[str], rows: list[dict]) -> None:
 
 
 def _append_leaderboard_local(csv_path: str, result: dict, notes: str) -> dict:
-    from init import CSV_FIELDS, leaderboard_row_from_eval_result
-    from metrics_config import LIVE_SCENARIO_KEYS
+    from analytics import compute_far_field_score_map
+    from init import CSV_FIELDS, leaderboard_row_from_eval_result, normalize_legacy_csv_row
 
     rows = _read_csv(csv_path)
     for row in rows:
         for k in CSV_FIELDS:
             row.setdefault(k, "")
+        normalize_legacy_csv_row(row)
     if any(r.get("model_id") == result["model_id"] for r in rows):
         raise RuntimeError(
             f"Model {result['model_id']!r} already in {csv_path}; refusing to duplicate."
         )
     new_row = leaderboard_row_from_eval_result(result, _now_iso(), submission_notes=notes)
+    normalize_legacy_csv_row(new_row)
     rows.append(new_row)
 
-    def _avg(r: dict) -> float:
-        vals: list[float] = []
-        for k in LIVE_SCENARIO_KEYS:
-            v = r.get(k, "")
-            if v == "" or v is None:
-                continue
-            try:
-                vals.append(float(v))
-            except Exception:
-                continue
-        return sum(vals) / len(vals) if vals else float("inf")
-
-    rows.sort(key=_avg)
+    scores = compute_far_field_score_map(rows)
+    rows.sort(key=lambda r: (-scores.get(r.get("model_id", ""), 0.0), r.get("model_id") or ""))
     _write_csv(csv_path, CSV_FIELDS, rows)
     return new_row
 
@@ -954,9 +945,11 @@ def main() -> int:
         print(f"device:           {device_str}")
         print(f"dtype:            {args.dtype}")
         print(f"batch_size:       {args.batch_size}")
-        print(f"wer_clean:        {result.get('wer_clean')}")
-        print(f"wer_noisy:        {result.get('wer_noisy')}")
-        print(f"wer_reverberant:  {result.get('wer_reverberant')}")
+        print(f"wer_clean (→ anechoic CSV):        {result.get('wer_clean')}")
+        print(f"wer_noisy (→ lab measured CSV):     {result.get('wer_noisy')}")
+        print(f"wer_reverberant (→ lab sim CSV):   {result.get('wer_reverberant')}")
+        print(f"wer_real (→ realistic hi SNR CSV): {result.get('wer_real')}")
+        print(f"wer_difficult (→ realistic lo CSV): {result.get('wer_difficult')}")
         print(f"num_samples:      {result.get('num_samples')}")
         print(f"eval_wall_time_s: {result.get('eval_wall_time_s')}")
         print(f"eval_rtf:         {result.get('eval_rtf')}")

utils_display.py

@@ -16,27 +16,39 @@ def fields(raw_class):
 @dataclass(frozen=True)
 class AutoEvalColumn:
     model = ColumnContent("Model", "markdown")
-    avg_wer = ColumnContent("Average ⬇️", "number")
-    wer_clean = ColumnContent("Anechoic", "number")
-    wer_noisy = ColumnContent("Noisy", "number")
-    wer_reverb = ColumnContent("Treble Eval Dataset", "number")
-    wer_real = ColumnContent("Real RIR Dataset", "number")
-    wer_difficult = ColumnContent("Difficult Conditions", "number")
+    ff_score = ColumnContent("Score (out of 100)", "number")
+    wer_anechoic = ColumnContent("Anechoic speech", "number")
+    wer_lab_measured = ColumnContent("Lab measured", "number")
+    wer_lab_simulated = ColumnContent("Lab simulated", "number")
+    wer_realistic_high_snr = ColumnContent("Realistic cond.: High SNR", "number")
+    wer_realistic_low_snr = ColumnContent("Realistic cond.: Low SNR", "number")
+    wer_moving_sources = ColumnContent("Moving sources", "number")
     eval_rtf = ColumnContent("RTF", "number")
-    params_m = ColumnContent("Params (M)", "number")
+    params_m = ColumnContent("# PARAMs", "number")
 
 
 # Display names of the per-condition WER benchmark columns. Used to:
-#   * compute Average WER across the visible benchmark columns in the leaderboard filter,
+#   * compute far-field Score from the visible benchmark columns in the leaderboard filter,
 #   * sanity-check column visibility logic.
 SCENARIO_DISPLAY_COLS: tuple[str, ...] = (
-    AutoEvalColumn.wer_clean.name,
-    AutoEvalColumn.wer_noisy.name,
-    AutoEvalColumn.wer_reverb.name,
-    AutoEvalColumn.wer_real.name,
-    AutoEvalColumn.wer_difficult.name,
+    AutoEvalColumn.wer_anechoic.name,
+    AutoEvalColumn.wer_lab_measured.name,
+    AutoEvalColumn.wer_lab_simulated.name,
+    AutoEvalColumn.wer_realistic_high_snr.name,
+    AutoEvalColumn.wer_realistic_low_snr.name,
+    AutoEvalColumn.wer_moving_sources.name,
 )
 
+# Leaderboard display header -> canonical CSV / analytics metric key.
+SCENARIO_DISPLAY_TO_KEY: dict[str, str] = {
+    AutoEvalColumn.wer_anechoic.name: "wer_anechoic_speech",
+    AutoEvalColumn.wer_lab_measured.name: "wer_lab_measured",
+    AutoEvalColumn.wer_lab_simulated.name: "wer_lab_simulated",
+    AutoEvalColumn.wer_realistic_high_snr.name: "wer_realistic_high_snr",
+    AutoEvalColumn.wer_realistic_low_snr.name: "wer_realistic_low_snr",
+    AutoEvalColumn.wer_moving_sources.name: "wer_moving_sources",
+}
+
 
 # Custom URL mappings for models not on HuggingFace or with special pages
 _CUSTOM_LINKS = {
@@ -86,3 +98,17 @@ def styled_warning(warn):
 
 def styled_message(message):
     return f"<p style='color: green; font-size: 20px; text-align: center;'>{message}</p>"
+
+
+def model_id_from_leaderboard_cell(cell) -> str:
+    """Recover Hugging Face model id from the markdown Model column."""
+    if not isinstance(cell, str):
+        return ""
+    cell = cell.strip()
+    if "</a>" in cell:
+        import re
+
+        m = re.search(r">([^<]+)</a>\s*$", cell)
+        if m:
+            return m.group(1).strip()
+    return cell