Add TSDecompose benchmark leaderboard Space

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+.venv/
+.gradio/

README.md

@@ -1,13 +1,23 @@
 ---
 title: TSDecompose Benchmark Leaderboard
-emoji: 🏢
+emoji: 📈
 colorFrom: blue
-colorTo: yellow
+colorTo: green
 sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
+sdk_version: 5.49.1
 app_file: app.py
 pinned: false
+license: mit
+datasets:
+- Zipeng365/TSDecompose-Benchmark
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# TSDecompose Benchmark Leaderboard
+
+Interactive leaderboard for the TSDecompose benchmark release.
+
+The Space reads leaderboard tables from the dataset repository:
+
+`Zipeng365/TSDecompose-Benchmark`
+
+The dataset repository remains the source of record. This Space is only the web presentation layer.

app.py

@@ -0,0 +1,412 @@
+import os
+from functools import lru_cache
+from pathlib import Path
+
+import gradio as gr
+import pandas as pd
+import plotly.express as px
+from huggingface_hub import hf_hub_download
+
+
+DATASET_REPO = os.getenv("TSDECOMPOSE_DATASET_REPO", "Zipeng365/TSDecompose-Benchmark")
+DATA_VERSION = os.getenv("TSDECOMPOSE_DATA_VERSION", "v1.0.0")
+LOCAL_DATA_DIR = os.getenv("TSDECOMPOSE_LOCAL_DATA_DIR")
+
+SITE_FILES = {
+    "synthetic": f"site_data/{DATA_VERSION}/leaderboard_synthetic_full22_overall.csv",
+    "real_proxy": f"site_data/{DATA_VERSION}/leaderboard_real_proxy22_overall.csv",
+    "semisynth": f"site_data/{DATA_VERSION}/leaderboard_semisynth_transfer_by_method.csv",
+    "track_b": f"site_data/{DATA_VERSION}/leaderboard_post_rebuttal_real_physics_track_b.csv",
+    "track_c": f"site_data/{DATA_VERSION}/leaderboard_post_rebuttal_real_proxy_track_c.csv",
+    "methods": f"site_data/{DATA_VERSION}/methods.json",
+    "suites": f"site_data/{DATA_VERSION}/suites.json",
+}
+
+VIEW_LABELS = {
+    "synthetic": "Paper-Aligned Synthetic Full22",
+    "real_proxy": "Paper-Aligned Real Proxy 22",
+    "semisynth": "Semi-Synthetic Transfer",
+    "track_b": "Post-Rebuttal Track B: CO2 / Tides",
+    "track_c": "Post-Rebuttal Track C: Real Proxy Panel",
+}
+
+VIEW_NOTES = {
+    "synthetic": (
+        "Core synthetic benchmark: 6 scenarios x 50 draws = 300 generated "
+        "time-series instances. The expanded roster gives 22 method rows, "
+        "or 6,600 method-instance evaluations. Lower mean metric rank is better."
+    ),
+    "real_proxy": (
+        "Paper-aligned real-data companion track. These are proxy diagnostics, "
+        "not exact component-recovery labels. Lower overall mean rank is better."
+    ),
+    "semisynth": (
+        "Known synthetic mechanisms injected into real monthly backgrounds. "
+        "The displayed rank is recomputed from trend and seasonal recovery metrics."
+    ),
+    "track_b": (
+        "Post-rebuttal mechanism-aware checks on CO2 and tides. These use "
+        "mechanism-informed approximate structure and should be read as companion evidence."
+    ),
+    "track_c": (
+        "Post-rebuttal six-dataset proxy/stability panel. These rows measure "
+        "plausibility and robustness where exact real-world components are unavailable."
+    ),
+}
+
+HIGHER_IS_BETTER = {
+    "metric_T_r2_mean": True,
+    "metric_S_r2_mean": True,
+    "metric_S_spectral_corr_mean": True,
+    "metric_S_maxlag_corr_mean": True,
+    "coverage_success": True,
+    "metric_T_r2": True,
+    "metric_S_r2": True,
+    "metric_S_spectral_corr": True,
+    "metric_S_maxlag_corr": True,
+    "trend_r2": True,
+    "seasonal_r2": True,
+    "quad_fit_r2": True,
+    "seasonal_amplitude_slope_sign_match": True,
+    "target_frequency_coverage": True,
+    "m2_s2_separation_success": True,
+    "band_plausibility": True,
+    "band_power_ratio": True,
+    "band_peak_hit": True,
+    "resampling_trend_corr": True,
+    "resampling_season_corr": True,
+    "resampling_season_spectral_corr": True,
+    "resampling_season_maxlag_corr": True,
+    "resampling_band_overlap": True,
+    "resampling_stability": True,
+    "temporal_spectrum_overlap": True,
+    "overall_mean_rank": False,
+    "metric_T_dtw_mean": False,
+    "metric_T_dtw": False,
+    "c2_relative_error": False,
+    "seasonal_amplitude_slope_error": False,
+    "main_peak_frequency_error": False,
+    "temporal_trend_smoothness_drift": False,
+    "temporal_dominant_frequency_drift": False,
+    "mean_metric_rank": False,
+}
+
+DEFAULT_METRIC = {
+    "synthetic": "mean_metric_rank",
+    "real_proxy": "overall_mean_rank",
+    "semisynth": "mean_metric_rank",
+    "track_b": "seasonal_r2",
+    "track_c": "band_plausibility",
+}
+
+
+def _local_path(filename: str) -> Path:
+    if LOCAL_DATA_DIR:
+        return Path(LOCAL_DATA_DIR) / Path(filename).name
+    return Path(__file__).resolve().parent.parent / "TSDecompose-Benchmark" / filename
+
+
+def _download(filename: str) -> str:
+    local_candidate = _local_path(filename)
+    if local_candidate.exists():
+        return str(local_candidate)
+    token = os.getenv("HF_TOKEN") or None
+    return hf_hub_download(
+        repo_id=DATASET_REPO,
+        repo_type="dataset",
+        filename=filename,
+        token=token,
+    )
+
+
+def _method_table() -> pd.DataFrame:
+    path = _download(SITE_FILES["methods"])
+    methods = pd.read_json(path)
+    return methods[["method", "display_name", "family"]].drop_duplicates("method")
+
+
+def _numeric(df: pd.DataFrame) -> pd.DataFrame:
+    out = df.copy()
+    for col in out.columns:
+        if col not in {"method", "display_name", "family", "dataset", "round_id"}:
+            try:
+                out[col] = pd.to_numeric(out[col])
+            except (TypeError, ValueError):
+                pass
+    return out
+
+
+def _attach_methods(df: pd.DataFrame, methods: pd.DataFrame) -> pd.DataFrame:
+    out = df.merge(methods, on="method", how="left")
+    out["display_name"] = out["display_name"].fillna(out["method"])
+    out["family"] = out["family"].fillna("unclassified")
+    return out
+
+
+def _add_mean_rank(df: pd.DataFrame, metrics: list[str]) -> pd.DataFrame:
+    out = df.copy()
+    rank_cols = []
+    for metric in metrics:
+        if metric not in out.columns:
+            continue
+        values = pd.to_numeric(out[metric], errors="coerce")
+        if values.notna().sum() == 0:
+            continue
+        ascending = not HIGHER_IS_BETTER.get(metric, True)
+        col = f"rank_{metric}"
+        out[col] = values.rank(ascending=ascending, method="min")
+        rank_cols.append(col)
+    if rank_cols:
+        out["mean_metric_rank"] = out[rank_cols].mean(axis=1).round(3)
+        out["rank"] = out["mean_metric_rank"].rank(ascending=True, method="min").astype(int)
+    return out
+
+
+@lru_cache(maxsize=1)
+def load_data() -> dict[str, pd.DataFrame]:
+    methods = _method_table()
+
+    synthetic = pd.read_csv(_download(SITE_FILES["synthetic"]))
+    synthetic = _attach_methods(_numeric(synthetic), methods)
+    synthetic = _add_mean_rank(
+        synthetic,
+        [
+            "metric_T_r2_mean",
+            "metric_T_dtw_mean",
+            "metric_S_r2_mean",
+            "metric_S_spectral_corr_mean",
+            "metric_S_maxlag_corr_mean",
+        ],
+    )
+
+    real_proxy = pd.read_csv(_download(SITE_FILES["real_proxy"]))
+    real_proxy = _attach_methods(_numeric(real_proxy), methods)
+    real_proxy["rank"] = pd.to_numeric(real_proxy["rank_order"], errors="coerce")
+
+    semisynth = pd.read_csv(_download(SITE_FILES["semisynth"]))
+    semisynth = _attach_methods(_numeric(semisynth), methods)
+    semisynth = _add_mean_rank(
+        semisynth,
+        [
+            "metric_T_r2_mean",
+            "metric_T_dtw_mean",
+            "metric_S_r2_mean",
+            "metric_S_spectral_corr_mean",
+            "metric_S_maxlag_corr_mean",
+        ],
+    )
+
+    track_b = pd.read_csv(_download(SITE_FILES["track_b"]))
+    track_b = _attach_methods(_numeric(track_b), methods)
+
+    track_c = pd.read_csv(_download(SITE_FILES["track_c"]))
+    track_c = _attach_methods(_numeric(track_c), methods)
+
+    return {
+        "synthetic": synthetic,
+        "real_proxy": real_proxy,
+        "semisynth": semisynth,
+        "track_b": track_b,
+        "track_c": track_c,
+    }
+
+
+def available_metrics(view: str) -> list[str]:
+    df = load_data()[view]
+    return [
+        col
+        for col in df.columns
+        if col not in {"method", "display_name", "family", "dataset", "round_id"}
+        and pd.api.types.is_numeric_dtype(df[col])
+    ]
+
+
+def filter_table(view: str, metric: str, family: str, query: str, top_n: int):
+    data = load_data()
+    df = data[view].copy()
+    metrics = available_metrics(view)
+    if metric not in metrics:
+        metric = DEFAULT_METRIC[view]
+
+    if family != "All":
+        df = df[df["family"] == family]
+    if query.strip():
+        q = query.strip().lower()
+        text_cols = [col for col in ["method", "display_name", "family", "dataset"] if col in df.columns]
+        mask = pd.Series(False, index=df.index)
+        for col in text_cols:
+            mask = mask | df[col].astype(str).str.lower().str.contains(q, regex=False)
+        df = df[mask]
+
+    ascending = not HIGHER_IS_BETTER.get(metric, True)
+    ranked = df.sort_values(metric, ascending=ascending, na_position="last").head(int(top_n))
+
+    show_cols = [
+        col
+        for col in [
+            "rank",
+            "display_name",
+            "method",
+            "family",
+            "dataset",
+            metric,
+            "mean_metric_rank",
+            "overall_mean_rank",
+            "coverage_success",
+            "row_count",
+            "setting_count",
+        ]
+        if col in ranked.columns
+    ]
+    remaining_metrics = [
+        col
+        for col in ranked.columns
+        if col not in show_cols
+        and col not in {"rank_order"}
+        and pd.api.types.is_numeric_dtype(ranked[col])
+    ]
+    table = ranked[show_cols + remaining_metrics].copy()
+    table = table.round(4)
+
+    plot_df = ranked.copy()
+    if "dataset" in plot_df.columns and plot_df["method"].duplicated().any():
+        plot_df = (
+            plot_df.groupby(["method", "display_name", "family"], as_index=False)[metric]
+            .mean(numeric_only=True)
+            .sort_values(metric, ascending=ascending)
+            .head(int(top_n))
+        )
+
+    title = f"{VIEW_LABELS[view]} - {metric}"
+    fig = px.bar(
+        plot_df,
+        x=metric,
+        y="display_name",
+        color="family",
+        orientation="h",
+        title=title,
+        hover_data=[col for col in ["method", "family"] if col in plot_df.columns],
+    )
+    fig.update_layout(
+        height=max(420, 28 * max(len(plot_df), 8)),
+        margin=dict(l=10, r=20, t=52, b=20),
+        yaxis=dict(autorange="reversed", title=""),
+        xaxis=dict(title=metric),
+        legend_title_text="Family",
+        paper_bgcolor="white",
+        plot_bgcolor="white",
+    )
+
+    summary = (
+        f"**{VIEW_LABELS[view]}**  \n"
+        f"{VIEW_NOTES[view]}  \n\n"
+        f"Rows shown: `{len(table)}` from `{len(data[view])}`. "
+        f"Metric direction: `{'higher is better' if HIGHER_IS_BETTER.get(metric, True) else 'lower is better'}`. "
+        f"Dataset source: [`{DATASET_REPO}`](https://huggingface.co/datasets/{DATASET_REPO})."
+    )
+    return table, fig, summary
+
+
+def refresh_metric_choices(view: str):
+    metrics = available_metrics(view)
+    return gr.update(choices=metrics, value=DEFAULT_METRIC[view])
+
+
+def stats_html() -> str:
+    data = load_data()
+    synthetic_methods = data["synthetic"]["method"].nunique()
+    return f"""
+    <div class="stats-grid">
+      <div class="stat"><span class="stat-value">300</span><span class="stat-label">Core synthetic series</span></div>
+      <div class="stat"><span class="stat-value">{synthetic_methods}</span><span class="stat-label">Expanded roster rows</span></div>
+      <div class="stat"><span class="stat-value">6,600</span><span class="stat-label">Synthetic method-instance rows</span></div>
+      <div class="stat"><span class="stat-value">2</span><span class="stat-label">Evidence versions</span></div>
+    </div>
+    """
+
+
+CSS = """
+.gradio-container { max-width: 1220px !important; }
+.stats-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 10px;
+  margin: 10px 0 16px;
+}
+.stat {
+  border: 1px solid #d8dee9;
+  border-radius: 8px;
+  padding: 12px 14px;
+  background: #ffffff;
+}
+.stat-value {
+  display: block;
+  font-size: 24px;
+  font-weight: 700;
+  color: #0f3b57;
+}
+.stat-label {
+  display: block;
+  font-size: 13px;
+  color: #53606f;
+  margin-top: 2px;
+}
+@media (max-width: 780px) {
+  .stats-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+}
+"""
+
+GRADIO_MAJOR = int(gr.__version__.split(".", 1)[0])
+BLOCKS_KWARGS = {"title": "TSDecompose Benchmark Leaderboard"}
+if GRADIO_MAJOR < 6:
+    BLOCKS_KWARGS["css"] = CSS
+
+with gr.Blocks(**BLOCKS_KWARGS) as demo:
+    gr.Markdown(
+        """
+        # TSDecompose Benchmark Leaderboard
+
+        Interactive leaderboard for **Time-Series Decomposition as a Standalone Task: A Mechanism-Identifiable Benchmark**.  
+        The dataset repository is the source of record; this Space is the web presentation layer.
+        """
+    )
+    gr.HTML(value=stats_html())
+
+    with gr.Row():
+        view = gr.Dropdown(
+            choices=[(label, key) for key, label in VIEW_LABELS.items()],
+            value="synthetic",
+            label="View",
+        )
+        metric = gr.Dropdown(
+            choices=available_metrics("synthetic"),
+            value=DEFAULT_METRIC["synthetic"],
+            label="Metric",
+        )
+    with gr.Row():
+        family = gr.Dropdown(
+            choices=["All", "classical", "extension_proxy", "unclassified"],
+            value="All",
+            label="Family",
+        )
+        query = gr.Textbox(label="Search", placeholder="method, family, or dataset")
+        top_n = gr.Slider(5, 40, value=22, step=1, label="Rows")
+
+    note = gr.Markdown()
+    plot = gr.Plot()
+    table = gr.Dataframe(label="Leaderboard table", wrap=True, interactive=False)
+
+    inputs = [view, metric, family, query, top_n]
+    for control in inputs:
+        control.change(filter_table, inputs=inputs, outputs=[table, plot, note])
+    view.change(refresh_metric_choices, inputs=view, outputs=metric).then(
+        filter_table, inputs=inputs, outputs=[table, plot, note]
+    )
+    demo.load(filter_table, inputs=inputs, outputs=[table, plot, note])
+
+
+if __name__ == "__main__":
+    if GRADIO_MAJOR >= 6:
+        demo.launch(css=CSS)
+    else:
+        demo.launch()

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=5.0,<6.0
+huggingface_hub>=0.25
+pandas>=2.0
+plotly>=5.20