Update app.py

app.py

@@ -1,46 +1,40 @@
-# app.py — DataSynthis_ML_JobTask (ARIMA + LSTM REQUIRED, simple UI)
+# app.py — DataSynthis_ML_JobTask (ARIMA + LSTM, minimal UI)
 
-import os, json, math, pickle, traceback
-from datetime import datetime, timedelta
+import os, math, json, pickle, traceback
+from typing import Tuple, Optional
 
 import numpy as np
 import pandas as pd
 import yfinance as yf
+from datetime import datetime, timedelta
 from pandas.tseries.offsets import BDay
-import matplotlib.pyplot as plt
+
 import gradio as gr
+import matplotlib.pyplot as plt
 
 from statsmodels.tsa.arima.model import ARIMA
 from sklearn.metrics import mean_squared_error, mean_absolute_error, mean_absolute_percentage_error
 
 # -------------------------
-# Artifact Paths
+# Required artifact paths
 # -------------------------
-ARIMA_ORDER_JSON = "arima_order.json"      # required for ARIMA order (p,d,q)
-ARIMA_PICKLE = "arima_model.pkl"           # optional (not used for inference)
+ARIMA_PKL   = "arima_model.pkl"   # used only to read (p,d,q) if possible; we don't unpickle the whole result
+LSTM_KERAS  = "lstm_model.keras"  # Keras 3 native format (no .h5)
+LSTM_INFO_1 = "lstm_info.json"    # metadata (lookback, train_min, train_max, feature_range)
+LSTM_INFO_2 = "lstm_model/info.json"  # alternate path if you saved inside a folder
 
-# LSTM artifacts (LSTM is REQUIRED in this build)
-LSTM_KERAS = "lstm_model.keras"            # required
-LSTM_INFO_PRIMARY = "lstm_info.json"       # primary metadata location
-LSTM_INFO_ALT = "lstm_model/info.json"     # alternate metadata location
+REQUIRE_LSTM = True  # make LSTM mandatory
 
-REQUIRE_LSTM = True  # <- make LSTM mandatory
-
-# -------------------------
-# Globals (lazy-load LSTM)
-# -------------------------
+# globals (lazy-loaded)
 _LSTM_MODEL = None
-_LSTM_META = None
+_LSTM_META  = None
 
-# -------------------------
+# =========================
 # Data utilities
-# -------------------------
+# =========================
 def fetch_data(ticker: str, start: str, end: str) -> pd.DataFrame:
-    """
-    Download daily data, convert to business-day frequency, forward-fill close.
-    """
-    df = yf.download(ticker, start=start, end=end, interval="1d",
-                     auto_adjust=True, progress=False)
+    """Download daily data, normalize to business days, forward-fill, return Close series."""
+    df = yf.download(ticker, start=start, end=end, interval="1d", auto_adjust=True, progress=False)
     if df is None or df.empty:
         raise ValueError(f"No data returned for '{ticker}'. Check ticker or dates.")
     df = df[['Close']].copy()
@@ -50,42 +44,51 @@ def fetch_data(ticker: str, start: str, end: str) -> pd.DataFrame:
     df['Close'] = df['Close'].ffill()
     return df
 
-def load_arima_order(default=(2, 1, 2)):
+def extract_order_from_pickle(default_order=(2,1,2)) -> Tuple[int, int, int]:
     """
-    Read (p,d,q) from arima_order.json; fallback to pickle; else default.
+    Try to read (p,d,q) from a previously saved ARIMA pickle without importing
+    version-specific internals. If it fails, just return the default.
     """
