Update app.py

app.py

@@ -1,9 +1,14 @@
 import os
+import math
+import time
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
 import numpy as np
 import pandas as pd
 import gradio as gr
-import matplotlib.pyplot as plt
 import torch
+import plotly.graph_objects as go
 
 from chronos import Chronos2Pipeline
 
@@ -13,322 +18,604 @@ from chronos import Chronos2Pipeline
 # =========================
 MODEL_ID_DEFAULT = os.getenv("CHRONOS_MODEL_ID", "amazon/chronos-2")
 DATA_DIR = "data"
+OUT_DIR = "/tmp"
 
 
 # =========================
-# Utils
+# Utilities
 # =========================
-def available_test_csv():
+def available_test_csv() -> list[str]:
     if not os.path.isdir(DATA_DIR):
         return []
-    return sorted(f for f in os.listdir(DATA_DIR) if f.lower().endswith(".csv"))
+    return sorted([f for f in os.listdir(DATA_DIR) if f.lower().endswith(".csv")])
 
 
 def pick_device(ui_choice: str) -> str:
-    if (ui_choice or "").startswith("cuda") and torch.cuda.is_available():
+    if ui_choice and ui_choice.startswith("cuda") and torch.cuda.is_available():
         return "cuda"
     return "cpu"
 
 
