Chapter 20: Time Series Forecasting with Deep Learning

Bloom's Taxonomy Map for This Chapter

Learning Objectives

By the end of this chapter, you will be able to:

• Define a time series and its four key components: trend, seasonality, cyclicality, and residual noise
• Explain stationarity using the Augmented Dickey-Fuller (ADF) test and apply differencing to make a series stationary
• Summarize the limitations of classical ARIMA/SARIMA models that motivate deep learning approaches
• Implement an LSTM network from scratch in NumPy for 30-day Nifty 50 price prediction using VIX India and FII/DII flow features
• Compare four deep architectures for time series: LSTM, Temporal Convolutional Networks (TCN), N-BEATS, and Informer (Transformer-based)
• Engineer time-series features including lag features, rolling statistics, and Indian holiday calendars
• Differentiate recursive, direct, and MIMO strategies for multi-step-ahead forecasting
• Apply walk-forward validation to prevent data leakage in temporal splits
• Calculate and interpret MAE, RMSE, MAPE, and Directional Accuracy metrics
• Critically assess why stock market prediction remains fundamentally difficult (Efficient Market Hypothesis) and the gap between backtest and live performance

Opening Hook

Core Concepts

# Convert time series to supervised learning windows
# Input: look_back=60 days → Output: next 30 days

# Series: [d1, d2, d3, ..., d100]
# Window 1: X=[d1..d60],   Y=[d61..d90]
# Window 2: X=[d2..d61],   Y=[d62..d91]
# Window 3: X=[d3..d62],   Y=[d63..d92]
# ...
# Shape: X → (num_samples, 60, num_features)
#        Y → (num_samples, 30)Python

# Create lag features for Nifty 50 closing price
import pandas as pd

df['close_lag_1']  = df['close'].shift(1)   # Yesterday
df['close_lag_5']  = df['close'].shift(5)   # Last week
df['close_lag_21'] = df['close'].shift(21)  # Last month (~21 trading days)
df['close_lag_63'] = df['close'].shift(63)  # Last quarterPython

# Rolling mean and standard deviation
df['sma_20']  = df['close'].rolling(20).mean()    # 20-day SMA
df['sma_50']  = df['close'].rolling(50).mean()    # 50-day SMA
df['std_20']  = df['close'].rolling(20).std()     # 20-day volatility
df['rsi_14'] = compute_rsi(df['close'], 14)    # Relative Strength Index

# Bollinger Bands
df['bb_upper'] = df['sma_20'] + 2 * df['std_20']
df['bb_lower'] = df['sma_20'] - 2 * df['std_20']Python

# Indian-specific temporal features
import numpy as np

# Standard calendar features
df['day_of_week']  = df.index.dayofweek       # 0=Mon, 4=Fri
df['month']        = df.index.month
df['is_monday']    = (df.index.dayofweek == 0).astype(int)
df['is_friday']    = (df.index.dayofweek == 4).astype(int)
df['is_month_end'] = df.index.is_month_end.astype(int)

# Indian market-specific features
df['is_expiry_week'] = is_nse_expiry_week(df.index)  # Last Thu
df['is_budget_day']  = (df.index.month == 2) & (df.index.day == 1)
df['is_rbi_policy']  = df.index.isin(rbi_policy_dates)

# Festival calendar (approximate — use 'holidays' library)
indian_holidays = {
    'diwali': ['2024-11-01', '2025-10-20'],
    'holi':   ['2024-03-25', '2025-03-14'],
    'ganesh_chaturthi': ['2024-09-07', '2025-08-27'],
}
# Pre-festival period (demand spike window)
for fest, dates in indian_holidays.items():
    fest_dates = pd.to_datetime(dates)
    for d in fest_dates:
        mask = (df.index >= d - pd.Timedelta(days=7)) & (df.index <= d)
        df.loc[mask, f'pre_{fest}'] = 1Python

# Walk-forward validation implementation
from sklearn.model_selection import TimeSeriesSplit

tscv = TimeSeriesSplit(n_splits=5)
fold_scores = []