-    if os.path.isfile(ARIMA_ORDER_JSON):
-        with open(ARIMA_ORDER_JSON, "r") as f:
-            obj = json.load(f)
-        order = tuple(int(x) for x in obj.get("order", list(default)))
-        return order
-
-    if os.path.isfile(ARIMA_PICKLE):
-        try:
-            with open(ARIMA_PICKLE, "rb") as f:
-                res = pickle.load(f)
-            if hasattr(res, "model") and hasattr(res.model, "order"):
-                return res.model.order
-        except Exception as e:
-            print(f"[WARN] Failed to read order from {ARIMA_PICKLE}: {e}")
-
-    return default
+    try:
+        if os.path.exists(ARIMA_PKL):
+            with open(ARIMA_PKL, "rb") as f:
+                obj = pickle.load(f)
+            # statsmodels ResultWrapper typically exposes .model.order
+            if hasattr(obj, "model") and hasattr(obj.model, "order"):
+                return tuple(int(x) for x in obj.model.order)
+            # some custom dict-like saves
+            mo = getattr(obj, "model_orders", None)
+            if isinstance(mo, dict):
+                return (int(mo.get("ar", 0)), int(mo.get("diff", 0)), int(mo.get("ma", 0)))
+    except Exception as e:
+        print(f"[WARN] Could not read order from pickle, using default {default_order}: {e}")
+    return default_order
 
-# -------------------------
-# ARIMA evaluation / forecast
-# -------------------------
-def arima_roll_single_fit(train_s: pd.Series, test_s: pd.Series, order=(2, 1, 2)):
+# =========================
+# ARIMA helpers
+# =========================
+def arima_roll_single_fit(train_s: pd.Series, test_s: pd.Series, order=(2,1,2)) -> Tuple[np.ndarray, np.ndarray]:
     """
-    Fair evaluation: fit once on TRAIN, then roll 1-step ahead through TEST.
-    Uses ARIMAResults.append() to update state; refits if append is unavailable.
+    Fair eval: fit once on TRAIN, then predict 1-step ahead across TEST.
+    Update model state each step (res.append), fallback to refit if needed.
     """
     res = ARIMA(train_s, order=order,
                 enforce_stationarity=False, enforce_invertibility=False).fit()
     preds, trues = [], []
     for i in range(len(test_s)):
-        preds.append(res.forecast(1)[0])
-        y_true = test_s.iloc[i]
+        fcast = res.forecast(1)
+        # robust scalar extraction (works whether Series or ndarray)
+        try:
+            fval = float(np.asarray(fcast).reshape(-1)[0])
+        except Exception:
+            # as a backup, try pandas iloc if available
+            fval = float(fcast.iloc[0]) if hasattr(fcast, "iloc") else float(fcast)
+        preds.append(fval)
+
+        y_true = float(test_s.iloc[i])
         trues.append(y_true)
+
+        # update internal state or refit on expanded history
         try:
             res = res.append(test_s.iloc[i:i+1])
         except Exception:
@@ -93,46 +96,24 @@ def arima_roll_single_fit(train_s: pd.Series, test_s: pd.Series, order=(2, 1, 2)
                         enforce_stationarity=False, enforce_invertibility=False).fit()
     return np.array(trues), np.array(preds)
 
-def arima_future_forecast(all_close: pd.Series, order, steps: int) -> np.ndarray:
-    """
-    Fit ARIMA on all data and forecast next 'steps' business days.
-    """
-    fitted = ARIMA(all_close, order=order,
-                   enforce_stationarity=False, enforce_invertibility=False).fit()
-    fc = fitted.get_forecast(steps=steps)
-    return np.asarray(fc.predicted_mean).reshape(-1,)
-
-# -------------------------
-# LSTM helpers (Keras .keras + simple min-max scaling)
-# -------------------------
-def _find_lstm_info_path():
-    if os.path.isfile(LSTM_INFO_PRIMARY):
-        return LSTM_INFO_PRIMARY
-    if os.path.isfile(LSTM_INFO_ALT):
-        return LSTM_INFO_ALT
-    return None
-
+# =========================
+# LSTM helpers
+# =========================
 def _maybe_load_lstm(required: bool = False) -> bool:
     """
-    Load LSTM and metadata once. If `required=True`, raise a RuntimeError when missing.
+    Load LSTM model + metadata (lookback, min/max, feature_range).
+    Uses a tolerant loader for Keras 3 + legacy initializers.
     """
     global _LSTM_MODEL, _LSTM_META
-
     if _LSTM_MODEL is not None and _LSTM_META is not None:
         return True
 