-def make_sample_series(n, seed, trend, season_period, season_amp, noise):
+def safe_mape(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    denom = np.maximum(1e-8, np.abs(y_true))
+    return float(np.mean(np.abs((y_true - y_pred) / denom)) * 100.0)
+
+
+def rmse(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    return float(np.sqrt(np.mean((y_true - y_pred) ** 2)))
+
+
+def mae(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    return float(np.mean(np.abs(y_true - y_pred)))
+
+
+def coverage(y_true: np.ndarray, low: np.ndarray, high: np.ndarray) -> float:
+    inside = (y_true >= low) & (y_true <= high)
+    return float(np.mean(inside) * 100.0)
+
+
+def interval_width(low: np.ndarray, high: np.ndarray) -> float:
+    return float(np.mean(high - low))
+
+
+def format_kpi(label: str, value: str, hint: str = "") -> str:
+    # Simple “card” layout via HTML
+    hint_html = f"<div style='opacity:.75;font-size:12px;margin-top:6px;'>{hint}</div>" if hint else ""
+    return f"""
+    <div style="
+        border:1px solid rgba(255,255,255,.12);
+        border-radius:16px;
+        padding:14px 16px;
+        background: rgba(255,255,255,.04);
+        backdrop-filter: blur(6px);
+        ">
+        <div style="font-size:12px;opacity:.8;">{label}</div>
+        <div style="font-size:22px;font-weight:700;margin-top:4px;">{value}</div>
+        {hint_html}
+    </div>
+    """
+
+
+def make_sample_series(
+    n: int,
+    seed: int,
+    trend: float,
+    season_period: int,
+    season_amp: float,
+    noise: float,
+    positive_shift: bool = True,
+) -> np.ndarray:
     rng = np.random.default_rng(int(seed))
-    t = np.arange(int(n))
+    t = np.arange(int(n), dtype=np.float32)
     y = (
         float(trend) * t
         + float(season_amp) * np.sin(2 * np.pi * t / max(1, int(season_period)))
-        + rng.normal(0.0, float(noise), size=len(t))
-    )
-    # shift up if negative to keep plots nice
-    mn = float(np.min(y))
-    if mn < 0:
-        y = y - mn
-    return y.astype(np.float32)
+        + rng.normal(0.0, float(noise), size=int(n))
+    ).astype(np.float32)
+
+    if positive_shift and float(np.min(y)) < 0:
+        y = y - float(np.min(y))
+    return y
 
 
-def load_series_from_csv(path_or_file, column=None):
-    df = pd.read_csv(path_or_file)
+def load_series_from_csv(csv_path: str, column: Optional[str]) -> Tuple[np.ndarray, str, pd.DataFrame]:
+    df = pd.read_csv(csv_path)
     if df.shape[1] == 0:
         raise ValueError("CSV vuoto o non leggibile.")
 
     col = (column or "").strip()
-    if col == "":
-        # try native numeric dtypes first
+    if not col:
         numeric_cols = [c for c in df.columns if pd.api.types.is_numeric_dtype(df[c])]
-        # fallback: try coercion
         if not numeric_cols:
+            # Try coercion: maybe numeric stored as strings
             for c in df.columns:
                 coerced = pd.to_numeric(df[c], errors="coerce")
-                if coerced.notna().sum() >= 10:
+                if coerced.notna().sum() > 0:
                     numeric_cols.append(c)
-        if not numeric_cols:
-            raise ValueError("Nessuna colonna numerica nel CSV. Specifica la colonna corretta.")
+            if not numeric_cols:
+                raise ValueError("Non trovo colonne numeriche nel CSV.")
         col = numeric_cols[0]
 
     if col not in df.columns:
-        raise ValueError(f"Colonna '{col}' non trovata. Colonne: {list(df.columns)}")
+        raise ValueError(f"Colonna '{col}' non trovata. Disponibili: {list(df.columns)}")
 
-    y = pd.to_numeric(df[col], errors="coerce").dropna().to_numpy()
+    y = pd.to_numeric(df[col], errors="coerce").dropna().astype(np.float32).to_numpy()
     if len(y) < 10:
-        raise ValueError("Serie troppo corta (minimo ~10 punti dopo dropna).")
+        raise ValueError("Serie troppo corta (minimo consigliato: 10 punti).")
 
-    return y.astype(np.float32), col
+    return y, col, df
 
 
 # =========================
-# Pipeline cache
+# Model cache
 # =========================
 _PIPELINE = None
-_PIPELINE_META = {}
+_PIPELINE_META = {"model_id": None, "device": None}
 
 
-def get_pipeline(model_id: str, device: str):
+def get_pipeline(model_id: str, device: str) -> Chronos2Pipeline:
     global _PIPELINE, _PIPELINE_META
 
     model_id = (model_id or MODEL_ID_DEFAULT).strip()
-    device = "cuda" if device == "cuda" and torch.cuda.is_available() else "cpu"
-
-    if (
-        _PIPELINE is None
-        or _PIPELINE_META.get("model_id") != model_id
-        or _PIPELINE_META.get("device") != device
-    ):
-        _PIPELINE = Chronos2Pipeline.from_pretrained(model_id, device_map=device)
+    device = "cuda" if (device == "cuda" and torch.cuda.is_available()) else "cpu"
+
+    if _PIPELINE is None or _PIPELINE_META["model_id"] != model_id or _PIPELINE_META["device"] != device:
+        pipe = Chronos2Pipeline.from_pretrained(model_id, device_map=device)
+        _PIPELINE = pipe
         _PIPELINE_META = {"model_id": model_id, "device": device}
 
     return _PIPELINE
 
 
 # =========================
-# Chronos-2 predict_df helpers
+# Plotly helpers
 # =========================
-def build_context_df(y: np.ndarray, freq: str = "D"):
-    """
-    Build a minimal context DataFrame compatible with Chronos2Pipeline.predict_df().
-    We generate a synthetic timestamp index so it works for Sample and numeric-only CSV.
-    """
-    ts = pd.date_range("2000-01-01", periods=len(y), freq=freq)
-    return pd.DataFrame({"id": "series_0", "timestamp": ts, "target": y})
-
-
-def pick_quantile_column(pred_df: pd.DataFrame, q: float) -> str:
-    """
-    Column naming can vary. We robustly find a column representing quantile q.
-    Common patterns: "0.1", "0.5", "0.9" OR "q0.1" OR "quantile_0.1" etc.
-    """
-    q = float(q)
-    # direct numeric-string match
-    for c in pred_df.columns:
-        try:
-            if abs(float(c) - q) < 1e-9:
-                return c
-        except Exception:
-            pass
-
-    # prefixed patterns
-    candidates = []
-    for c in pred_df.columns:
-        lc = str(c).lower()
-        if "quant" in lc or lc.startswith("q"):
-            # try to extract float from tail
-            for token in [lc.replace("quantile", "").replace("_", ""), lc.replace("q", "")]:
-                try:
-                    if abs(float(token) - q) < 1e-9:
-                        candidates.append(c)
-                except Exception:
-                    pass
-
-    if candidates:
-        return candidates[0]
-
-    raise ValueError(
-        f"Non riesco a trovare la colonna del quantile {q}. "
-        f"Colonne disponibili: {list(pred_df.columns)}"
+def plot_forecast_interactive(
+    y: np.ndarray,
+    median: np.ndarray,
+    low: np.ndarray,
+    high: np.ndarray,
+    title: str,
+    q_low: float,
+    q_high: float,
+) -> go.Figure:
+    t_hist = np.arange(len(y))
+    t_fcst = np.arange(len(y), len(y) + len(median))
+
+    fig = go.Figure()
+
+    fig.add_trace(go.Scatter(
+        x=t_hist, y=y, mode="lines",
+        name="History",
+        hovertemplate="t=%{x}<br>y=%{y:.4f}<extra></extra>"
+    ))
+
+    # Upper bound (invisible line), then lower bound with fill to create band
+    fig.add_trace(go.Scatter(
+        x=t_fcst, y=high, mode="lines",
+        name="Upper",
+        line=dict(width=0),
+        showlegend=False,
+        hoverinfo="skip"
+    ))
+    fig.add_trace(go.Scatter(
+        x=t_fcst, y=low, mode="lines",
+        name=f"Band [{q_low:.2f}, {q_high:.2f}]",
+        fill="tonexty",
+        line=dict(width=0),
+        hovertemplate="t=%{x}<br>low=%{y:.4f}<extra></extra>"
+    ))
+
+    fig.add_trace(go.Scatter(
+        x=t_fcst, y=median, mode="lines",
+        name="Forecast (median)",
+        hovertemplate="t=%{x}<br>median=%{y:.4f}<extra></extra>"
+    ))
+
+    fig.add_vline(x=len(y) - 1, line_width=1, line_dash="dash", opacity=0.6)
+
+    fig.update_layout(
+        title=title,
+        hovermode="x unified",
+        margin=dict(l=10, r=10, t=55, b=10),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="left", x=0),
+        xaxis_title="t",
+        yaxis_title="value",
     )
+    return fig
+
+
+def plot_backtest_interactive(
+    y_train: np.ndarray,
+    y_true: np.ndarray,
+    pred_median: np.ndarray,
+    low: np.ndarray,
+    high: np.ndarray,
+    q_low: float,
+    q_high: float,
+) -> go.Figure:
+    t_train = np.arange(len(y_train))
+    t_test = np.arange(len(y_train), len(y_train) + len(y_true))
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=t_train, y=y_train, mode="lines", name="Train"))
+    fig.add_trace(go.Scatter(x=t_test, y=y_true, mode="lines", name="True (holdout)"))
+
+    fig.add_trace(go.Scatter(x=t_test, y=high, mode="lines", line=dict(width=0), showlegend=False, hoverinfo="skip"))
+    fig.add_trace(go.Scatter(
+        x=t_test, y=low, mode="lines",
+        fill="tonexty", line=dict(width=0),
+        name=f"Band [{q_low:.2f}, {q_high:.2f}]"
+    ))
+    fig.add_trace(go.Scatter(x=t_test, y=pred_median, mode="lines", name="Pred (median)"))
+
+    fig.add_vline(x=len(y_train) - 1, line_width=1, line_dash="dash", opacity=0.6)
+
+    fig.update_layout(
+        title="Backtest (holdout) — interactive",
+        hovermode="x unified",
+        margin=dict(l=10, r=10, t=55, b=10),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="left", x=0),
+        xaxis_title="t",
+        yaxis_title="value",
+    )
+    return fig
+
+
+def plot_sample_distribution(samples: np.ndarray) -> go.Figure:
+    # show distribution for a few horizons
+    if samples.ndim != 2:
+        samples = np.asarray(samples)
+    n_h = samples.shape[1]
+    idxs = []
+    for frac in [0.1, 0.5, 0.9]:
+        i = int(round((n_h - 1) * frac))
+        idxs.append(i)
+    idxs = sorted(set(idxs))
+
+    fig = go.Figure()
+    for i in idxs:
+        fig.add_trace(go.Histogram(
+            x=samples[:, i],
+            name=f"h={i+1}",
+            opacity=0.6
+        ))
+    fig.update_layout(
+        barmode="overlay",
+        title="Forecast sample distributions (selected horizons)",
+        margin=dict(l=10, r=10, t=55, b=10),
+        xaxis_title="value",
+        yaxis_title="count",
+    )
+    return fig
 
 
 # =========================
