Spaces:
Sleeping
Sleeping
Download src/streamlit_app.py from EnYa32/StockPriceTimeSeries: direct link, hf CLI and curl.
- Browser
- Download file 8.31 kB
-
https://huggingface.co/spaces/EnYa32/StockPriceTimeSeries/resolve/main/src/streamlit_app.py
- Command line
-
hf download hf://spaces/EnYa32/StockPriceTimeSeries/src/streamlit_app.py
-
curl -L -o streamlit_app.py https://huggingface.co/spaces/EnYa32/StockPriceTimeSeries/resolve/main/src/streamlit_app.py
8.31 kB
| import os | |
| from pathlib import Path | |
| import joblib | |
| import numpy as np | |
| import pandas as pd | |
| import streamlit as st | |
| import matplotlib.pyplot as plt | |
| from sklearn.metrics import mean_absolute_error, mean_squared_error | |
| from tensorflow.keras.models import load_model | |
| st.set_page_config(page_title="Stock LSTM Forecast", page_icon="π", layout="wide") | |
| BASE_DIR = Path(__file__).resolve().parent | |
| TICKERS = ["AAPL", "GOOG", "MSFT", "NFLX"] | |
| FEATURE_COLS = ["Open", "High", "Low", "Close", "Volume"] | |
| def find_file(name_candidates): | |
| for name in name_candidates: | |
| p = BASE_DIR / name | |
| if p.exists(): | |
| return p | |
| return None | |
| def load_artifacts(ticker: str): | |
| model_path = find_file([f"{ticker}_lstm.keras", f"{ticker}_lstm.keras".lower(), f"{ticker}_lstm.keras".upper(), | |
| f"{ticker}_lstm.keras".replace("_", ""), f"{ticker}_lstm.keras"]) | |
| # You used: "AAPL_lstm.keras", "GOOG_lstm.keras" ... | |
| model_path = find_file([f"{ticker}_lstm.keras"]) | |
| x_scaler_path = find_file([f"{ticker}_x_scaler.pkl"]) | |
| y_scaler_path = find_file([f"{ticker}_y_scaler.pkl"]) | |
| if model_path is None or x_scaler_path is None or y_scaler_path is None: | |
| missing = [] | |
| if model_path is None: missing.append(f"{ticker}_lstm.keras") | |
| if x_scaler_path is None: missing.append(f"{ticker}_x_scaler.pkl") | |
| if y_scaler_path is None: missing.append(f"{ticker}_y_scaler.pkl") | |
| raise FileNotFoundError(f"Missing artifacts: {missing}. Make sure they are in the repo root.") | |
| model = load_model(model_path) | |
| x_scaler = joblib.load(x_scaler_path) | |
| y_scaler = joblib.load(y_scaler_path) | |
| return model, x_scaler, y_scaler | |
| def load_data(uploaded_file): | |
| # Default local file | |
| if uploaded_file is None: | |
| default_csv = find_file(["stocks.csv", "stocks"]) | |
| if default_csv is None: | |
| raise FileNotFoundError("No stocks.csv found in repo. Upload a CSV in the sidebar or add stocks.csv to repo root.") | |
| df = pd.read_csv(default_csv) | |
| else: | |
| df = pd.read_csv(uploaded_file) | |
| # Basic cleanup | |
| df.columns = [c.strip() for c in df.columns] | |
| if "Date" not in df.columns or "Ticker" not in df.columns: | |
| raise ValueError("CSV must contain at least columns: Ticker, Date, Open, High, Low, Close, Volume") | |
| df["Date"] = pd.to_datetime(df["Date"]) | |
| df = df.sort_values(["Ticker", "Date"]).reset_index(drop=True) | |
| # Ensure needed columns exist | |
| for c in FEATURE_COLS + ["Adj Close"]: | |
| if c not in df.columns: | |
| # Adj Close is optional; we won't require it | |
| pass | |
| missing_feats = [c for c in FEATURE_COLS if c not in df.columns] | |
| if missing_feats: | |
| raise ValueError(f"Missing required feature columns: {missing_feats}") | |
| return df | |
| def make_sequences(X: np.ndarray, y: np.ndarray, lookback: int): | |
| xs, ys = [], [] | |
| for i in range(lookback, len(X)): | |
| xs.append(X[i - lookback:i]) | |
| ys.append(y[i]) | |
| return np.array(xs), np.array(ys) | |
| def eval_on_test(df_ticker: pd.DataFrame, model, x_scaler, y_scaler, lookback: int, split_ratio: float = 0.8): | |
| X = df_ticker[FEATURE_COLS] | |
| y = df_ticker["Close"] | |
| split = int(len(X) * split_ratio) | |
| X_train = X.iloc[:split] | |
| X_test = X.iloc[split:] | |
| y_train = y.iloc[:split] | |
| y_test = y.iloc[split:] | |
| # Scale (fit on train only) | |
| X_train_s = x_scaler.fit_transform(X_train) | |
| X_test_s = x_scaler.transform(X_test) | |
| y_train_s = y_scaler.fit_transform(y_train.values.reshape(-1, 1)) | |
| y_test_s = y_scaler.transform(y_test.values.reshape(-1, 1)) | |
| # Sequences | |
| X_train_seq, y_train_seq = make_sequences(X_train_s, y_train_s, lookback) | |
| X_test_seq, y_test_seq = make_sequences(X_test_s, y_test_s, lookback) | |
| if len(X_test_seq) == 0: | |
| raise ValueError(f"Not enough test rows to build sequences. " | |
| f"Test rows={len(X_test_s)} must be > LOOKBACK={lookback}. " | |
| f"Try smaller LOOKBACK.") | |
| # Predict | |
| y_pred_s = model.predict(X_test_seq, verbose=0) | |
| # Inverse | |
| y_pred = y_scaler.inverse_transform(y_pred_s).flatten() | |
| y_true = y_scaler.inverse_transform(y_test_seq).flatten() | |
| mae = mean_absolute_error(y_true, y_pred) | |
| rmse = np.sqrt(mean_squared_error(y_true, y_pred)) | |
| return { | |
| "mae": mae, | |
| "rmse": rmse, | |
| "y_true": y_true, | |
| "y_pred": y_pred, | |
| "test_dates": df_ticker["Date"].iloc[split:].reset_index(drop=True).iloc[lookback:].values | |
| } | |
| def next_day_forecast(df_ticker: pd.DataFrame, model, x_scaler, y_scaler, lookback: int): | |
| # Fit scalers on ALL available data for "latest window" inference (common for deployment) | |
| X_all = df_ticker[FEATURE_COLS].values | |
| y_all = df_ticker["Close"].values.reshape(-1, 1) | |
| X_all_s = x_scaler.fit_transform(X_all) | |
| y_all_s = y_scaler.fit_transform(y_all) | |
| if len(X_all_s) < lookback: | |
| raise ValueError(f"Not enough rows for LOOKBACK={lookback}. Need at least {lookback} rows.") | |
| last_window = X_all_s[-lookback:] # (lookback, features) | |
| last_window = np.expand_dims(last_window, axis=0) # (1, lookback, features) | |
| pred_s = model.predict(last_window, verbose=0) | |
| pred = y_scaler.inverse_transform(pred_s).flatten()[0] | |
| last_date = df_ticker["Date"].iloc[-1] | |
| return pred, last_date | |
| # ---------------- UI ---------------- | |
| st.title("π Multivariate Stock Forecasting (LSTM)") | |
| st.caption("Train/test evaluation + next-step forecast for AAPL, GOOG, MSFT, NFLX.") | |
| with st.sidebar: | |
| st.header("Settings") | |
| uploaded = st.file_uploader("Upload CSV (optional)", type=["csv"]) | |
| ticker = st.selectbox("Select Ticker", TICKERS, index=0) | |
| lookback = st.slider("LOOKBACK (timesteps)", min_value=3, max_value=20, value=5, step=1) | |
| split_ratio = st.slider("Train/Test split ratio", 0.6, 0.9, 0.8, 0.05) | |
| run_btn = st.button("Run Forecast") | |
| try: | |
| df = load_data(uploaded) | |
| except Exception as e: | |
| st.error(str(e)) | |
| st.stop() | |
| df_t = df[df["Ticker"] == ticker].copy().sort_values("Date").reset_index(drop=True) | |
| if df_t.empty: | |
| st.error(f"No rows found for ticker: {ticker}") | |
| st.stop() | |
| # Quick preview | |
| c1, c2, c3 = st.columns(3) | |
| c1.metric("Rows", len(df_t)) | |
| c2.metric("Date start", str(df_t["Date"].min().date())) | |
| c3.metric("Date end", str(df_t["Date"].max().date())) | |
| st.subheader("Data preview") | |
| st.dataframe(df_t.head(10), use_container_width=True) | |
| # Load artifacts for selected ticker | |
| try: | |
| model, x_scaler, y_scaler = load_artifacts(ticker) | |
| except Exception as e: | |
| st.error(str(e)) | |
| st.stop() | |
| if run_btn: | |
| st.subheader("Test evaluation (chronological split)") | |
| try: | |
| out = eval_on_test(df_t, model, x_scaler, y_scaler, lookback=lookback, split_ratio=split_ratio) | |
| except Exception as e: | |
| st.error(str(e)) | |
| st.stop() | |
| m1, m2 = st.columns(2) | |
| m1.metric("Test MAE (USD)", f"{out['mae']:.3f}") | |
| m2.metric("Test RMSE (USD)", f"{out['rmse']:.3f}") | |
| # Plot actual vs predicted | |
| fig = plt.figure(figsize=(12, 5)) | |
| plt.plot(out["test_dates"], out["y_true"], label="Actual") | |
| plt.plot(out["test_dates"], out["y_pred"], label="Predicted") | |
| plt.title(f"{ticker} LSTM β Actual vs Predicted Close") | |
| plt.xlabel("Date") | |
| plt.ylabel("Close Price") | |
| plt.legend() | |
| st.pyplot(fig) | |
| # Residuals | |
| resid = out["y_true"] - out["y_pred"] | |
| fig2 = plt.figure(figsize=(12, 4)) | |
| plt.plot(out["test_dates"], resid) | |
| plt.axhline(0, linestyle="--") | |
| plt.title("Residuals (Actual - Predicted)") | |
| plt.xlabel("Date") | |
| plt.ylabel("Error (USD)") | |
| st.pyplot(fig2) | |
| # Error histogram | |
| fig3 = plt.figure(figsize=(7, 4)) | |
| plt.hist(resid, bins=10) | |
| plt.title("Distribution of Prediction Errors") | |
| plt.xlabel("Error (USD)") | |
| plt.ylabel("Frequency") | |
| st.pyplot(fig3) | |
| st.subheader("Next-step forecast (latest window)") | |
| try: | |
| pred_next, last_date = next_day_forecast(df_t, model, x_scaler, y_scaler, lookback=lookback) | |
| st.success(f"Predicted next close after {last_date.date()} for **{ticker}**: **{pred_next:.2f} USD**") | |
| except Exception as e: | |
| st.warning(str(e)) | |
| else: | |
| st.info("Click **Run Forecast** in the sidebar to evaluate and forecast.") |