مین مواد پر جائیں

Chapter 26: Time Series Forecasting

MODULE 5 | WEEK 26​

Chapter 26: Time Series Forecasting​

Time series woh data hai jo waqt ke saath record hota hai: rozana ki sales, mahine ki bijli ki khapat, ghante ka mausam, share ki qeemat. Business me sab se zyada poocha jane wala sawal hai: "Aane wale waqt me kya hoga?" Is chapter me hum forecasting ke asli usool seekhenge: waqt ki tarteeb ko kabhi na todna, baseline banana, windowing se time series ko supervised learning me badalna, aur phir ML aur LSTM/GRU se forecast karna.

26.1 Time Series kya hai?​

Time series me har observation ke saath waqt juda hota hai aur qareeb ke observations aapas me jude hote hain (aaj ki sales kal ki sales se milti hai). Isi liye aam ML ke qaidey (random shuffle) yahan nahi chalte.

Hum ek banawati (synthetic) magar haqeeqat se milti hui series banate hain: 10 saal (120 mahine) ki dukan ki sales, jis me barhta hua rujhan (trend) , saalana mausam ka asar (seasonality) aur thora shor (noise) hai. Banawati data ka fayda ye hai ke hume pata hai andar kya chhupa hai.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
rng = np.random.RandomState(42)
months = pd.date_range("2015-01-01", periods=120, freq="MS") # har mahine ki pehli tareekh
t = np.arange(120)
trend = 100 + 0.8 * t # har mahine thori barhti hui
season = 15 * np.sin(2 * np.pi * t / 12) # 12 mahine me ek chakkar
noise = rng.normal(0, 3, 120)
sales = trend + season + noise
ts = pd.Series(sales, index=months, name="sales")
print(ts.head(4).round(1))
print("Kul mahine:", len(ts), "| Min:", ts.min().round(1), "| Max:", ts.max().round(1))
fig, ax = plt.subplots(figsize=(10, 3.6))
ax.plot(ts, color="#6B5B95", lw=1.8)
ax.set_title("Mahana sales (banawati data): trend + seasonality + noise")
ax.set_ylabel("sales")
plt.show()

OUTPUT 2015-01-01 101.5

2015-02-01 107.9
2015-03-01 116.5
2015-04-01 122.0
Freq: MS, Name: sales, dtype: float64
Kul mahine: 120 | Min: 92.0 | Max: 205.3
OUTPUT (chart)​
26.1 Time Series kya hai?: Mahana sales(banawati data):trend + seasonality+noise 200 180 160 sales 140 120 100 2015 2016 2019 2020 2021 2022 2024 2017 2018 2023 2025
26.1 Time Series kya hai?: Mahana sales(banawati data):trend + seasonality+noise 200 180 160 sales 140 120 100 2015 2016 2019 2020 2021 2022 2024 2017 2018 2023 2025
HissaMatlabIs series me
TrendLambay arse me upar ya neeche ka rujhanHar mahine +0.8 ka izafa
SeasonalityDohrane wala mausami nizamHar 12 mahine baad wohi shakal
NoiseBe-tarteeb chhote utaar chadhaoRandom shor (std = 3)

Asli series se in hisson ko alag karna ( decomposition ) sab se pehla qadam hai:

trend_est = ts.rolling(window=12, center=True).mean() # 12 mahine ka
average =
trend
detrended = ts - trend_est
season_est = detrended.groupby(detrended.index.month).mean() # har mahine ka aam asar
print("Har mahine ka seasonal asar (pehle 6 mahine):")
print(season_est.round(1).head(6))
print("Sab se zyada asar wala mahina:", int(season_est.idxmax()), " | sab se kam:",
int(season_est.idxmin()))
fig, axes = plt.subplots(1, 3, figsize=(10, 2.8))
axes[0].plot(ts.index, trend_est, color="#6B5B95")
axes[0].set_title("Trend")
axes[1].bar(season_est.index, season_est.values, color="#A4457A")
axes[1].set_title("Seasonality (mahine ke hisaab se)")
axes[2].plot(ts.index, (detrended - detrended.index.month.map(season_est)), color="#2F7D4F",
lw=1)
axes[2].set_title("Bacha hua (noise)")
plt.tight_layout()
plt.show()
OUTPUT​
Har mahine ka seasonal asar (pehle 6 mahine):
1 0.6
2 6.8
3 10.9
4 15.6
5 13.0
6 9.8
Name: sales, dtype: float64
Sab se zyada asar wala mahina: 4 | sab se kam: 10
OUTPUT (chart)​
26.1 Time Series kya hai?: Trend Seasonality(mahinekehisaabse) Bacha hua (noise) 180 5.0 10 2.5 160 0.0 140 -2.5 120 -10 -5.0 201801201201902D022022022024 10 2015012012019022022022023024
26.1 Time Series kya hai?: Trend Seasonality(mahinekehisaabse) Bacha hua (noise) 180 5.0 10 2.5 160 0.0 140 -2.5 120 -10 -5.0 201801201201902D022022022024 10 2015012012019022022022023024