-# Forecast core
+# Core run
 # =========================
-def run_forecast(
-    input_mode,
-    test_csv_name,
+@dataclass
+class RunResult:
+    forecast_fig: go.Figure
+    backtest_fig: Optional[go.Figure]
+    dist_fig: go.Figure
+    forecast_table: pd.DataFrame
+    backtest_table: Optional[pd.DataFrame]
+    forecast_csv_path: str
+    backtest_csv_path: Optional[str]
+    kpi_html: str
+    info: dict
+
+
+def run_dashboard(
+    input_mode: str,
+    test_csv_name: str,
     upload_csv,
-    csv_column,
-    n,
-    seed,
-    trend,
-    season_period,
-    season_amp,
-    noise,
-    prediction_length,
-    q_low,
-    q_high,
-    device_ui,
-    model_id,
-):
-    q_low = float(q_low)
-    q_high = float(q_high)
+    csv_column: str,
+
+    # sample params
+    n: int,
+    seed: int,
+    trend: float,
+    season_period: int,
+    season_amp: float,
+    noise: float,
+
+    # forecast params
+    prediction_length: int,
+    num_samples: int,
+    q_low: float,
+    q_high: float,
+
+    # backtest
+    do_backtest: bool,
+    holdout: int,
+
+    # system
+    device_ui: str,
+    model_id: str,
+) -> RunResult:
+
     if q_low >= q_high:
         raise gr.Error("Quantile low deve essere < quantile high.")
 
     device = pick_device(device_ui)