for fold, (train_idx, val_idx) in enumerate(tscv.split(X)):
    X_train, X_val = X[train_idx], X[val_idx]
    y_train, y_val = y[train_idx], y[val_idx]
    
    # CRITICAL: Scale using ONLY training data statistics!
    scaler = StandardScaler()
    X_train = scaler.fit_transform(X_train)    # fit + transform
    X_val   = scaler.transform(X_val)           # transform only!
    
    model = build_lstm_model()
    model.fit(X_train, y_train, epochs=50,
              validation_data=(X_val, y_val),
              callbacks=[EarlyStopping(patience=5)])
    
    val_pred = model.predict(X_val)
    fold_scores.append(mean_absolute_error(y_val, val_pred))
    print(f"Fold {fold+1} MAE: {fold_scores[-1]:.4f}")

print(f"Mean Walk-Forward MAE: {np.mean(fold_scores):.4f}")Python

From-Scratch Code: LSTM for 30-Day Nifty 50 Prediction

We build a complete LSTM forecaster from scratch in NumPy. The model takes 60 days of historical data (Nifty close, VIX India, FII net flow) and predicts the next 30 days of Nifty closing prices.

Step 1: Data Preparation & Windowing

import numpy as np

# ──────────────────────────────────────────────
# LSTM for Nifty 50 — From Scratch in NumPy
# Features: [nifty_close, vix_india, fii_net_flow]
# Lookback: 60 days | Forecast: 30 days
# ──────────────────────────────────────────────

def create_windows(data, lookback=60, horizon=30):
    """Convert multivariate time series into supervised windows.
    
    Args:
        data: ndarray of shape (T, num_features)
        lookback: number of past timesteps as input
        horizon: number of future steps to predict
    
    Returns:
        X: (num_samples, lookback, num_features)
        Y: (num_samples, horizon) — only first feature (nifty close)
    """
    X, Y = [], []
    for i in range(len(data) - lookback - horizon + 1):
        X.append(data[i : i + lookback])                # all features
        Y.append(data[i + lookback : i + lookback + horizon, 0])  # nifty only
    return np.array(X), np.array(Y)

def normalize(train, val, test):
    """Normalize using ONLY training statistics — no leakage!"""
    mu  = train.mean(axis=0)
    std = train.std(axis=0) + 1e-8
    return (train - mu) / std, (val - mu) / std, (test - mu) / std, mu, std

# Simulate realistic Nifty data for demonstration
np.random.seed(42)
T = 1000  # ~4 years of trading days
nifty_close = 18000 + np.cumsum(np.random.randn(T) * 100)  # random walk
vix_india   = 14 + np.random.randn(T) * 3                   # VIX India
fii_net     = np.random.randn(T) * 2000                       # FII net ₹Cr

data = np.column_stack([nifty_close, vix_india, fii_net])

# Temporal split: 70% train, 15% val, 15% test
n_train = int(0.70 * T)
n_val   = int(0.15 * T)

train_data = data[:n_train]
val_data   = data[n_train:n_train+n_val]
test_data  = data[n_train+n_val:]

# Normalize (fit on train only!)
train_n, val_n, test_n, mu, std = normalize(train_data, val_data, test_data)

# Create windows
LOOKBACK, HORIZON = 60, 30
X_train, Y_train = create_windows(train_n, LOOKBACK, HORIZON)
X_val,   Y_val   = create_windows(val_n,   LOOKBACK, HORIZON)
X_test,  Y_test  = create_windows(test_n,  LOOKBACK, HORIZON)

print(f"X_train: {X_train.shape}, Y_train: {Y_train.shape}")
print(f"X_val:   {X_val.shape},   Y_val:   {Y_val.shape}")
print(f"X_test:  {X_test.shape},  Y_test:  {Y_test.shape}")Python

Step 2: LSTM Cell — Forward Pass

def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-np.clip(x, -500, 500)))

def tanh(x):
    return np.tanh(x)