26.2 Forecasting ke sunehre usool​

SUNEHRA USOOL​
  • Kabhi shuffle nahi. Train/test split hamesha waqt ke hisaab se : purana data train, naya data test.

  • Mustaqbil ka data kabhi training me nahi. Scaler ko bhi sirf train par fit karo.

  • Pehle baseline. Agar tumhara model "kal jitni sales aaj bhi hongi" se behtar nahi, to wo bekar hai.

  • Har feature ke baare me poocho: kya ye prediction ke waqt maloom hoga?

test_size = 24 # aakhri 2 saal test
train, test = ts[:-test_size], ts[-test_size:]
print("Train:", train.index[0].strftime("%Y-%m"), "se", train.index[-1].strftime("%Y-%m"),
"(", len(train), "mahine )")
print("Test :", test.index[0].strftime("%Y-%m"), "se", test.index[-1].strftime("%Y-%m"),
"(", len(test), "mahine )")
OUTPUT​
Train: 2015-01 se 2022-12 ( 96 mahine )
Test : 2023-01 se 2024-12 ( 24 mahine )

26.3 Baseline models aur Metrics​

BaselineIdea
NaiveAgle mahine ki sales = pichle mahine ki sales
Seasonal NaiveAgle mahine ki sales =pichle saal usi mahineki sales
Moving AveragePichle 12 mahine ka average
MetricFormula (mukhtasar)Matlab
MAEAam (|asli - andaza|)Average galti, wohi unit jo data ka
RMSEsqrt(aam((asli - andaza)^2))Bari ghaltiyon ko zyada saza
MAPEAam(|asli - andaza| / |asli|) x 100Percent me galti (asli 0 ke qareeb ho to ghalat)
def metrics(y_true, y_pred):
y_true, y_pred = np.asarray(y_true), np.asarray(y_pred)
mae = np.mean(np.abs(y_true - y_pred))
rmse = np.sqrt(np.mean((y_true - y_pred) ** 2))
mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100
return round(mae, 2), round(rmse, 2), round(mape, 2)
full = ts.values
n_tr = len(train)
y_test = test.values
# One-step baselines:
har test mahine ke liye pichli ASLI values istemal hoti hain
naive = full[n_tr - 1:-1] # pichla mahina
seasonal_naive = full[n_tr - 12:-12] # 12 mahine pehle
moving_avg = np.array([full[i - 12:i].mean() for i in range(n_tr, len(full))])
print("Baseline".ljust(16), "MAE RMSE MAPE%")
for name, pred in [("Naive", naive), ("Seasonal naive", seasonal_naive), ("Moving avg (12)",
moving_avg)]:
print(name.ljust(16), *metrics(y_test, pred))
OUTPUT​
Baseline MAE RMSE MAPE%
Naive 5.65 6.78 3.05
Seasonal naive 10.03 10.67 5.39
Moving avg (12) 9.8 11.77 5.16

Ye numbers hamari muqabla ki line hain. Koi bhi model jo in se behtar na ho, uski zaroorat nahi.

26.4 Windowing: time series ko supervised learning me badalna​

ML model ko (X, y) chahiye. Time series me hum pichle window qadam ko X aur agle qadam ko y bana lete hain. Is tareeqe ko sliding window kehte hain.

Series: 10, 12, 11, 14, 15, 17, 16
window = 3
X (pichle 3) y (agla)
[10, 12, 11] -> 14
[12, 11, 14] -> 15
[11, 14, 15] -> 17
[14, 15, 17] -> 16
def make_windows(values, window):
X, y = [], []
for i in range(window, len(values)):
X.append(values[i - window:i])
y.append(values[i])
return np.array(X), np.array(y)
demo = np.array([10, 12, 11, 14, 15, 17, 16], dtype=float)
Xd, yd = make_windows(demo, 3)
print(Xd)
print("y:", yd)
print("X shape:", Xd.shape, " y shape:", yd.shape)
OUTPUT​
[[10. 12. 11.]
[12. 11. 14.]
[11. 14. 15.]
[14. 15. 17.]]
y: [14. 15. 17. 16.]
X shape: (4, 3) y shape: (4,)

RNN/LSTM/GRU ko input 3D chahiye: (samples, timesteps, features) . Humari series me sirf 1 feature (sales) hai:

