Model Adverse Selection in Gold Trading - Cut Slippage by 40%

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

# Personal note: Learned this after misclassifying market impact for 2 months
class AdverseSelectionModel:
    def __init__(self, tick_data, execution_data):
        """
        tick_data: DataFrame with columns [timestamp, bid, ask, mid_price]
        execution_data: DataFrame with columns [timestamp, side, quantity, price]
        """
        self.ticks = tick_data.copy()
        self.executions = execution_data.copy()
        
        # Watch out: Timezone mismatches will skew results by hours
        self.ticks['timestamp'] = pd.to_datetime(self.ticks['timestamp'])
        self.executions['timestamp'] = pd.to_datetime(self.executions['timestamp'])
        
    def calculate_pre_trade_benchmark(self, window_minutes=5):
        """Calculate arrival price before order submission"""
        results = []
        
        for idx, trade in self.executions.iterrows():
            # Get price 5 minutes before trade submission
            cutoff = trade['timestamp'] - timedelta(minutes=window_minutes)
            pre_trade_ticks = self.ticks[
                (self.ticks['timestamp'] >= cutoff) & 
                (self.ticks['timestamp'] < trade['timestamp'])
            ]
            
            if len(pre_trade_ticks) > 0:
                arrival_price = pre_trade_ticks['mid_price'].iloc[-1]
            else:
                arrival_price = np.nan
                
            results.append({
                'trade_id': idx,
                'arrival_price': arrival_price,
                'execution_price': trade['price'],
                'side': trade['side']
            })
        
        return pd.DataFrame(results)

def measure_price_reversion(self, reversion_windows=[1, 5, 15, 30, 60]):
    """
    Measure price levels at multiple horizons post-execution
    reversion_windows: minutes after execution to sample price
    """
    # Personal note: I initially only checked 5min - missed the full reversion pattern
    
    results = []
    
    for idx, trade in self.executions.iterrows():
        trade_time = trade['timestamp']
        trade_price = trade['price']
        side = trade['side']  # 'buy' or 'sell'
        
        reversion_prices = {}
        
        for window in reversion_windows:
            # Get price N minutes after execution
            target_time = trade_time + timedelta(minutes=window)
            post_ticks = self.ticks[
                (self.ticks['timestamp'] >= target_time) & 
                (self.ticks['timestamp'] < target_time + timedelta(seconds=30))
            ]
            
            if len(post_ticks) > 0:
                reversion_prices[f'price_{window}min'] = post_ticks['mid_price'].iloc[0]
            else:
                reversion_prices[f'price_{window}min'] = np.nan
        
        # Calculate slippage at each horizon (basis points)
        trade_data = {
            'trade_id': idx,
            'execution_price': trade_price,
            'side': side
        }
        
        for window in reversion_windows:
            price_key = f'price_{window}min'
            if price_key in reversion_prices and not np.isnan(reversion_prices[price_key]):
                rev_price = reversion_prices[price_key]
                
                # Slippage in bps (negative = loss)
                if side == 'buy':
                    slippage_bps = -10000 * (trade_price - rev_price) / rev_price
                else:  # sell
                    slippage_bps = -10000 * (rev_price - trade_price) / rev_price
                
                trade_data[f'slippage_{window}min_bps'] = slippage_bps
            else:
                trade_data[f'slippage_{window}min_bps'] = np.nan
        
        results.append(trade_data)
    
    return pd.DataFrame(results)

# Add to AdverseSelectionModel class
AdverseSelectionModel.measure_price_reversion = measure_price_reversion

def calculate_adverse_selection(self, reversion_df):
    """
    Adverse selection = Permanent price impact that doesn't revert
    Formula: AS = Slippage(60min) - this is the permanent component
    Temporary Impact = Slippage(1min) - Slippage(60min)
    """
    
    results = []
    
    for idx, row in reversion_df.iterrows():
        # Watch out: NaN values will break your analysis - handle them explicitly
        if pd.notna(row['slippage_1min_bps']) and pd.notna(row['slippage_60min_bps']):
            
            immediate_slippage = row['slippage_1min_bps']
            long_term_slippage = row['slippage_60min_bps']
            
            # Adverse selection = permanent impact (doesn't revert)
            adverse_selection = long_term_slippage
            
            # Temporary impact = reverts over time
            temporary_impact = immediate_slippage - long_term_slippage
            
            # Calculate reversion ratio (higher = more temporary, less toxic)
            reversion_ratio = abs(temporary_impact / immediate_slippage) if immediate_slippage != 0 else 0
            
            results.append({
                'trade_id': row['trade_id'],
                'immediate_slippage_bps': immediate_slippage,
                'adverse_selection_bps': adverse_selection,
                'temporary_impact_bps': temporary_impact,
                'reversion_ratio': reversion_ratio,
                'is_toxic': reversion_ratio < 0.3  # Less than 30% reversion = toxic flow
            })
    
    return pd.DataFrame(results)

# Add to AdverseSelectionModel class
AdverseSelectionModel.calculate_adverse_selection = calculate_adverse_selection

def detect_leakage_patterns(self, adverse_df, executions):
    """
    Identify characteristics of trades with high adverse selection
    """
    
    # Merge with execution details
    analysis = adverse_df.merge(
        executions[['timestamp', 'quantity', 'side']], 
        left_on='trade_id', 
        right_index=True
    )
    
    # Personal note: Discovered my morning orders had 2x worse adverse selection
    analysis['hour'] = analysis['timestamp'].dt.hour
    analysis['day_of_week'] = analysis['timestamp'].dt.dayofweek
    
    # Categorize trade size
    analysis['size_category'] = pd.cut(
        analysis['quantity'], 
        bins=[0, 100, 500, 1000, np.inf],
        labels=['small', 'medium', 'large', 'jumbo']
    )
    
    # Calculate average adverse selection by characteristics
    leakage_report = {
        'by_hour': analysis.groupby('hour')['adverse_selection_bps'].agg(['mean', 'count']),
        'by_size': analysis.groupby('size_category')['adverse_selection_bps'].agg(['mean', 'count']),
        'by_day': analysis.groupby('day_of_week')['adverse_selection_bps'].agg(['mean', 'count']),
        'by_side': analysis.groupby('side')['adverse_selection_bps'].agg(['mean', 'count'])
    }
    
    # Flag high-risk patterns (adverse selection > 5 bps)
    high_risk = analysis[analysis['adverse_selection_bps'] < -5.0]
    
    print(f"\n=== INFORMATION LEAKAGE ANALYSIS ===")
    print(f"Total trades analyzed: {len(analysis)}")
    print(f"High adverse selection trades (>5bps): {len(high_risk)} ({100*len(high_risk)/len(analysis):.1f}%)")
    print(f"\nAverage adverse selection: {analysis['adverse_selection_bps'].mean():.2f} bps")
    print(f"Average temporary impact: {analysis['temporary_impact_bps'].mean():.2f} bps")
    print(f"Average reversion ratio: {analysis['reversion_ratio'].mean():.2%}")
    
    return leakage_report, analysis

# Add to AdverseSelectionModel class
AdverseSelectionModel.detect_leakage_patterns = detect_leakage_patterns