-    # find metadata path (either root json or inside folder)
-    info_path = None
-    if os.path.isfile("lstm_info.json"):
-        info_path = "lstm_info.json"
-    elif os.path.isfile("lstm_model/info.json"):
-        info_path = "lstm_model/info.json"
-
+    info_path = LSTM_INFO_1 if os.path.isfile(LSTM_INFO_1) else (LSTM_INFO_2 if os.path.isfile(LSTM_INFO_2) else None)
     missing = []
-    if not os.path.isfile("lstm_model.keras"):
-        missing.append("lstm_model.keras")
+    if not os.path.isfile(LSTM_KERAS):
+        missing.append(LSTM_KERAS)
     if info_path is None:
-        missing.append("lstm_info.json (or lstm_model/info.json)")
+        missing.append("lstm_info.json")
 
     if missing:
         msg = "LSTM artifacts missing: " + ", ".join(missing)
@@ -143,22 +124,16 @@ def _maybe_load_lstm(required: bool = False) -> bool:
 
     try:
         import tensorflow as tf
-
-        # 1) first try safe_mode=False (accept legacy objects)
+        # load with custom Orthogonal mapping; safe_mode=False for broader compatibility
         try:
             _LSTM_MODEL = tf.keras.models.load_model(
-                "lstm_model.keras",
-                compile=False,
-                safe_mode=False,                 # <-- key change
-                custom_objects={                  # <-- helps resolve common initializers
-                    "Orthogonal": tf.keras.initializers.Orthogonal
-                },
+                LSTM_KERAS, compile=False, safe_mode=False,
+                custom_objects={"Orthogonal": tf.keras.initializers.Orthogonal},
             )
         except TypeError:
-            # older TF/Keras without safe_mode kw: retry without it
+            # backoff for older TF wheels
             _LSTM_MODEL = tf.keras.models.load_model(
-                "lstm_model.keras",
-                compile=False,
+                LSTM_KERAS, compile=False,
                 custom_objects={"Orthogonal": tf.keras.initializers.Orthogonal},
             )
 
@@ -172,7 +147,6 @@ def _maybe_load_lstm(required: bool = False) -> bool:
             _LSTM_META["feature_range"] = [0.0, 1.0]
 
         return True
-
     except Exception as e:
         if required:
             raise RuntimeError(f"LSTM load failed: {e}")
@@ -180,118 +154,96 @@ def _maybe_load_lstm(required: bool = False) -> bool:
         _LSTM_MODEL, _LSTM_META = None, None
         return False
 
-def _scale(x, xmin, xmax):
-    denom = (xmax - xmin) if (xmax - xmin) != 0 else 1.0
-    return (x - xmin) / denom
+def _minmax_scale_1d(x: np.ndarray, vmin: float, vmax: float, fr_low: float, fr_high: float) -> np.ndarray:
+    x = np.asarray(x, dtype="float32").reshape(-1,)
+    denom = (vmax - vmin) if vmax != vmin else 1.0
+    return (x - vmin) / denom * (fr_high - fr_low) + fr_low
 
-def _unscale(x, xmin, xmax):
-    return x * (xmax - xmin) + xmin
+def _minmax_unscale_1d(z: np.ndarray, vmin: float, vmax: float, fr_low: float, fr_high: float) -> np.ndarray:
+    z = np.asarray(z, dtype="float32").reshape(-1,)
+    return ((z - fr_low) / (fr_high - fr_low)) * (vmax - vmin) + vmin
 
-def _seq(data_1d: np.ndarray, L: int):
-    X, y = [], []
-    for i in range(L, len(data_1d)):
-        X.append(data_1d[i-L:i])
-        y.append(data_1d[i])
-    X = np.asarray(X)[..., None]   # (N, L, 1)
-    y = np.asarray(y)
-    return X, y
-
-def lstm_roll_eval_and_forecast(close_train: pd.Series, close_test: pd.Series, horizon: int):
+def _make_lstm_input(last_close_series: pd.Series, lookback: int, meta: dict) -> np.ndarray:
     """
-    Use the fixed pre-trained LSTM:
-      (1) fair 1-step-ahead evaluation across TEST
-      (2) recursive forecast for 'horizon' steps
+    Create a strict (1, lookback, 1) float32 input from the most recent closes.
     """
