shakti tiwari

Posted on Aug 16 • Originally published at optiontradingwithai.in

AI से Nifty Options Trading शुरू कैसे करें (शुरुआत से)

#trading #nifty #options #ai

सीधी बात: Nifty 50 Options Trading में AI लगाने के लिए तीन चीज़ें चाहिए — (1) Option Chain से Features बनाना, (2) दिशा बताने वाला Gradient Boosting Model, और (3) Greeks पर आधारित Risk Limit वाला Backtest। Model सिर्फ Probability देता है, असली फैसला Risk Layer लेती है। नीचे चलने वाला Python code है।

यह गाइड उन Retail Traders के लिए है जो Nifty 50 (NSE) पर काम करते हैं और Python जानते हैं।

सिर्फ सीखने के लिए। निवेश सलाह नहीं। Options में पूरा पैसा डूब सकता है। SEBI से registered सलाहकार से मिलें।

Nifty 50 Options में AI क्यों काम करता है

Liquidity मुख्य Strikes पर बहुत अच्छी है → टाइट Spread, साफ Labels।
India VIX → अपना Regime signal (जैसे VIX)।
SEBI Regulation → साफ Cost disclosure।

Architecture (तीन Layers)

1. Data/Feature Pipeline → Chain, IV, PCR
2. Model (Gradient Boosting) → P(direction | features)
3. Rules + Greeks Engine → Size, Stop, DTE limit

Layer 1 — Features (Python)

# Mac / Linux / Termux
python3 features.py
# Windows CMD
py features.py

import pandas as pd, numpy as np

def build_features(chain: pd.DataFrame, pcr: float) -> pd.DataFrame:
    # Option chain से साफ features बनाएँ
    df = chain.copy()
    df["mid"] = (df["bid"] + df["ask"]) / 2.0           # मध्य मूल्य
    df["spread_pct"] = (df["ask"] - df["bid"]) / df["mid"].clip(lower=1e-9)
    df["moneyness"] = df["strike"] / df["spot"] - 1.0   # Strike बनाम Spot
    atm_iv = df.loc[(df["moneyness"].abs()).idxmin(), "iv"]
    df["iv_skew"] = df["iv"] - atm_iv                    # IV skew
    df["pcr"] = pcr
    df["theta_per_delta"] = df["theta"] / df["delta"].clip(lower=1e-9)
    return df

if __name__ == "__main__":
    # Nifty 50 उदाहरण: spot 24800, ATM strike 24800
    demo = pd.DataFrame([{"strike": 24800, "bid": 85, "ask": 89, "iv": 0.16,
        "delta": 0.50, "gamma": 0.002, "theta": -12, "vega": 35,
        "oi": 90000, "volume": 6000, "spot": 24800, "dte": 8}])
    f = build_features(demo, pcr=0.95)
    print(f[["mid","spread_pct","moneyness","iv_skew","theta_per_delta"]].to_string())

Layer 2 — Model (Gradient Boosting)

# Mac / Linux / Termux
python3 train_signal.py
# Windows CMD
py train_signal.py

from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.model_selection import TimeSeriesSplit, roc_auc_score

FEATURES = ["spread_pct","moneyness","iv_skew","pcr",
            "theta_per_delta","gamma","vega","dte"]

def train_signal(X, y):
    tscv = TimeSeriesSplit(n_splits=5)   # समय क्रम बचाएँ
    for tr, te in tscv.split(X):
        m = HistGradientBoostingClassifier(max_depth=4, learning_rate=0.05,
                                            max_iter=300, l2_regularization=1.0)
        m.fit(X.iloc[tr], y.iloc[tr])
        p = m.predict_proba(X.iloc[te])[:, 1]
        print("Fold AUC:", round(roc_auc_score(y.iloc[te], p), 3))
    return m

Layer 3 — Risk Layer (Rules)

