feat: merge real (paper) results with new community results

Previously the board showed HF contents OR the bundled sample_results.json
(fallback) — so the first worker write would have hidden the real paper
results. Now the leaderboard treats the bundled paper results as an immutable
base and OVERLAYS new results from braindecode/contents, deduped by
(model, adapter); a freshly evaluated result wins on a same-key clash, every
other paper result is preserved. Falls back to base-only when contents is
absent. Also alias oeb 'frozen' -> arena 'probe' in results mapping so new
linear-probe results align with the paper rows and the frontend filters.

Tests: leaderboard merge + frozen->probe alias (22 passing).

backend/app/services/leaderboard.py

@@ -25,59 +25,70 @@ def _build_entry_id(data: Dict[str, Any]) -> str:
     )
 
 
+def _merge_results(
+    base: List[Dict[str, Any]], overlay: List[Dict[str, Any]]
+) -> List[Dict[str, Any]]:
+    """Merge curated/base results with new ones, deduped by (model, adapter).
+
+    ``base`` is the bundled real/paper results; ``overlay`` is new community
+    results from the HF contents dataset. Overlay rows override base rows that
+    share the same (fullname, adapter) so a freshly evaluated result supersedes
+    the baseline, while every other base result is preserved.
+    """
+    merged: Dict[tuple, Dict[str, Any]] = {}
+    for row in list(base) + list(overlay):  # overlay last => wins on conflict
+        merged[(row.get("fullname"), row.get("adapter"))] = row
+    return list(merged.values())
+
+
 class LeaderboardService:
     def __init__(self):
         pass
 
     async def fetch_raw_data(self) -> List[Dict[str, Any]]:
-        """Fetch raw leaderboard data from HuggingFace dataset, with local fallback"""
+        """Merge the bundled real/paper results with new community results.
+
+        ``sample_results.json`` (the paper results) is the immutable base. New
+        results from the HF ``contents`` dataset are overlaid on top so the board
+        shows BOTH; on a (model, adapter) clash the new result wins. Falls back
+        to base-only when the contents dataset isn't available yet.
+        """
         try:
             logger.info(LogFormatter.section("FETCHING LEADERBOARD DATA"))
 
-            # Try HuggingFace dataset first
+            # Base: bundled real/paper results (always present).
+            base: List[Dict[str, Any]] = []
+            if SAMPLE_DATA_PATH.exists():
+                with open(SAMPLE_DATA_PATH, "r") as f:
+                    base = json.load(f)
+
+            # Overlay: new community results from the HF contents dataset.
+            overlay: List[Dict[str, Any]] = []
             try:
-                logger.info(LogFormatter.info(f"Loading dataset from {HF_ORGANIZATION}/contents"))
                 dataset = datasets.load_dataset(
                     f"{HF_ORGANIZATION}/contents",
-                    cache_dir=cache_config.get_cache_path("datasets")
+                    cache_dir=cache_config.get_cache_path("datasets"),
+                    download_mode="force_redownload",
                 )["train"]
-
-                df = dataset.to_pandas()
-                data = df.to_dict('records')
-
-                stats = {
-                    "Total_Entries": len(data),
-                    "Dataset_Size": f"{df.memory_usage(deep=True).sum() / 1024 / 1024:.1f}MB",
-                    "Source": "HuggingFace Hub",
-                }
-                for line in LogFormatter.stats(stats, "Dataset Statistics"):
-                    logger.info(line)
-
-                return data
-
+                overlay = dataset.to_pandas().to_dict("records")
             except Exception as hf_error:
                 logger.warning(LogFormatter.warning(
-                    f"Could not load HF dataset: {hf_error}. Using local sample data."
+                    f"No HF contents dataset yet ({hf_error}); showing bundled results only."
                 ))
 
-                # Fallback to local sample data
-                if SAMPLE_DATA_PATH.exists():
-                    with open(SAMPLE_DATA_PATH, "r") as f:
-                        data = json.load(f)
-
-                    stats = {
-                        "Total_Entries": len(data),
-                        "Source": "Local sample data",
-                    }
-                    for line in LogFormatter.stats(stats, "Dataset Statistics"):
-                        logger.info(line)
-
-                    return data
-                else:
-                    raise HTTPException(
-                        status_code=500,
-                        detail="No data source available: HF dataset not found and no local data."
-                    )
+            data = _merge_results(base, overlay)
+            if not data:
+                raise HTTPException(
+                    status_code=500,
+                    detail="No leaderboard data available: no bundled or HF results.",
+                )
+
+            for line in LogFormatter.stats(
+                {"Base": len(base), "New": len(overlay), "Merged": len(data)},
+                "Leaderboard Merge",
+            ):
+                logger.info(line)
+            return data
 
         except HTTPException:
             raise

