| import json |
| import os |
| from functools import lru_cache |
| from html import escape |
| from pathlib import Path |
|
|
| import gradio as gr |
| import pandas as pd |
| import plotly.graph_objects as go |
| 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 = { |
| "paper_global": "data/paper_tables/global_performance_summary.csv", |
| "paper_radar": "data/paper_figures/selected_radar_charts.png", |
| "synthetic": f"site_data/{DATA_VERSION}/leaderboard_synthetic_full22_overall.csv", |
| "synthetic_rank": "data/synthetic_full22_extension/results/summary/ranking_paper_5metric_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", |
| "semisynth_rank": "data/semisynth_transfer/results/summary/ranking_paper_5metric_overall.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", |
| "metrics": f"site_data/{DATA_VERSION}/evaluation_metrics.json", |
| } |
|
|
| VIEW_LABELS = { |
| "paper_global": "Paper Table 2 / Figure 3 Anchors", |
| "synthetic": "Benchmark 22-Method Synthetic Extension", |
| "real_proxy": "Benchmark 22-Method Real Proxy", |
| "semisynth": "Benchmark 22-Method Semi-Synthetic Transfer", |
| "track_b": "Post-Rebuttal Track B: CO2 / Tides", |
| "track_c": "Post-Rebuttal Track C: Real Proxy Panel", |
| } |
|
|
| VIEW_NOTES = { |
| "paper_global": ( |
| "Camera-ready paper-aligned view. This reproduces Table 2's six-family " |
| "global performance summary from the 6-scenario, 50-draw core protocol. " |
| "Table 2 reports two of the five paper-core component-recovery metrics, " |
| "using tier-balanced stationary aggregation over Tiers 1-2 and Tier 3 for " |
| "the non-stationary columns; Figure 3 shows the " |
| "five-axis capability profile. This is not a single universal ranking." |
| ), |
| "synthetic": ( |
| "Benchmark-only expanded synthetic board: 6 scenarios x 50 draws = 300 generated " |
| "time-series instances. The expanded roster gives 22 method rows, " |
| "or 6,600 method-instance evaluations. This is a living extension view, not the " |
| "paper's primary Table 2/Figure 3 view. It reuses the five component-recovery " |
| "metrics and uses the released five-metric mean within-setting ranking." |
| ), |
| "real_proxy": ( |
| "Benchmark-only real-data companion track. These are proxy diagnostics, " |
| "not exact component-recovery labels and not camera-ready paper rankings. " |
| "Lower overall mean rank is better." |
| ), |
| "semisynth": ( |
| "Benchmark-only 22-method semi-synthetic transfer track: known synthetic " |
| "mechanisms injected into six real monthly backgrounds with three mechanisms, " |
| "two background scales, and eight windows per setting. This is a living " |
| "benchmark extension, not a camera-ready paper table; the displayed rank uses " |
| "the released five-metric mean within-setting ranking." |
| ), |
| "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 = { |
| "stationary_trend_r2": True, |
| "stationary_seasonal_spectral_corr": True, |
| "nonstationary_trend_r2": True, |
| "nonstationary_seasonal_spectral_corr": True, |
| "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 = { |
| "paper_global": "stationary_trend_r2", |
| "synthetic": "overall_mean_rank", |
| "real_proxy": "overall_mean_rank", |
| "semisynth": "overall_mean_rank", |
| "track_b": "seasonal_r2", |
| "track_c": "band_plausibility", |
| } |
|
|
| COLUMN_LABELS = { |
| "stationary_trend_r2": "Stationary Trend R2", |
| "stationary_seasonal_spectral_corr": "Stationary Seasonal Spectral Corr", |
| "nonstationary_trend_r2": "Non-stationary Trend R2", |
| "nonstationary_seasonal_spectral_corr": "Non-stationary Seasonal Spectral Corr", |
| "metric_T_r2": "Trend R2", |
| "metric_T_r2_mean": "Trend R2 mean", |
| "metric_T_dtw": "Trend DTW", |
| "metric_T_dtw_mean": "Trend DTW mean", |
| "metric_S_r2": "Seasonal R2", |
| "metric_S_r2_mean": "Seasonal R2 mean", |
| "metric_S_spectral_corr": "Seasonal spectral corr", |
| "metric_S_spectral_corr_mean": "Seasonal spectral corr mean", |
| "metric_S_maxlag_corr": "Seasonal max-lag corr", |
| "metric_S_maxlag_corr_mean": "Seasonal max-lag corr mean", |
| "mean_metric_rank": "Mean metric rank", |
| "overall_mean_rank": "Overall mean rank", |
| "overall_std_rank": "Overall rank SD", |
| "coverage_success": "Coverage", |
| "row_count": "Rows", |
| "setting_count": "Settings", |
| } |
|
|
| TABLE_LABELS = { |
| "display_name": "Method", |
| "family": "Family", |
| "method": "Method ID", |
| "stationary_trend_r2": "Stat. T R2", |
| "stationary_seasonal_spectral_corr": "Stat. S spec.", |
| "nonstationary_trend_r2": "Nonstat. T R2", |
| "nonstationary_seasonal_spectral_corr": "Nonstat. S spec.", |
| "metric_T_r2_mean": "T R2", |
| "metric_T_dtw_mean": "T DTW", |
| "metric_S_r2_mean": "S R2", |
| "metric_S_spectral_corr_mean": "S spec.", |
| "metric_S_maxlag_corr_mean": "S max-lag", |
| "overall_mean_rank": "Mean rank", |
| "overall_std_rank": "Rank SD", |
| } |
|
|
| PAPER_GLOBAL_METRICS = [ |
| "stationary_trend_r2", |
| "stationary_seasonal_spectral_corr", |
| "nonstationary_trend_r2", |
| "nonstationary_seasonal_spectral_corr", |
| ] |
|
|
| FAMILY_COLORS = { |
| "paper family": "#2563eb", |
| "classical": "#2563eb", |
| "extension_proxy": "#d97706", |
| "neural_block": "#7c3aed", |
| "unclassified": "#64748b", |
| } |
|
|
|
|
| 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, |
| ) |
|
|
|
|
| @lru_cache(maxsize=1) |
| def metric_metadata() -> dict: |
| with open(_download(SITE_FILES["metrics"]), encoding="utf-8") as handle: |
| return json.load(handle) |
|
|
|
|
| def _metric_label(metric: str) -> str: |
| return COLUMN_LABELS.get(metric, metric) |
|
|
|
|
| def _table_label(column: str) -> str: |
| return TABLE_LABELS.get(column, COLUMN_LABELS.get(column, column)) |
|
|
|
|
| def metrics_html() -> str: |
| meta = metric_metadata() |
| metrics = meta.get("metrics", []) |
| cards = [] |
| for item in metrics: |
| direction = "higher is better" if item.get("direction") == "higher" else "lower is better" |
| cards.append( |
| f""" |
| <div class="metric-card"> |
| <div class="metric-name">{escape(item.get("display_name", ""))}</div> |
| <div class="metric-direction">{escape(direction)}</div> |
| <code>{escape(item.get("formula", ""))}</code> |
| <p>{escape(item.get("description", ""))}</p> |
| </div> |
| """ |
| ) |
| return f""" |
| <section class="metric-panel"> |
| <div class="metric-title">Paper Evaluation Protocol</div> |
| <p> |
| The classic paper benchmark uses <strong>{int(meta.get("paper_core_metric_count", 5))} core component-recovery metrics</strong>. |
| Each metric is computed per generated draw after output alignment, then averaged by scenario, tier, or regime. |
| </p> |
| <p> |
| <strong>Table 2</strong> displays only <strong>{int(meta.get("paper_table2_display_metric_count", 2))}</strong> |
| of those metrics: Trend R2 and Seasonal spectral correlation, split over stationary regimes (Tiers 1-2) |
| and the non-stationary regime (Tier 3). Its stationary columns use a tier-balanced average of Tier 1 |
| and Tier 2 means over valid metric values; non-stationary columns use Tier 3 means. <strong>Figure 3</strong> is the five-metric profile view. |
| </p> |
| <div class="metric-grid">{''.join(cards)}</div> |
| </section> |
| """ |
|
|
|
|
| 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 _paper_family_table() -> pd.DataFrame: |
| df = pd.read_csv(_download(SITE_FILES["paper_global"])) |
| df = _numeric(df) |
| df["display_name"] = df["method_family"] |
| df["method"] = df["method_family"] |
| df["family"] = "paper family" |
| return df |
|
|
|
|
| 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 |
|
|
|
|
| def _attach_released_rank(df: pd.DataFrame, rank_file: str) -> pd.DataFrame: |
| rank = pd.read_csv(_download(rank_file)) |
| rank = _numeric(rank) |
| keep = [ |
| col |
| for col in ["method", "overall_mean_rank", "overall_std_rank", "setting_count", "rank_order"] |
| if col in rank.columns |
| ] |
| out = df.drop(columns=[col for col in keep if col != "method" and col in df.columns]) |
| out = out.merge(rank[keep], on="method", how="left") |
| if "rank_order" in out.columns: |
| out["rank"] = pd.to_numeric(out["rank_order"], errors="coerce") |
| elif "overall_mean_rank" in out.columns: |
| values = pd.to_numeric(out["overall_mean_rank"], errors="coerce") |
| out["rank"] = values.rank(ascending=True, method="min") |
| return out |
|
|
|
|
| @lru_cache(maxsize=1) |
| def load_data() -> dict[str, pd.DataFrame]: |
| methods = _method_table() |
| paper_global = _paper_family_table() |
|
|
| synthetic = pd.read_csv(_download(SITE_FILES["synthetic"])) |
| synthetic = _attach_methods(_numeric(synthetic), methods) |
| synthetic = _attach_released_rank(synthetic, SITE_FILES["synthetic_rank"]) |
|
|
| 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 = _attach_released_rank(semisynth, SITE_FILES["semisynth_rank"]) |
|
|
| 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 { |
| "paper_global": paper_global, |
| "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 metric_choices(view: str) -> list[tuple[str, str]]: |
| return [(_metric_label(metric), metric) for metric in available_metrics(view)] |
|
|
|
|
| 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) |
| if view == "paper_global": |
| ranked = df.head(int(top_n)) |
| else: |
| ranked = df.sort_values(metric, ascending=ascending, na_position="last").head(int(top_n)) |
|
|
| if view == "paper_global": |
| show_cols = ["display_name", metric] |
| show_cols += [col for col in PAPER_GLOBAL_METRICS if col != metric] |
| remaining_metrics = [] |
| else: |
| show_cols = [] |
| for col in [ |
| "rank", |
| "display_name", |
| "family", |
| "dataset", |
| metric, |
| "method", |
| "mean_metric_rank", |
| "overall_mean_rank", |
| "coverage_success", |
| "row_count", |
| "setting_count", |
| ]: |
| if col in ranked.columns and col not in show_cols: |
| show_cols.append(col) |
| 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) |
| table_html = _table_html(table) |
|
|
| 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)) |
| ) |
|
|
| metric_name = _metric_label(metric) |
| fig = _bar_figure(plot_df, metric, metric_name, view) |
|
|
| summary = ( |
| f"**{VIEW_LABELS[view]}** \n" |
| f"{VIEW_NOTES[view]} \n\n" |
| f"Rows shown: `{len(table)}` from `{len(data[view])}`. " |
| f"Metric: `{metric_name}`. " |
| 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})." |
| ) |
| figure = _figure_update(view) |
| return table_html, fig, summary, figure |
|
|
|
|
| def _table_html(table: pd.DataFrame) -> str: |
| display = table.copy() |
| if "family" in display.columns: |
| display["family"] = display["family"].replace( |
| {"extension_proxy": "extension proxy"} |
| ) |
| display = display.rename(columns={col: _table_label(col) for col in display.columns}) |
| html = display.to_html(index=False, escape=False, classes="leaderboard-table") |
| return f""" |
| <div class="table-title">Leaderboard table</div> |
| <div class="table-wrap">{html}</div> |
| """ |
|
|
|
|
| def _bar_figure(plot_df: pd.DataFrame, metric: str, metric_name: str, view: str) -> go.Figure: |
| data = plot_df.copy() |
| data[metric] = pd.to_numeric(data[metric], errors="coerce") |
| data = data[data[metric].notna()] |
| labels = data["display_name"].astype(str).tolist() |
| values = [float(value) for value in data[metric].tolist()] |
| families = data.get("family", pd.Series(["unclassified"] * len(data))).astype(str).tolist() |
| colors = [FAMILY_COLORS.get(family, "#0f766e") for family in families] |
| hover = [ |
| f"Family: {family}<br>Method: {method}" |
| for family, method in zip(families, data.get("method", data["display_name"]).astype(str)) |
| ] |
|
|
| fig = go.Figure() |
| fig.add_bar( |
| x=values, |
| y=labels, |
| orientation="h", |
| marker=dict(color=colors, line=dict(color="#1f2937", width=0.5)), |
| customdata=hover, |
| hovertemplate="%{y}<br>" + escape(metric_name) + ": %{x:.4f}<br>%{customdata}<extra></extra>", |
| ) |
| title = f"{VIEW_LABELS[view]} - {metric_name}" |
| fig.update_layout( |
| title=dict(text=title, x=0.01, xanchor="left"), |
| height=max(360, 34 * max(len(labels), 6)), |
| margin=dict(l=150, r=24, t=56, b=48), |
| yaxis=dict( |
| autorange="reversed", |
| title="", |
| type="category", |
| categoryorder="array", |
| categoryarray=labels, |
| tickfont=dict(size=13), |
| ), |
| xaxis=dict(title=metric_name, zeroline=True, rangemode="tozero"), |
| showlegend=False, |
| paper_bgcolor="white", |
| plot_bgcolor="white", |
| bargap=0.28, |
| ) |
| return fig |
|
|
|
|
| def _figure_update(view: str): |
| if view != "paper_global": |
| return gr.update(value=None, visible=False) |
| bundled = Path(__file__).resolve().parent / "assets" / "selected_radar_charts.png" |
| if bundled.exists(): |
| return gr.update(value=str(bundled), visible=True) |
| return gr.update(value=_download(SITE_FILES["paper_radar"]), visible=True) |
|
|
|
|
| def refresh_controls(view: str): |
| metrics = available_metrics(view) |
| return gr.update(choices=metric_choices(view), value=DEFAULT_METRIC[view]), gr.update(value="All") |
|
|
|
|
| def stats_html() -> str: |
| data = load_data() |
| paper_families = data["paper_global"]["method"].nunique() |
| synthetic_methods = data["synthetic"]["method"].nunique() |
| return f""" |
| <div class="stats-grid"> |
| <div class="stat"><span class="stat-value">{paper_families}</span><span class="stat-label">Paper method families</span></div> |
| <div class="stat"><span class="stat-value">5</span><span class="stat-label">Paper core metrics</span></div> |
| <div class="stat"><span class="stat-value">6 x 50</span><span class="stat-label">Classic synthetic instances</span></div> |
| <div class="stat"><span class="stat-value">{synthetic_methods}</span><span class="stat-label">Expansion method 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(5, 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; |
| } |
| .metric-panel { |
| border: 1px solid #d8dee9; |
| border-radius: 8px; |
| padding: 14px; |
| background: #ffffff; |
| margin: 0 0 16px; |
| } |
| .metric-title { |
| font-size: 16px; |
| font-weight: 700; |
| color: #1f2937; |
| margin-bottom: 6px; |
| } |
| .metric-panel p { |
| color: #374151; |
| font-size: 14px; |
| margin: 6px 0; |
| } |
| .metric-grid { |
| display: grid; |
| grid-template-columns: repeat(5, minmax(0, 1fr)); |
| gap: 8px; |
| margin-top: 12px; |
| } |
| .metric-card { |
| border: 1px solid #e5e9f0; |
| border-radius: 8px; |
| padding: 10px; |
| background: #fbfcfd; |
| min-width: 0; |
| } |
| .metric-name { |
| font-size: 13px; |
| font-weight: 700; |
| color: #1f2937; |
| } |
| .metric-direction { |
| font-size: 12px; |
| color: #53606f; |
| margin: 3px 0 6px; |
| } |
| .metric-card code { |
| display: block; |
| white-space: normal; |
| overflow-wrap: anywhere; |
| background: #f3f5f8; |
| border-radius: 6px; |
| padding: 6px; |
| font-size: 11px; |
| color: #273142; |
| } |
| .metric-card p { |
| font-size: 12px; |
| margin: 7px 0 0; |
| } |
| .table-title { |
| font-size: 14px; |
| color: #303946; |
| margin: 12px 0 8px; |
| } |
| .table-wrap { |
| overflow-x: auto; |
| border: 1px solid #d8dee9; |
| border-radius: 8px; |
| background: #ffffff; |
| max-height: 520px; |
| } |
| .leaderboard-table { |
| border-collapse: collapse; |
| width: max-content; |
| min-width: 100%; |
| font-size: 13px; |
| } |
| .leaderboard-table th, |
| .leaderboard-table td { |
| border-bottom: 1px solid #edf0f4; |
| padding: 8px 10px; |
| text-align: left; |
| white-space: nowrap; |
| } |
| .leaderboard-table th { |
| position: sticky; |
| top: 0; |
| background: #f7f9fb; |
| color: #1f2937; |
| z-index: 1; |
| } |
| .leaderboard-table th:nth-child(1), |
| .leaderboard-table td:nth-child(1) { |
| min-width: 48px; |
| } |
| .leaderboard-table th:nth-child(2), |
| .leaderboard-table td:nth-child(2) { |
| min-width: 210px; |
| } |
| .leaderboard-table th:nth-child(3), |
| .leaderboard-table td:nth-child(3) { |
| min-width: 130px; |
| } |
| .leaderboard-table tr:nth-child(even) td { |
| background: #fbfcfd; |
| } |
| @media (max-width: 780px) { |
| .stats-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); } |
| .metric-grid { grid-template-columns: repeat(1, 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()) |
| gr.HTML(value=metrics_html()) |
|
|
| with gr.Row(): |
| view = gr.Dropdown( |
| choices=[(label, key) for key, label in VIEW_LABELS.items()], |
| value="paper_global", |
| label="View", |
| ) |
| metric = gr.Dropdown( |
| choices=metric_choices("paper_global"), |
| value=DEFAULT_METRIC["paper_global"], |
| label="Metric", |
| ) |
| with gr.Row(): |
| family = gr.Dropdown( |
| choices=["All", "paper family", "classical", "extension_proxy"], |
| 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() |
| figure_ref = gr.Image( |
| label="Paper Figure 3 reference", |
| type="filepath", |
| interactive=False, |
| visible=True, |
| ) |
| plot = gr.Plot() |
| table = gr.HTML() |
|
|
| inputs = [view, metric, family, query, top_n] |
| for control in inputs: |
| control.change(filter_table, inputs=inputs, outputs=[table, plot, note, figure_ref]) |
| view.change(refresh_controls, inputs=view, outputs=[metric, family]).then( |
| filter_table, inputs=inputs, outputs=[table, plot, note, figure_ref] |
| ) |
| demo.load(filter_table, inputs=inputs, outputs=[table, plot, note, figure_ref]) |
|
|
|
|
| if __name__ == "__main__": |
| if GRADIO_MAJOR >= 6: |
| demo.launch(css=CSS) |
| else: |
| demo.launch() |
|
|
