Spaces:
Sleeping
Sleeping
Download src/streamlit_app.py from EnYa32/PassengersTimeSeries: direct link, hf CLI and curl.
- Browser
- Download file 6.59 kB
-
https://huggingface.co/spaces/EnYa32/PassengersTimeSeries/resolve/main/src/streamlit_app.py
- Command line
-
hf download hf://spaces/EnYa32/PassengersTimeSeries/src/streamlit_app.py
-
curl -L -o streamlit_app.py https://huggingface.co/spaces/EnYa32/PassengersTimeSeries/resolve/main/src/streamlit_app.py
6.59 kB
| import pickle | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| import streamlit as st | |
| import joblib | |
| import matplotlib.pyplot as plt | |
| from tensorflow.keras.models import load_model | |
| # ------------------------- | |
| # Page config | |
| # ------------------------- | |
| st.set_page_config( | |
| page_title="Airline Passengers LSTM Forecast", | |
| page_icon="✈️", | |
| layout="wide" | |
| ) | |
| st.title("✈️ Airline Passengers Forecast (LSTM)") | |
| st.caption("Time Series Forecasting using an LSTM model (train: up to 1958, test: 1959–1960).") | |
| # ------------------------- | |
| # Paths (robust: root or src) | |
| # ------------------------- | |
| BASE_DIR = Path(__file__).resolve().parent | |
| CANDIDATE_DIRS = [BASE_DIR, BASE_DIR / "src"] | |
| def find_file(filename: str) -> Path | None: | |
| for d in CANDIDATE_DIRS: | |
| p = d / filename | |
| if p.exists(): | |
| return p | |
| return None | |
| MODEL_PATH = find_file("lstm_airline_model.keras") | |
| SCALER_PATH = find_file("scaler.pkl") | |
| METRICS_PATH = find_file("metrics.pkl") | |
| DATA_URL = "https://raw.githubusercontent.com/amankharwal/Website-data/master/airline-passengers.csv" | |
| LOOKBACK = 12 # must match training | |
| # ------------------------- | |
| # Load artifacts | |
| # ------------------------- | |
| def load_artifacts(): | |
| if MODEL_PATH is None: | |
| raise FileNotFoundError("Missing model file: lstm_airline_model.keras") | |
| if SCALER_PATH is None: | |
| raise FileNotFoundError("Missing scaler file: scaler.pkl") | |
| model = load_model(MODEL_PATH, compile=False) | |
| scaler = joblib.load(SCALER_PATH) | |
| return model, scaler | |
| # ------------------------- | |
| # Load data | |
| # ------------------------- | |
| def load_data(): | |
| df = pd.read_csv(DATA_URL) | |
| # Standardize | |
| df["Month"] = pd.to_datetime(df["Month"]) | |
| df = df.sort_values("Month").set_index("Month") | |
| df["Passengers"] = df["Passengers"].astype("float32") | |
| return df | |
| def create_sequences(data_2d: np.ndarray, lookback: int = 12): | |
| # data_2d shape: (n, 1) | |
| X = np.array([data_2d[i-lookback:i] for i in range(lookback, len(data_2d))]) | |
| y = data_2d[lookback:] | |
| return X, y | |
| def inverse_safe(scaler, arr_2d: np.ndarray): | |
| # scaler expects 2D | |
| return scaler.inverse_transform(arr_2d) | |
| def rolling_forecast(model, scaler, last_values: np.ndarray, steps: int, lookback: int = 12): | |
| """ | |
| last_values: unscaled original values, shape (lookback, 1) | |
| steps: how many future points to forecast | |
| """ | |
| # scale with the saved scaler | |
| window = scaler.transform(last_values.astype("float32")) | |
| preds_scaled = [] | |
| for _ in range(steps): | |
| x = window.reshape(1, lookback, 1) | |
| pred_scaled = model.predict(x, verbose=0) # shape (1,1) | |
| preds_scaled.append(pred_scaled[0, 0]) | |
| # shift window | |
| window = np.vstack([window[1:], pred_scaled]) | |
| preds_scaled = np.array(preds_scaled).reshape(-1, 1) | |
| preds = inverse_safe(scaler, preds_scaled) | |
| return preds | |
| # ------------------------- | |
| # Sidebar controls | |
| # ------------------------- | |
| st.sidebar.header("Settings") | |
| forecast_steps = st.sidebar.slider("Forecast months into the future", min_value=1, max_value=36, value=12, step=1) | |
| show_metrics = st.sidebar.checkbox("Show saved metrics (metrics.pkl)", value=True) | |
| show_test_plot = st.sidebar.checkbox("Show test forecast plot (1959–1960)", value=True) | |
| show_future_plot = st.sidebar.checkbox("Show future forecast plot", value=True) | |
| # ------------------------- | |
| # Main | |
| # ------------------------- | |
| try: | |
| model, scaler = load_artifacts() | |
| df = load_data() | |
| except Exception as e: | |
| st.error(str(e)) | |
| st.stop() | |
| col1, col2 = st.columns([1.2, 1]) | |
| with col1: | |
| st.subheader("Dataset preview") | |
| st.dataframe(df.head(10), use_container_width=True) | |
| with col2: | |
| st.subheader("Basic info") | |
| st.write(f"Rows: **{len(df)}**") | |
| st.write(f"Date range: **{df.index.min().date()} → {df.index.max().date()}**") | |
| st.write("Lookback window:", f"**{LOOKBACK} months**") | |
| if show_metrics and METRICS_PATH is not None: | |
| st.subheader("Saved metrics") | |
| try: | |
| m = joblib.load(METRICS_PATH) | |
| c1, c2, c3 = st.columns(3) | |
| c1.metric("RMSE", f"{m['rmse']:.2f}") | |
| c2.metric("MAE", f"{m['mae']:.2f}") | |
| c3.metric("MAPE (%)", f"{m['mape']:.2f}") | |
| except Exception as e: | |
| st.info(f"metrics.pkl found but could not be read. ({e})") | |
| st.divider() | |
| # Plot original series | |
| st.subheader("Time series") | |
| fig = plt.figure(figsize=(10, 4)) | |
| plt.plot(df.index, df["Passengers"]) | |
| plt.title("Monthly Airline Passengers (1949–1960)") | |
| plt.xlabel("Date") | |
| plt.ylabel("Passengers") | |
| plt.grid(alpha=0.3) | |
| st.pyplot(fig) | |
| # ------------------------- | |
| # Test forecast (1959–1960) | |
| # ------------------------- | |
| if show_test_plot: | |
| st.subheader("Test forecast (1959–1960)") | |
| # Split exactly like training | |
| train = df.loc[: "1958", ["Passengers"]].values.astype("float32") | |
| test = df.loc["1959":, ["Passengers"]].values.astype("float32") | |
| # Scale with loaded scaler (fitted on train during your training) | |
| train_scaled = scaler.transform(train) # NOTE: scaler already fitted | |
| test_scaled = scaler.transform(test) | |
| # Sequences | |
| x_test, y_test = create_sequences(test_scaled, LOOKBACK) | |
| # Predict | |
| y_pred_scaled = model.predict(x_test, verbose=0) | |
| y_pred = inverse_safe(scaler, y_pred_scaled) | |
| y_true = inverse_safe(scaler, y_test) | |
| test_dates = df.loc["1959":].index[LOOKBACK:] | |
| fig2 = plt.figure(figsize=(10, 4)) | |
| plt.plot(test_dates, y_true, label="Actual") | |
| plt.plot(test_dates, y_pred, label="Predicted") | |
| plt.title("LSTM Forecast vs Actual (Test)") | |
| plt.xlabel("Date") | |
| plt.ylabel("Passengers") | |
| plt.legend() | |
| plt.grid(alpha=0.3) | |
| st.pyplot(fig2) | |
| # ------------------------- | |
| # Future forecast | |
| # ------------------------- | |
| if show_future_plot: | |
| st.subheader("Future forecast") | |
| last_window = df[["Passengers"]].values.astype("float32")[-LOOKBACK:] | |
| future_preds = rolling_forecast(model, scaler, last_window, steps=forecast_steps, lookback=LOOKBACK) | |
| last_date = df.index.max() | |
| future_dates = pd.date_range(last_date + pd.offsets.MonthBegin(1), periods=forecast_steps, freq="MS") | |
| fig3 = plt.figure(figsize=(10, 4)) | |
| plt.plot(df.index, df["Passengers"].values, label="History") | |
| plt.plot(future_dates, future_preds, label="Forecast") | |
| plt.title("Future Forecast") | |
| plt.xlabel("Date") | |
| plt.ylabel("Passengers") | |
| plt.legend() | |
| plt.grid(alpha=0.3) | |
| st.pyplot(fig3) | |
| st.success("✅ App ready. Make sure model/scaler files are in the repo (root or src).") |