Model Gold Trading Slippage in 20 Minutes Using Python

import pandas as pd
import numpy as np

# Personal note: Learned this after getting crushed during FOMC announcements
def calculate_rolling_volatility(prices, window=20):
    """
    Calculate rolling standard deviation of returns
    
    Args:
        prices: Series of gold prices (1-minute bars work best)
        window: Lookback period (20 mins = typical volatility window)
    
    Returns:
        Series of volatility values
    """
    returns = prices.pct_change()
    volatility = returns.rolling(window=window).std() * np.sqrt(window)
    
    # Watch out: First 'window' values will be NaN
    return volatility.fillna(method='bfill')

# Load your gold price data
df = pd.read_csv('gold_1min_prices.csv', parse_dates=['timestamp'])
df['volatility'] = calculate_rolling_volatility(df['close'], window=20)

print(f"Average volatility: {df['volatility'].mean():.4f}")
print(f"Max volatility spike: {df['volatility'].max():.4f}")

from scipy.stats import linregress

# Personal note: Tracked every trade for 3 months to build this dataset
def build_slippage_model(historical_trades):
    """
    Fit linear model: slippage = baseline + (volatility_coefficient * volatility)
    
    Args:
        historical_trades: DataFrame with 'volatility_at_entry' and 'actual_slippage_ticks'
    
    Returns:
        Dict with model parameters
    """
    # Filter out outliers (more than 5 ticks = something weird happened)
    clean_data = historical_trades[historical_trades['actual_slippage_ticks'] < 5]
    
    slope, intercept, r_value, p_value, std_err = linregress(
        clean_data['volatility_at_entry'],
        clean_data['actual_slippage_ticks']
    )
    
    model = {
        'baseline_slippage': intercept,
        'volatility_coefficient': slope,
        'r_squared': r_value**2,
        'confidence': 'high' if r_value**2 > 0.7 else 'medium'
    }
    
    print(f"\nModel fitted:")
    print(f"Baseline slippage: {intercept:.3f} ticks")
    print(f"Volatility impact: {slope:.1f}x multiplier")
    print(f"Model R²: {r_value**2:.3f}")
    
    return model

# Example: Load your trade history
trades = pd.read_csv('my_gold_trades.csv')
slippage_model = build_slippage_model(trades)

def predict_slippage(current_volatility, model, contract_size=100, tick_value=10):
    """
    Estimate slippage cost for upcoming trade
    
    Args:
        current_volatility: Latest 20-period volatility reading
        model: Dict from build_slippage_model()
        contract_size: Gold futures = 100 oz
        tick_value: GC contract = $10 per tick
    
    Returns:
        Dict with slippage estimates
    """
    expected_ticks = (model['baseline_slippage'] + 
                      model['volatility_coefficient'] * current_volatility)
    
    # Calculate costs
    slippage_per_contract = expected_ticks * tick_value
    
    # Add confidence interval (±1 std dev ≈ 68% confidence)
    std_dev_ticks = 0.3  # Typical from my data
    lower_bound = (expected_ticks - std_dev_ticks) * tick_value
    upper_bound = (expected_ticks + std_dev_ticks) * tick_value
    
    return {
        'expected_slippage_ticks': round(expected_ticks, 2),
        'expected_cost_per_contract': round(slippage_per_contract, 2),
        'range_68pct': (round(lower_bound, 2), round(upper_bound, 2)),
        'recommendation': 'TRADE' if expected_ticks < 1.0 else 'WAIT'
    }

# Real-time usage
current_vol = df['volatility'].iloc[-1]  # Latest reading
prediction = predict_slippage(current_vol, slippage_model)

print(f"\nSlippage Forecast:")
print(f"Expected: {prediction['expected_slippage_ticks']} ticks")
print(f"Cost per contract: ${prediction['expected_cost_per_contract']}")
print(f"68% confident range: ${prediction['range_68pct'][0]} - ${prediction['range_68pct'][1]}")
print(f"Decision: {prediction['recommendation']}")

import time
from datetime import datetime

def monitor_slippage_conditions(price_stream, model, threshold_ticks=1.0):
    """
    Real-time slippage monitor
    
    Args:
        price_stream: Live price feed (DataFrame updating every minute)
        model: Your fitted slippage model
        threshold_ticks: Max acceptable slippage
    """
    print(f"Monitoring started at {datetime.now().strftime('%H:%M:%S')}")
    print(f"Alert threshold: {threshold_ticks} ticks\n")
    
    while True:
        # Calculate current volatility
        recent_prices = price_stream['close'].tail(20)
        current_vol = calculate_rolling_volatility(recent_prices, window=20).iloc[-1]
        
        # Predict slippage
        prediction = predict_slippage(current_vol, model)
        
        timestamp = datetime.now().strftime('%H:%M:%S')
        status = "✅ TRADE" if prediction['expected_slippage_ticks'] < threshold_ticks else "⌠WAIT"
        
        print(f"[{timestamp}] Volatility: {current_vol:.4f} | "
              f"Expected slippage: {prediction['expected_slippage_ticks']:.2f} ticks | "
              f"{status}")
        
        # Check every minute
        time.sleep(60)

# Run monitor (stop with Ctrl+C)
# monitor_slippage_conditions(df, slippage_model, threshold_ticks=1.0)