class LSTMCell:
    """Single LSTM cell with forget, input, and output gates."""
    
    def __init__(self, input_size, hidden_size):
        self.input_size  = input_size
        self.hidden_size = hidden_size
        scale = 0.01
        
        # Combined weight matrix: [h_{t-1}, x_t] → gates
        concat_size = hidden_size + input_size
        
        # Forget gate weights
        self.W_f = np.random.randn(hidden_size, concat_size) * scale
        self.b_f = np.zeros((1, hidden_size))
        
        # Input gate weights
        self.W_i = np.random.randn(hidden_size, concat_size) * scale
        self.b_i = np.zeros((1, hidden_size))
        
        # Candidate cell weights
        self.W_c = np.random.randn(hidden_size, concat_size) * scale
        self.b_c = np.zeros((1, hidden_size))
        
        # Output gate weights
        self.W_o = np.random.randn(hidden_size, concat_size) * scale
        self.b_o = np.zeros((1, hidden_size))
    
    def forward(self, x_t, h_prev, c_prev):
        """One timestep of LSTM.
        
        Args:
            x_t:    (batch, input_size)
            h_prev: (batch, hidden_size)
            c_prev: (batch, hidden_size)
        
        Returns:
            h_t, c_t, cache (for backprop)
        """
        # Concatenate [h_{t-1}, x_t]
        concat = np.concatenate([h_prev, x_t], axis=1)  # (batch, H+D)
        
        # Gate computations
        f_t = sigmoid(concat @ self.W_f.T + self.b_f)     # Forget gate
        i_t = sigmoid(concat @ self.W_i.T + self.b_i)     # Input gate
        c_tilde = tanh(concat @ self.W_c.T + self.b_c)    # Candidate
        o_t = sigmoid(concat @ self.W_o.T + self.b_o)     # Output gate
        
        # Cell state update
        c_t = f_t * c_prev + i_t * c_tilde
        
        # Hidden state
        h_t = o_t * tanh(c_t)
        
        cache = (x_t, h_prev, c_prev, concat, f_t, i_t, c_tilde, o_t, c_t)
        return h_t, c_t, cachePython

Step 3: Full LSTM Network with Dense Output

