Table view polish: gold/silver/bronze shimmer + wider sweep + all 8 metrics

- Table view re-rendered as HTML with per-cell rank badges (top-3 per column
get a small gold/silver/bronze 01/02/03 chip in the top-left)
- Top-3 cells get a rich diagonal gradient (gold / silver / bronze) plus a
wide soft animated reflection sweeping across (variant B: 140% width,
multi-stop bright peak, ~5.6s linear loop, staggered per rank)
- Table-layout: fixed with equal-width metric columns; model column 22%
- All 8 metrics in the table (Accuracy, AUC, F1, Precision, Recall,
Cross-entropy, Elo, % over XGBoost). Cache rebuilt to 72 combos.
- Cross-entropy sorts ascending (lower-is-better)
- Drop the "Evaluation / Public datasets" tag chips from the section header
- Intro: add the ~190 OpenML classification datasets framing

app.py

@@ -750,6 +750,137 @@ body, .gradio-container, .prose, button, input, select, textarea {
 .nk-bar-plot .modebar-container,
 .nk-bar-plot .js-plotly-plot .plotly .modebar { display: none !important; }
 
+/* ===== Leaderboard table view (HTML, with per-cell rank badge) ===== */
+.nk-lb-wrap { padding: 0 !important; }
+.nk-empty-table {
+    padding: 32px; text-align: center; color: var(--nk-muted);
+    font-family: 'Geist Mono', monospace; font-size: 12px;
+}
+table.nk-lb {
+    width: 100%;
+    border-collapse: collapse;
+    background: var(--nk-surface);
+    border: 1px solid var(--nk-line);
+    border-radius: 10px;
+    overflow: hidden;
+    font-family: 'Geist Mono', monospace;
+    table-layout: fixed;          /* equal-width metric columns */
+}
+/* Model column gets more room; the rest split the remainder equally. */
+table.nk-lb th.mdl, table.nk-lb td.mdl { width: 22%; }
+table.nk-lb th:not(.mdl), table.nk-lb td:not(.mdl) { width: auto; }
+table.nk-lb th {
+    font-size: 11px; text-transform: uppercase; letter-spacing: 0.04em;
+    padding: 10px 14px; text-align: right; color: var(--nk-muted);
+    border-bottom: 1px solid var(--nk-line);
+    background: var(--nk-surface);
+    font-weight: 500;
+}
+table.nk-lb th.mdl { text-align: left; }
+table.nk-lb td {
+    padding: 14px 18px;
+    font-size: 13px;
+    text-align: right;
+    border-bottom: 1px solid var(--nk-line);
+    position: relative;
+    vertical-align: middle;
+    color: var(--nk-ink);
+    overflow: hidden;             /* clip shimmer overlay */
+}
+table.nk-lb td.mdl {
+    text-align: left;
+    font-family: 'BDO Grotesk', 'Inter', sans-serif;
+    font-weight: 500;
+    overflow: visible;
+}
+table.nk-lb tr:last-child td { border-bottom: none; }
+table.nk-lb tr:hover td:not(.plated) { background: var(--nk-hover); }
+
+/* Top-left rank-badge */
+.nk-rank-badge {
+    position: absolute;
+    top: 4px; left: 4px;
+    display: inline-block;
+    font-family: 'Geist Mono', ui-monospace, SFMono-Regular, monospace;
+    font-size: 9px;
+    font-weight: 500;
+    letter-spacing: 0.04em;
+    color: #ffffff !important;
+    padding: 2px 4px;
+    border-radius: 3px;
+    line-height: 1;
+    z-index: 3;
+    box-shadow: 0 1px 2px rgba(6,5,16,0.25);
+}
+.nk-rb-1 { background: linear-gradient(180deg, #d4a72c, #8a6614); }
+.nk-rb-2 { background: linear-gradient(180deg, #7a818c, #4a525c); }
+.nk-rb-3 { background: linear-gradient(180deg, #a06736, #6a3f1a); }
+
+/* ===== Top-3 "plated" cells: rich diagonal gradient + animated reflection ===== */
+table.nk-lb td.plated > .val {
+    position: relative; z-index: 2;
+    text-shadow: 0 1px 0 rgba(255,255,255,0.5);
+}
+.p-1 {
+    background:
+        radial-gradient(ellipse at 25% 0%, rgba(255,255,255,0.6) 0%, transparent 55%),
+        linear-gradient(135deg,
+            #fff8d3 0%, #ffeea1 12%, #ffd866 28%, #f5c44e 42%,
+            #e0a82b 55%, #f5c44e 68%, #ffd866 82%, #ffeea1 92%, #fff8d3 100%);
+    box-shadow:
+        inset 0 1px 0 rgba(255,255,255,0.7),
+        inset 0 -1px 0 rgba(138,102,20,0.4),
+        inset 0 0 0 1px rgba(212,167,44,0.35);
+}
+.p-2 {
+    background:
+        radial-gradient(ellipse at 25% 0%, rgba(255,255,255,0.6) 0%, transparent 55%),
+        linear-gradient(135deg,
+            #f6f7f9 0%, #e2e5ea 12%, #c4c9d1 28%, #adb3bd 42%,
+            #8a909b 55%, #adb3bd 68%, #c4c9d1 82%, #e2e5ea 92%, #f6f7f9 100%);
+    box-shadow:
+        inset 0 1px 0 rgba(255,255,255,0.7),
+        inset 0 -1px 0 rgba(74,82,92,0.4),
+        inset 0 0 0 1px rgba(154,163,173,0.35);
+}
+.p-3 {
+    background:
+        radial-gradient(ellipse at 25% 0%, rgba(255,255,255,0.55) 0%, transparent 55%),
+        linear-gradient(135deg,
+            #ffe2cd 0%, #f0bc94 12%, #d99767 28%, #c47e4b 42%,
+            #9c5e2c 55%, #c47e4b 68%, #d99767 82%, #f0bc94 92%, #ffe2cd 100%);
+    box-shadow:
+        inset 0 1px 0 rgba(255,255,255,0.6),
+        inset 0 -1px 0 rgba(74,40,15,0.4),
+        inset 0 0 0 1px rgba(184,115,51,0.35);
+}
+/* Animated sweeping reflection — wide soft cinematic sweep (variant B) */
+@keyframes nk-shimmer { 0% { left: -180%; } 100% { left: 180%; } }
+.plated::before {
+    content: '';
+    position: absolute;
+    top: -60%; left: -180%;
+    width: 140%; height: 220%;
+    background: linear-gradient(115deg,
+        transparent 10%,
+        rgba(255,255,255,0.20) 28%,
+        rgba(255,255,255,0.50) 40%,
+        rgba(255,255,255,0.85) 47%,
+        rgba(255,255,255,1.0)  50%,
+        rgba(255,255,255,0.85) 53%,
+        rgba(255,255,255,0.50) 60%,
+        rgba(255,255,255,0.20) 72%,
+        transparent 90%);
+    transform: skewX(-18deg);
+    pointer-events: none;
+    filter: blur(1px);
+    animation: nk-shimmer 5.6s linear infinite;
+    z-index: 1;
+}
+.p-1::before { animation-delay: 0s;   animation-duration: 5s; }
+.p-2::before { animation-delay: 1.6s; animation-duration: 5.8s; }
+.p-3::before { animation-delay: 3.2s; animation-duration: 6.4s; }
+
 /* Filter frame: visually group all filter controls together */
 .nk-filter-frame {
     border: 1px solid var(--nk-line) !important;
@@ -1310,7 +1441,7 @@ with gr.Blocks(css=css, theme=nk_theme, head=NAV_HEAD_JS) as demo:
                 """
                 Tabular foundation models — TabPFN, TabICL, TabDPT, Seldon, Mitra, Limix, and others — are the most active frontier in tabular ML. They promise general-purpose performance without per-task training, but it's hard to tell which ones actually deliver, and where.
 
-                **TabBench is a benchmark dedicated to tracking that frontier.** We evaluate every released tabular foundation model on a broad, IID-filtered dataset universe spanning healthcare, finance, retail, and other verticals, and compare them head-to-head against the strongest classical baselines (XGBoost, CatBoost, LightGBM) and tuned neural networks (RealMLP, TabM, ModernNCA).
+                **TabBench is a benchmark dedicated to tracking that frontier.** We evaluate every released tabular foundation model on **~190 classification datasets curated from OpenML**, spanning healthcare, finance, retail, and other verticals, all filtered to be IID across rows. Foundation models are compared head-to-head against the strongest classical baselines (XGBoost, CatBoost, LightGBM) and tuned neural networks (RealMLP, TabM, ModernNCA).
 
                 Pick a vertical to see which model leads, browse the per-model scores in the table view, or read the methodology below for evaluation details.
                 """
@@ -1347,7 +1478,7 @@ with gr.Blocks(css=css, theme=nk_theme, head=NAV_HEAD_JS) as demo:
                 _rows_min = int(public_per_dataset_with_meta['rows'].min())
                 _rows_max = int(public_per_dataset_with_meta['rows'].max())
 
-                gr.Markdown('## <span class="nk-num">02</span>Leaderboard\n<span class="nk-tag">Evaluation</span> &nbsp;<span class="nk-tag nk-tag--orange">Public datasets</span>')
+                gr.Markdown('## <span class="nk-num">02</span>Leaderboard')
                 gr.Markdown('  ')
 
                 # Filter band: ONE frame, three rows ---------------------
@@ -1419,29 +1550,71 @@ with gr.Blocks(css=css, theme=nk_theme, head=NAV_HEAD_JS) as demo:
                     elem_classes=["nk-bar-plot"],
                     visible=True,
                 )
-                _initial_table = public_enter_model_agg.round(4).rename(columns={
-                    "model": "Model",
-                    "F1_score": "F1",
+                # --- Pretty-display name maps + table HTML builder ---
+                _MODEL_DISPLAY_FULL = {
+                    "xgboost": "XGBoost", "catboost": "CatBoost", "lightgbm": "LightGBM",
+                    "realmlp": "RealMLP", "tabm": "TabM",
+                    "modern_nca": "ModernNCA", "modernnca": "ModernNCA",
+                    "tabpfn": "TabPFN v2.5", "tabpfn_2_5": "TabPFN v2.5", "tabpfn_v3": "TabPFN v3.0",
+                    "tabicl": "TabICL v1.1", "tabicl_v1": "TabICL v1.1", "tabicl_v2": "TabICL v2.0",
+                    "tabdpt": "TabDPT", "limix": "LimiX", "mitra": "Mitra",
+                    "seldon": "Seldon", "nicl": "NICL", "sap": "SAP RPT-1",
+                }
+                _METRIC_DISPLAY_FULL = {
+                    "Accuracy": "Accuracy", "AUC": "AUC", "F1_score": "F1",
+                    "Precision": "Precision", "Recall": "Recall",
                     "Cross_entropy": "Cross-entropy",
-                    "Elo_score": "Elo",
-                    "%↗ over XGBoost": "% over XGBoost",
-                })
-                if "Model" in _initial_table.columns:
-                    _initial_table["Model"] = _initial_table["Model"].map(lambda m: {
-                        "xgboost": "XGBoost", "catboost": "CatBoost", "lightgbm": "LightGBM",
-                        "realmlp": "RealMLP", "tabm": "TabM",
-                        "modern_nca": "ModernNCA", "modernnca": "ModernNCA",
-                        "tabpfn": "TabPFN v2.5", "tabpfn_2_5": "TabPFN v2.5", "tabpfn_v3": "TabPFN v3.0",
-                        "tabicl": "TabICL v1.1", "tabicl_v1": "TabICL v1.1", "tabicl_v2": "TabICL v2.0",
-                        "tabdpt": "TabDPT", "limix": "LimiX", "mitra": "Mitra",
-                        "seldon": "Seldon", "nicl": "NICL", "sap": "SAP RPT-1",
-                    }.get(m, m))
-                ranking_table = gr.DataFrame(
-                    value=_initial_table,
-                    interactive=False,
-                    wrap=True,
-                    type="pandas",
+                    "Elo_score": "Elo", "%↗ over XGBoost": "% over XGBoost",
+                }
+                _LOWER_IS_BETTER = {"Cross_entropy"}
+
+                def _fmt_metric(v, m):
+                    if pd.isna(v): return ""
+                    if m == "Elo_score": return f"{int(round(v))}"
+                    if m == "%↗ over XGBoost": return f"{v:+.2f}"
+                    return f"{v:.3f}"
+
+                def _table_html(df):
+                    """Render the agg dataframe to HTML with top-3 rank badges per column.
+
+                    df is expected to have raw column names (model, Accuracy, AUC, ...).
+                    """
+                    if df is None or df.empty:
+                        return '<div class="nk-empty-table">No data for this filter</div>'
+                    metric_cols = [c for c in df.columns if c != 'model']
+                    # Per-column rank: 1 = best per metric (min for lower-is-better, max otherwise).
+                    rank_per_col = {}
+                    for m in metric_cols:
+                        vals = df[m].tolist()
+                        ascending = m in _LOWER_IS_BETTER
+                        # Get the rank-3 set
+                        idxs = list(range(len(vals)))
+                        idxs.sort(key=lambda i: (vals[i] if vals[i] is not None and not pd.isna(vals[i]) else (float('inf') if ascending else float('-inf'))), reverse=not ascending)
+                        rank_per_col[m] = {i: r+1 for r, i in enumerate(idxs[:3])}
+
+                    h = ['<table class="nk-lb">']
+                    h.append('<thead><tr><th class="mdl">Model</th>')
+                    for m in metric_cols:
+                        h.append(f'<th>{_METRIC_DISPLAY_FULL.get(m, m)}</th>')
+                    h.append('</tr></thead><tbody>')
+                    for i in range(len(df)):
+                        model_raw = df.iloc[i]['model']
+                        model_disp = _MODEL_DISPLAY_FULL.get(model_raw, model_raw)
+                        h.append(f'<tr><td class="mdl">{model_disp}</td>')
+                        for m in metric_cols:
+                            v = df.iloc[i][m]
+                            rank = rank_per_col[m].get(i)
+                            cell_extra = f" plated p-{rank}" if rank else ""
+                            badge = f'<span class="nk-rank-badge nk-rb-{rank}">{rank:02d}</span>' if rank else ''
+                            h.append(f'<td class="num{cell_extra}">{badge}<span class="val">{_fmt_metric(v, m)}</span></td>')
+                        h.append('</tr>')
+                    h.append('</tbody></table>')
+                    return ''.join(h)
+
+                ranking_table = gr.HTML(
+                    value=_table_html(public_enter_model_agg.round(4)),
                     visible=False,
+                    elem_classes=["nk-lb-wrap"],
                 )
 
                 # Load pre-built figures cache built by build_figures_cache.py.
@@ -1462,7 +1635,7 @@ with gr.Blocks(css=css, theme=nk_theme, head=NAV_HEAD_JS) as demo:
                     df = df[(df['features'].fillna(0) >= min_features) &
                             (df['rows'].fillna(0) >= min_samples)]
                     if df.empty:
-                        empty = pd.DataFrame(columns=['model', 'Accuracy', 'AUC', 'Elo_score', '%↗ over XGBoost'])
+                        empty = pd.DataFrame(columns=['model', 'Accuracy', 'AUC', 'F1_score', 'Precision', 'Recall', 'Cross_entropy', 'Elo_score', '%↗ over XGBoost'])
                         return empty, df
                     df = compute_elo_for_subset(df, metric="Accuracy")
                     df = compute_pct_improvement_over_baseline(df, baseline_model="xgboost", metric="Accuracy")
@@ -1518,10 +1691,12 @@ with gr.Blocks(css=css, theme=nk_theme, head=NAV_HEAD_JS) as demo:
 
                     if use_cache and view == "Table":
                         table = pd.DataFrame(_figures_cache[raw]["table"])
-                        sorted_df = table.sort_values(by=metric, ascending=False).round(4).reset_index(drop=True) if not table.empty else table
+                        # Sort by the selected metric (lower is better for Cross_entropy)
+                        ascending = metric in _LOWER_IS_BETTER
+                        sorted_df = table.sort_values(by=metric, ascending=ascending).round(4).reset_index(drop=True) if not table.empty else table
                         return (
                             gr.update(visible=False),
-                            gr.update(visible=True, value=_prettify_table(sorted_df)),
+                            gr.update(visible=True, value=_table_html(sorted_df)),
                         )
 
                     # Slow path: any non-default slider → compute live.
@@ -1536,10 +1711,11 @@ with gr.Blocks(css=css, theme=nk_theme, head=NAV_HEAD_JS) as demo:
                             gr.update(visible=False),
                         )
                     else:
-                        sorted_df = agg.sort_values(by=metric, ascending=False).round(4).reset_index(drop=True) if not agg.empty else agg
+                        ascending = metric in _LOWER_IS_BETTER
+                        sorted_df = agg.sort_values(by=metric, ascending=ascending).round(4).reset_index(drop=True) if not agg.empty else agg
                         return (
                             gr.update(visible=False),
-                            gr.update(visible=True, value=_prettify_table(sorted_df)),
+                            gr.update(visible=True, value=_table_html(sorted_df)),
                         )
 
                 _filter_inputs = [view_selector, metric_selector, industry_selector, features_slider, samples_slider]
@@ -1580,7 +1756,7 @@ with gr.Blocks(css=css, theme=nk_theme, head=NAV_HEAD_JS) as demo:
                 gr.Markdown("""
 - **Neuralk** — [neuralk.ai](https://www.neuralk.ai/)
 - **Package documentation** — [docs.neuralk-ai.com/api](https://docs.neuralk-ai.com/api/)
-- **Previous dashboard** — [tabbench-dashboard.netlify.app](https://tabbench-dashboard.netlify.app/)
+- **Previous version of TabBench** — [https://dashboard.neuralk-ai.com/](https://dashboard.neuralk-ai.com/)
 """)
 
                 # Hidden placeholders so the rest of the navigation wiring
@@ -2105,4 +2281,4 @@ with gr.Blocks(css=css, theme=nk_theme, head=NAV_HEAD_JS) as demo:
     # appropriate nav button when the user hits Back/Forward. Also, if the URL
     # already has a #hash on first load, navigate to that pane.
 
-demo.launch(ssr_mode=False, share=False)
+demo.launch(ssr_mode=False, share=False)

build_figures_cache.py

@@ -43,7 +43,7 @@ INDUSTRY_BUCKETS = [
     "Social/Public",
     "Other",
 ]
-METRICS = ["Accuracy", "AUC", "Elo_score", "%↗ over XGBoost"]
+METRICS = ["Accuracy", "AUC", "F1_score", "Precision", "Recall", "Cross_entropy", "Elo_score", "%↗ over XGBoost"]
 
 # Same metadata merge as the app does at boot.
 meta_df = pd.DataFrame(json.load(open("public_datasets_info.json")))
@@ -63,7 +63,7 @@ def build_one(industry, metric):
         return None, [], 0
     df = compute_elo_for_subset(df, metric="Accuracy")
     df = compute_pct_improvement_over_baseline(df, baseline_model="xgboost", metric="Accuracy")
-    agg = df.groupby('model')[['Accuracy', 'AUC', 'Elo_score', '%↗ over XGBoost']].mean().reset_index()
+    agg = df.groupby('model')[['Accuracy', 'AUC', 'F1_score', 'Precision', 'Recall', 'Cross_entropy', 'Elo_score', '%↗ over XGBoost']].mean().reset_index()
     fig = plot_global_model_ranking_plotly(agg, metric=metric, per_dataset_df=df)
     return fig.to_plotly_json(), agg.round(6).to_dict(orient="records"), int(df['dataset_id'].nunique())