def decide(prob_up, g, max_capital=50000):
    # Probability 0.58 से 0.80 के बीच ही आगे बढ़ें
    if not (0.58 <= prob_up <= 0.80):
        return {}
    if g["dte"] <= 1:           # समाप्ति करीब है तो मत चलो
        return {}
    if abs(g["vega"]) > 8.0:    # Volatility बहुत है
        return {}
    size = (max_capital * 0.01) / max(g["theta"], 1e-9)
    return {"action": "paper entry", "size": round(size, 2)}

पूरी Production Pipeline (Data Engine → Predictor → Filter)

असली सिस्टम में कच्चे बाज़ार Data और Trade के बीच पाँच चरण होते हैं:

1. Data Engine     हर कुछ सेकंड में Chain + IV + PCR लाएँ
2. Feature Engine  build_features() → साफ, duplicate हटाएँ, label
3. Predictor       Gradient Boosting Model → हर Strike की Probability
4. Filter          Greeks + Regime + Prob-band rules → allow/block
5. Executor        paper या live entry, size तय

Data Engine ब्रोकर Feed (Zerodha Kite आदि) से जोड़ता है। Feature Engine गलत Data हटाता है। Predictor Probability देता है। Filter सख्त नियम लगाता है — यही वजह है कि Model जो Training में नहीं देखा वो Regime भी सिस्टम झेल लेती है। Executor अनुमत Signal को size वाला Order बनाता है।

Paper Trading से शुरुआत

Live जाने से पहले 4 हफ्ते Paper Trade करो:

def paper_loop(model, get_chain, sleep_s=60):
    while True:
        chain = get_chain()
        feats = build_features(chain, pcr=0.95)
        p = model.predict_proba(feats)[:, 1]
        for i, prob in enumerate(p):
            g = feats.iloc[i].to_dict()
            act = decide(prob, g, max_capital=50000)
            if act:
                print("PAPER ENTRY", act)
        time.sleep(sleep_s)

SEBI Rules Retail Traders के लिए

Options सिर्फ registered ब्रोकर से।
F&O में Leverage सीमित है (SEBI ने cap किया)।
Paper/Live automation ब्रोकर की मंज़ूरी से।
कोई भी Option पूरी तरह safe नहीं — सब Risky।

Market Microstructure और Liquidity (Model के लिए क्यों ज़रूरी)

Signal तभी काम करता है जब उसे लिक्विडिटी मिले। तीन microstructure facts जो Model मानता है:

Bid-ask Spread छोटे edges को खा जाता है। ATM Option में 0.3% spread हो तो Signal को break-even के लिए 0.3% से ज़्यादा clear करना पड़ता है। spread_pct feature सजावट नहीं — पहला Filter है।
Open Interest build-up support/resistance बनाता है। OI किसी Strike पर जमा हो तो Expiry में वो Strike magnet बनती है। Model OI concentration को नज़रअंदाज़ करे तो pinning effect गलत price करता है।
Volume confirm करता है, OI position बताता है। बढ़ता Volume + बढ़ता OI = नया पैसा (trend confirm)। बढ़ता Volume + घटता OI = squaring (exhaustion)।

Entry भरोसा करने से पहले: spread tight, OI slope signal direction के साथ, volume exhaustion pattern में न हो।

Volatility Regime Detection (असली Code)

Market stationary नहीं है। Calm IV में सीखा Model vol spike में बिगड़ता है। Vol Index से Regime पहचानें:

# Mac / Linux / Termux
python3 regime.py
# Windows CMD
py regime.py

def regime_state(vix, vix_ma20):
    z = (vix - vix_ma20) / (vix_ma20 + 1e-9)
    if z > 2.0:
        return "CRASH", 0.5      # size आधा
    if z > 1.0:
        return "STRESS", 0.75    # size घटाएँ
    if z < -1.0:
        return "CALM", 1.0       # full size
    return "NORMAL", 1.0

CRASH state size 50% कर देता है — यही rule 2020 जैसे gaps में naive bots को बचाता है। Model की Probability वही रहती है; बस Executor की Capital adapt करती है।

Execution और Broker Reality

Backtest मानता है fill मध्य (mid) पर मिलेगा। Live fill ask (buy) / bid (sell) पर, plus brokerage और STT। तीन सच्चाइयाँ:

Brokerage + Taxes: per-lot flat fee + exchange charges। सस्ते Option का round-trip 0.5-1% का पड़ता है — Backtest में fees_bps रखें, zero नहीं।
Slippage: तेज बाज़ार में quoted mid signal और fill के बीच घूमता है। Position size छोटी रखें ताकि slippage edge से कम रहे।
Margin: short Options के लिए margin block, long के लिए premium। position_size() function premium risk से size करता है।

कभी ऐसा Backtest profit न दिखाएँ जो fees के बाद live account न दे सके।

Realistic Weekly Routine

Consistency bursts से जीतती है। इस सिस्टम का काम का हफ़्ता:

सोमवार: पिछले हफ़्ते का Chain CSV लाएँ, अगर drift alert बजा तो retrain, regime state देखें।
मंगल–गुरु: market hours में paper loop चलाएँ, हर entry/exit लॉग करें (Model की Probability + Filter का फैसला)।
शुक्रवार: expiry week हो तो DTE limits कसें, realized vs predicted देखें।
वीकेंड: एक regulatory update पढ़ें, broker margin rules बदले तो check करें।

ये get-rich loop नहीं — measurement loop है। 8-12 हफ़्ते ईमानदार paper logs के बाद असली edge पता चलती है।

Worked Example — पूरा नंबरों के साथ

मान लें Nifty 50 Spot = 24800, ATM Strike = 24800, Expiry 8 दिन दूर (DTE=8)।

Input	Value
Spot	24800
ATM Strike	24800
IV	16%
Delta	0.50
Gamma	0.002
Theta	-12 रु/दिन
Vega	35
OI	90000
Volume	6000
PCR	0.95
India VIX	14.5

Step 1 — Features बनाएँ: build_features() चलाने पर moneyness = 0, iv_skew ATM पर 0, theta_per_delta = -12/0.50 = -24।

Step 2 — Model Prediction: मान लें Model ने prob_up = 0.62 दिया।

Step 3 — Risk Layer: 0.58 <= 0.62 <= 0.80 ✅, DTE=8 > 1 ✅, Vega=35 > 8 ❌ → BLOCK (Volatility बहुत है)।

यही अंतर है सही और गलत के बीच। Model bullish है पर Risk Layer ने रोका — क्योंकि Vega=35 मतलब IV बहुत high, ऐसे में Theta जल्दी काटता।

Step 4 — अगर Vega=5 होता: तब Risk Layer allow करती, size = (50000 * 0.01)/24 ≈ 20 units। 20 units का premium risk = 20 × 89 ≈ 1780 रु — छोटा, manageable।

ज़्यादा FAQ

प्र६. Vega high होने पर क्या करें?
या तो wait करें जब तक IV शांत न हो, या size आधा करें।

प्र७. DTE कम होने पर क्यों रोकें?
Theta तेज़ हो जाता है — हर दिन value घटती है, edge मार जाती है।

प्र८. Paper Trade कितने दिन?
कम से कम 20-30 trading sessions, ताकि अलग-अलग Regime देखें।

प्र९. Model कब Retrain करें?
जब drift alert बजे (feature mean 2 std घूमे) या हर सोमवार।

प्र१०. Loss कैसे control करें?
हर trade का max loss = premium ही (long option) → position size से ही सीमित।

Practical Tips Retail Traders के लिए

शुरू में सिर्फ 1 Index (Nifty या Bank Nifty) पर focus करें।
एक बार में 2-3 Strikes से ज़्यादा मत लें।
Expiry week में DTE limit कसें (<= 3)।
अपना हर trade लॉग करें — बिना लॉग के सुधार नहीं।
कभी भी पूरा capital एक trade में मत लगाएँ।

Glossary (और Terms)