class LSTMForecaster:
    """LSTM network for multi-step time series forecasting.
    
    Architecture:
        Input (batch, seq_len, features)
        → LSTM layer (hidden_size units)
        → Dense layer (hidden_size → horizon)
        → Output (batch, horizon)
    """
    
    def __init__(self, input_size, hidden_size, horizon, lr=0.001):
        self.lstm = LSTMCell(input_size, hidden_size)
        self.hidden_size = hidden_size
        self.horizon = horizon
        self.lr = lr
        
        # Dense layer: h_final → forecast
        self.W_out = np.random.randn(horizon, hidden_size) * 0.01
        self.b_out = np.zeros((1, horizon))
    
    def forward(self, X):
        """Forward pass through all timesteps.
        
        Args:
            X: (batch, seq_len, input_size)
        Returns:
            predictions: (batch, horizon)
        """
        batch_size, seq_len, _ = X.shape
        
        # Initialize hidden and cell states
        h = np.zeros((batch_size, self.hidden_size))
        c = np.zeros((batch_size, self.hidden_size))
        
        self.caches = []
        
        # Unroll LSTM across timesteps
        for t in range(seq_len):
            h, c, cache = self.lstm.forward(X[:, t, :], h, c)
            self.caches.append(cache)
        
        # Final hidden state → Dense → prediction
        self.h_final = h
        predictions = h @ self.W_out.T + self.b_out  # (batch, horizon)
        
        return predictions
    
    def compute_loss(self, y_pred, y_true):
        """Mean Squared Error loss."""
        self.y_pred = y_pred
        self.y_true = y_true
        loss = np.mean((y_pred - y_true) ** 2)
        return loss
    
    def backward_dense(self):
        """Backprop through the dense output layer."""
        batch = self.y_pred.shape[0]
        
        # Gradient of MSE loss
        dL_dpred = 2.0 * (self.y_pred - self.y_true) / batch  # (batch, horizon)
        
        # Gradients for W_out and b_out
        dW_out = dL_dpred.T @ self.h_final    # (horizon, hidden_size)
        db_out = dL_dpred.sum(axis=0, keepdims=True)
        
        # Gradient flowing back to h_final
        dh = dL_dpred @ self.W_out              # (batch, hidden_size)
        
        # Update dense layer (SGD)
        self.W_out -= self.lr * dW_out
        self.b_out -= self.lr * db_out
        
        return dh
    
    def backward_lstm(self, dh_final):
        """Backprop Through Time (BPTT) for LSTM.
        
        Simplified: we update weights using accumulated gradients
        across all timesteps (truncated BPTT).
        """
        dh_next = dh_final
        dc_next = np.zeros_like(dh_next)
        
        # Accumulators for weight gradients
        dW_f = np.zeros_like(self.lstm.W_f)
        dW_i = np.zeros_like(self.lstm.W_i)
        dW_c = np.zeros_like(self.lstm.W_c)
        dW_o = np.zeros_like(self.lstm.W_o)
        db_f = np.zeros_like(self.lstm.b_f)
        db_i = np.zeros_like(self.lstm.b_i)
        db_c = np.zeros_like(self.lstm.b_c)
        db_o = np.zeros_like(self.lstm.b_o)
        
        for t in reversed(range(len(self.caches))):
            cache = self.caches[t]
            x_t, h_prev, c_prev, concat, f_t, i_t, c_tilde, o_t, c_t = cache
            
            # Gradients through output gate
            tanh_c = tanh(c_t)
            do = dh_next * tanh_c
            dc = dh_next * o_t * (1 - tanh_c ** 2) + dc_next
            
            # Gradients through cell state update
            df = dc * c_prev
            di = dc * c_tilde
            dc_tilde = dc * i_t
            dc_next = dc * f_t  # flows to previous timestep
            
            # Gradients through gate activations
            df_raw = df * f_t * (1 - f_t)   # sigmoid derivative
            di_raw = di * i_t * (1 - i_t)
            do_raw = do * o_t * (1 - o_t)
            dc_raw = dc_tilde * (1 - c_tilde ** 2)  # tanh derivative
            
            # Accumulate weight gradients
            dW_f += df_raw.T @ concat
            dW_i += di_raw.T @ concat
            dW_c += dc_raw.T @ concat
            dW_o += do_raw.T @ concat
            db_f += df_raw.sum(axis=0, keepdims=True)
            db_i += di_raw.sum(axis=0, keepdims=True)
            db_c += dc_raw.sum(axis=0, keepdims=True)
            db_o += do_raw.sum(axis=0, keepdims=True)
            
            # Gradient flowing to h_{t-1}
            d_concat = (df_raw @ self.lstm.W_f + di_raw @ self.lstm.W_i +
                        dc_raw @ self.lstm.W_c + do_raw @ self.lstm.W_o)
            dh_next = d_concat[:, :self.hidden_size]
        
        # Gradient clipping to prevent exploding gradients
        for grad in [dW_f, dW_i, dW_c, dW_o]:
            np.clip(grad, -5, 5, out=grad)
        
        # Update LSTM weights (SGD)
        self.lstm.W_f -= self.lr * dW_f
        self.lstm.W_i -= self.lr * dW_i
        self.lstm.W_c -= self.lr * dW_c
        self.lstm.W_o -= self.lr * dW_o
        self.lstm.b_f -= self.lr * db_f
        self.lstm.b_i -= self.lr * db_i
        self.lstm.b_c -= self.lr * db_c
        self.lstm.b_o -= self.lr * db_oPython

Step 4: Training Loop with Walk-Forward Awareness

def train_lstm(model, X_train, Y_train, X_val, Y_val,
               epochs=100, batch_size=32, patience=10):
    """Train LSTM with mini-batch SGD and early stopping."""
    n = X_train.shape[0]
    best_val_loss = float('inf')
    wait = 0
    train_losses, val_losses = [], []
    
    for epoch in range(epochs):
        # Mini-batch training (shuffle within train set only)
        indices = np.random.permutation(n)
        epoch_loss = 0.0
        n_batches = 0
        
        for start in range(0, n, batch_size):
            end = min(start + batch_size, n)
            batch_idx = indices[start:end]
            
            X_b = X_train[batch_idx]
            Y_b = Y_train[batch_idx]
            
            # Forward pass
            y_pred = model.forward(X_b)
            loss = model.compute_loss(y_pred, Y_b)
            epoch_loss += loss
            n_batches += 1
            
            # Backward pass
            dh = model.backward_dense()
            model.backward_lstm(dh)
        
        train_loss = epoch_loss / n_batches
        train_losses.append(train_loss)
        
        # Validation loss
        val_pred = model.forward(X_val)
        val_loss = model.compute_loss(val_pred, Y_val)
        val_losses.append(val_loss)
        
        # Early stopping
        if val_loss < best_val_loss:
            best_val_loss = val_loss
            wait = 0
        else:
            wait += 1
            if wait >= patience:
                print(f"Early stopping at epoch {epoch+1}")
                break
        
        if (epoch + 1) % 10 == 0:
            print(f"Epoch {epoch+1:3d} | Train Loss: {train_loss:.6f} | Val Loss: {val_loss:.6f}")
    
    return train_losses, val_losses

