Update app.py

app.py

@@ -1,4 +1,5 @@
-# app.py — DataSynthis_ML_JobTask (ARIMA + LSTM, fixed date window)
+# app.py — DataSynthis_ML_JobTask
+# Evaluate pretrained ARIMA + LSTM on a user-picked historical window inside 2020-10-03..2025-10-03
 
 import os, math, json, pickle, traceback
 from typing import Tuple
@@ -15,38 +16,42 @@ from statsmodels.tsa.arima.model import ARIMA
 from sklearn.metrics import mean_squared_error, mean_absolute_error, mean_absolute_percentage_error
 
 # -------------------------
-# Fixed historical window (for fair evaluation)
+# Historical universe bounds (DO NOT change)
 # -------------------------
-START_DATE_STR = "2020-10-03"
-END_DATE_STR   = "2025-10-03"
-START_DATE = datetime.strptime(START_DATE_STR, "%Y-%m-%d").date()
-END_DATE   = datetime.strptime(END_DATE_STR,   "%Y-%m-%d").date()
+UNIVERSE_START = date(2020, 10, 3)
+UNIVERSE_END   = date(2025, 10, 3)
 
 # -------------------------
-# Required artifact paths
+# Artifact paths (must exist)
 # -------------------------
-ARIMA_PKL   = "arima_model.pkl"   # used only to read (p,d,q) if possible
-LSTM_KERAS  = "lstm_model.keras"  # Keras 3 native format
-LSTM_INFO_1 = "lstm_info.json"    # metadata (lookback, train_min, train_max, feature_range)
+ARIMA_PKL   = "arima_model.pkl"      # only to read (p,d,q) back
+LSTM_KERAS  = "lstm_model.keras"     # Keras 3 native format
+LSTM_INFO_1 = "lstm_info.json"       # scaler/meta
 LSTM_INFO_2 = "lstm_model/info.json"
 
-REQUIRE_LSTM = True  # make LSTM mandatory
+REQUIRE_LSTM = True  # enforce LSTM presence
 
-# globals (lazy-loaded)
+# lazy globals
 _LSTM_MODEL = None
 _LSTM_META  = None
 
+POPULAR = ["AAPL","MSFT","GOOGL","AMZN","TSLA","NVDA","META","NFLX","IBM","ORCL"]
+
 # =========================
 # Data utilities
 # =========================
-def fetch_data(ticker: str, start: date, end: date) -> pd.DataFrame:
-    """Download daily data in the fixed window, business-day freq, forward-fill."""
+def fetch_universe_data(ticker: str) -> pd.DataFrame:
+    """Download daily close for the fixed universe, B-day freq, forward-fill."""
     df = yf.download(
-        ticker, start=start.isoformat(), end=end.isoformat(),
-        interval="1d", auto_adjust=True, progress=False
+        ticker,
+        start=UNIVERSE_START.isoformat(),
+        end=UNIVERSE_END.isoformat(),
+        interval="1d",
+        auto_adjust=True,
+        progress=False,
     )
     if df is None or df.empty:
-        raise ValueError(f"No data returned for '{ticker}' in {start}..{end}.")
+        raise ValueError(f"No data returned for '{ticker}' within the universe window.")
     df = df[['Close']].copy()
     if df.index.tz is not None:
         df.index = df.index.tz_convert(None)
@@ -54,8 +59,41 @@ def fetch_data(ticker: str, start: date, end: date) -> pd.DataFrame:
     df['Close'] = df['Close'].ffill()
     return df
 
