Deploy Space: update src

src/about.py

@@ -39,6 +39,6 @@ CITATION_BUTTON_TEXT = r"""
   title={TSFM Realworld Bench: A Benchmark for Time Series Foundation Models},
   author={TSFM Realworld Bench Team},
   year={2026},
-  howpublished={\url{https://huggingface.co/spaces/ziyuzhou02/TSFM-Realworld-Bench}}
+  howpublished={\url{https://huggingface.co/spaces/CityMindDev/TSFM-Realworld-Bench}}
 }
 """

src/utils.py

@@ -1,3 +1,4 @@
+import json
 import os
 import re
 from pathlib import Path
@@ -290,12 +291,30 @@ def dataset_short_name(dataset: str) -> str:
 
 
 def lookup_dataset_domain(dataset: str, root_dir: str = "results") -> str:
+    # Primary: dataset_properties.csv
     props_path = Path(root_dir) / "dataset_properties.csv"
     if props_path.exists():
         props = pd.read_csv(props_path)
         match = props[props["dataset"].str.lower() == dataset.lower()]
         if not match.empty and "domain" in match.columns:
             return str(match.iloc[0]["domain"])
+
+    # Fallback: read domain column from any all_results.csv
+    for subdir in Path(root_dir).iterdir():
+        csv_path = subdir / "all_results.csv"
+        if not csv_path.exists():
+            continue
+        try:
+            df = pd.read_csv(csv_path)
+            if "domain" not in df.columns or "dataset" not in df.columns:
+                continue
+            # dataset column in all_results is "dataset_id/freq/term", strip suffix
+            df["_ds_key"] = df["dataset"].astype(str).str.split("/").str[0]
+            match = df[df["_ds_key"].str.lower() == dataset.lower()]
+            if not match.empty:
+                return str(match.iloc[0]["domain"])
+        except Exception:
+            continue
     return "Other"
 
 
@@ -341,3 +360,224 @@ def dataset_section_title(dataset: str, root_dir: str, *, ranks: bool = False) -
     if ranks:
         return f"**{label} · ranks (lower is better)**"
     return f"**{label} · metric values (absolute, lower is better)**"
