Update app.py

app.py

@@ -1,8 +1,7 @@
 import os
 import time
 import inspect
-from dataclasses import dataclass
-from typing import Optional, Tuple, Any, Dict, List
+from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
 import pandas as pd
@@ -13,17 +12,14 @@ import plotly.graph_objects as go
 from chronos import Chronos2Pipeline
 
 
-# =========================
-# Config
-# =========================
 MODEL_ID_DEFAULT = os.getenv("CHRONOS_MODEL_ID", "amazon/chronos-2")
 DATA_DIR = "data"
 OUT_DIR = "/tmp"
 
 
-# =========================
-# Data helpers
-# =========================
+# -------------------------
+# Data
+# -------------------------
 def available_test_csv() -> List[str]:
     if not os.path.isdir(DATA_DIR):
         return []
@@ -31,42 +27,25 @@ def available_test_csv() -> List[str]:
 
 
 def pick_device(ui_choice: str) -> str:
-    if (ui_choice or "").startswith("cuda") and torch.cuda.is_available():
-        return "cuda"
-    return "cpu"
-
-
-def make_sample_series(
-    n: int,
-    seed: int,
-    trend: float,
-    season_period: int,
-    season_amp: float,
-    noise: float,
-) -> np.ndarray:
+    return "cuda" if (ui_choice or "").startswith("cuda") and torch.cuda.is_available() else "cpu"
+
+
+def make_sample_series(n: int, seed: int, trend: float, season_period: int, season_amp: float, noise: float) -> np.ndarray:
     rng = np.random.default_rng(int(seed))
     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=int(n))
-    ).astype(np.float32)
+    y = (trend * t + season_amp * np.sin(2 * np.pi * t / max(1, int(season_period))) + rng.normal(0, noise, size=int(n))).astype(np.float32)
     if float(np.min(y)) < 0:
-        y = y - float(np.min(y))
+        y -= float(np.min(y))
     return y
 
 
-def load_series_from_csv(csv_path: str, column: Optional[str]) -> Tuple[np.ndarray, str, pd.DataFrame]:
+def load_series_from_csv(csv_path: str, column: Optional[str]) -> Tuple[np.ndarray, str]:
     df = pd.read_csv(csv_path)
-    if df.shape[1] == 0:
-        raise ValueError("CSV vuoto o non leggibile.")
-
     col = (column or "").strip()
     if not col:
-        # numeric columns first
         numeric_cols = [c for c in df.columns if pd.api.types.is_numeric_dtype(df[c])]
         if not numeric_cols:
-            # try coercion (strings -> numbers)
+            # try coercion
             for c in df.columns:
                 coerced = pd.to_numeric(df[c], errors="coerce")
                 if coerced.notna().sum() > 0:
@@ -74,62 +53,34 @@ def load_series_from_csv(csv_path: str, column: Optional[str]) -> Tuple[np.ndarr
             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. Disponibili: {list(df.columns)}")
-
     y = pd.to_numeric(df[col], errors="coerce").dropna().astype(np.float32).to_numpy()
     if len(y) < 10:
-        raise ValueError("Serie troppo corta (minimo consigliato: 10 punti).")
-    return y, col, df
-
-
-# =========================
-# Metrics
-# =========================
-def mae(y_true: np.ndarray, y_pred: np.ndarray) -> float:
-    return float(np.mean(np.abs(y_true - y_pred)))
-
-
-def rmse(y_true: np.ndarray, y_pred: np.ndarray) -> float:
-    return float(np.sqrt(np.mean((y_true - y_pred) ** 2)))
-
-
-def 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 coverage(y_true: np.ndarray, low: np.ndarray, high: np.ndarray) -> float:
-    return float(np.mean((y_true >= low) & (y_true <= high)) * 100.0)
-
+        raise ValueError("Serie troppo corta.")
+    return y, col
 
-def avg_width(low: np.ndarray, high: np.ndarray) -> float:
-    return float(np.mean(high - low))
 
-
-# =========================
+# -------------------------
 # Model cache
-# =========================
+# -------------------------
 _PIPE = None
-_PIPE_META = {"model_id": None, "device": None}
+_META = {"model_id": None, "device": None}
 
 
 def get_pipeline(model_id: str, device: str) -> Chronos2Pipeline:
-    global _PIPE, _PIPE_META
+    global _PIPE, _META
     model_id = (model_id or MODEL_ID_DEFAULT).strip()
-    device = "cuda" if (device == "cuda" and torch.cuda.is_available()) else "cpu"
-
-    if _PIPE is None or _PIPE_META["model_id"] != model_id or _PIPE_META["device"] != device:
+    device = "cuda" if device == "cuda" and torch.cuda.is_available() else "cpu"
+    if _PIPE is None or _META["model_id"] != model_id or _META["device"] != device:
         _PIPE = Chronos2Pipeline.from_pretrained(model_id, device_map=device)
-        _PIPE_META = {"model_id": model_id, "device": device}
-
+        _META = {"model_id": model_id, "device": device}
     return _PIPE
 
 
-# =========================
-# Chronos-2 predict (BULLETPROOF)
-# =========================
+# -------------------------
+# Predict (STABLE)
+# -------------------------
 def _to_numpy(x: Any) -> np.ndarray:
     if isinstance(x, np.ndarray):
         return x
@@ -139,126 +90,105 @@ def _to_numpy(x: Any) -> np.ndarray:
 
 
 def _extract_samples(raw: Any) -> np.ndarray:
-    """
-    Normalizza l’output in np.ndarray.
-    Possibili output visti in librerie “young”:
-    - list[list[float]] (samples x horizon)
-    - list[float] (horizon) -> 1 sample
-    - np.ndarray / torch.Tensor (horizon) o (samples, horizon)
-    - dict con chiavi tipo 'samples', 'predictions'
-    """
     if isinstance(raw, dict):
         for k in ["samples", "predictions", "prediction", "output"]:
             if k in raw:
                 return _to_numpy(raw[k])
-        # fallback: prova primo valore
         if len(raw) > 0:
             return _to_numpy(next(iter(raw.values())))
         return np.asarray([], dtype=np.float32)
-
     return _to_numpy(raw)
 
 
-def chronos2_predict_samples(
-    pipe: Chronos2Pipeline,
-    y: np.ndarray,
-    prediction_length: int,
-    num_samples_ui: int,
-) -> np.ndarray:
+def chronos2_predict(pipe: Chronos2Pipeline, y: np.ndarray, horizon: int, requested_samples: int) -> Tuple[np.ndarray, bool, str]:
     """
-    Gestisce:
-    - inputs obbligatorio (posizionale o keyword)
-    - prediction_length può chiamarsi prediction_length / horizon / steps
-    - numero campioni può chiamarsi n_samples / num_return_sequences / ...
-    - oppure non esiste: allora torna 1 sample e noi facciamo broadcast
+    Returns:
+      samples: (S, H)
+      multi: whether S>1 is real (not replicated)
+      note: debug note
     """
-    ctx = y.tolist()
-
     sig = inspect.signature(pipe.predict)
     params = sig.parameters
 
-    # 1) name for horizon
+    # input format: ALWAYS batch = [series]
+    inputs = [y.tolist()]
+
+    # kw for horizon
     horizon_kw = None
     for cand in ["prediction_length", "horizon", "steps", "n_steps", "pred_len"]:
         if cand in params:
             horizon_kw = cand
             break
 
-    # 2) name for samples count
+    # kw for samples count (many versions don't have it!)
     sample_kw = None
-    for cand in ["n_samples", "num_samples", "num_return_sequences", "samples", "n"]:
+    for cand in ["n_samples", "num_return_sequences", "num_samples"]:
         if cand in params:
             sample_kw = cand
             break
 
-    # build kwargs
     kwargs: Dict[str, Any] = {}
-    if horizon_kw is not None:
-        kwargs[horizon_kw] = int(prediction_length)
-
-    # include sample kw only if supported
-    if sample_kw is not None:
-        kwargs[sample_kw] = int(num_samples_ui)
-
-    # inputs handling
-    if "inputs" in params:
-        raw = pipe.predict(inputs=ctx, **kwargs)
+    if horizon_kw:
+        kwargs[horizon_kw] = int(horizon)
     else:
-        # some builds may accept positional only
-        raw = pipe.predict(ctx, **kwargs)
+        # worst case: try positional horizon if supported (rare)
+        kwargs["prediction_length"] = int(horizon)
 
+    if sample_kw:
+        kwargs[sample_kw] = int(requested_samples)
+
+    # call
+    raw = pipe.predict(inputs=inputs, **kwargs) if "inputs" in params else pipe.predict(inputs, **kwargs)
     arr = _extract_samples(raw).astype(np.float32, copy=False)
 
-    # normalize shape -> (samples, horizon)
-    if arr.ndim == 0:
-        # degenerate
-        arr = arr.reshape(1, 1)
-    elif arr.ndim == 1:
-        # (horizon,) -> (1, horizon)
+    # normalize shape -> (S,H)
+    arr = np.squeeze(arr)
+    if arr.ndim == 1:
+        # could be (H,) or (S,) - assume horizon if length == H
         arr = arr[None, :]
-    elif arr.ndim >= 3:
-        # squeeze extras if any
-        arr = np.squeeze(arr)
+
+    # Sometimes output is (B,S,H) or (B,H). If batch dim exists, take first
+    if arr.ndim == 3:
+        # assume (B,S,H) or (S,B,H); safest: pick first on axis=0
+        arr = arr[0]
         if arr.ndim == 1:
             arr = arr[None, :]
 
-    # ensure horizon matches if possible (some APIs might return longer/shorter)
-    if arr.shape[1] != int(prediction_length):
-        # best-effort: trim or pad with last value
-        h = int(prediction_length)
-        if arr.shape[1] > h:
-            arr = arr[:, :h]
+    # ensure horizon length
+    if arr.shape[-1] != horizon:
+        if arr.shape[-1] > horizon:
+            arr = arr[..., :horizon]
         else:
-            pad = h - arr.shape[1]
-            last = arr[:, -1:]
-            arr = np.concatenate([arr, np.repeat(last, pad, axis=1)], axis=1)
-
-    # if API didn’t support sample count, we may only have 1 sample: replicate to compute quantiles smoothly
-    if arr.shape[0] == 1 and num_samples_ui > 1:
-        arr = np.repeat(arr, repeats=int(num_samples_ui), axis=0)
+            pad = horizon - arr.shape[-1]
+            last = arr[..., -1:]
+            arr = np.concatenate([arr, np.repeat(last, pad, axis=-1)], axis=-1)
 
-    return arr
+    # If we got only 1 sample, we can still plot median but band is not meaningful
+    real_multi = arr.shape[0] > 1
+    note = f"predict_signature={sig} | used_horizon_kw={horizon_kw} | used_sample_kw={sample_kw} | got_shape={tuple(arr.shape)}"
+    return arr, real_multi, note
 
 
-# =========================
+# -------------------------
 # Plotly
-# =========================
-def plot_forecast(y, median, low, high, title, q_low, q_high) -> go.Figure:
+# -------------------------
+def plot_forecast(y, median, low, high, title, show_band: bool, band_label: str) -> 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"))
-
-    fig.add_trace(go.Scatter(x=t_fcst, y=high, mode="lines", line=dict(width=0),
-                             showlegend=False, hoverinfo="skip"))
-    fig.add_trace(go.Scatter(
-        x=t_fcst, 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_fcst, y=median, mode="lines", name="Forecast (median)"))
     fig.add_vline(x=len(y) - 1, line_width=1, line_dash="dash", opacity=0.6)
 
+    if show_band:
+        fig.add_trace(go.Scatter(x=t_fcst, y=high, mode="lines", line=dict(width=0),
+                                 showlegend=False, hoverinfo="skip"))
+        fig.add_trace(go.Scatter(
+            x=t_fcst, y=low, mode="lines", fill="tonexty",
+            line=dict(width=0), name=band_label
+        ))
+
     fig.update_layout(
         title=title,
         hovermode="x unified",
@@ -270,46 +200,23 @@ def plot_forecast(y, median, low, high, title, q_low, q_high) -> go.Figure:
     return fig
 
 
-def plot_backtest(y_train, y_true, pred, low, high, q_low, q_high) -> go.Figure:
-    t_train = np.arange(len(y_train))
-    t_test = np.arange(len(y_train), len(y_train) + len(y_true))
+def kpi_card(label: str, value: str, hint: str = "") -> str:
+    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);">
+      <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>
+    """
 
-    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, 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 kpi_grid(cards: List[str]) -> str:
+    return f"<div style='display:grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap:12px;'>{''.join(cards)}</div>"
 
 
-# =========================
-# Natural language explanation
-# =========================
-def explain_output(
-    y: np.ndarray,
-    median: np.ndarray,
-    low: np.ndarray,
-    high: np.ndarray,
-    q_low: float,
-    q_high: float,
-    backtest: Optional[Dict[str, float]],
-) -> str:
+def explain(y, median, low, high, band_enabled: bool, q_low: float, q_high: float, extra: str) -> str:
     horizon = len(median)
     base = float(np.mean(y))
     delta = float(median[-1] - median[0])
@@ -322,280 +229,131 @@ def explain_output(
     else:
         trend_txt = "in calo"
 
-    w = float(np.mean(high - low))
-    rel_w = (w / max(1e-6, float(np.mean(median)))) * 100.0
-    if rel_w < 10:
-        uncert_txt = "bassa"
-    elif rel_w < 25:
-        uncert_txt = "moderata"
-    else:
-        uncert_txt = "alta"
-
     txt = f"""
-### 🧠 Spiegazione (linguaggio naturale)
-
-**Cosa sta dicendo il modello:** nei prossimi **{horizon} step** la serie è **{trend_txt}** (variazione mediana complessiva ≈ **{pct:+.1f}%** rispetto al livello medio storico).
+### 🧠 Spiegazione
 
-- **Mediana all’ultimo step:** **{median[-1]:.2f}**
-- **Intervallo [{q_low:.0%}–{q_high:.0%}] all’ultimo step:** **[{low[-1]:.2f} – {high[-1]:.2f}]**
-- **Incertezza:** **{uncert_txt}** (larghezza media banda ≈ **{w:.2f}**, ~**{rel_w:.1f}%** della mediana)
-
-**Come usarlo:** usa la **mediana** come previsione “baseline”; usa il **quantile alto** per scenari prudenziali (es. scorte/capacità) e il **quantile basso** per scenari conservativi (es. budget).
+Nei prossimi **{horizon} step** la previsione mediana è **{trend_txt}** (variazione ≈ **{pct:+.1f}%** rispetto al livello medio storico).
+- **Ultimo valore mediano previsto:** **{median[-1]:.2f}**
 """
+    if band_enabled:
+        txt += f"- **Banda [{q_low:.0%}–{q_high:.0%}] (ultimo step):** **[{low[-1]:.2f} – {high[-1]:.2f}]**\n"
+    else:
+        txt += "- **Banda di incertezza:** disattivata (questa versione di Chronos2 non restituisce campioni multipli con i parametri disponibili).\n"
 
-    if backtest:
-        target_cov = (q_high - q_low) * 100.0
-        cov = backtest["coverage"]
-        calib = "buona" if abs(cov - target_cov) <= 10 else "migliorabile"
-        txt += f"""
-
-### 🧪 Affidabilità (backtest)
-
-Sul tratto holdout:
-- **MAE:** {backtest["mae"]:.3f}
-- **RMSE:** {backtest["rmse"]:.3f}
-- **MAPE:** {backtest["mape"]:.2f}%
-- **Coverage:** {cov:.1f}% (target atteso ≈ {target_cov:.1f}%)
-
-Interpretazione: la banda di incertezza ha una calibrazione **{calib}** sul passato recente.
-"""
+    txt += f"\n<details><summary>Debug</summary>\n\n`{extra}`\n\n</details>\n"
     return txt
 
 
-# =========================
-# KPI HTML
-# =========================
-def kpi_card(label: str, value: str, hint: str = "") -> str:
-    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 kpi_grid(cards: List[str]) -> str:
-    return f"<div style='display:grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap:12px;'>{''.join(cards)}</div>"
-
-
-@dataclass
-class Outputs:
-    kpis_html: str
-    explanation_md: str
-    forecast_fig: go.Figure
-    backtest_fig: go.Figure
-    forecast_table: pd.DataFrame
-    backtest_table: pd.DataFrame
-    forecast_csv_path: str
-    backtest_csv_path: Optional[str]
-    info: dict
-
-
-# =========================
-# Core run
-# =========================
-def run_dashboard(
-    input_mode: str,
-    test_csv_name: str,
-    upload_csv,
-    csv_column: str,
-
-    n: int,
-    seed: int,
-    trend: float,
-    season_period: int,
-    season_amp: float,
-    noise: float,
-
-    prediction_length: int,
-    num_samples: int,
-    q_low: float,
-    q_high: float,
-
-    do_backtest: bool,
-    holdout: int,
-
-    device_ui: str,
-    model_id: str,
-) -> Outputs:
+# -------------------------
+# Run
+# -------------------------
+def run_all(
+    input_mode, test_csv_name, upload_csv, csv_column,
+    n, seed, trend, season_period, season_amp, noise,
+    prediction_length, requested_samples, q_low, q_high,
+    device_ui, model_id,
+):
     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)
 
-    # Load series
+    # data
     if input_mode == "Test CSV":
         if not test_csv_name:
             raise gr.Error("Seleziona un Test CSV.")
         path = os.path.join(DATA_DIR, test_csv_name)
-        if not os.path.exists(path):
-            raise gr.Error(f"File non trovato: {path}")
-        y, used_col, _ = load_series_from_csv(path, csv_column)
+        y, used_col = load_series_from_csv(path, csv_column)
         source = 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.")
-        y, used_col, _ = load_series_from_csv(upload_csv.name, csv_column)
+        y, used_col = load_series_from_csv(upload_csv.name, csv_column)
         source = f"Upload CSV • col={used_col}"
-
     else:
         y = make_sample_series(n, seed, trend, season_period, season_amp, noise)
         source = "Sample series"
 
-    if do_backtest and holdout >= len(y):
-        raise gr.Error("Holdout deve essere più piccolo della lunghezza dello storico.")
-
     t0 = time.time()
-    pipe = get_pipeline(model_id, device)
+    samples, real_multi, note = chronos2_predict(pipe, y, int(prediction_length), int(requested_samples))
+    latency = time.time() - t0
 
-    # Forecast (samples x horizon)
-    samples = chronos2_predict_samples(pipe, y, int(prediction_length), int(num_samples))
     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)
+    band_enabled = real_multi and samples.shape[0] > 2
+    if band_enabled:
+        low = np.quantile(samples, float(q_low), axis=0)
+        high = np.quantile(samples, float(q_high), axis=0)
+    else:
+        low = median.copy()
+        high = median.copy()
 
-    # Tables & export
+    # KPI
+    cards = [
+        kpi_card("Device", device.upper(), f"cuda_available={torch.cuda.is_available()}"),
+        kpi_card("Latency", f"{latency:.2f}s", "predict()"),
+        kpi_card("Samples", str(samples.shape[0]), "returned by model"),
+        kpi_card("Band", "ON" if band_enabled else "OFF", "needs multi-samples"),
+        kpi_card("Horizon", str(prediction_length)),
+        kpi_card("Model", (model_id or MODEL_ID_DEFAULT)),
+    ]
+    kpis_html = kpi_grid(cards)
+
+    # Plot
+    fig = plot_forecast(
+        y=y,
+        median=median,
+        low=low,
+        high=high,
+        title=f"Forecast — {source}",
+        show_band=band_enabled,
+        band_label=f"Band [{q_low:.2f}, {q_high:.2f}]",
+    )
+
+    # Table + export
     t_fcst = np.arange(len(y), len(y) + int(prediction_length))
-    forecast_df = pd.DataFrame({
+    out_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)
+    if band_enabled:
+        out_df[f"q{q_low:.2f}"] = low
+        out_df[f"q{q_high:.2f}"] = high
 
-    forecast_fig = plot_forecast(y, median, low, high, f"Forecast — {source}", q_low, q_high)
+    out_path = os.path.join(OUT_DIR, "chronos2_forecast.csv")
+    out_df.to_csv(out_path, index=False)
 
-    # Backtest optional
-    empty_backtest_fig = go.Figure().update_layout(
-        title="Backtest disabled",
-        margin=dict(l=10, r=10, t=55, b=10),
-    )
-    backtest_fig = empty_backtest_fig
-    backtest_df = pd.DataFrame()
-    backtest_csv_path = None
-    backtest_metrics = None
-
-    # KPIs base
-    elapsed = time.time() - t0
-    cards = [
-        kpi_card("Device", device.upper(), f"cuda_available={torch.cuda.is_available()}"),
-        kpi_card("Model", (model_id or MODEL_ID_DEFAULT), "Chronos-2"),
-        kpi_card("Latency", f"{elapsed:.2f}s", "cached after first run"),
-        kpi_card("Samples (req)", f"{int(num_samples)}", "requested"),
-        kpi_card("Interval", f"[{q_low:.2f}, {q_high:.2f}]", "uncertainty band"),
-        kpi_card("Band width", f"{avg_width(low, high):.3f}", "forecast band"),
-    ]
-
-    if do_backtest:
-        y_train = y[:-int(holdout)]
-        y_true = y[-int(holdout):]
-
-        bt_samples = chronos2_predict_samples(pipe, y_train, int(holdout), int(num_samples))
-        bt_med = 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)
-
-        bt_mae = mae(y_true, bt_med)
-        bt_rmse = rmse(y_true, bt_med)
-        bt_mape = mape(y_true, bt_med)
-        bt_cov = coverage(y_true, bt_low, bt_high)
-        bt_w = avg_width(bt_low, bt_high)
-
-        backtest_metrics = {"mae": bt_mae, "rmse": bt_rmse, "mape": bt_mape, "coverage": bt_cov}
-
-        cards += [
-            kpi_card("BT MAE", f"{bt_mae:.3f}", f"holdout={holdout}"),
-            kpi_card("BT RMSE", f"{bt_rmse:.3f}"),
-            kpi_card("BT MAPE", f"{bt_mape:.2f}%"),
-            kpi_card("Coverage", f"{bt_cov:.1f}%", "inside band"),
-            kpi_card("BT width", f"{bt_w:.3f}", "avg band"),
-        ]
-
-        backtest_fig = plot_backtest(y_train, y_true, bt_med, bt_low, bt_high, q_low, q_high)
-
-        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_med,
-            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)
-
-    explanation_md = explain_output(y, median, low, high, q_low, q_high, backtest_metrics)
+    explanation_md = explain(y, median, low, high, band_enabled, q_low, q_high, note)
 
     info = {
         "source": source,
         "history_points": int(len(y)),
         "prediction_length": int(prediction_length),
-        "num_samples_requested": 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,
+        "requested_samples": int(requested_samples),
+        "returned_samples": int(samples.shape[0]),
+        "band_enabled": bool(band_enabled),
         "predict_signature": str(inspect.signature(pipe.predict)),
+        "debug_note": note,
     }
 
-    return Outputs(
-        kpis_html=kpi_grid(cards),
-        explanation_md=explanation_md,
-        forecast_fig=forecast_fig,
-        backtest_fig=backtest_fig,
-        forecast_table=forecast_df,
-        backtest_table=backtest_df,
-        forecast_csv_path=forecast_csv_path,
-        backtest_csv_path=backtest_csv_path,
-        info=info,
-    )
-
-
-def run_wrapped(*args):
-    out = run_dashboard(*args)
-    return (
-        out.kpis_html,
-        out.explanation_md,
-        out.forecast_fig,
-        out.backtest_fig,
-        out.forecast_table,
-        out.backtest_table,
-        out.forecast_csv_path,
-        out.backtest_csv_path,
-        out.info,
-    )
+    return kpis_html, explanation_md, fig, out_df, out_path, info
 
 
-# =========================
+# -------------------------
 # UI
-# =========================
-css = """
-.gradio-container { max-width: 1200px !important; }
-"""
+# -------------------------
+css = """.gradio-container { max-width: 1200px !important; }"""
 
-with gr.Blocks(title="Chronos-2 • Forecast Dashboard", css=css) as demo:
-    gr.Markdown(
-        """
-# ⏱️ Chronos-2 Forecast Dashboard (Bulletproof)
-Plotly interattivo + KPI + backtest + export + spiegazione in linguaggio naturale.
-"""
-    )
+with gr.Blocks(title="Chronos-2 • Pro Dashboard (Stable)", css=css) as demo:
+    gr.Markdown("# ⏱️ Chronos-2 Forecast Dashboard — Stable Edition")
 
     with gr.Row():
         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")
+            input_mode = gr.Radio(["Sample", "Test CSV", "Upload CSV"], value="Sample", label="Input")
             test_csv_name = gr.Dropdown(choices=available_test_csv(), label="Test CSV (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",
@@ -611,61 +369,35 @@ Plotly interattivo + KPI + backtest + export + spiegazione in linguaggio natural
                 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")
             prediction_length = gr.Slider(1, 365, value=30, step=1, label="Prediction length")
-            num_samples = gr.Slider(1, 800, value=300, step=25, label="Num samples (requested)")
+            requested_samples = gr.Slider(1, 800, value=200, step=25, label="Requested samples (best effort)")
             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, 365, value=30, step=1, label="Holdout points")
-
             run_btn = gr.Button("Run", variant="primary")
 
         with gr.Column(scale=2):
-            gr.Markdown("## KPI")
             kpis = gr.HTML()
-
             with gr.Tabs():
                 with gr.Tab("Forecast"):
-                    forecast_plot = gr.Plot(label="Forecast (interactive)")
-                    forecast_table = gr.Dataframe(label="Forecast table", interactive=False)
-
-                with gr.Tab("Backtest"):
-                    backtest_plot = gr.Plot(label="Backtest (interactive)")
-                    backtest_table = gr.Dataframe(label="Backtest table", interactive=False)
-
+                    forecast_plot = gr.Plot()
+                    forecast_table = gr.Dataframe(interactive=False)
                 with gr.Tab("Spiegazione"):
                     explanation = gr.Markdown()
-
                 with gr.Tab("Export"):
-                    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")
+                    download = gr.File()
+                with gr.Tab("Info"):
+                    info = gr.JSON()
 
     run_btn.click(
-        fn=run_wrapped,
+        fn=run_all,
         inputs=[
             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,
+            prediction_length, requested_samples, q_low, q_high,
             device_ui, model_id,
         ],
-        outputs=[
-            kpis,
-            explanation,
-            forecast_plot,
-            backtest_plot,
-            forecast_table,
-            backtest_table,
-            forecast_download,
-            backtest_download,
-            run_info,
-        ],
+        outputs=[kpis, explanation, forecast_plot, forecast_table, download, info],
     )
 
 demo.queue()