Xd3 = Xd.reshape(Xd.shape[0], Xd.shape[1], 1)
print("RNN ke liye shape:", Xd3.shape, "-> (samples, timesteps, features)")
OUTPUT​
RNN ke liye shape: (4, 3, 1) -> (samples, timesteps, features)

26.5 Scaling aur poori tayyari​

Neural networks ko scaled data chahiye. Scaler sirf train par fit hoga (warna mustaqbil ki maloomat leak hogi):

from sklearn.preprocessing import MinMaxScaler
window = 12
scaler = MinMaxScaler().fit(train.values.reshape(-1, 1)) # sirf train par
scaled = scaler.transform(ts.values.reshape(-1, 1)).ravel()
X_all, y_all = make_windows(scaled, window)
# window ka target wohi mahina hai jo index (window + i) par hai
target_idx = np.arange(window, len(scaled))
is_test = target_idx >= n_tr # jin ka target test period me ho
X_tr, y_tr = X_all[~is_test], y_all[~is_test]
X_te, y_te = X_all[is_test], y_all[is_test]
print("Train windows:", X_tr.shape, " Test windows:", X_te.shape)
print("Scaled train range:", scaled[:n_tr].min().round(2), "se",
scaled[:n_tr].max().round(2))
print("Scaled test range :", scaled[n_tr:].min().round(2), "se",
scaled[n_tr:].max().round(2))
OUTPUT​
Train windows: (84, 12) Test windows: (24, 12)
Scaled train range: 0.0 se 1.0
Scaled test range : 0.83 se 1.21

26.6 ML aur Neural Network se forecast​

Teen models: Ridge Regression (linear), Random Forest , aur ek chhota neural network (MLPRegressor, asli neural net). Teeno ko wohi 12 pichle mahine dete hain:

from sklearn.linear_model import Ridge
from sklearn.ensemble import RandomForestRegressor
from sklearn.neural_network import MLPRegressor
import warnings
warnings.filterwarnings("ignore")
models = {
"Ridge": Ridge(alpha=0.1),
"Random Forest": RandomForestRegressor(n_estimators=200, random_state=0),
"Neural Net (MLP)": MLPRegressor(hidden_layer_sizes=(32, 16), max_iter=3000,
random_state=0),
}
preds = {}
print("Model".ljust(18), "MAE RMSE MAPE%")
for name, m in models.items():
m.fit(X_tr, y_tr)
p_scaled = m.predict(X_te)
p = scaler.inverse_transform(p_scaled.reshape(-1, 1)).ravel() # wapas asli unit me
preds[name] = p
print(name.ljust(18), *metrics(y_test, p))
OUTPUT​
Model MAE RMSE MAPE%
Ridge 2.62 3.42 1.4
Random Forest 7.76 9.95 4.04
Neural Net (MLP) 8.59 10.08 4.67
fig, ax = plt.subplots(figsize=(10, 3.8))
ax.plot(train.index[-36:], train.values[-36:], color="gray", lw=1.5, label="Train (aakhri 3
saal)")
ax.plot(test.index, y_test, color="black", lw=2, label="Asli (test)")
cols = {"Ridge": "#6B5B95", "Random Forest": "#B7791F", "Neural Net (MLP)": "#A4457A"}
for name, p in preds.items():
ax.plot(test.index, p, color=cols[name], lw=1.6, ls="--", label=name)
ax.set_title("One-step forecast: test period")
ax.legend(ncol=2, fontsize=8)
plt.show()
OUTPUT (chart)​
26.6 ML aur Neural Network se forecast: One-stepforecast:testperiod Train (aakhri 3 saal) Random Forest 200 Asli (test) Neural Net (MLP) Ridge 190 180 170 160 150 140 2020 2021 2022 2023 2024 2025
26.6 ML aur Neural Network se forecast: One-stepforecast:testperiod Train (aakhri 3 saal) Random Forest 200 Asli (test) Neural Net (MLP) Ridge 190 180 170 160 150 140 2020 2021 2022 2023 2024 2025

Dekho ke Ridge (linear) sab se behtar aaya, aur Random Forest aur Neural Net dono naive baseline se bhi peeche reh gaye. Wajah: Random Forest trees ke andar train me dekhi hui values ka average deta hai, is liye wo train ki sab se bari value se aage extrapolate nahi kar sakta ; neural net bhi train range ke bahar kamzor hota hai. Linear model trend ko seedha pakadta hai.

SUNEHRA USOOL​
  • Trend wali series me tree-based models ko seedhi qeemat dene ke bajaye farq (difference) ya trend hata kar do.

  • Sab se saada aur taqatwar tareeqa: y(t) - y(t-1) (farq) predict karo, phir wapas jama karo.