# Initialize and train
INPUT_SIZE  = 3   # nifty_close, vix_india, fii_net
HIDDEN_SIZE = 32  # LSTM hidden units
HORIZON     = 30  # 30-day forecast

model = LSTMForecaster(INPUT_SIZE, HIDDEN_SIZE, HORIZON, lr=0.0005)
train_losses, val_losses = train_lstm(
    model, X_train, Y_train, X_val, Y_val,
    epochs=100, batch_size=32, patience=15
)Python

Step 5: Evaluation with All Four Metrics

def evaluate_forecast(y_true, y_pred, mu_target, std_target):
    """Compute MAE, RMSE, MAPE, and Directional Accuracy.
    
    Args:
        y_true, y_pred: normalized predictions
        mu_target, std_target: for de-normalization
    """
    # De-normalize to original scale (Nifty points)
    y_true_orig = y_true * std_target + mu_target
    y_pred_orig = y_pred * std_target + mu_target
    
    # MAE
    mae = np.mean(np.abs(y_true_orig - y_pred_orig))
    
    # RMSE
    rmse = np.sqrt(np.mean((y_true_orig - y_pred_orig) ** 2))
    
    # MAPE
    mape = np.mean(np.abs(y_true_orig - y_pred_orig) / 
                   (np.abs(y_true_orig) + 1e-8)) * 100
    
    # Directional Accuracy
    # Compare day-over-day direction: did we predict up/down correctly?
    true_dir = np.diff(y_true_orig, axis=1)
    pred_dir = np.diff(y_pred_orig, axis=1)
    da = np.mean((np.sign(true_dir) == np.sign(pred_dir))) * 100
    
    print(f"╔══════════════════════════════════╗")
    print(f"║   NIFTY 50 FORECAST EVALUATION   ║")
    print(f"╠══════════════════════════════════╣")
    print(f"║  MAE:   {mae:8.2f} points         ║")
    print(f"║  RMSE:  {rmse:8.2f} points         ║")
    print(f"║  MAPE:  {mape:8.2f}%              ║")
    print(f"║  DA:    {da:8.2f}%              ║")
    print(f"╚══════════════════════════════════╝")
    
    return {'mae': mae, 'rmse': rmse, 'mape': mape, 'da': da}

# Evaluate on test set
test_pred = model.forward(X_test)
metrics = evaluate_forecast(Y_test, test_pred, mu[0], std[0])Python

Industry Code: Production LSTM with TensorFlow/Keras

# ──────────────────────────────────────────────────
# Production-Grade LSTM for Multi-Step Forecasting
# TensorFlow/Keras Implementation
# ──────────────────────────────────────────────────

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout, Bidirectional
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from sklearn.preprocessing import StandardScaler
import numpy as np

# ── Model Architecture ──
def build_lstm_model(lookback, n_features, horizon):
    """Build a stacked Bidirectional LSTM for time series."""
    model = Sequential([
        # Layer 1: Bidirectional LSTM (captures both directions)
        Bidirectional(
            LSTM(128, return_sequences=True,
                 dropout=0.2, recurrent_dropout=0.1),
            input_shape=(lookback, n_features)
        ),
        
        # Layer 2: Second LSTM layer
        LSTM(64, return_sequences=False,
             dropout=0.2, recurrent_dropout=0.1),
        
        # Dense head for multi-step output
        Dense(64, activation='relu'),
        Dropout(0.1),
        Dense(horizon)  # MIMO: output all 30 steps at once
    ])
    
    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
        loss='mse',
        metrics=['mae']
    )
    return model

# ── Build & Train ──
LOOKBACK   = 60
N_FEATURES = 3    # nifty_close, vix_india, fii_net
HORIZON    = 30

