Update app.py

app.py

@@ -1,12 +1,11 @@
-# app.py — DataSynthis_ML_JobTask (ARIMA + LSTM, minimal UI)
+# app.py — DataSynthis_ML_JobTask (ARIMA + LSTM, fixed date window)
 
 import os, math, json, pickle, traceback
-from typing import Tuple, Optional
-
+from typing import Tuple
 import numpy as np
 import pandas as pd
 import yfinance as yf
-from datetime import datetime, timedelta
+from datetime import datetime, date
 from pandas.tseries.offsets import BDay
 
 import gradio as gr
@@ -15,13 +14,21 @@ 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
 
+# -------------------------
+# Fixed historical window (for fair evaluation)
+# -------------------------
+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()
+
 # -------------------------
 # Required artifact paths
 # -------------------------
-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)
+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)
-LSTM_INFO_2 = "lstm_model/info.json"  # alternate path if you saved inside a folder
+LSTM_INFO_2 = "lstm_model/info.json"
 
 REQUIRE_LSTM = True  # make LSTM mandatory
 
@@ -32,11 +39,14 @@ _LSTM_META  = None
 # =========================
 # Data utilities
 # =========================
-def fetch_data(ticker: str, start: str, end: str) -> pd.DataFrame:
-    """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)
+def fetch_data(ticker: str, start: date, end: date) -> pd.DataFrame:
+    """Download daily data in the fixed window, business-day freq, forward-fill."""
+    df = yf.download(
+        ticker, start=start.isoformat(), end=end.isoformat(),
+        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.")
+        raise ValueError(f"No data returned for '{ticker}' in {start}..{end}.")
     df = df[['Close']].copy()
     if df.index.tz is not None:
         df.index = df.index.tz_convert(None)
@@ -45,52 +55,35 @@ def fetch_data(ticker: str, start: str, end: str) -> pd.DataFrame:
     return df
 
 def extract_order_from_pickle(default_order=(2,1,2)) -> Tuple[int, int, int]:
-    """
-    Try to read (p,d,q) from a previously saved ARIMA pickle without importing
-    version-specific internals. If it fails, just return the default.
-    """
+    """Try to read (p,d,q) from your saved ARIMA pickle; fallback to 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}")
+        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)) -> Tuple[np.ndarray, np.ndarray]:
-    """
-    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.
-    """
+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."""
     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)
-        # 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)
+        fval = float(np.asarray(fcast).reshape(-1)[0])  # robust scalar
         preds.append(fval)
-
-        y_true = float(test_s.iloc[i])
-        trues.append(y_true)
-
-        # update internal state or refit on expanded history
+        trues.append(float(test_s.iloc[i]))
         try:
-            res = res.append(test_s.iloc[i:i+1])
+            res = res.append(test_s.iloc[i:i+1])  # update internal state
         except Exception:
             res = ARIMA(pd.concat([train_s, test_s.iloc[:i+1]]), order=order,
                         enforce_stationarity=False, enforce_invertibility=False).fit()
@@ -100,10 +93,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 (lookback, min/max, feature_range).
-    Uses a tolerant loader for Keras 3 + legacy initializers.
-    """
+    """Load LSTM model + metadata with robust compatibility."""
     global _LSTM_MODEL, _LSTM_META
     if _LSTM_MODEL is not None and _LSTM_META is not None:
         return True
@@ -124,14 +114,12 @@ def _maybe_load_lstm(required: bool = False) -> bool:
 
     try:
         import tensorflow as tf
-        # load with custom Orthogonal mapping; safe_mode=False for broader compatibility
         try:
             _LSTM_MODEL = tf.keras.models.load_model(
                 LSTM_KERAS, compile=False, safe_mode=False,
                 custom_objects={"Orthogonal": tf.keras.initializers.Orthogonal},
             )
         except TypeError:
-            # backoff for older TF wheels
             _LSTM_MODEL = tf.keras.models.load_model(
                 LSTM_KERAS, compile=False,
                 custom_objects={"Orthogonal": tf.keras.initializers.Orthogonal},
@@ -145,8 +133,8 @@ def _maybe_load_lstm(required: bool = False) -> bool:
                 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}")
@@ -154,19 +142,16 @@ def _maybe_load_lstm(required: bool = False) -> bool:
         _LSTM_MODEL, _LSTM_META = None, None
         return False
 
-def _minmax_scale_1d(x: np.ndarray, vmin: float, vmax: float, fr_low: float, fr_high: float) -> np.ndarray:
+def _minmax_scale_1d(x, vmin, vmax, fr_low, fr_high):
     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 _minmax_unscale_1d(z: np.ndarray, vmin: float, vmax: float, fr_low: float, fr_high: float) -> np.ndarray:
+def _minmax_unscale_1d(z, vmin, vmax, fr_low, fr_high):
     z = np.asarray(z, dtype="float32").reshape(-1,)
     return ((z - fr_low) / (fr_high - fr_low)) * (vmax - vmin) + vmin
 
 def _make_lstm_input(last_close_series: pd.Series, lookback: int, meta: dict) -> np.ndarray:
-    """
-    Create a strict (1, lookback, 1) float32 input from the most recent closes.
-    """
     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)}.")
@@ -174,24 +159,17 @@ def _make_lstm_input(last_close_series: pd.Series, lookback: int, meta: dict) ->
     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
+    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) -> 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).
-    """
+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."""
     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"])
 
-    if len(train_s) < lookback:
-        raise ValueError(f"LSTM lookback={lookback} exceeds training length={len(train_s)}. Increase 'Years'.")
-
-    # ---- Rolling eval
+    # rolling eval
     full_hist = train_s.copy()
     preds, trues = [], []
     for i in range(len(test_s)):
@@ -202,7 +180,7 @@ def lstm_roll_eval_and_forecast(train_s: pd.Series, test_s: pd.Series, horizon_d
         trues.append(float(test_s.iloc[i]))
         full_hist = pd.concat([full_hist, test_s.iloc[i:i+1]])
 
-    # ---- Multi-step future
+    # 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()
@@ -244,7 +222,7 @@ def make_chart(hist_df: pd.DataFrame, fut_df: pd.DataFrame):
             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_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()
@@ -258,24 +236,23 @@ def make_chart(hist_df: pd.DataFrame, fut_df: pd.DataFrame):
 # =========================
 POPULAR = ["AAPL","MSFT","GOOGL","AMZN","TSLA","NVDA","META"]
 
-def do_forecast(ticker_choice: str, years_back: int, horizon_days: int):
+def do_forecast(ticker_choice: str, horizon_days: int):
     """
-    Returns: historical table, future table, KPI markdown, chart
+    Returns: historical table (fixed window), future table (beyond END_DATE),
+             KPI markdown (evaluation only inside fixed window), chart.
     """
     try:
         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())
+        # Fixed window
+        df = fetch_data(ticker, START_DATE, END_DATE)
         split_idx = int(len(df) * 0.8)
 
         # ----------
-        # ARIMA
+        # ARIMA (eval inside fixed window)
         # ----------
         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_tbl = metrics_df(ar_true, ar_pred)
 
@@ -285,7 +262,7 @@ def do_forecast(ticker_choice: str, years_back: int, horizon_days: int):
         arima_future = np.asarray(fc.predicted_mean).reshape(-1,)
 
         # ----------
-        # LSTM (required)
+        # 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)
@@ -313,16 +290,13 @@ def do_forecast(ticker_choice: str, years_back: int, horizon_days: int):
         # KPI summary
         # ----------
         kpi = (
-            f"**Ticker:** {ticker}  |  **Horizon:** {horizon_days} business days  \n"
+            f"**Window:** {START_DATE_STR} → {END_DATE_STR}  |  **Horizon (not evaluated):** {horizon_days} business days  \n"
+            f"**Ticker:** {ticker}  \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
-        # ----------
         chart = make_chart(hist_out, fut_out)
-
         return hist_out, fut_out, kpi, chart
 
     except Exception as e:
@@ -335,61 +309,50 @@ def do_forecast(ticker_choice: str, years_back: int, horizon_days: int):
 # =========================
 with gr.Blocks(title="DataSynthis_ML_JobTask", theme=gr.themes.Soft()) as demo:
     gr.Markdown(
-        """
-        # 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**.
+        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).
         """
     )
 
     with gr.Row():
         ticker_choice = gr.Dropdown(
             choices=POPULAR, value="AAPL", label="Choose a stock",
-            info="Use the dropdown to pick a symbol."
+            info="Pick a symbol. Data is limited to the fixed evaluation window above."
         )
-
-    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).")
+        horizon = gr.Slider(1, 30, value=5, step=1, label="Forecast days (beyond fixed window)",
+                            info="Business days only; not used for evaluation.")
 
     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)")
+    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", wrap=True, interactive=False)
+        fut_df  = gr.Dataframe(label="Future Forecasts (not evaluated)", wrap=True, interactive=False)
 
     run_btn.click(
         do_forecast,
-        inputs=[ticker_choice, years, horizon],
+        inputs=[ticker_choice, horizon],
         outputs=[hist_df, fut_df, kpi, chart]
     )
 
     with gr.Tab("Help & Glossary"):
         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
-            - **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.
+            - **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.
             """
         )