Differencing: trend hata kar dobara aazmao​

diff = np.diff(ts.values) # har mahine ka farq
d_tr_end = n_tr - 1 # diff me train ke itne elements
sc2 = MinMaxScaler().fit(diff[:d_tr_end].reshape(-1, 1))
d_scaled = sc2.transform(diff.reshape(-1, 1)).ravel()
Xd_all, yd_all = make_windows(d_scaled, window)
d_target_idx = np.arange(window, len(d_scaled)) # diff ke index
is_test_d = d_target_idx >= d_tr_end
Xd_tr, yd_tr = Xd_all[~is_test_d], yd_all[~is_test_d]
Xd_te, yd_te = Xd_all[is_test_d], yd_all[is_test_d]
print("Differenced train windows:", Xd_tr.shape, " test windows:", Xd_te.shape)
prev_values = full[n_tr - 1:-1] # pichli ASLI value (wapas jama
karne ke liye)
for name, m in [("Random Forest (diff)", RandomForestRegressor(n_estimators=200,
random_state=0)),
("Neural Net (diff)", MLPRegressor(hidden_layer_sizes=(32, 16),
max_iter=3000, random_state=0)),
("Ridge (diff)", Ridge(alpha=0.1))]:
m.fit(Xd_tr, yd_tr)
d_pred = sc2.inverse_transform(m.predict(Xd_te).reshape(-1, 1)).ravel()
p = prev_values + d_pred # pichli value + predicted farq
preds[name] = p
print(name.ljust(22), *metrics(y_test, p))
OUTPUT​
Differenced train windows: (83, 12) test windows: (24, 12)
Random Forest (diff) 3.42 4.14 1.83
Neural Net (diff) 3.36 4.71 1.8
Ridge (diff) 2.89 3.54 1.54

Differencing ke baad Random Forest aur Neural Net dono ka RMSE 10 ke aas paas se 4 ke aas paas aa gaya, kyun ke ab model ko trend nahi, sirf farq aur seasonality seekhni hai jo train range me dikh chuki hai. (Is series me Ridge phir bhi saada aur mazboot rehta hai.)

26.7 Multi-step forecast: kai mahine aage​

Ab tak hum ne ek qadam aage (one-step) predict kiya aur har baar asli pichli values di. Asli zindagi me hume aksar kai mahine aage chahiye, jab ke asli values maloom nahi hoti. Recursive tareeqa: pehla forecast bana kar usay window me jod do aur agla banao.

rm = Ridge(alpha=0.1).fit(X_tr, y_tr) # train windows par seekha hua model
history = list(scaled[:n_tr]) # sirf train tak ka data maloom hai
forecast = []
for step in range(test_size):
x = np.array(history[-window:]).reshape(1, -1)
p = rm.predict(x)[0]
forecast.append(p)
history.append(p) # khud ki prediction agle qadam ka input
forecast = scaler.inverse_transform(np.array(forecast).reshape(-1, 1)).ravel()
print("24 mahine ka recursive forecast (Ridge):", *metrics(y_test, forecast))
print("Naive (aakhri value dohrao, muqabla) :", *metrics(y_test, [full[n_tr - 1]] *
test_size))
fig, ax = plt.subplots(figsize=(10, 3.6))
ax.plot(train.index[-36:], train.values[-36:], color="gray", lw=1.5, label="Train")
ax.plot(test.index, y_test, color="black", lw=2, label="Asli")
ax.plot(test.index, forecast, color="#A4457A", lw=2, ls="--", label="24 mahine ka forecast")
ax.set_title("Multi-step (recursive) forecast")
ax.legend()
plt.show()
OUTPUT​
24 mahine ka recursive forecast (Ridge): 2.48 3.17 1.33
Naive (aakhri value dohrao, muqabla) : 22.04 24.15 11.59
OUTPUT (chart)​
26.7 Multi-step forecast: kai mahine aage: Multi-step(recursive)forecast Train 200 Asli 190 24mahinekaforecast 180 170 160 150 140 2021 2022 2023 2024 2020 2025
26.7 Multi-step forecast: kai mahine aage: Multi-step(recursive)forecast Train 200 Asli 190 24mahinekaforecast 180 170 160 150 140 2021 2022 2023 2024 2020 2025
AAM GALTIYAN​
  • Recursive me galti jama hoti hai: pehli prediction ki chhoti ghalti agle step ka input ban kar barhti jati hai. Jitna lamba forecast, utna kam bharosa.

  • Doosra tareeqa Direct : har ufuq (1 mahina, 2 mahine, ...) ke liye alag model. Ya ek model jo ek sath 24 outputs de.