model = build_lstm_model(LOOKBACK, N_FEATURES, HORIZON)
model.summary()

# Callbacks
callbacks = [
    EarlyStopping(monitor='val_loss', patience=15,
                  restore_best_weights=True),
    ReduceLROnPlateau(monitor='val_loss', factor=0.5,
                      patience=5, min_lr=1e-6)
]

history = model.fit(
    X_train, Y_train,
    epochs=200,
    batch_size=32,
    validation_data=(X_val, Y_val),
    callbacks=callbacks,
    verbose=1
)

# ── Evaluate ──
test_pred = model.predict(X_test)
print(f"Test MAE: {np.mean(np.abs(Y_test - test_pred)):.4f} (normalized)")Python

TCN Alternative with Keras

# Temporal Convolutional Network using keras-tcn
# pip install keras-tcn
from tcn import TCN

def build_tcn_model(lookback, n_features, horizon):
    model = Sequential([
        TCN(
            nb_filters=64,
            kernel_size=3,
            dilations=[1, 2, 4, 8, 16, 32],
            padding='causal',
            dropout_rate=0.2,
            return_sequences=False,
            input_shape=(lookback, n_features)
        ),
        Dense(64, activation='relu'),
        Dense(horizon)
    ])
    model.compile(optimizer='adam', loss='mse', metrics=['mae'])
    return model

tcn_model = build_tcn_model(LOOKBACK, N_FEATURES, HORIZON)
print(f"TCN parameters: {tcn_model.count_params():,}")
print(f"LSTM parameters: {model.count_params():,}")
# TCN typically has 2-3× fewer parameters and trains 5× faster!Python

Walk-Forward Validation — Production Pipeline

# Full walk-forward validation pipeline
from sklearn.model_selection import TimeSeriesSplit
from sklearn.metrics import mean_absolute_error, mean_squared_error
import gc

def walk_forward_validate(data, lookback=60, horizon=30, 
                          n_splits=5, build_fn=build_lstm_model):
    """Walk-forward validation with proper temporal splits."""
    tscv = TimeSeriesSplit(n_splits=n_splits)
    results = []
    
    for fold, (train_idx, val_idx) in enumerate(tscv.split(data)):
        print(f"\n{'='*50}")
        print(f"Fold {fold+1}/{n_splits}")
        print(f"  Train: indices {train_idx[0]}–{train_idx[-1]}")
        print(f"  Val:   indices {val_idx[0]}–{val_idx[-1]}")
        
        train_data = data[train_idx]
        val_data   = data[val_idx]
        
        # Scale on training data ONLY
        scaler = StandardScaler()
        train_scaled = scaler.fit_transform(train_data)
        val_scaled   = scaler.transform(val_data)
        
        # Create windows
        X_tr, Y_tr = create_windows(train_scaled, lookback, horizon)
        X_vl, Y_vl = create_windows(val_scaled,   lookback, horizon)
        
        if len(X_vl) == 0:
            print("  Skipping — not enough val data for windowing")
            continue
        
        # Build fresh model for each fold
        fold_model = build_fn(lookback, data.shape[1], horizon)
        fold_model.fit(X_tr, Y_tr, epochs=100, batch_size=32,
                       validation_data=(X_vl, Y_vl),
                       callbacks=[EarlyStopping(patience=10,
                                  restore_best_weights=True)],
                       verbose=0)
        
        val_pred = fold_model.predict(X_vl, verbose=0)
        
        # De-normalize for interpretable metrics
        mu_y, std_y = scaler.mean_[0], scaler.scale_[0]
        Y_vl_orig   = Y_vl * std_y + mu_y
        val_pred_orig = val_pred * std_y + mu_y
        
        mae  = mean_absolute_error(Y_vl_orig.flatten(), val_pred_orig.flatten())
        rmse = np.sqrt(mean_squared_error(Y_vl_orig.flatten(), val_pred_orig.flatten()))
        
        results.append({'fold': fold+1, 'mae': mae, 'rmse': rmse})
        print(f"  MAE: {mae:.2f} | RMSE: {rmse:.2f}")
        
        # Free memory
        del fold_model
        gc.collect()
    
    print(f"\n{'='*50}")
    print(f"Mean MAE across folds: {np.mean([r['mae'] for r in results]):.2f}")
    return results