Strike Price: वो कीमत जिस पर Option चलेगा।
Premium: Option खरीदने की कीमत (हमारा max loss)।
Spot: अंतर्निहित का वर्तमान भाव।
IV Crush: Expiry के पास IV गिरना (value टूटना)।
Hedging: एक position से दूसरे का risk कवर करना।
Break-even: वो Spot जहाँ न तो profit न loss।
Leverage: छोटी रकम से बड़ी exposure (F&O में common, risky)। ## Strategy Variations (अलग-अलग सेटअप)

एक ही Pipeline से कई रणनीतियाँ चल सकती हैं बिना Model बदले:

Directional Long: prob_up > 0.62 → ATM Call लें, DTE 5-15।
Spread: prob_up बैंड में + IV high → Bull Call Spread (limit Vega)।
Contrarian: PCR > 1.2 + Skew negative → mean-reversion Put sell (sophisticated, margin चाहिए)।
Vol Play: IV crush से बचने के लिए Expiry week में Long शुरू न करें।

हर वेरिएशन अलग Risk Layer सेटिंग्स लेता है — Vega limit, DTE limit, size multiplier अलग।

Model Comparison (कौन सा लें)

Model	Speed	Accuracy	Phone fit
Logistic Regression	सबसे तेज़	कम	बढ़िया
HistGradientBoosting	तेज़	अच्छी	बढ़िया
XGBoost	GPU तेज़	सबसे अच्छी	wheel चाहिए
LightGBM	सबसे तेज़	अच्छी	बढ़िया

Retail के लिए HistGradientBoosting या LightGBM शुरुआत के लिए सही हैं — तेज़, सटीक, कम झंझट।

Troubleshooting (जब कुछ टूटे)

Model हमेशा 0.5 दे रहा → Features में bug, या Label leak।
Backtest profit, Live loss → fees/slippage नहीं जोड़ा।
डाटा गायब → Feed gap, stale mid मत भेजें Model को।
Overfit → max_depth कम करें, Early Stop चालू करें।
Regime बदला → Retrain, drift alert सुनें।

ये सब कॉमन हैं — हर एक का fix ऊपर लिखा है। जल्दबाज़ी मत करो, लॉग देखो।

Common Mistakes

सिर्फ Model पर भरोसा, Risk Layer छोड़ देना।
Random Data बाँटना (समय क्रम तोड़ना)।
बहुत छोटी Expiry (Theta जल्दी काटता)।
IV Skew न देखना।
बिना Paper Trade के सीधे Live।

FAQ

प्र१. शुरू कहाँ से करें?
Python सीखें, NSE से Option Chain का Data लाएँ, ऊपर का Code चलाएँ, फिर 4 हफ्ते Paper Trade।

प्र२. Gradient Boosting क्या है?
एक Machine Learning तरीका जो कमज़ोर Decision Trees को क्रम से जोड़ता है ताकि Error कम हो।

प्र३. Greeks क्यों ज़रूरी हैं?
ये बताते हैं कि Price, Time और Volatility बदलने पर Option का Value कैसे बदलेगा।

प्र४. Paper Trade क्यों?
बिना पैसे के रणनीति जाँचो; यहाँ घाटा हो रहा है तो Live मत जाओ।

प्र५. सबसे बड़ी चीज़ क्या है?
Model या Risk Layer? Risk Layer। औसत Model भी सख्त Limits से बच जाता है; बेहतरीन Model बिना Limits के डूबता है।

Glossary

OI (Open Interest): खुले Contracts।
PCR (Put-Call Ratio): Put OI / Call OI।
IV (Implied Volatility): बाज़ार की अपेक्षित Volatility।
Max Pain: Expiry पर सबसे ज़्यादा नुकसान वाली Strike।
DTE (Days To Expiry): समाप्ति तक बचे दिन।
Moneyness: Strike / Spot - 1।

Footer

Shakti Tiwari — Options Trader, XGBoost Expert।
Books: Option Trading with AI (B0H9ZNTBPK) · The AI Opportunity (B0HBBFKDQF)
Site: optiontradingwithai.in · मुफ़्त मदद: shaktitiwari715@gmail.com
Dev.to: @shaktitiwari · X: @shaktitiwari

DEV Community