backend/app/services/results_mapping.py

@@ -8,6 +8,10 @@ from app.config.submission_config import DATASET_ID_TO_ACCURACY_FIELD
 
 AVERAGE_FIELD = "Average ⬆️"  # "Average ⬆️"
 
+# Map oeb finetuning kinds to the arena's adapter vocabulary used by the existing
+# (paper) results and the frontend filters — frozen linear probing == "probe".
+_ADAPTER_ALIAS = {"frozen": "probe"}
+
 
 def _submitted_date(request: Dict[str, Any]) -> str:
     ts = str(request.get("submitted_time", ""))
@@ -56,7 +60,7 @@ def map_oeb_results_to_contents(df, request: Dict[str, Any]) -> List[Dict[str, A
 
         row: Dict[str, Any] = {
             "fullname": request.get("model_name", ""),
-            "adapter": str(strategy),
+            "adapter": _ADAPTER_ALIAS.get(str(strategy), str(strategy)),
             "Precision": "",
             "Model sha": None,
             "Architecture": backbone or arch_fallback,

backend/tests/test_leaderboard_merge.py

@@ -0,0 +1,34 @@
+from app.services.leaderboard import _merge_results
+
+
+def test_merge_overlay_wins_on_conflict():
+    base = [
+        {"fullname": "BIOT", "adapter": "full_finetune", "Average ⬆️": 30.0},
+        {"fullname": "LaBraM", "adapter": "probe", "Average ⬆️": 12.0},
+    ]
+    overlay = [
+        {"fullname": "BIOT", "adapter": "full_finetune", "Average ⬆️": 40.0},  # overrides base
+        {"fullname": "MyModel", "adapter": "lora", "Average ⬆️": 50.0},        # brand new
+    ]
+    out = _merge_results(base, overlay)
+    by = {(r["fullname"], r["adapter"]): r for r in out}
+    assert len(out) == 3
+    assert by[("BIOT", "full_finetune")]["Average ⬆️"] == 40.0   # new result wins
+    assert by[("LaBraM", "probe")]["Average ⬆️"] == 12.0          # paper result preserved
+    assert ("MyModel", "lora") in by                              # new model added
+
+
+def test_merge_empty_overlay_returns_base():
+    base = [{"fullname": "BIOT", "adapter": "probe"}]
+    assert len(_merge_results(base, [])) == 1
+
+
+def test_merge_empty_base_returns_overlay():
+    assert len(_merge_results([], [{"fullname": "X", "adapter": "frozen"}])) == 1
+
+
+def test_merge_distinct_adapters_both_kept():
+    # paper "probe" and a new "frozen" for the same model are different keys -> both shown
+    base = [{"fullname": "BIOT", "adapter": "probe"}]
+    overlay = [{"fullname": "BIOT", "adapter": "frozen"}]
+    assert len(_merge_results(base, overlay)) == 2

backend/tests/test_results_mapping.py

@@ -30,7 +30,7 @@ def test_one_row_per_strategy():
     assert len(rows) == 1
     row = rows[0]
     assert row["fullname"] == "BIOT-frozen"
-    assert row["adapter"] == "frozen"
+    assert row["adapter"] == "probe"  # oeb "frozen" linear probing -> arena "probe"
     assert row["Architecture"] == "BIOT"
     # mean over seeds: bcic2a = (0.40+0.60)/2 = 0.50 (fraction)
     assert abs(row["bcic2a_accuracy"] - 0.50) < 1e-9
@@ -52,7 +52,7 @@ def test_multiple_strategies_multiple_rows():
     df = _df()
     extra = df.copy(); extra["finetuning"] = "lora"
     rows = map_oeb_results_to_contents(pd.concat([df, extra], ignore_index=True), _request())
-    assert {r["adapter"] for r in rows} == {"frozen", "lora"}
+    assert {r["adapter"] for r in rows} == {"probe", "lora"}  # frozen aliased to probe; lora unchanged
 
 def test_all_failed_run_has_no_metric_column():
     # When every experiment fails, oeb's DataFrame has NO test_balanced_accuracy