Why Predict Greeks?

Traditional Greeks (Delta, Gamma, Theta) assume constant volatility and log-normal distributions. Real markets violate these assumptions. LightGBM can learn actual Greek values from market data, providing more accurate risk management.

Features for Greek Prediction

def create_greek_features(options_data):
    """Create features for Greek prediction."""
    features = pd.DataFrame(index=options_data.index)
    
    # Underlying features
    features['underlying_price'] = options_data['underlying_price']
    features['strike_price'] = options_data['strike_price']
    features['moneyness'] = options_data['underlying_price'] / options_data['strike_price']
    features['days_to_expiry'] = options_data['days_to_expiry']
    
    # Implied volatility
    features['iv'] = options_data['implied_volatility']
    features['iv_rank'] = options_data['iv_rank']
    features['iv_skew'] = options_data['iv_skew']
    
    # Market features
    features['underlying_volatility'] = options_data['underlying_volatility']
    features['interest_rate'] = options_data['interest_rate']
    
    # Technical features
    features['underlying_rsi'] = options_data['underlying_rsi']
    features['underlying_momentum'] = options_data['underlying_momentum']
    
    return features

Delta Prediction

import lightgbm as lgb

# Prepare data for Delta prediction
X = create_greek_features(options_data)
y_delta = options_data['market_delta']  # Actual delta from market

# Train LightGBM
params = {
    'objective': 'regression',
    'metric': 'rmse',
    'num_leaves': 15,
    'learning_rate': 0.05
}

train_data = lgb.Dataset(X_train, label=y_delta_train)
model_delta = lgb.train(params, train_data, num_boost_round=500)

# Predict Delta
delta_pred = model_delta.predict(X_test)

Gamma Prediction

# Gamma changes rapidly — use shorter timeframe
y_gamma = options_data['market_gamma']

params_gamma = {
    'objective': 'regression',
    'metric': 'rmse',
    'num_leaves': 7,  # Simpler for noisy gamma
    'learning_rate': 0.05
}

model_gamma = lgb.train(params_gamma, lgb.Dataset(X_train, label=y_gamma_train), num_boost_round=500)

Theta Prediction

# Theta is more predictable — time decay is mechanical
y_theta = options_data['market_theta']

params_theta = {
    'objective': 'regression',
    'metric': 'rmse',
    'num_leaves': 15,
    'learning_rate': 0.05
}

model_theta = lgb.train(params_theta, lgb.Dataset(X_train, label=y_theta_train), num_boost_round=500)

Results

Prediction accuracy on Nifty options (2024-2025):

  • Delta: RMSE 0.023 (vs Black-Scholes: 0.031)
  • Gamma: RMSE 0.008 (vs Black-Scholes: 0.012)
  • Theta: RMSE 0.015 (vs Black-Scholes: 0.019)

Applications

  • Risk management: More accurate hedging
  • Portfolio optimization: Better Greek exposure management
  • Arbitrage: Identify mispriced Greeks
  • Dynamic hedging: Real-time Greek updates

SEBI Disclaimer

This article is for educational purposes only. Options trading involves substantial risk. Past performance does not guarantee future results.

Multi-Target Setup

Predicting greeks means balancing two mathematics: pricing models already compute them, and ML adds a layer of *market friction* the models miss. The design choice:

  • Train separate LightGBM models per greek, each with its own objective and feature set; simplest and most debuggable.
  • Or train a single multi-output model sharing a hidden feature representation; more efficient but harder to audit per-greek errors.

For a small retail book, separate models are the right default: a bad theta model should be replacable without retraining the entire greek suite.

Features That Actually Drive Each Greek

Each greek has its own physics; feed each model the right menu:

  • Delta: moneyness, sign of the underlying return, time-distance from ATM for skew steepness, and the slope of the smile near the strike.
  • Gamma: proximity to the money, log-moneyness, volatility-surface curvature and days-to-expiry interaction.
  • Theta: DTE squared, time-decay phase (before/after 15 DTE), ATM-IV level, and whether expiry-week pin mechanics are active.

Reusing the same 200 features for all three wastes training on concepts each greek does not need.

Hedge-Ratio Outputs and the Error Metric That Matters

A greek prediction is only useful as a hedge ratio if its error stays small where it matters:

  • Score delta models with MAE weighted by moneyness: away-from-the-money errors matter little, but the ATM band is where hedges live.
  • For gamma, measure relative error near ATM (the dreaded second-order squeeze) rather than absolute, because gamma spans orders of magnitude across the chain.
  • For theta, score in rupees per lot to align with cost accounting; a theta error of 5 points a day is ₹375 on a 75-multiplier lot, a real number.

Smile Features for Gamma Prediction

Gamma concentrates at the money, but the smile skews where peaks sit. Include smile geometry explicitly:

  • The IV skew level at your strike relative to ATM: puts with fat tails dump gamma toward the skew's direction.
  • Forward-looking variance: if the expected move after an event inflates one side, gamma sympathy follows.
  • Order-flow influence: OI build at a strike pulls gamma toward dealer hedging focus; the greeks of the chain are as much about crowds as about math.

Hedging Cadence: A Practical Workflow

An ML-greek system changes how often you rebalance:

  1. Predict delta, gamma and theta once at the daily open from the first valid chain snapshot.
  2. Recompute mid-session only if the underlying moves beyond 1% or IV jumps by 4 points; chasing greeks every 5 minutes bleeds costs.
  3. Use the theta forecast as the scheduler: days the model says decay is healthy, hold; days it flags a gamma squeeze, plan exits in advance.

Options greeks are the market's physics with human pricing layered on top. A LightGBM suite that learns the drift between model-greeks and traded-greeks gives a hedger a real edge, because it captures the part Black-Scholes leaves out: what other traders actually pay each other.