+def clip_to_universe(d: date) -> date:
+    return min(max(d, UNIVERSE_START), UNIVERSE_END)
+
+def build_train_test_for_window(df: pd.DataFrame, start_sel: date, end_sel: date):
+    """
+    Train = all history strictly before start_sel (business days).
+    Test  = start_sel..end_sel inclusive (business days).
+    """
+    # ensure B-day indexes exist
+    idx = df.index
+    # align selection to nearest business days inside universe
+    start_sel = clip_to_universe(start_sel)
+    end_sel   = clip_to_universe(end_sel)
+    if start_sel > end_sel:
+        raise ValueError("Selected start date must be <= end date.")
+
+    # Slice by label (dates) safely
+    train_mask = idx < pd.Timestamp(start_sel)
+    test_mask  = (idx >= pd.Timestamp(start_sel)) & (idx <= pd.Timestamp(end_sel))
+
+    train_s = df.loc[train_mask, 'Close']
+    test_s  = df.loc[test_mask,  'Close']
+
+    if len(test_s) < 5:
+        raise ValueError("Selected test window is too short. Pick a wider evaluation window.")
+    if len(train_s) < 40:
+        raise ValueError("Not enough training history before the selected start date.")
+
+    return train_s, test_s
+
+# =========================
+# ARIMA helpers
+# =========================
 def extract_order_from_pickle(default_order=(2,1,2)) -> Tuple[int, int, int]:
-    """Try to read (p,d,q) from your saved ARIMA pickle; fallback to default."""
+    """Read (p,d,q) from your saved ARIMA pickle if possible; fallback to default."""
     try:
         if os.path.exists(ARIMA_PKL):
             with open(ARIMA_PKL, "rb") as f:
@@ -69,21 +107,18 @@ def extract_order_from_pickle(default_order=(2,1,2)) -> Tuple[int, int, int]:
         print(f"[WARN] Could not read order from pickle: {e}")
     return default_order
 
-# =========================
-# ARIMA helpers
-# =========================
-def arima_roll_single_fit(train_s: pd.Series, test_s: pd.Series, order=(2,1,2)):
-    """Fit once on TRAIN, roll 1-step across TEST, updating state each step."""
+def arima_roll_eval(train_s: pd.Series, test_s: pd.Series, order=(2,1,2)):
+    """Fit once on TRAIN, then roll 1-step across TEST, updating state each step."""
     res = ARIMA(train_s, order=order,
                 enforce_stationarity=False, enforce_invertibility=False).fit()
     preds, trues = [], []
     for i in range(len(test_s)):
         fcast = res.forecast(1)
-        fval = float(np.asarray(fcast).reshape(-1)[0])  # robust scalar
+        fval = float(np.asarray(fcast).reshape(-1)[0])  # robust scalar, avoids FutureWarning
         preds.append(fval)
         trues.append(float(test_s.iloc[i]))
         try:
-            res = res.append(test_s.iloc[i:i+1])  # update internal state
+            res = res.append(test_s.iloc[i:i+1])  # update state with the realized value
         except Exception:
             res = ARIMA(pd.concat([train_s, test_s.iloc[:i+1]]), order=order,
                         enforce_stationarity=False, enforce_invertibility=False).fit()
@@ -93,7 +128,7 @@ def arima_roll_single_fit(train_s: pd.Series, test_s: pd.Series, order=(2,1,2)):
 # LSTM helpers
 # =========================
 def _maybe_load_lstm(required: bool = False) -> bool:
-    """Load LSTM model + metadata with robust compatibility."""
+    """Load LSTM model + metadata with robust compatibility across TF/Keras builds."""
     global _LSTM_MODEL, _LSTM_META
     if _LSTM_MODEL is not None and _LSTM_META is not None:
         return True
@@ -104,11 +139,9 @@ def _maybe_load_lstm(required: bool = False) -> bool:
         missing.append(LSTM_KERAS)
     if info_path is None:
         missing.append("lstm_info.json")
-
     if missing:
         msg = "LSTM artifacts missing: " + ", ".join(missing)
-        if required:
-            raise RuntimeError(msg)
+        if required: raise RuntimeError(msg)
         print("[WARN]", msg)
         return False
 
@@ -124,20 +157,16 @@ def _maybe_load_lstm(required: bool = False) -> bool:
                 LSTM_KERAS, compile=False,
                 custom_objects={"Orthogonal": tf.keras.initializers.Orthogonal},
             )
-
         with open(info_path, "r") as f:
             _LSTM_META = json.load(f)
-
         for k in ("lookback", "train_min", "train_max"):
             if k not in _LSTM_META:
                 raise RuntimeError(f"Missing key '{k}' in {info_path}")
         if "feature_range" not in _LSTM_META:
             _LSTM_META["feature_range"] = [0.0, 1.0]
         return True