-    pipe = get_pipeline(model_id, device)
 
-    # 1) pick data
+    # ---------
+    # Load series
+    # ---------
     if input_mode == "Test CSV":
         if not test_csv_name:
-            raise gr.Error("Seleziona un file nella dropdown dei Test CSV.")
-        path = os.path.join(DATA_DIR, test_csv_name)
-        if not os.path.exists(path):
-            raise gr.Error(f"Non trovo {path}. Assicurati che sia nel repo.")
-        y, used_col = load_series_from_csv(path, csv_column)
-        source = f"Test CSV: {test_csv_name} ({used_col})"
+            raise gr.Error("Seleziona un Test CSV dalla dropdown.")
+        csv_path = os.path.join(DATA_DIR, test_csv_name)
+        if not os.path.exists(csv_path):
+            raise gr.Error(f"File non trovato: {csv_path}")
+        y, used_col, df_preview = load_series_from_csv(csv_path, csv_column)
+        source_title = f"Test CSV: {test_csv_name} • col={used_col}"
 
     elif input_mode == "Upload CSV":
         if upload_csv is None:
-            raise gr.Error("Carica un CSV per usare la modalità Upload.")
-        y, used_col = load_series_from_csv(upload_csv.name, csv_column)
-        source = f"Upload CSV ({used_col})"
-
-    else:  # Sample
-        y = make_sample_series(n, seed, trend, season_period, season_amp, noise)
-        source = "Sample data"
-
-    # 2) build context df (single series)
-    context_df = build_context_df(y, freq="D")
+            raise gr.Error("Carica un CSV (Upload CSV) oppure cambia modalità.")
+        y, used_col, df_preview = load_series_from_csv(upload_csv.name, csv_column)
+        source_title = f"Upload CSV • col={used_col}"
+
+    else:
+        y = make_sample_series(n, seed, trend, season_period, season_amp, noise, positive_shift=True)
+        df_preview = pd.DataFrame({"value": y})
+        used_col = "value"
+        source_title = "Sample series"
+
+    if do_backtest and holdout >= len(y):
+        raise gr.Error("Holdout deve essere più piccolo della lunghezza dello storico.")
+
+    # ---------
+    # Model
+    # ---------
+    t0 = time.time()
+    pipe = get_pipeline(model_id, device)
 