+
+
+BASELINE_RANK_HISTORY_COLUMNS = [
+    "date",
+    "model",
+    "MASE_Rank",
+    "CRPS_Rank",
+    "MAE_Rank",
+    "RMSE_Rank",
+    "sMAPE_Rank",
+    "MSIS_Rank",
+    "ND_Rank",
+    "NRMSE_Rank",
+    "MAPE_Rank",
+]
+
+_RANK_COLS = [c for c in BASELINE_RANK_HISTORY_COLUMNS if c.endswith("_Rank")]
+_DAILY_DISPLAY_COLS = ["date"] + _RANK_COLS
+_WEEKLY_DISPLAY_COLS = ["week"] + _RANK_COLS
+
+
+def _read_rank_history(path: Path, date_col: str) -> pd.DataFrame:
+    """Read a rank history CSV, coerce rank columns to float, sort by date_col."""
+    if not path.exists():
+        return pd.DataFrame(columns=[date_col] + _RANK_COLS)
+    try:
+        df = pd.read_csv(path)
+    except Exception:
+        return pd.DataFrame(columns=[date_col] + _RANK_COLS)
+    for col in _RANK_COLS:
+        if col in df.columns:
+            df[col] = pd.to_numeric(df[col], errors="coerce").round(2)
+    if date_col in df.columns:
+        df = df.sort_values(date_col)
+    present = [c for c in [date_col] + _RANK_COLS if c in df.columns]
+    return df[present].reset_index(drop=True)
+
+
+def load_baseline_rank_history(root_dir: str = "results") -> pd.DataFrame:
+    """Load daily baseline rank history (baseline_rank_history_daily.csv)."""
+    # Also try the legacy single-file name for backward-compat
+    for name in ("baseline_rank_history_daily.csv", "baseline_rank_history.csv"):
+        path = Path(root_dir) / name
+        if path.exists():
+            return _read_rank_history(path, "date")
+    return pd.DataFrame(columns=_DAILY_DISPLAY_COLS)
+
+
+def load_baseline_rank_history_weekly(root_dir: str = "results") -> pd.DataFrame:
+    """Load weekly aggregated baseline rank history (baseline_rank_history_weekly.csv)."""
+    return _read_rank_history(Path(root_dir) / "baseline_rank_history_weekly.csv", "week")
+
+
+# ---------------------------------------------------------------------------
+# Forecast snapshot utilities
+# ---------------------------------------------------------------------------
+
+def load_forecast_snapshots(root_dir: str, model_slug: str) -> dict[str, dict]:
+    """Load all forecast JSON files for a given model slug.
+
+    Returns a dict keyed by the dataset display name (from snapshot["dataset"]).
+    """
+    forecasts_dir = Path(root_dir) / model_slug / "forecasts"
+    snapshots: dict[str, dict] = {}
+    if not forecasts_dir.exists():
+        return snapshots
+    for fp in sorted(forecasts_dir.glob("*.json")):
+        try:
+            snap = json.loads(fp.read_text())
+            snapshots[snap.get("dataset", fp.stem)] = snap
+        except Exception:
+            pass
+    return snapshots
+
+
+def _get_plotly():
+    """Lazy import plotly to avoid import errors in non-chart contexts."""
+    try:
+        import plotly.graph_objects as go
+        return go
+    except ImportError:
+        return None
+
+
+def make_forecast_plot(snapshot: dict | None) -> object | None:
+    """Build a plotly Figure showing context + actuals vs p50 forecast with p10/p90 band.
+
+    Returns None if snapshot is None or plotly is unavailable.
+    """
+    go = _get_plotly()
+    if go is None or snapshot is None:
+        return None
+
+    ctx = snapshot.get("context", [])
+    actuals = snapshot.get("actuals", [])
+    p50 = snapshot.get("p50", [])
+    p10 = snapshot.get("p10", [])
+    p90 = snapshot.get("p90", [])
+    n_ctx = len(ctx)
+    n_fut = len(actuals)
+
+    ctx_x = list(range(n_ctx))
+    fut_x = list(range(n_ctx, n_ctx + n_fut))
+
+    fig = go.Figure()
+
+    # Context (historical)
+    fig.add_trace(go.Scatter(
+        x=ctx_x, y=ctx,
+        mode="lines",
+        name="Context (history)",
+        line=dict(color="#94a3b8", width=1.5),
+    ))
+
+    # Actuals (ground truth for forecast horizon)
+    fig.add_trace(go.Scatter(
+        x=fut_x, y=actuals,
+        mode="lines",
+        name="Actual",
+        line=dict(color="#3b82f6", width=2),
+    ))
+
+    # p10-p90 confidence band
+    if p10 and p90 and len(p10) == n_fut and len(p90) == n_fut:
+        fig.add_trace(go.Scatter(
+            x=fut_x + fut_x[::-1],
+            y=p90 + p10[::-1],
+            fill="toself",
+            fillcolor="rgba(239,68,68,0.15)",
+            line=dict(color="rgba(255,255,255,0)"),
+            name="p10-p90 band",
+            showlegend=True,
+        ))
+
+    # p50 forecast
+    if p50 and len(p50) == n_fut:
+        fig.add_trace(go.Scatter(
+            x=fut_x, y=p50,
+            mode="lines",
+            name="Forecast (p50)",
+            line=dict(color="#ef4444", width=2, dash="dash"),
+        ))
+
+    dataset_label = snapshot.get("dataset", "").split("/")[0]
+    model_label = snapshot.get("model", "")
+    evaluated_at = snapshot.get("evaluated_at", "")[:10]
+    fig.update_layout(
+        title=dict(
+            text=f"{dataset_label} — {model_label} ({evaluated_at})",
+            font=dict(size=14),
+        ),
+        xaxis_title="Time step",
+        yaxis_title="Value",
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        margin=dict(l=40, r=20, t=60, b=40),
+        height=350,
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        font=dict(color="#e2e8f0"),
+        xaxis=dict(gridcolor="rgba(255,255,255,0.08)"),
+        yaxis=dict(gridcolor="rgba(255,255,255,0.08)"),
+    )
+    # Vertical line separating context from forecast
+    fig.add_vline(
+        x=n_ctx - 0.5,
+        line_dash="dot",
+        line_color="rgba(255,255,255,0.3)",
+        annotation_text="forecast start",
+        annotation_font_color="#94a3b8",
+    )
+    return fig
+
+
+def make_rank_trend_plot(history_df: pd.DataFrame, metrics: list[str] | None = None) -> object | None:
+    """Build a plotly Figure showing selected rank metrics over time (date on X axis).
+
+    Args:
+        history_df: DataFrame from load_baseline_rank_history() with a 'date' column.
+        metrics: List of rank column names to plot. Defaults to MASE_Rank and CRPS_Rank.
+
+    Returns None if fewer than 1 data point or plotly unavailable.
+    """
+    go = _get_plotly()
+    if go is None or history_df is None or history_df.empty:
+        return None
+
+    if metrics is None:
+        metrics = ["MASE_Rank", "CRPS_Rank", "MAE_Rank", "RMSE_Rank"]
+
+    date_col = "date" if "date" in history_df.columns else "week"
+    present_metrics = [m for m in metrics if m in history_df.columns]
+    if not present_metrics:
+        return None
+
+    COLORS = ["#f97316", "#a78bfa", "#34d399", "#60a5fa", "#fb7185", "#fbbf24"]
+
+    fig = go.Figure()
+    for i, col in enumerate(present_metrics):
+        fig.add_trace(go.Scatter(
+            x=history_df[date_col],
+            y=history_df[col],
+            mode="lines+markers",
+            name=col.replace("_Rank", ""),
+            line=dict(color=COLORS[i % len(COLORS)], width=2),
+            marker=dict(size=6),
+        ))
+
+    fig.update_layout(
+        title=dict(text="Baseline rank trend over time (lower is better)", font=dict(size=14)),
+        xaxis_title=date_col.capitalize(),
+        yaxis_title="Average rank",
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        margin=dict(l=40, r=20, t=60, b=40),
+        height=320,
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        font=dict(color="#e2e8f0"),
+        xaxis=dict(gridcolor="rgba(255,255,255,0.08)"),
+        yaxis=dict(gridcolor="rgba(255,255,255,0.08)"),
+    )
+    return fig