-
     except Exception as e:
-        if required:
-            raise RuntimeError(f"LSTM load failed: {e}")
+        if required: raise RuntimeError(f"LSTM load failed: {e}")
         print(f"[WARN] LSTM load failed: {e}")
         _LSTM_MODEL, _LSTM_META = None, None
         return False
@@ -161,15 +190,14 @@ def _make_lstm_input(last_close_series: pd.Series, lookback: int, meta: dict) ->
     win_scaled = _minmax_scale_1d(window, vmin, vmax, fr_low, fr_high).reshape(lookback, 1)
     return np.asarray(win_scaled, dtype="float32").reshape(1, lookback, 1)
 
-def lstm_roll_eval_and_forecast(train_s: pd.Series, test_s: pd.Series, horizon_days: int):
-    """Rolling 1-step evaluation on TEST; then multi-step forecast beyond END_DATE."""
+def lstm_roll_eval(train_s: pd.Series, test_s: pd.Series):
+    """Rolling 1-step evaluation across the TEST window."""
     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"])
 
-    # rolling eval
     full_hist = train_s.copy()
     preds, trues = [], []
     for i in range(len(test_s)):
@@ -178,21 +206,10 @@ def lstm_roll_eval_and_forecast(train_s: pd.Series, test_s: pd.Series, horizon_d
         yhat = _minmax_unscale_1d([yhat_scaled], vmin, vmax, fr_low, fr_high)[0]
         preds.append(float(yhat))
         trues.append(float(test_s.iloc[i]))
+        # update history with the REAL observed value (fair evaluation)
         full_hist = pd.concat([full_hist, test_s.iloc[i:i+1]])
 
-    # multi-step future starting after END_DATE (not evaluated)
-    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)
+    return np.array(trues), np.array(preds)
 
 # =========================
 # Metrics & formatting
@@ -203,106 +220,85 @@ def metrics_df(y_true, y_pred) -> pd.DataFrame:
     mape = mean_absolute_percentage_error(y_true, y_pred) * 100
     return pd.DataFrame({"RMSE":[rmse], "MAE":[mae], "MAPE (%)":[mape]})
 
-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, label: np.round(vals, 2)})
-
-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=(9, 4))
-        ax.plot(h_last['Date'], h_last['Close ($)'], label="Historical Close", linewidth=2)
-        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 (fixed history) + next forecasts (not evaluated)")
-        ax.set_xlabel("Date"); ax.set_ylabel("USD ($)")
-        ax.grid(True, alpha=0.3); ax.legend()
-        fig.tight_layout()
-        return fig
-    except Exception as e:
-        print(f"[WARN] chart error: {e}")
-        return None
+def plot_series(dates, actual, pred, title):
+    fig, ax = plt.subplots(figsize=(9, 4))
+    ax.plot(dates, actual, label="Actual", linewidth=2)
+    ax.plot(dates, pred,   label="Prediction", linewidth=2)
+    ax.set_title(title)
+    ax.set_xlabel("Date"); ax.set_ylabel("USD ($)")
+    ax.grid(True, alpha=0.3); ax.legend()
+    fig.tight_layout()
+    return fig
 
 # =========================
-# Main forecast callback
+# Main callback
 # =========================
-POPULAR = ["AAPL","MSFT","GOOGL","AMZN","TSLA","NVDA","META"]
-
-def do_forecast(ticker_choice: str, horizon_days: int):
+def run_evaluation(ticker_choice: str, start_sel: str, end_sel: str):
     """
-    Returns: historical table (fixed window), future table (beyond END_DATE),
-             KPI markdown (evaluation only inside fixed window), chart.
+    Evaluate pretrained ARIMA + LSTM on [start_sel, end_sel] inside the fixed universe.
+    Show metrics, two plots, and table (Date, Actual, ARIMA, LSTM).
     """
     try:
         ticker = ticker_choice.strip().upper()