-    # 3) predict quantiles via predict_df (stable API per chronos-2)
-    quantiles = sorted({q_low, 0.5, q_high})
-    pred_df = pipe.predict_df(
-        context_df,
+    # ---------
+    # Forecast
+    # ---------
+    samples = pipe.predict(
+        context=y.tolist(),
         prediction_length=int(prediction_length),
-        quantile_levels=quantiles,
-        id_column="id",
-        timestamp_column="timestamp",
-        target="target",
+        num_samples=int(num_samples),
     )
+    samples = np.asarray(samples, dtype=np.float32)
 
-    # 4) extract arrays
-    col_low = pick_quantile_column(pred_df, q_low)
-    col_med = pick_quantile_column(pred_df, 0.5)
-    col_high = pick_quantile_column(pred_df, q_high)
-
-    # pred_df contains the forecast horizon rows; keep only series_0
-    pred_df = pred_df[pred_df["id"] == "series_0"].copy()
-
-    ts_fcst = pd.to_datetime(pred_df["timestamp"]).to_numpy()
-    low = pred_df[col_low].to_numpy(dtype=np.float32)
-    median = pred_df[col_med].to_numpy(dtype=np.float32)
-    high = pred_df[col_high].to_numpy(dtype=np.float32)
+    median = np.quantile(samples, 0.50, axis=0)
+    low = np.quantile(samples, float(q_low), axis=0)
+    high = np.quantile(samples, float(q_high), axis=0)
 
-    # 5) plot (use integer axis for simplicity)
-    t_hist = np.arange(len(y))
+    # Tables
     t_fcst = np.arange(len(y), len(y) + int(prediction_length))
-
-    fig, ax = plt.subplots(figsize=(10, 4))
-    ax.plot(t_hist, y, label="history")
-    ax.plot(t_fcst, median, label="forecast (median)")
-    ax.fill_between(t_fcst, low, high, alpha=0.25, label=f"band [{q_low:.2f}, {q_high:.2f}]")
-    ax.axvline(len(y) - 1, linestyle="--", linewidth=1)
-    ax.set_title(source)
-    ax.set_xlabel("t")
-    ax.set_ylabel("value")
-    ax.grid(True, alpha=0.3)
-    ax.legend()
-
-    # 6) output table + downloadable csv
-    out_df = pd.DataFrame(
-        {
-            "t": t_fcst,
-            "timestamp": ts_fcst,
-            "median": median,
-            f"q{q_low:.2f}": low,
-            f"q{q_high:.2f}": high,
-        }
+    forecast_df = pd.DataFrame({
+        "t": t_fcst,
+        "median": median,
+        f"q{q_low:.2f}": low,
+        f"q{q_high:.2f}": high,
+    })
+
+    forecast_csv_path = os.path.join(OUT_DIR, "chronos2_forecast.csv")
+    forecast_df.to_csv(forecast_csv_path, index=False)
+
+    # Plots
+    forecast_fig = plot_forecast_interactive(
+        y=y,
+        median=median,
+        low=low,
+        high=high,
+        title=f"Forecast — {source_title}",
+        q_low=q_low,
+        q_high=q_high,
     )
+    dist_fig = plot_sample_distribution(samples)
+
+    # ---------
+    # Backtest (optional)
+    # ---------
+    backtest_fig = None
+    backtest_df = None
+    backtest_csv_path = None
+
+    kpi_items = []
+    # Always show run/system KPIs
+    elapsed = time.time() - t0
+    kpi_items.append(format_kpi("Device", device.upper(), f"torch.cuda={torch.cuda.is_available()}"))
+    kpi_items.append(format_kpi("Model", (model_id or MODEL_ID_DEFAULT), "Chronos-2 pipeline"))
+    kpi_items.append(format_kpi("Latency", f"{elapsed:.2f}s", "model load cached after first run"))
+    kpi_items.append(format_kpi("Samples", f"{int(num_samples)}", "more = smoother quantiles"))
+
+    # Coverage/width (forecast only) – informational
+    kpi_items.append(format_kpi("Interval", f"[{q_low:.2f}, {q_high:.2f}]", "uncertainty band"))
+    kpi_items.append(format_kpi("Avg band width", f"{interval_width(low, high):.3f}", "forecast band only"))
+
+    if do_backtest:
+        y_train = y[:-int(holdout)]
+        y_true = y[-int(holdout):]
+
+        bt_samples = pipe.predict(
+            context=y_train.tolist(),
+            prediction_length=int(holdout),
+            num_samples=int(num_samples),
+        )
+        bt_samples = np.asarray(bt_samples, dtype=np.float32)
+        bt_median = np.quantile(bt_samples, 0.50, axis=0)
+        bt_low = np.quantile(bt_samples, float(q_low), axis=0)
+        bt_high = np.quantile(bt_samples, float(q_high), axis=0)
+
+        # Metrics
+        bt_mae = mae(y_true, bt_median)
+        bt_rmse = rmse(y_true, bt_median)
+        bt_mape = safe_mape(y_true, bt_median)
+        bt_cov = coverage(y_true, bt_low, bt_high)
+        bt_w = interval_width(bt_low, bt_high)
+
+        kpi_items.append(format_kpi("Backtest MAE", f"{bt_mae:.3f}", f"holdout={holdout}"))
+        kpi_items.append(format_kpi("Backtest RMSE", f"{bt_rmse:.3f}", ""))
+        kpi_items.append(format_kpi("Backtest MAPE", f"{bt_mape:.2f}%", ""))
+        kpi_items.append(format_kpi("Coverage", f"{bt_cov:.1f}%", "inside band"))
+        kpi_items.append(format_kpi("Backtest width", f"{bt_w:.3f}", "avg band width"))
+
+        backtest_fig = plot_backtest_interactive(
+            y_train=y_train,
+            y_true=y_true,
+            pred_median=bt_median,
+            low=bt_low,
+            high=bt_high,
+            q_low=q_low,
+            q_high=q_high,
+        )
 
-    out_path = "/tmp/chronos2_forecast.csv"
-    out_df.to_csv(out_path, index=False)
+        t_test = np.arange(len(y_train), len(y_train) + int(holdout))
+        backtest_df = pd.DataFrame({
+            "t": t_test,
+            "true": y_true,
+            "pred_median": bt_median,
+            f"q{q_low:.2f}": bt_low,
+            f"q{q_high:.2f}": bt_high,
+        })
+        backtest_csv_path = os.path.join(OUT_DIR, "chronos2_backtest.csv")
+        backtest_df.to_csv(backtest_csv_path, index=False)
+
+    kpi_html = f"""
+    <div style="display:grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap:12px;">
+      {''.join(kpi_items)}
+    </div>
+    """
 
     info = {
-        "model_id": (model_id or MODEL_ID_DEFAULT),
-        "device": device,
-        "source": source,
+        "source": source_title,
         "history_points": int(len(y)),
         "prediction_length": int(prediction_length),
-        "quantile_levels": quantiles,
-        "pred_df_columns": list(out_df.columns),
+        "num_samples": int(num_samples),
+        "q_low": float(q_low),
+        "q_high": float(q_high),
+        "backtest": bool(do_backtest),
+        "holdout": int(holdout) if do_backtest else None,
+        "column_used": used_col,
     }
 
-    return fig, out_df, out_path, info
+    return RunResult(
+        forecast_fig=forecast_fig,
+        backtest_fig=backtest_fig,
+        dist_fig=dist_fig,
+        forecast_table=forecast_df,
+        backtest_table=backtest_df,
+        forecast_csv_path=forecast_csv_path,
+        backtest_csv_path=backtest_csv_path,
+        kpi_html=kpi_html,
+        info=info,
+    )
+
+
+def run_dashboard_wrapped(*args):
+    res = run_dashboard(*args)
+    # outputs must be basic objects
+    # If no backtest, send an empty placeholder plot and empty table/file
+    empty_fig = go.Figure().update_layout(
+        title="Backtest disabled",
+        margin=dict(l=10, r=10, t=55, b=10),
+    )
+    empty_df = pd.DataFrame()
+
+    return (
+        res.kpi_html,
+        res.forecast_fig,
+        (res.backtest_fig if res.backtest_fig is not None else empty_fig),
+        res.dist_fig,
+        res.forecast_table,
+        (res.backtest_table if res.backtest_table is not None else empty_df),
+        res.forecast_csv_path,
+        (res.backtest_csv_path if res.backtest_csv_path is not None else None),
+        res.info,
+    )
 
 
 # =========================
 # UI
 # =========================
-with gr.Blocks(title="Chronos-2 • HF Spaces Demo") as demo:
+css = """
+:root { --radius: 18px; }
+.gradio-container { max-width: 1200px !important; }
+"""
+
+with gr.Blocks(title="Chronos-2 • Forecast Dashboard", css=css) as demo:
     gr.Markdown(
-        "# ⏱️ Chronos-2 Forecast Demo (HF Spaces)\n"
-        "- **Sample**: genera una serie sintetica\n"
-        "- **Test CSV**: usa file in `data/`\n"
-        "- **Upload CSV**: carica un tuo CSV\n\n"
-        "Questa versione usa **predict_df()** (API consigliata per Chronos-2) e calcola direttamente i **quantili**. "
+        """
+# ⏱️ Chronos-2 Forecast Dashboard
+Una dashboard interattiva (Plotly) per testare **Amazon Chronos-2** su serie storiche (sample / CSV / upload), con **bande di incertezza** e **backtest**.
+"""
     )
 
     with gr.Row():
-        input_mode = gr.Radio(["Sample", "Test CSV", "Upload CSV"], value="Sample", label="Input source")
-        device_ui = gr.Dropdown(
-            ["cpu", "cuda (se disponibile)"],
-            value="cuda (se disponibile)" if torch.cuda.is_available() else "cpu",
-            label="Device",
-        )
-        model_id = gr.Textbox(value=MODEL_ID_DEFAULT, label="Model ID")
-
-    with gr.Row():
-        test_csv_name = gr.Dropdown(choices=available_test_csv(), label="Test CSV disponibili (data/)")
-        upload_csv = gr.File(label="Upload CSV", file_types=[".csv"])
-        csv_column = gr.Textbox(label="Colonna numerica (opzionale)", placeholder="es: value")
-
-    with gr.Accordion("Sample data settings", open=False):
-        n = gr.Slider(60, 600, 220, step=10, label="History length")
-        seed = gr.Number(42, precision=0, label="Seed")
-        trend = gr.Slider(0.0, 0.2, 0.03, step=0.005, label="Trend")
-        season_period = gr.Slider(2, 90, 14, step=1, label="Season period")
-        season_amp = gr.Slider(0.0, 10.0, 3.0, step=0.1, label="Season amplitude")
-        noise = gr.Slider(0.0, 5.0, 0.8, step=0.05, label="Noise")
-
-    with gr.Accordion("Forecast settings", open=True):
-        prediction_length = gr.Slider(1, 180, 30, step=1, label="Prediction length")
-        q_low = gr.Slider(0.01, 0.49, 0.10, step=0.01, label="Quantile low")
-        q_high = gr.Slider(0.51, 0.99, 0.90, step=0.01, label="Quantile high")
-
-    run_btn = gr.Button("Run forecast", variant="primary")
-
-    plot = gr.Plot(label="Forecast")
-    table = gr.Dataframe(label="Forecast values", interactive=False)
-    download = gr.File(label="Download CSV")
-    info = gr.JSON(label="Run info")
+        with gr.Column(scale=1, min_width=360):
+            gr.Markdown("## Input")
+
+            input_mode = gr.Radio(
+                ["Sample", "Test CSV", "Upload CSV"],
+                value="Sample",
+                label="Sorgente dati",
+            )
+
+            test_csv_name = gr.Dropdown(
+                choices=available_test_csv(),
+                value=None,
+                label="Test CSV (cartella data/)",
+                info="Comparirà qui se metti .csv dentro data/",
+            )
+
+            upload_csv = gr.File(label="Upload CSV", file_types=[".csv"])
+            csv_column = gr.Textbox(label="Colonna numerica (opzionale)", placeholder="es: value")
+
+            gr.Markdown("## Sistema")
+            device_ui = gr.Dropdown(
+                ["cpu", "cuda (se disponibile)"],
+                value="cuda (se disponibile)" if torch.cuda.is_available() else "cpu",
+                label="Device",
+            )
+            model_id = gr.Textbox(value=MODEL_ID_DEFAULT, label="Model ID")
+
+            with gr.Accordion("Sample generator", open=False):
+                n = gr.Slider(60, 1200, value=300, step=10, label="History length")
+                seed = gr.Number(value=42, precision=0, label="Seed")
+                trend = gr.Slider(0.0, 0.2, value=0.03, step=0.005, label="Trend")
+                season_period = gr.Slider(2, 120, value=14, step=1, label="Season period")
+                season_amp = gr.Slider(0.0, 12.0, value=3.0, step=0.1, label="Season amplitude")
+                noise = gr.Slider(0.0, 6.0, value=0.8, step=0.05, label="Noise")
+
+            gr.Markdown("## Forecast settings")
+            prediction_length = gr.Slider(1, 365, value=30, step=1, label="Prediction length")
+            num_samples = gr.Slider(50, 800, value=300, step=25, label="Num samples (quantili più stabili)")
+            q_low = gr.Slider(0.01, 0.49, value=0.10, step=0.01, label="Quantile low")
+            q_high = gr.Slider(0.51, 0.99, value=0.90, step=0.01, label="Quantile high")
+
+            gr.Markdown("## Backtest")
+            do_backtest = gr.Checkbox(value=True, label="Esegui backtest holdout")
+            holdout = gr.Slider(5, 240, value=30, step=1, label="Holdout points")
+
+            run_btn = gr.Button("Run", variant="primary")
+
+        with gr.Column(scale=2):
+            gr.Markdown("## KPI")
+            kpi_html = gr.HTML()
+
+            with gr.Tabs():
+                with gr.Tab("Forecast"):
+                    forecast_plot = gr.Plot(label="Interactive forecast (Plotly)")
+                    forecast_table = gr.Dataframe(label="Forecast table", interactive=False)
+
+                with gr.Tab("Backtest"):
+                    backtest_plot = gr.Plot(label="Interactive backtest (Plotly)")
+                    backtest_table = gr.Dataframe(label="Backtest table", interactive=False)
+
+                with gr.Tab("Distributions"):
+                    dist_plot = gr.Plot(label="Sample distributions (selected horizons)")
+
+                with gr.Tab("Export"):
+                    gr.Markdown("Scarica i CSV prodotti dall’ultima run:")
+                    forecast_download = gr.File(label="Forecast CSV")
+                    backtest_download = gr.File(label="Backtest CSV")
+
+                with gr.Tab("Run info"):
+                    run_info = gr.JSON(label="Info")
 
     run_btn.click(
-        fn=run_forecast,
+        fn=run_dashboard_wrapped,
         inputs=[
-            input_mode,
-            test_csv_name,
-            upload_csv,
-            csv_column,
-            n,
-            seed,
-            trend,
-            season_period,
-            season_amp,
-            noise,
-            prediction_length,
-            q_low,
-            q_high,
-            device_ui,
-            model_id,
+            input_mode, test_csv_name, upload_csv, csv_column,
+            n, seed, trend, season_period, season_amp, noise,
+            prediction_length, num_samples, q_low, q_high,
+            do_backtest, holdout,
+            device_ui, model_id,
+        ],
+        outputs=[
+            kpi_html,
+            forecast_plot, backtest_plot, dist_plot,
+            forecast_table, backtest_table,
+            forecast_download, backtest_download,
+            run_info,
         ],
-        outputs=[plot, table, download, info],
     )
 
 demo.queue()