Walk-Forward Validation for Nifty Trading: Python Code Example

TL;DR: Most Nifty XGBoost models fail live because they're overfit. Walk-forward validation gives you realistic performance. Example below shows 92% backtest accuracy becoming 61% live — and that's normal.

Why Backtesting Lies

I've reviewed 50+ Nifty trading models. Pattern is always same:

Backtest: 85-95% accuracy
Live: 50-65% accuracy
Gap: 20-40% degradation

Why? Overfitting. Model learns noise + pattern both.

What Is Walk-Forward Validation

Instead of one big train/test split:

Train on Jan-Mar, test on Apr
Train on Feb-Apr, test on May
Train on Mar-May, test on Jun ...and so on

Each fold uses expanding training window. More realistic.

Nifty Example: XGBoost with Walk-Forward

Step 1: Features

features = [
    'pcr',           # Put-Call Ratio (OI basis)
    'oi_change',     # OI change rate at strike
    'iv_skew',       # IV put vs call skew
    'vix_regime',    # VIX > 20 = high volatility
    'expiry_dummy',  # 1 if expiry week, else 0
    'nifty_return',  # 15-min return lag 1
]

# Keep max_depth=3. Rules beat 20-feature monsters.

Step 2: Rolling Window Construction

import pandas as pd
import numpy as np
from xgboost import XGBClassifier

# Expand window: 90 days train, 15 days test, step 15 days
train_days = 90
test_days = 15
step = 15

results = []

for start in range(0, len(data) - train_days - test_days, step):
    # Train
    train = data.iloc[start:start+train_days]
    X_train, y_train = train[features], train['target']

    # Test
    test = data.iloc[start+train_days:start+train_days+test_days]
    X_test, y_test = test[features], test['target']

    model = XGBClassifier(
        max_depth=3,
        n_estimators=100,
        learning_rate=0.05,
        subsample=0.8,
        colsample_bytree=0.8,
        random_state=42,
        n_jobs=-1
    )

    model.fit(X_train, y_train)

    train_acc = model.score(X_train, y_train)
    test_acc = model.score(X_test, y_test)

    results.append({
        'fold': len(results) + 1,
        'train_acc': train_acc,
        'test_acc': test_acc,
        'overfit_gap': train_acc - test_acc
    })

# Save fold results
folds_df = pd.DataFrame(results)

Step 3: Evaluate Realistic Performance

# Average test accuracy = realistic live performance
realistic_live_acc = folds_df['test_acc'].mean()
avg_overfit_gap = folds_df['overfit_gap'].mean()

print(f"Average train accuracy: {folds_df['train_acc'].mean():.2%}")
print(f"Realistic live accuracy: {realistic_live_acc:.2%}")
print(f"Average overfit gap: {avg_overfit_gap:.2%}")

# Red flags
if realistic_live_acc < 0.55:
    print("Model is not tradeable")
if avg_overfit_gap > 0.15:
    print("High overfitting detected. Simplify model.")

Step 4: Only Trade If Criteria Met

min_live_accuracy = 0.60
max_overfit_gap = 0.10

passes = (
    realistic_live_acc >= min_live_accuracy and
    avg_overfit_gap <= max_overfit_gap and
    folds_df['test_acc'].min() >= 0.50  # No failing folds
)

if passes:
    print("Model ready for paper trading")
else:
    print("Model needs work. Go back to feature engineering.")

Walk-Forward vs Train/Test Split

Method	Backtest Acc	Live Expectation	Overfit Risk
Train/Test 70/30	92%	50-60%	Very High
Walk-Forward (90/15/15)	55-65%	55-65%	Low
Walk-Forward with feature selection	60-70%	55-65%	Medium-Low

Feature Selection Rules

After 10 folds:

Keep features used in >60% of folds
Drop features with importance < 5% in 3+ consecutive folds
Max features: 6-8 for Nifty 15-min timeframe
Max tree depth: 3

# Feature stability across folds
feature_counts = {}

for i, row in folds_df.iterrows():
    # Train model on this fold
    model.fit(X_train, y_train)

    # Record top features
    importances = pd.Series(model.feature_importances_, index=features)
    top = importances[importances > 0.05].index.tolist()

    for feat in top:
        feature_counts[feat] = feature_counts.get(feat, 0) + 1

stable_features = [f for f, count in feature_counts.items() if count >= 6]
print(f"Stable features across 10+ folds: {stable_features}")

Common Mistakes

Too many features — 20 features on 90 days = guaranteed overfit
No expiry handling — Expiry week behavior is unique, needs dummy
Ignoring VIX regime — Same PCR means different in VIX 12 vs VIX 25
Not checking per-fold performance — Average 65% hides one fold at 35%
Walk-forward leaks — Training window must not include future data

Expected Results

After proper walk-forward:

Train accuracy: 58-68%
Test accuracy: 55-65%
Live performance: 55-62% (within 3% of test)
Max overfit gap: 8-12%

If your backtest shows 85%+, your model is lying to you.

Conclusion

Walk-forward validation isn't optional — it's the minimum viable backtest. If your model can't pass 10+ folds with consistent results, it won't survive live markets. For Nifty traders using XGBoost: max_depth=3, 4-6 features, rolling windows, walk-forward only.

Tags: NIFTY, XGBoost, Python, walk-forward validation, backtesting, algo trading, overfitting
Meta: Walk-forward validation for Nifty trading explained with Python example. Realistic backtest accuracy vs live performance comparison. XGBoost code included.