+        if not ticker:
+            raise ValueError("Please choose a stock.")
+
+        # Parse user-selected dates and clip to universe
+        s_sel = clip_to_universe(datetime.strptime(start_sel, "%Y-%m-%d").date())
+        e_sel = clip_to_universe(datetime.strptime(end_sel,   "%Y-%m-%d").date())
+        if s_sel > e_sel:
+            raise ValueError("Start date must be before or equal to end date.")
+        # Fetch universe data and build window train/test
+        df = fetch_universe_data(ticker)
+        train_s, test_s = build_train_test_for_window(df, s_sel, e_sel)
+
+        # Ensure LSTM can run (needs lookback history)
+        _maybe_load_lstm(required=REQUIRE_LSTM)
+        lookback = int(_LSTM_META["lookback"])
+        if len(train_s) < lookback:
+            raise ValueError(f"Not enough training history for LSTM lookback={lookback}. "
+                             f"Pick an earlier start date.")
 
-        # Fixed window
-        df = fetch_data(ticker, START_DATE, END_DATE)
-        split_idx = int(len(df) * 0.8)
-
-        # ----------
-        # ARIMA (eval inside fixed window)
-        # ----------
+        # ARIMA
         order = extract_order_from_pickle(default_order=(2,1,2))
-        train_s, test_s = df['Close'][:split_idx], df['Close'][split_idx:]
-        ar_true, ar_pred = arima_roll_single_fit(train_s, test_s, order=order)
+        ar_true, ar_pred = arima_roll_eval(train_s, test_s, order=order)
         ar_tbl = metrics_df(ar_true, ar_pred)
 
-        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; eval inside fixed window)
-        # ----------
-        _maybe_load_lstm(required=REQUIRE_LSTM)
-        lstm_true, lstm_pred, fut_lstm = lstm_roll_eval_and_forecast(train_s, test_s, horizon_days)
+        # LSTM
+        lstm_true, lstm_pred = lstm_roll_eval(train_s, test_s)
         lstm_tbl = metrics_df(lstm_true, lstm_pred)
 
-        # ----------
-        # 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,)
+        # Build aligned outputs
+        dates = pd.Index(test_s.index).astype(str).tolist()
+        actual = np.asarray(test_s.values).reshape(-1,)
+        arima_p = np.asarray(ar_pred).reshape(-1,)
+        lstm_p  = np.asarray(lstm_pred).reshape(-1,)
+
+        table = pd.DataFrame({
+            "Date": dates,
+            "Actual ($)": np.round(actual, 2),
+            "ARIMA ($)":  np.round(arima_p, 2),
+            "LSTM ($)":   np.round(lstm_p,  2),
         })
 
-        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)
+        # Plots
+        fig_arima = plot_series(pd.to_datetime(dates), actual, arima_p,
+                                f"ARIMA {order} — Actual vs Prediction")
+        fig_lstm  = plot_series(pd.to_datetime(dates), actual, lstm_p,
+                                f"LSTM (lookback={lookback}) — Actual vs Prediction")
 
-        # ----------
-        # KPI summary
-        # ----------
+        # KPI Markdown
         kpi = (
-            f"**Window:** {START_DATE_STR} → {END_DATE_STR}  |  **Horizon (not evaluated):** {horizon_days} business days  \n"
-            f"**Ticker:** {ticker}  \n"
+            f"**Ticker:** {ticker}  |  **Window:** {s_sel} → {e_sel}  \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}%"
+            f"**LSTM (lookback={lookback})** — RMSE: {lstm_tbl['RMSE'][0]:.2f} | MAE: {lstm_tbl['MAE'][0]:.2f} | MAPE: {lstm_tbl['MAPE (%)'][0]:.2f}%"
         )
 
-        chart = make_chart(hist_out, fut_out)
-        return hist_out, fut_out, kpi, chart
+        return kpi, fig_arima, fig_lstm, table
 
     except Exception as e:
         traceback.print_exc()
-        err = f"❌ {str(e)}"
-        return pd.DataFrame(), pd.DataFrame(), err, None
+        return f"❌ {str(e)}", None, None, pd.DataFrame()
 
 # =========================
 # UI