26.8 Walk-forward Validation (TimeSeriesSplit)​

Time series me K-Fold (shuffle) galat hai. Sahi tareeqa: purana data train, uske baad ka data validate , aur har baar train ko thora lamba karte jao.

from sklearn.model_selection import TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=4, test_size=12)
for k, (tr_idx, va_idx) in enumerate(tscv.split(X_tr), 1):
m = Ridge(alpha=0.1).fit(X_tr[tr_idx], y_tr[tr_idx])
p = m.predict(X_tr[va_idx])
rmse = np.sqrt(np.mean((y_tr[va_idx] - p) ** 2))
print("Fold", k, "| train:", tr_idx[0], "se", tr_idx[-1], "| validate:", va_idx[0],
"se", va_idx[-1],
"| RMSE (scaled):", round(rmse, 4))
OUTPUT​
Fold 1 | train: 0 se 35 | validate: 36 se 47 | RMSE (scaled): 0.0302
Fold 2 | train: 0 se 47 | validate: 48 se 59 | RMSE (scaled): 0.0298
Fold 3 | train: 0 se 59 | validate: 60 se 71 | RMSE (scaled): 0.0437
Fold 4 | train: 0 se 71 | validate: 72 se 83 | RMSE (scaled): 0.0305

26.9 Keras me LSTM, GRU aur Conv1D forecasting​

Ab wohi masla Keras me. Input shape (window, 1) . Data pichle section ka X_tr hi hai, bas ek feature ka axis jodna hai.

import numpy as np
from tensorflow import keras
from tensorflow.keras import layers
X_tr3 = X_tr.reshape(-1, 12, 1) # (samples, 12 timesteps, 1 feature)
X_te3 = X_te.reshape(-1, 12, 1)
lstm_model = keras.Sequential([
keras.Input(shape=(12, 1)),
layers.LSTM(32),
layers.Dense(1), # regression: koi activation nahi
])
lstm_model.compile(optimizer="adam", loss="mse")
lstm_model.summary()

OUTPUT (namoona)

Model: "sequential"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type) Output Shape Param # ┃┃┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ lstm (LSTM) │ (None, 32) │ 4,352 │
│ dense (Dense) │ (None, 1) │ 33 │
└───────────────────────────────────┴──────────────────────────┴─────────────────┘
Total params: 4,385 (17.13 KB)
Trainable params: 4,385 (17.13 KB)
Non-trainable params: 0 (0.00 B)
OUTPUT (namoona)​
3393 161

26.10 Aam Galtiyan aur Hands-on​

AAM GALTIYAN​
  • Random train_test_split istemal karna. Hamesha waqt ke hisaab se split.

  • Scaler poore data par fit karna (mustaqbil ki maloomat leak).

  • Baseline ke baghair model ko "achha" kehna. Saada naive aksar tumhari soch se behtar nikalta hai (yahan Naive ne Seasonal naive ko haraya, kyun ke trend hai).

  • Scaled predictions par metric nikalna (inverse_transform bhoolna).

  • Trend wali series par Random Forest se seedha forecast.

  • Lamba recursive forecast par bharosa karna.

  • MAPE jab asli values 0 ke qareeb hon.

Hands-on​

  • Series badlo: noise ka std 3 se 10 karo aur dekho kaun sa model sab se behtar rehta hai.

  • Window badlo: 6, 12, 24 aazmao aur RMSE ka muqabla likho.

  • Seasonality hatao: series me season wala hissa nikal do aur dekho baseline kaise badalti hai.

  • Apna data: apne ghar ki mahine ki bijli ka bill (ya koi bhi apna data) 24 mahine ka likh kar seasonal naive baseline banao.

  • Keras: Colab me LSTM, GRU aur Conv1D ke parameters, waqt aur RMSE ka table banao.

KEY TAKEAWAYS​
  • Time series = trend + seasonality + noise. Tarteeb kabhi na todo; shuffle nahi.

  • Hamesha pehle baseline: naive, seasonal naive, moving average.

  • Metrics: MAE, RMSE, MAPE. Scaled values ko wapas asli unit me laa kar naapo.

  • Windowing se series ko (X, y) banao; RNN ke liye shape (samples, timesteps, features).

  • Scaler sirf train par fit. Test ka range train se bahar ho sakta hai.

  • Trend wali series me differencing se tree-based models bhi theek chalte hain.

  • Multi-step: recursive (galti jama hoti hai) ya direct.

  • Validation: TimeSeriesSplit / walk-forward, kabhi shuffled K-Fold nahi.