results = walk_forward_validate(data)Python

Visual Diagrams

LSTM Unrolled for Time Series Forecasting

TCN Dilated Causal Convolution

Walk-Forward vs Wrong Cross-Validation

N-BEATS Block Architecture

Worked Example: Predicting Next Week's Nifty 50

Let's trace through a concrete LSTM prediction, step by step, for a 5-day (1-week) ahead forecast.

Given Data

Step 1: Observation

VIX India rising from 13.2 → 14.8 (increasing fear). FII flows turning negative (−₹1,500 Cr, −₹2,000 Cr). Nifty declining from 22,510 → 22,350. The pattern suggests continued selling pressure.

Step 2: Normalization

Using training set statistics: μ_nifty = 21,800, σ_nifty = 1,200

Step 3: LSTM Processing (Simplified)

The LSTM processes the last 60 days. At the final timestep:

• Forget gate f_t ≈ 0.3 for the "calm market" memory (VIX was low 2 weeks ago — forget it)
• Input gate i_t ≈ 0.8 for the "FII selling" signal (strong, recent, write it in)
• Cell state now encodes: "bearish regime — falling prices + rising volatility + FII outflow"
• Output h₆₀ is a 32-dim vector summarizing the market state

Step 4: Dense Layer → 5-Day Forecast

h₆₀ passes through Dense(64, relu) → Dense(5):

Step 5: Evaluate

Case Study: Jio Network Traffic Prediction

Common Mistakes & Critical Warnings

Comparison: Time Series Forecasting Architectures

Exercises

Chapter Summary

References & Further Reading

Foundational Papers

1. Hochreiter, S. & Schmidhuber, J. (1997). "Long Short-Term Memory." Neural Computation, 9(8), 1735–1780. — The original LSTM paper.
2. Box, G. E. P. & Jenkins, G. M. (1970). Time Series Analysis: Forecasting and Control. Holden-Day. — Foundation of ARIMA methodology.
3. Bai, S., Kolter, J. Z., & Koltun, V. (2018). "An Empirical Evaluation of Generic Convolutional and Recurrent Networks for Sequence Modeling." arXiv:1803.01271. — TCN vs LSTM benchmark.
4. Oreshkin, B. N. et al. (2020). "N-BEATS: Neural Basis Expansion Analysis for Interpretable Time Series Forecasting." ICLR 2020. — M4 Competition winner.
5. Zhou, H. et al. (2021). "Informer: Beyond Efficient Transformer for Long Sequence Time-Series Forecasting." AAAI 2021. — ProbSparse attention for time series.
6. Nie, Y. et al. (2023). "A Time Series is Worth 64 Words: Long-term Forecasting with Transformers." ICLR 2023. — PatchTST.
7. Fama, E. F. (1970). "Efficient Capital Markets: A Review of Theory and Empirical Work." Journal of Finance, 25(2), 383–417. — EMH.

Textbooks

8. Hyndman, R. J. & Athanasopoulos, G. (2021). Forecasting: Principles and Practice, 3rd edition. OTexts. — Free online at otexts.com/fpp3.
9. Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press. Chapter 10: Sequence Modeling.
10. Lazzeri, F. (2021). Machine Learning for Time Series Forecasting with Python. Wiley.

Indian Context

11. NSE India. "Nifty 50 Index Methodology Document." niftyindices.com
12. India Meteorological Department (IMD). "Extended Range Prediction System." — Uses ML/DL for seasonal monsoon forecasting.
13. Reliance Jio Annual Report 2024. "Digital Infrastructure & Network Optimization." — AI-driven capacity planning.
14. SEBI (2023). "Circular on Algorithmic Trading." — Regulatory guidelines for AI-based trading in Indian markets.

Libraries & Tools

15. statsmodels — ARIMA, seasonal decomposition, ADF test: statsmodels.org
16. pmdarima — Auto ARIMA for Python: alkaline-ml.com/pmdarima
17. keras-tcn — TCN implementation for Keras: GitHub
18. darts — Unified time series library by Unit8: unit8co.github.io/darts
19. pytorch-forecasting — Production time series with PyTorch: pytorch-forecasting.readthedocs.io
20. holidays — Indian public holiday library: GitHub