-    # MUST be loaded; raise if not
-    _maybe_load_lstm(required=True)
-
-    import tensorflow as tf  # assured by requirements
-    model = _LSTM_MODEL
-    L      = int(_LSTM_META["lookback"])
-    xmin   = float(_LSTM_META["train_min"])
-    xmax   = float(_LSTM_META["train_max"])
-
-    # Scale with training min/max
-    train_vals = close_train.values.astype("float32")
-    test_vals  = close_test.values.astype("float32")
-
-    if len(train_vals) < L:
-        raise RuntimeError(
-            f"Not enough history for LSTM lookback L={L}. "
-            f"Increase 'How much history?' so train length ≥ {L}."
-        )
-
-    train_s = _scale(train_vals, xmin, xmax)
-    test_s  = _scale(test_vals,  xmin, xmax)
-
-    # Build windows over train+test to start test windows with exactly L prior points
-    all_scaled = np.concatenate([train_s, test_s], axis=0)
-    X_all, y_all = _seq(all_scaled, L)
-
-    test_start_idx = len(train_s) - L
-    if test_start_idx < 0:
-        raise RuntimeError(
-            f"Not enough history for LSTM lookback L={L}. "
-            f"Increase 'How much history?' so train length ≥ {L}."
-        )
-
-    X_test = X_all[test_start_idx : test_start_idx + len(test_s)]
-    y_test = y_all[test_start_idx : test_start_idx + len(test_s)]
-
-    # Predict test
-    y_pred_scaled = model.predict(X_test, verbose=0).reshape(-1)
-    y_true = _unscale(y_test, xmin, xmax)
-    y_pred = _unscale(y_pred_scaled, xmin, xmax)
-
-    # Recursive future forecast using last L points from all history
-    hist_vals = np.concatenate([train_vals, test_vals], axis=0)
-    hist_scaled = _scale(hist_vals, xmin, xmax)
-    window = hist_scaled[-L:].copy()
-
-    fut = []
-    for _ in range(horizon):
-        x = window.reshape(1, L, 1)
-        yhat_s = model.predict(x, verbose=0).reshape(-1)[0]
-        fut.append(_unscale(yhat_s, xmin, xmax))
-        window = np.concatenate([window[1:], [yhat_s]], axis=0)  # roll in scaled space
+    closes = np.asarray(last_close_series.values, dtype="float32").reshape(-1,)
+    if len(closes) < lookback:
+        raise ValueError(f"Not enough history for LSTM: need {lookback}, have {len(closes)}.")
+    window = closes[-lookback:]
+    fr_low, fr_high = map(float, meta.get("feature_range", [0.0, 1.0]))
+    vmin, vmax = float(meta["train_min"]), float(meta["train_max"])
+    win_scaled = _minmax_scale_1d(window, vmin, vmax, fr_low, fr_high).reshape(lookback, 1)
+    x = np.asarray(win_scaled, dtype="float32").reshape(1, lookback, 1)
+    return x
+
+def lstm_roll_eval_and_forecast(train_s: pd.Series, test_s: pd.Series, horizon_days: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Rolling 1-step evaluation on test; then multi-step forecast from all history.
+    Returns (y_true, y_pred, future_forecast).
+    """
+    global _LSTM_MODEL, _LSTM_META
+    model, meta = _LSTM_MODEL, _LSTM_META
+    lookback = int(meta["lookback"])
+    fr_low, fr_high = map(float, meta.get("feature_range", [0.0, 1.0]))
+    vmin, vmax = float(meta["train_min"]), float(meta["train_max"])
 
-    return y_true, y_pred, np.asarray(fut)
+    if len(train_s) < lookback:
+        raise ValueError(f"LSTM lookback={lookback} exceeds training length={len(train_s)}. Increase 'Years'.")
 
-# -------------------------
-# Metrics / formatting / plotting
-# -------------------------
+    # ---- Rolling eval
+    full_hist = train_s.copy()
+    preds, trues = [], []
+    for i in range(len(test_s)):
+        x = _make_lstm_input(full_hist, lookback, meta)
+        yhat_scaled = model.predict(x, verbose=0).reshape(-1)[0]
+        yhat = _minmax_unscale_1d([yhat_scaled], vmin, vmax, fr_low, fr_high)[0]
+        preds.append(float(yhat))
+        trues.append(float(test_s.iloc[i]))
+        full_hist = pd.concat([full_hist, test_s.iloc[i:i+1]])
+
+    # ---- Multi-step future
+    hist_for_fc = pd.concat([train_s, test_s])
+    future_preds = []
+    hist_values = hist_for_fc.copy()
+    for _ in range(int(horizon_days)):
+        x = _make_lstm_input(hist_values, lookback, meta)
+        yhat_scaled = model.predict(x, verbose=0).reshape(-1)[0]
+        yhat = _minmax_unscale_1d([yhat_scaled], vmin, vmax, fr_low, fr_high)[0]
+        future_preds.append(float(yhat))
+        next_idx = hist_values.index[-1] + BDay(1)
+        hist_values.loc[next_idx] = yhat
+
+    return np.array(trues), np.array(preds), np.array(future_preds)
+
+# =========================
+# Metrics & formatting
+# =========================
 def metrics_df(y_true, y_pred) -> pd.DataFrame:
     rmse = math.sqrt(mean_squared_error(y_true, y_pred))
     mae  = mean_absolute_error(y_true, y_pred)
     mape = mean_absolute_percentage_error(y_true, y_pred) * 100
-    return pd.DataFrame({"RMSE": [rmse], "MAE": [mae], "MAPE (%)": [mape]})
+    return pd.DataFrame({"RMSE":[rmse], "MAE":[mae], "MAPE (%)":[mape]})
 
-def format_prices_df(df: pd.DataFrame, date_col: str, value_col: str, value_label: str):
+def format_prices_df(df: pd.DataFrame, date_col: str, value_col: str, label: str) -> pd.DataFrame:
     dates_str = pd.Index(df[date_col]).astype(str)
     vals = np.asarray(df[value_col]).reshape(-1,)
-    return pd.DataFrame({"Date": dates_str, value_label: np.round(vals, 2)})
+    return pd.DataFrame({"Date": dates_str, label: np.round(vals, 2)})
 
-def make_chart(hist_df: pd.DataFrame,
-               arima_fut: pd.DataFrame | None,
-               lstm_fut: pd.DataFrame | None):
+def make_chart(hist_df: pd.DataFrame, fut_df: pd.DataFrame):
     try:
         h = hist_df.copy()
+        f = fut_df.copy()
         h['Date'] = pd.to_datetime(h['Date'])
+        f['Date'] = pd.to_datetime(f['Date'])
         h_last = h.iloc[-252:] if len(h) > 252 else h
 
-        fig, ax = plt.subplots(figsize=( nine := 9, four := 4))
+        fig, ax = plt.subplots(figsize=(9, 4))
         ax.plot(h_last['Date'], h_last['Close ($)'], label="Historical Close", linewidth=2)
-
-        if arima_fut is not None and not arima_fut.empty:
-            f = arima_fut.copy()
-            f['Date'] = pd.to_datetime(f['Date'])
-            ax.plot(f['Date'], f['Forecast ($)'], label="ARIMA Forecast", linewidth=2)
-
-        if lstm_fut is not None and not lstm_fut.empty:
-            lf = lstm_fut.copy()
-            lf['Date'] = pd.to_datetime(lf['Date'])
-            ax.plot(lf['Date'], lf['Forecast ($)'], label="LSTM Forecast", linewidth=2, linestyle="--")
-
+        if "Forecast ($) (ARIMA)" in f.columns:
+            ax.plot(f['Date'], f['Forecast ($) (ARIMA)'], label="ARIMA Forecast", linewidth=2)
+        if "Forecast ($) (LSTM)" in f.columns:
+            ax.plot(f['Date'], f['Forecast ($) (LSTM)'], label="LSTM Forecast", linewidth=2)
         ax.set_title("Price (last ~1 year) + next forecasts")
         ax.set_xlabel("Date"); ax.set_ylabel("USD ($)")
         ax.grid(True, alpha=0.3); ax.legend()
@@ -301,132 +253,144 @@ def make_chart(hist_df: pd.DataFrame,
         print(f"[WARN] chart error: {e}")
         return None
 
-# -------------------------
-# Gradio callback
-# -------------------------
+# =========================
+# Main forecast callback
+# =========================
+POPULAR = ["AAPL","MSFT","GOOGL","AMZN","TSLA","NVDA","META"]
+
 def do_forecast(ticker_choice: str, years_back: int, horizon_days: int):
     """
-    Returns:
-      - Historical table
-      - Future ARIMA forecast table
-      - KPI markdown (ARIMA + LSTM)
-      - Chart (ARIMA + LSTM)
-      - Comparison table (ARIMA vs LSTM)
+    Returns: historical table, future table, KPI markdown, chart
     """
     try:
-        # Require LSTM to be present & loadable (will raise otherwise)
-        _maybe_load_lstm(required=REQUIRE_LSTM)
-
-        ticker = (ticker_choice or "").strip().upper()
+        ticker = ticker_choice.strip().upper()
         end = datetime.utcnow().date()
         start = end - timedelta(days=int(years_back * 365.25))
 
         df = fetch_data(ticker, start.isoformat(), end.isoformat())
-        if len(df) < 80:
-            raise RuntimeError("Not enough data to evaluate. Increase 'How much history?'.")
-
-        order = load_arima_order(default=(2, 1, 2))
         split_idx = int(len(df) * 0.8)
 
-        # ---------- ARIMA ----------
+        # ----------
+        # ARIMA
+        # ----------
+        order = extract_order_from_pickle(default_order=(2,1,2))
         train_s, test_s = df['Close'][:split_idx], df['Close'][split_idx:]
-        y_true_a, y_pred_a = arima_roll_single_fit(train_s, test_s, order=order)
-        ar_tbl = metrics_df(y_true_a, y_pred_a)
-        fut_ar = arima_future_forecast(df['Close'], order, horizon_days)
 
-        # Tables for UI (ARIMA)
-        hist = pd.DataFrame({"date": pd.Index(df.index).astype(str),
-                             "close": np.asarray(df['Close']).reshape(-1,)})
-        future_dates = pd.bdate_range(df.index[-1] + BDay(1), periods=horizon_days)
-        fut_ar_df = pd.DataFrame({"date": pd.Index(future_dates).astype(str),
-                                  "forecast": fut_ar})
-        hist_out = format_prices_df(hist, "date", "close", "Close ($)")
-        fut_ar_out = format_prices_df(fut_ar_df, "date", "forecast", "Forecast ($)")
+        ar_true, ar_pred = arima_roll_single_fit(train_s, test_s, order=order)
+        ar_tbl = metrics_df(ar_true, ar_pred)
 
-        # ---------- LSTM (REQUIRED) ----------
+        fitted = ARIMA(df['Close'], order=order,
+                       enforce_stationarity=False, enforce_invertibility=False).fit()
+        fc = fitted.get_forecast(steps=horizon_days)
+        arima_future = np.asarray(fc.predicted_mean).reshape(-1,)
+
+        # ----------
+        # LSTM (required)
+        # ----------
+        _maybe_load_lstm(required=REQUIRE_LSTM)
         lstm_true, lstm_pred, fut_lstm = lstm_roll_eval_and_forecast(train_s, test_s, horizon_days)
         lstm_tbl = metrics_df(lstm_true, lstm_pred)
 
-        fut_lstm_df = pd.DataFrame({"date": pd.Index(future_dates).astype(str),
-                                    "forecast": fut_lstm.reshape(-1,)})
-        fut_lstm_out = format_prices_df(fut_lstm_df, "date", "forecast", "Forecast ($)")
+        # ----------
+        # Tables (safe types)
+        # ----------
+        hist = pd.DataFrame({
+            "date": pd.Index(df.index).astype(str),
+            "close": np.asarray(df['Close']).reshape(-1,)
+        })
+        future_dates = pd.bdate_range(df.index[-1] + BDay(1), periods=horizon_days)
+        fut = pd.DataFrame({
+            "date": pd.Index(future_dates).astype(str),
+            "arima": np.asarray(arima_future).reshape(-1,),
+            "lstm":  np.asarray(fut_lstm).reshape(-1,)
+        })
 
-        # Comparison table
-        comp_tbl = pd.DataFrame({
-            "Model": ["ARIMA", "LSTM"],
-            "RMSE": [ar_tbl["RMSE"][0], lstm_tbl["RMSE"][0]],
-            "MAE": [ar_tbl["MAE"][0],  lstm_tbl["MAE"][0]],
-            "MAPE (%)": [ar_tbl["MAPE (%)"][0], lstm_tbl["MAPE (%)"][0]],
-        }).round(3)
+        hist_out = format_prices_df(hist, "date", "close", "Close ($)")
+        fut_out  = format_prices_df(fut.rename(columns={"arima":"forecast"}), "date", "forecast", "Forecast ($) (ARIMA)")
+        fut_out["Forecast ($) (LSTM)"] = np.round(fut["lstm"].values, 2)
 
-        # KPI text
+        # ----------
+        # KPI summary
+        # ----------
         kpi = (
-            f"**ARIMA {order}** | Test RMSE ≈ {ar_tbl['RMSE'][0]:.2f}, "
-            f"MAE ≈ {ar_tbl['MAE'][0]:.2f}, MAPE ≈ {ar_tbl['MAPE (%)'][0]:.2f}%  "
-            f"| **Ticker:** {ticker}  |  **Forecast days:** {horizon_days}\n"
-            f"**LSTM** | Test RMSE ≈ {lstm_tbl['RMSE'][0]:.2f}, "
-            f"MAE ≈ {lstm_tbl['MAE'][0]:.2f}, MAPE ≈ {lstm_tbl['MAPE (%)'][0]:.2f}%"
+            f"**Ticker:** {ticker}  |  **Horizon:** {horizon_days} business days  \n"
+            f"**ARIMA {order}** — RMSE: {ar_tbl['RMSE'][0]:.2f} | MAE: {ar_tbl['MAE'][0]:.2f} | MAPE: {ar_tbl['MAPE (%)'][0]:.2f}%  \n"
+            f"**LSTM (lookback={_LSTM_META['lookback']})** — RMSE: {lstm_tbl['RMSE'][0]:.2f} | MAE: {lstm_tbl['MAE'][0]:.2f} | MAPE: {lstm_tbl['MAPE (%)'][0]:.2f}%"
         )
 
-        # Chart overlay
-        fig = make_chart(hist_out, fut_ar_out, fut_lstm_out)
+        # ----------
+        # Chart
+        # ----------
+        chart = make_chart(hist_out, fut_out)
 
-        return hist_out, fut_ar_out, kpi, fig, comp_tbl
+        return hist_out, fut_out, kpi, chart
 
     except Exception as e:
         traceback.print_exc()
         err = f"❌ {str(e)}"
-        empty = pd.DataFrame()
-        # Return an error message in KPI area so users immediately see what's wrong
-        return empty, empty, err, None, pd.DataFrame()
-
-# -------------------------
-# UI (simple & clear)
-# -------------------------
-POPULAR = ["AAPL", "MSFT", "GOOGL", "AMZN", "TSLA", "NVDA", "META"]
+        return pd.DataFrame(), pd.DataFrame(), err, None
 
+# =========================
+# UI
+# =========================
 with gr.Blocks(title="DataSynthis_ML_JobTask", theme=gr.themes.Soft()) as demo:
     gr.Markdown(
         """
-        # DataSynthis_ML_JobTask — Stock Forecasts (ARIMA + LSTM)
-        **What it does:** Downloads recent daily prices, evaluates ARIMA and LSTM fairly,
-        and predicts the next trading days.  
-        **How to use:** Pick a stock, choose how many years of history and how far ahead to forecast, then press **Run Forecast**.
+        # DataSynthis_ML_JobTask — Stock Forecasts (Simple & Clear)
+        **What it does:** Downloads recent daily prices, evaluates two models fairly (ARIMA & LSTM),
+        and predicts the next trading days.
+
+        **How to use:**  
+        1) Pick a stock.  
+        2) Choose how many years of history to learn from.  
+        3) Choose how many **trading days** to forecast.  
+        4) Press **Run Forecast**.
         """
     )
 
-    with gr.Tab("Forecast"):
-        with gr.Row():
-            ticker_choice = gr.Dropdown(
-                choices=POPULAR, value="AAPL",
-                label="Choose a popular stock",
-                info="Pick one from the list."
-            )
-
-        with gr.Row():
-            years = gr.Slider(
-                1, 15, value=5, step=1, label="How much history?",
-                info="We pull this many *years* of past daily prices."
-            )
-            horizon = gr.Slider(
-                1, 30, value=5, step=1, label="How many days to predict?",
-                info="Business days only (markets closed on weekends/holidays)."
-            )
-
-        run_btn = gr.Button("Run Forecast", variant="primary")
+    with gr.Row():
+        ticker_choice = gr.Dropdown(
+            choices=POPULAR, value="AAPL", label="Choose a stock",
+            info="Use the dropdown to pick a symbol."
+        )
 
-        gr.Markdown("### Results")
-        kpi = gr.Markdown(label="Model summary", value="")
-        chart = gr.Plot(label="Chart (last year + forecast)")
-        with gr.Accordion("Tables (click to expand)", open=False):
-            hist_df = gr.Dataframe(label="Historical Prices", wrap=True, interactive=False)
-            fut_df  = gr.Dataframe(label="Future Forecasts (ARIMA)", wrap=True, interactive=False)
-            comp_df = gr.Dataframe(label="Score Comparison (ARIMA vs LSTM)", wrap=True, interactive=False)
+    with gr.Row():
+        years  = gr.Slider(1, 15, value=5, step=1, label="How much history (years)?",
+                           info="We pull this many years of past daily prices.")
+        horizon = gr.Slider(1, 30, value=5, step=1, label="How many days to predict?",
+                            info="Business days only (markets closed on weekends/holidays).")
+
+    run_btn = gr.Button("Run Forecast", variant="primary")
+
+    gr.Markdown("### Results")
+    kpi = gr.Markdown(label="Model summary (lower = better)", value="")
+    chart = gr.Plot(label="Chart (last year + forecasts)")
+    with gr.Accordion("Tables (click to expand)", open=False):
+        hist_df = gr.Dataframe(label="Historical Prices", wrap=True, interactive=False)
+        fut_df  = gr.Dataframe(label="Future Forecasts", wrap=True, interactive=False)
+
+    run_btn.click(
+        do_forecast,
+        inputs=[ticker_choice, years, horizon],
+        outputs=[hist_df, fut_df, kpi, chart]
+    )
 
-        run_btn.click(
-            do_forecast,
-            inputs=[ticker_choice, years, horizon],
-            outputs=[hist_df, fut_df, kpi, chart, comp_df]
+    with gr.Tab("Help & Glossary"):
+        gr.Markdown(
+            """
+            ### Terms
+            - **Ticker**: Stock symbol, e.g., `AAPL` for Apple.
+            - **Years**: How far back we look to learn from history.
+            - **Forecast horizon**: How many **trading days** we predict.
+            - **ARIMA (p, d, q)**: Model settings that control how it uses past levels and past changes.
+            - **LSTM lookback**: How many past days the neural net reads each time it predicts.
+            - **RMSE / MAE**: Average error sizes in dollars (smaller is better).
+            - **MAPE**: Average percentage error (smaller is better).
+
+            ### Fair evaluation
+            We split the data into **train** (older) and **test** (recent).  
+            Each model predicts **one day ahead** across the test period, always using only the information available up to that day.
+            """
         )
 
 demo.launch()