@@ -310,49 +306,49 @@ def do_forecast(ticker_choice: str, horizon_days: int):
 with gr.Blocks(title="DataSynthis_ML_JobTask", theme=gr.themes.Soft()) as demo:
     gr.Markdown(
         f"""
-        # DataSynthis_ML_JobTask — Fixed-Window Evaluation (ARIMA & LSTM)
-        **Evaluation window:** **{START_DATE_STR} → {END_DATE_STR}** (historical prices only)  
-        We fairly evaluate both models **inside this fixed history** using rolling 1-day-ahead predictions.  
-        Forecasts **beyond {END_DATE_STR}** are shown for reference but **not scored** (future is unknown in this setup).
+        # DataSynthis_ML_JobTask — ARIMA & LSTM (Historical Window Evaluation)
+        **Universe:** {UNIVERSE_START} → {UNIVERSE_END}  
+        Pick a stock and a date range **inside the universe**. We’ll evaluate both pretrained models using
+        **rolling 1-day-ahead** predictions across that range and show metrics, plots, and a comparison table.
         """
     )
 
     with gr.Row():
-        ticker_choice = gr.Dropdown(
-            choices=POPULAR, value="AAPL", label="Choose a stock",
-            info="Pick a symbol. Data is limited to the fixed evaluation window above."
-        )
-        horizon = gr.Slider(1, 30, value=5, step=1, label="Forecast days (beyond fixed window)",
-                            info="Business days only; not used for evaluation.")
+        ticker_choice = gr.Dropdown(choices=POPULAR, value="AAPL",
+                                    label="Choose a stock")
+    with gr.Row():
+        start_sel = gr.Date(label="Start date (inside universe)", value=str(UNIVERSE_START))
+        end_sel   = gr.Date(label="End date (inside universe)",   value=str(UNIVERSE_END))
 
-    run_btn = gr.Button("Run Forecast", variant="primary")
+    run_btn = gr.Button("Run Evaluation", variant="primary")
 
     gr.Markdown("### Results")
-    kpi = gr.Markdown(label="Model summary (lower = better)", value="")
-    chart = gr.Plot(label="Chart (fixed window + non-evaluated 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 (not evaluated)", wrap=True, interactive=False)
+    kpi = gr.Markdown(label="Model scores (lower = better)", value="")
+    with gr.Row():
+        chart_arima = gr.Plot(label="ARIMA — Actual vs Predicted")
+        chart_lstm  = gr.Plot(label="LSTM — Actual vs Predicted")
+    table = gr.Dataframe(label="Details", interactive=False)
 
     run_btn.click(
-        do_forecast,
-        inputs=[ticker_choice, horizon],
-        outputs=[hist_df, fut_df, kpi, chart]
+        run_evaluation,
+        inputs=[ticker_choice, start_sel, end_sel],
+        outputs=[kpi, chart_arima, chart_lstm, table]
     )
 
-    with gr.Tab("Help & Glossary"):
+    with gr.Tab("Help"):
         gr.Markdown(
             """
-            ### Why fix the dates?
-            To evaluate fairly, we must only use **known history**. We therefore pin the window to fixed dates so
-            every “test day” has a real, known closing price. Any forecast **after** the window is shown for context
-            but **not scored**.
-
-            ### Terms
-            - **ARIMA (p,d,q)**: settings for the statistical model.
-            - **LSTM lookback**: how many past days the neural net reads each time it predicts.
-            - **RMSE / MAE / MAPE**: error metrics (smaller is better).
-            - **Rolling 1-day ahead**: predict tomorrow from information available today, walk forward one day at a time.
+            ### What happens here?
+            - We fetch daily closing prices for your stock within the **fixed universe** (2020-10-03 → 2025-10-03).
+            - For your selected range, we train on all history **before** the start date, then predict **one day ahead** repeatedly
+              across the selected range (fair rolling evaluation).
+            - We do this for **both** models (ARIMA and LSTM) and show the metrics, plots, and a detailed table.
+
+            ### Notes
+            - If the start date is too close to the universe start, LSTM may not have enough history for its lookback.
+              Pick an earlier start or reduce lookback when you train your LSTM.
+            - ARIMA order is read from your saved `arima_model.pkl`.
+            - LSTM scaling/metadata is read from `lstm_info.json` (or `lstm_model/info.json`).
             """
         )