""" Game Theory Analysis: Retail Traders vs Big Players Models the strategic interaction between retail traders (driven by FOMO/group psychology) and institutional players in financial markets. Key Features: - Retail traders exhibit FOMO behavior (herding, momentum following) - Big players act strategically to exploit retail behavior - Finite repeated game (not infinite, as big players are human) - Nash equilibrium analysis - Order book model: realistic price impact based on order book depth - Big players have more capital and their trades move markets through order book consumption """ import numpy as np import matplotlib matplotlib.use('Agg') # Use non-interactive backend import matplotlib.pyplot as plt import pandas as pd from scipy.optimize import minimize, differential_evolution from scipy.stats import norm import itertools from collections import defaultdict class RetailTrader: """Models retail trader behavior with FOMO and group psychology""" def __init__(self, base_risk_aversion=0.5, fomo_sensitivity=0.3, herd_tendency=0.4, memory_decay=0.9): self.base_risk_aversion = base_risk_aversion self.fomo_sensitivity = fomo_sensitivity self.herd_tendency = herd_tendency self.memory_decay = memory_decay self.price_memory = [] self.sentiment = 0.0 # -1 (bearish) to +1 (bullish) def update_sentiment(self, price_change, market_momentum, retail_activity): """Update sentiment based on FOMO and herding""" # FOMO component: stronger reaction to positive moves fomo_component = self.fomo_sensitivity * np.tanh(price_change * 10) # Herding component: follow the crowd herd_component = self.herd_tendency * np.tanh(retail_activity * 5) # Momentum component momentum_component = 0.2 * np.tanh(market_momentum * 3) # Update sentiment with memory decay new_sentiment = fomo_component + herd_component + momentum_component self.sentiment = self.memory_decay * self.sentiment + (1 - self.memory_decay) * new_sentiment self.sentiment = np.clip(self.sentiment, -1, 1) return self.sentiment def decide_action(self, current_price, expected_return, volatility): """Decide trading action based on sentiment and risk""" # Risk-adjusted expected utility risk_adjusted_return = expected_return - self.base_risk_aversion * volatility**2 # Sentiment bias sentiment_bias = self.sentiment * (1 - self.base_risk_aversion) # Decision threshold decision_score = risk_adjusted_return + sentiment_bias if decision_score > 0.02: return 'buy', min(abs(decision_score) * 10, 1.0) # position size elif decision_score < -0.02: return 'sell', min(abs(decision_score) * 10, 1.0) else: return 'hold', 0.0 class OrderBook: """Models order book depth and price impact""" def __init__(self, base_liquidity=1000, depth_levels=10, liquidity_decay=0.95, liquidity_replenish=0.02): """ base_liquidity: Base liquidity at each price level depth_levels: Number of price levels in order book liquidity_decay: How much liquidity is consumed (0-1) liquidity_replenish: Rate at which liquidity replenishes per round """ self.base_liquidity = base_liquidity self.depth_levels = depth_levels self.liquidity_decay = liquidity_decay self.liquidity_replenish = liquidity_replenish self.bid_depth = np.ones(depth_levels) * base_liquidity # Liquidity at each level below price self.ask_depth = np.ones(depth_levels) * base_liquidity # Liquidity at each level above price def calculate_price_impact(self, volume, direction, current_price): """ Calculate price impact based on order book consumption direction: +1 for buy, -1 for sell Returns: price impact as fraction (e.g., 0.01 = 1% move) """ if volume == 0: return 0.0 remaining_volume = abs(volume) total_impact = 0.0 price_level = current_price # Determine which side of book to consume if direction > 0: # Buying - consume ask side (above current price) depth_array = self.ask_depth.copy() else: # Selling - consume bid side (below current price) depth_array = self.bid_depth.copy() # Consume order book levels level_spread = 0.002 # 0.2% price increment per level (increased impact) for level in range(self.depth_levels): if remaining_volume <= 0: break available_liquidity = depth_array[level] consumed = min(remaining_volume, available_liquidity) # Price impact increases as we go deeper into the book # Impact = (level + 1) * spread * (consumed / available_liquidity) # More impact when consuming larger portion of available liquidity consumption_ratio = consumed / max(available_liquidity, 1) level_impact = (level + 1) * level_spread * consumption_ratio total_impact += level_impact # Consume liquidity depth_array[level] -= consumed remaining_volume -= consumed # If volume exceeds all available depth, add extra impact if remaining_volume > 0: # Large impact for exceeding available liquidity excess_impact = 0.005 * (remaining_volume / self.base_liquidity) total_impact += excess_impact # Update order book if direction > 0: self.ask_depth = depth_array else: self.bid_depth = depth_array return total_impact * np.sign(direction) def replenish_liquidity(self): """Replenish order book liquidity over time""" # Replenish both sides self.bid_depth = np.minimum( self.bid_depth + self.base_liquidity * self.liquidity_replenish, self.base_liquidity ) self.ask_depth = np.minimum( self.ask_depth + self.base_liquidity * self.liquidity_replenish, self.base_liquidity ) def get_total_liquidity(self): """Get total available liquidity""" return np.sum(self.bid_depth) + np.sum(self.ask_depth) class BigPlayer: """Models institutional/big player strategic behavior""" def __init__(self, capital=1000000, market_impact_coef=0.001, patience=0.7, exploit_retail=True, sentiment_threshold=0.6, volume_threshold=20, trade_size_pct=0.20): self.capital = capital self.market_impact_coef = market_impact_coef self.patience = patience # How long to wait before acting self.exploit_retail = exploit_retail self.position = 0.0 self.retail_sentiment_history = [] # Configurable thresholds self.sentiment_threshold = sentiment_threshold self.volume_threshold = volume_threshold self.trade_size_pct = trade_size_pct def observe_retail_behavior(self, retail_sentiment, retail_volume): """Observe and learn from retail behavior""" self.retail_sentiment_history.append(retail_sentiment) if len(self.retail_sentiment_history) > 20: self.retail_sentiment_history.pop(0) def strategic_action(self, current_price, retail_sentiment, retail_volume, fundamental_value, game_round, order_book=None): """ Strategic action based on retail behavior and fundamentals Returns: (action, size) where size is in actual units (not normalized) """ if not self.exploit_retail: # Simple fundamental trading if current_price < fundamental_value * 0.98: # Buy: use 5% of capital size = min(100, self.capital * 0.05 / current_price) return 'buy', size elif current_price > fundamental_value * 1.02: # Sell: close position size = min(100, abs(self.position)) return 'sell', size else: return 'hold', 0.0 # Exploit retail FOMO avg_retail_sentiment = np.mean(self.retail_sentiment_history) if self.retail_sentiment_history else 0 # Strategy: fade extreme retail sentiment # Use configurable thresholds if avg_retail_sentiment > self.sentiment_threshold and retail_volume > self.volume_threshold: # Retail is bullish - sell to them (large size) size = min(300, self.capital * self.trade_size_pct / current_price) return 'sell', size elif avg_retail_sentiment < -self.sentiment_threshold and retail_volume > self.volume_threshold: # Retail is bearish - buy from them (large size) size = min(300, self.capital * self.trade_size_pct / current_price) return 'buy', size # Trade on fundamentals more frequently (less patience) if game_round % max(1, int(3 / (1 - self.patience))) == 0: # Trade every 3-10 rounds if current_price < fundamental_value * 0.98: # More sensitive # Medium size fundamental trade size = min(100, self.capital * 0.05 / current_price) return 'buy', size elif current_price > fundamental_value * 1.02: # More sensitive # Medium size fundamental trade size = min(100, abs(self.position)) return 'sell', size return 'hold', 0.0 class TradingGame: """Simulates the repeated game between retail traders and big players""" def __init__(self, num_retail_traders=100, num_big_players=5, initial_price=100, fundamental_value=100, volatility=0.02, order_book_liquidity=50, fundamental_reversion=0.01, big_sentiment_threshold=0.6, big_volume_threshold=20, big_trade_size_pct=0.20): self.num_retail_traders = num_retail_traders self.num_big_players = num_big_players self.initial_price = initial_price self.fundamental_value = fundamental_value self.volatility = volatility self.fundamental_reversion = fundamental_reversion # Initialize order book with realistic liquidity # Lower liquidity = more price impact from trades # 50 units per level means 500 total units (10 levels) # Retail can trade 0-200 units total, so this creates meaningful impact self.order_book = OrderBook( base_liquidity=order_book_liquidity, depth_levels=10, liquidity_decay=0.95, liquidity_replenish=0.05 # Faster replenishment ) # Create independent random state for this game # Use a unique seed based on time, object id, and random component import time import os base_seed = (int(time.time() * 1000000) % (2**31) + id(self) % 1000000 + os.getpid() * 1000) % (2**31) # Add some randomness from global RNG to ensure uniqueness try: base_seed = (base_seed + np.random.randint(0, 1000000)) % (2**31) except: pass self.rng = np.random.RandomState(base_seed) # Initialize players with game-specific random state self.retail_traders = [RetailTrader( base_risk_aversion=self.rng.uniform(0.3, 0.7), fomo_sensitivity=self.rng.uniform(0.2, 0.5), herd_tendency=self.rng.uniform(0.3, 0.6) ) for _ in range(num_retail_traders)] self.big_players = [BigPlayer( capital=self.rng.uniform(500000, 2000000), exploit_retail=True, sentiment_threshold=big_sentiment_threshold, volume_threshold=big_volume_threshold, trade_size_pct=big_trade_size_pct ) for _ in range(num_big_players)] self.price_history = [initial_price] self.retail_sentiment_history = [] self.retail_volume_history = [] self.big_player_volume_history = [] self.retail_pnl_history = [] self.big_player_pnl_history = [] # Track cumulative positions for proper PnL calculation self.retail_position = 0.0 # Cumulative position (positive = long, negative = short) self.big_player_position = 0.0 def update_price(self, retail_net_volume, big_player_net_volume, fundamental_shock=0): """ Update price based on trading through order book and fundamentals Volumes are in actual units (not normalized) """ current_price = self.price_history[-1] # Calculate price impact through order book # Retail traders aggregate volume can be significant (100 traders * 0-2 units = 0-200 units) retail_impact = 0.0 if retail_net_volume != 0: retail_direction = np.sign(retail_net_volume) retail_impact = self.order_book.calculate_price_impact( abs(retail_net_volume), retail_direction, current_price ) # Order book naturally gives less impact per unit for smaller trades # But when retail herds together (FOMO), aggregate volume creates impact # Big players have much larger trades - more impact big_impact = 0.0 if big_player_net_volume != 0: big_direction = np.sign(big_player_net_volume) # Big players' trades consume more order book depth big_impact = self.order_book.calculate_price_impact( abs(big_player_net_volume), big_direction, current_price ) # Big players' trades have full impact (they move markets) big_impact *= 1.0 # Replenish order book liquidity self.order_book.replenish_liquidity() # Fundamental mean reversion (much stronger to prevent price explosion) # Pull price back toward fundamental value price_deviation = (current_price - self.fundamental_value) / self.fundamental_value fundamental_drift = -self.fundamental_reversion * price_deviation # Random shock using game's independent random state random_shock = self.rng.normal(0, self.volatility) # Price update (multiplicative but bounded) total_change = retail_impact + big_impact + fundamental_drift + random_shock + fundamental_shock total_change = np.clip(total_change, -0.1, 0.1) # Cap at 10% per round new_price = current_price * (1 + total_change) return max(new_price, 0.01) # Prevent negative prices def play_round(self, game_round, fundamental_shock=0): """Play one round of the game""" current_price = self.price_history[-1] # Calculate market momentum if len(self.price_history) > 1: momentum = (self.price_history[-1] - self.price_history[-2]) / self.price_history[-2] else: momentum = 0 # Retail traders decide retail_actions = [] retail_sentiments = [] retail_net_volume = 0 for trader in self.retail_traders: expected_return = momentum # Simple expectation sentiment = trader.update_sentiment(momentum, momentum, len([a for a in retail_actions if a[0] != 'hold']) / max(len(retail_actions), 1)) action, normalized_size = trader.decide_action(current_price, expected_return, self.volatility) # Convert normalized size to actual units (retail traders trade small) # Normalized size is 0-1, convert to 0.1-2 units per trader actual_size = normalized_size * 2.0 # Retail traders trade 0-2 units each retail_actions.append((action, actual_size)) retail_sentiments.append(sentiment) if action == 'buy': retail_net_volume += actual_size elif action == 'sell': retail_net_volume -= actual_size avg_retail_sentiment = np.mean(retail_sentiments) retail_volume = sum([size for _, size in retail_actions]) # Big players observe and act big_player_net_volume = 0 for big_player in self.big_players: big_player.observe_retail_behavior(avg_retail_sentiment, retail_volume) action, size = big_player.strategic_action( current_price, avg_retail_sentiment, retail_volume, self.fundamental_value, game_round, order_book=self.order_book ) # Big players trade in actual units (already calculated based on capital) if action == 'buy': big_player_net_volume += size elif action == 'sell': big_player_net_volume -= size # Update price new_price = self.update_price(retail_net_volume, big_player_net_volume, fundamental_shock) # Calculate PnL properly # PnL on existing position: position_at_start * price_change # PnL on new trades: new_trades * price_change (they entered at current_price, price moved to new_price) # Total PnL = (position_at_start + new_trades) * price_change = position_at_end * price_change price_change_amount = new_price - current_price # Calculate PnL on average position during the round # This accounts for both existing positions and new trades position_at_start = self.retail_position position_at_end = self.retail_position + retail_net_volume average_position = (position_at_start + position_at_end) / 2 # Retail PnL: average position * price change retail_pnl = average_position * price_change_amount # Update retail position for next round self.retail_position = position_at_end # Big player PnL: same calculation position_at_start_big = self.big_player_position position_at_end_big = self.big_player_position + big_player_net_volume average_position_big = (position_at_start_big + position_at_end_big) / 2 big_player_pnl = average_position_big * price_change_amount # Update big player position for next round self.big_player_position = position_at_end_big # Update history self.price_history.append(new_price) self.retail_sentiment_history.append(avg_retail_sentiment) self.retail_volume_history.append(retail_volume) self.big_player_volume_history.append(abs(big_player_net_volume)) self.retail_pnl_history.append(retail_pnl) self.big_player_pnl_history.append(big_player_pnl) # Calculate exploitation metric: big players trading opposite to retail sentiment # Positive sentiment (bullish retail) -> big players should sell (negative volume) # Negative sentiment (bearish retail) -> big players should buy (positive volume) exploitation_signal = -np.sign(avg_retail_sentiment) * np.sign(big_player_net_volume) if big_player_net_volume != 0 else 0 return { 'price': new_price, 'retail_sentiment': avg_retail_sentiment, 'retail_volume': retail_volume, 'big_player_volume': abs(big_player_net_volume), 'big_player_direction': np.sign(big_player_net_volume), 'retail_pnl': retail_pnl, 'big_player_pnl': big_player_pnl, 'exploitation_signal': exploitation_signal } def simulate_game(self, num_rounds=100, fundamental_shocks=None): """Simulate the full game""" if fundamental_shocks is None: fundamental_shocks = [0] * num_rounds results = [] for round_num in range(num_rounds): shock = fundamental_shocks[round_num] if round_num < len(fundamental_shocks) else 0 result = self.play_round(round_num, shock) result['round'] = round_num results.append(result) return pd.DataFrame(results) def calculate_nash_equilibrium(self): """Calculate approximate Nash equilibrium""" # Simplified Nash equilibrium calculation # In equilibrium, big players should not be able to improve by changing strategy # given retail behavior, and vice versa # Average retail sentiment in equilibrium if len(self.retail_sentiment_history) > 10: eq_retail_sentiment = np.mean(self.retail_sentiment_history[-10:]) else: eq_retail_sentiment = 0 # Equilibrium price should be close to fundamental when both sides are balanced if len(self.price_history) > 10: eq_price = np.mean(self.price_history[-10:]) else: eq_price = self.initial_price return { 'equilibrium_price': eq_price, 'equilibrium_retail_sentiment': eq_retail_sentiment, 'price_deviation': abs(eq_price - self.fundamental_value) / self.fundamental_value } def analyze_game_theory(num_simulations=50, num_rounds=100): """Run multiple game simulations and analyze results""" all_results = [] nash_equilibria = [] for sim in range(num_simulations): # Each game gets completely independent random state # Use simulation number + time + random component for unique seed import time base_seed = int(time.time() * 1000000) % (2**31) game_seed = (base_seed + sim * 7919 + np.random.randint(0, 1000000)) % (2**31) game_rng = np.random.RandomState(game_seed) # Vary initial conditions for more diversity initial_price = 100 + game_rng.normal(0, 2) # Small variation in starting price fundamental_value = 100 + game_rng.normal(0, 1) # Small variation in fundamental game = TradingGame( num_retail_traders=100, num_big_players=5, initial_price=initial_price, fundamental_value=fundamental_value, volatility=0.02 ) # Override game's RNG with our independent one for shocks game.rng = game_rng # Add random fundamental shocks - unique per game fundamental_shocks = game_rng.normal(0, 0.01, num_rounds) # Add random large shocks at random times (not fixed rounds) num_large_shocks = game_rng.randint(1, 4) # 1-3 large shocks per game shock_times = game_rng.choice(num_rounds, num_large_shocks, replace=False) shock_sizes = game_rng.normal(0, 0.03, num_large_shocks) # Random shock sizes for time, size in zip(shock_times, shock_sizes): fundamental_shocks[time] = size results = game.simulate_game(num_rounds, fundamental_shocks) results['simulation'] = sim # Calculate Nash equilibrium nash = game.calculate_nash_equilibrium() nash['simulation'] = sim nash_equilibria.append(nash) all_results.append(results) combined_results = pd.concat(all_results, ignore_index=True) nash_df = pd.DataFrame(nash_equilibria) return combined_results, nash_df def calculate_meta_analysis(results_df, nash_df): """Calculate comprehensive meta-analysis across all games""" meta_stats = {} # Aggregate PnL statistics final_retail_pnl = results_df.groupby('simulation')['retail_pnl'].sum() final_big_pnl = results_df.groupby('simulation')['big_player_pnl'].sum() meta_stats['retail_pnl'] = { 'mean': final_retail_pnl.mean(), 'median': final_retail_pnl.median(), 'std': final_retail_pnl.std(), 'min': final_retail_pnl.min(), 'max': final_retail_pnl.max(), 'win_rate': (final_retail_pnl > 0).mean(), 'sharpe': final_retail_pnl.mean() / final_retail_pnl.std() if final_retail_pnl.std() > 0 else 0 } meta_stats['big_player_pnl'] = { 'mean': final_big_pnl.mean(), 'median': final_big_pnl.median(), 'std': final_big_pnl.std(), 'min': final_big_pnl.min(), 'max': final_big_pnl.max(), 'win_rate': (final_big_pnl > 0).mean(), 'sharpe': final_big_pnl.mean() / final_big_pnl.std() if final_big_pnl.std() > 0 else 0 } # Price efficiency price_efficiency = [] for sim in results_df['simulation'].unique(): sim_data = results_df[results_df['simulation'] == sim] price_deviations = np.abs(sim_data['price'].values - 100) / 100 efficiency = 1 - price_deviations.mean() price_efficiency.append(max(0, efficiency)) meta_stats['market_efficiency'] = { 'mean': np.mean(price_efficiency), 'median': np.median(price_efficiency), 'std': np.std(price_efficiency), 'min': np.min(price_efficiency), 'max': np.max(price_efficiency) } # Nash equilibrium statistics meta_stats['nash_equilibrium'] = { 'mean_price': nash_df['equilibrium_price'].mean(), 'std_price': nash_df['equilibrium_price'].std(), 'mean_deviation': nash_df['price_deviation'].mean(), 'mean_sentiment': nash_df['equilibrium_retail_sentiment'].mean() } # FOMO and herding metrics sentiment_volatility = results_df.groupby('simulation')['retail_sentiment'].std() volume_volatility = results_df.groupby('simulation')['retail_volume'].std() sentiment_volume_corr = results_df.groupby('simulation').apply( lambda x: x['retail_sentiment'].corr(x['retail_volume']) ) meta_stats['fomo_herding'] = { 'avg_sentiment_volatility': sentiment_volatility.mean(), 'avg_volume_volatility': volume_volatility.mean(), 'sentiment_volume_correlation': sentiment_volume_corr.mean(), 'sentiment_volume_correlation_std': sentiment_volume_corr.std() } # Exploitation metrics exploitation_scores = [] for sim in results_df['simulation'].unique(): sim_data = results_df[results_df['simulation'] == sim] if len(sim_data) < 10: continue retail_sentiment = sim_data['retail_sentiment'].values big_volume = sim_data['big_player_volume'].values abs_sentiment = np.abs(retail_sentiment) if len(abs_sentiment) > 5 and big_volume.std() > 0 and abs_sentiment.std() > 0: try: corr = np.corrcoef(abs_sentiment, big_volume)[0, 1] if not np.isnan(corr) and not np.isinf(corr): exploitation_scores.append(corr) except: pass if len(exploitation_scores) > 0: meta_stats['exploitation'] = { 'mean': np.mean(exploitation_scores), 'median': np.median(exploitation_scores), 'std': np.std(exploitation_scores) } else: meta_stats['exploitation'] = { 'mean': 0, 'median': 0, 'std': 0 } return meta_stats def plot_game_analysis(num_simulations=100, show_random_games=10): """Plot comprehensive game theory analysis with meta-analysis""" results_df, nash_df = analyze_game_theory(num_simulations, num_rounds=100) # Calculate meta-analysis meta_stats = calculate_meta_analysis(results_df, nash_df) fig = plt.figure(figsize=(20, 16)) gs = fig.add_gridspec(4, 3, hspace=0.4, wspace=0.3) # Plot 1: Random 10 Games Evolution (Price) ax1 = fig.add_subplot(gs[0, 0]) random_sims = np.random.choice(results_df['simulation'].unique(), min(show_random_games, len(results_df['simulation'].unique())), replace=False) colors = plt.cm.tab10(np.linspace(0, 1, len(random_sims))) for idx, sim in enumerate(random_sims): sim_data = results_df[results_df['simulation'] == sim] ax1.plot(sim_data['round'], sim_data['price'], color=colors[idx], alpha=0.6, linewidth=1.5, label=f'Game {sim}') ax1.axhline(100, color='r', linestyle='--', linewidth=2, label='Fundamental Value') ax1.set_xlabel('Game Round') ax1.set_ylabel('Price') ax1.set_title(f'Random {len(random_sims)} Games: Price Evolution') ax1.legend(loc='best', fontsize=7, ncol=2) ax1.grid(True, alpha=0.3) # Plot 2: Random 10 Games Evolution (Sentiment) ax2 = fig.add_subplot(gs[0, 1]) for idx, sim in enumerate(random_sims): sim_data = results_df[results_df['simulation'] == sim] ax2.plot(sim_data['round'], sim_data['retail_sentiment'], color=colors[idx], alpha=0.6, linewidth=1.5) ax2.axhline(0, color='black', linestyle=':', linewidth=1, alpha=0.5) ax2.set_xlabel('Game Round') ax2.set_ylabel('Retail Sentiment') ax2.set_title(f'Random {len(random_sims)} Games: Sentiment Evolution') ax2.grid(True, alpha=0.3) # Plot 3: Retail vs Big Player PnL Distribution ax3 = fig.add_subplot(gs[0, 2]) final_retail_pnl = results_df.groupby('simulation')['retail_pnl'].sum() final_big_pnl = results_df.groupby('simulation')['big_player_pnl'].sum() ax3.hist(final_retail_pnl, bins=30, alpha=0.5, label='Retail Traders', color='red', edgecolor='black') ax3.hist(final_big_pnl, bins=30, alpha=0.5, label='Big Players', color='blue', edgecolor='black') ax3.axvline(0, color='black', linestyle='--', linewidth=2) ax3.axvline(final_retail_pnl.mean(), color='red', linestyle=':', linewidth=2, alpha=0.7) ax3.axvline(final_big_pnl.mean(), color='blue', linestyle=':', linewidth=2, alpha=0.7) ax3.set_xlabel('Total PnL') ax3.set_ylabel('Frequency') ax3.set_title('PnL Distribution: Retail vs Big Players') ax3.legend() ax3.grid(True, alpha=0.3) # Plot 4: Nash Equilibrium Analysis ax4 = fig.add_subplot(gs[1, 0]) ax4.scatter(nash_df['equilibrium_price'], nash_df['price_deviation'], c=nash_df['equilibrium_retail_sentiment'], cmap='RdYlGn', s=100, alpha=0.6, edgecolors='black') ax4.axvline(100, color='r', linestyle='--', label='Fundamental Value') ax4.set_xlabel('Equilibrium Price') ax4.set_ylabel('Price Deviation from Fundamental') ax4.set_title('Nash Equilibrium Analysis') ax4.legend() ax4.grid(True, alpha=0.3) cbar = plt.colorbar(ax4.collections[0], ax=ax4) cbar.set_label('Retail Sentiment') # Plot 5: Sentiment vs Volume Relationship ax5 = fig.add_subplot(gs[1, 1]) scatter = ax5.scatter(results_df['retail_sentiment'], results_df['retail_volume'], alpha=0.3, s=10, c=results_df['round'], cmap='viridis') ax5.set_xlabel('Retail Sentiment') ax5.set_ylabel('Retail Trading Volume') ax5.set_title('FOMO Effect: Sentiment vs Volume') ax5.grid(True, alpha=0.3) cbar = plt.colorbar(scatter, ax=ax5) cbar.set_label('Game Round') # Plot 6: Cumulative PnL Over Time (All 100 Games) ax6 = fig.add_subplot(gs[1, 2]) # Calculate cumulative PnL for each game retail_cum_pnl_by_game = [] big_cum_pnl_by_game = [] rounds = sorted(results_df['round'].unique()) for sim in results_df['simulation'].unique(): sim_data = results_df[results_df['simulation'] == sim].sort_values('round') retail_cum = sim_data['retail_pnl'].cumsum().values big_cum = sim_data['big_player_pnl'].cumsum().values retail_cum_pnl_by_game.append(retail_cum) big_cum_pnl_by_game.append(big_cum) # Convert to numpy array (pad with NaN if games have different lengths) max_rounds = max(len(cum) for cum in retail_cum_pnl_by_game) retail_matrix = np.full((len(retail_cum_pnl_by_game), max_rounds), np.nan) big_matrix = np.full((len(big_cum_pnl_by_game), max_rounds), np.nan) for i, (retail_cum, big_cum) in enumerate(zip(retail_cum_pnl_by_game, big_cum_pnl_by_game)): retail_matrix[i, :len(retail_cum)] = retail_cum big_matrix[i, :len(big_cum)] = big_cum # Calculate mean and std across all games retail_mean = np.nanmean(retail_matrix, axis=0) retail_std = np.nanstd(retail_matrix, axis=0) retail_upper = retail_mean + 1.96 * retail_std # 95% confidence interval retail_lower = retail_mean - 1.96 * retail_std big_mean = np.nanmean(big_matrix, axis=0) big_std = np.nanstd(big_matrix, axis=0) big_upper = big_mean + 1.96 * big_std big_lower = big_mean - 1.96 * big_std # Plot confidence bands ax6.fill_between(range(len(retail_mean)), retail_lower, retail_upper, alpha=0.2, color='red', label='Retail 95% CI') ax6.fill_between(range(len(big_mean)), big_lower, big_upper, alpha=0.2, color='blue', label='Big Players 95% CI') # Plot mean lines ax6.plot(range(len(retail_mean)), retail_mean, 'r-', linewidth=2, label=f'Retail Traders (Mean, n={num_simulations})') ax6.plot(range(len(big_mean)), big_mean, 'b-', linewidth=2, label=f'Big Players (Mean, n={num_simulations})') # Show a few individual game trajectories (random sample) sample_games = np.random.choice(results_df['simulation'].unique(), min(5, len(results_df['simulation'].unique())), replace=False) for sim in sample_games: sim_data = results_df[results_df['simulation'] == sim].sort_values('round') ax6.plot(sim_data['round'], sim_data['retail_pnl'].cumsum(), 'r-', alpha=0.15, linewidth=0.5) ax6.plot(sim_data['round'], sim_data['big_player_pnl'].cumsum(), 'b-', alpha=0.15, linewidth=0.5) ax6.axhline(0, color='black', linestyle='--', linewidth=1) ax6.set_xlabel('Game Round') ax6.set_ylabel('Cumulative PnL') ax6.set_title(f'Cumulative PnL Evolution (All {num_simulations} Games)') ax6.legend(fontsize=8) ax6.grid(True, alpha=0.3) # Plot 7: Market Efficiency (Price vs Fundamental) ax7 = fig.add_subplot(gs[2, 0]) price_efficiency = [] for sim in results_df['simulation'].unique(): sim_data = results_df[results_df['simulation'] == sim] price_deviations = np.abs(sim_data['price'].values - 100) / 100 efficiency = 1 - price_deviations.mean() # Efficiency: 1 = perfect, 0 = 100% deviation price_efficiency.append(max(0, efficiency)) # Ensure non-negative price_efficiency = np.array(price_efficiency) if len(price_efficiency) > 0: ax7.hist(price_efficiency, bins=30, color='purple', alpha=0.7, edgecolor='black') ax7.axvline(np.mean(price_efficiency), color='red', linestyle='--', linewidth=2, label=f'Mean: {np.mean(price_efficiency):.3f}') ax7.set_xlabel('Market Efficiency (1 - |Price - Fundamental|/Fundamental)') ax7.set_ylabel('Frequency') ax7.set_title('Market Efficiency Distribution') ax7.legend() ax7.grid(True, alpha=0.3) # Plot 8: Herding Behavior Analysis ax8 = fig.add_subplot(gs[2, 1]) sentiment_volatility = results_df.groupby('simulation')['retail_sentiment'].std() volume_volatility = results_df.groupby('simulation')['retail_volume'].std() ax8.scatter(sentiment_volatility, volume_volatility, alpha=0.6, s=100, edgecolors='black') ax8.set_xlabel('Sentiment Volatility') ax8.set_ylabel('Volume Volatility') ax8.set_title('Herding Behavior: Sentiment vs Volume Volatility') ax8.grid(True, alpha=0.3) # Plot 9: Meta-Analysis Summary ax9 = fig.add_subplot(gs[2, 2]) # Simulate games of different lengths game_lengths = [50, 100, 150, 200] final_pnl_by_length = [] for length in game_lengths: game = TradingGame() results = game.simulate_game(num_rounds=length) final_pnl_by_length.append({ 'length': length, 'retail_pnl': results['retail_pnl'].sum(), 'big_pnl': results['big_player_pnl'].sum() }) length_df = pd.DataFrame(final_pnl_by_length) x = np.arange(len(game_lengths)) width = 0.35 ax8.bar(x - width/2, length_df['retail_pnl'], width, label='Retail', color='red', alpha=0.7) ax8.bar(x + width/2, length_df['big_pnl'], width, label='Big Players', color='blue', alpha=0.7) ax8.set_xlabel('Game Length (Rounds)') ax8.set_ylabel('Final PnL') ax8.set_title('Finite Game Effects: PnL vs Game Length') ax8.set_xticks(x) ax8.set_xticklabels(game_lengths) ax8.legend() ax8.grid(True, alpha=0.3, axis='y') ax8.axhline(0, color='black', linestyle='--', linewidth=1) # Plot 9: Meta-Analysis Summary # Create summary table visualization ax9.axis('off') summary_text = f""" META-ANALYSIS SUMMARY (n={num_simulations} games) Retail Traders: Mean PnL: ${meta_stats['retail_pnl']['mean']:.2f} Win Rate: {meta_stats['retail_pnl']['win_rate']:.1%} Sharpe: {meta_stats['retail_pnl']['sharpe']:.3f} Big Players: Mean PnL: ${meta_stats['big_player_pnl']['mean']:.2f} Win Rate: {meta_stats['big_player_pnl']['win_rate']:.1%} Sharpe: {meta_stats['big_player_pnl']['sharpe']:.3f} Market Efficiency: {meta_stats['market_efficiency']['mean']:.3f} FOMO Correlation: {meta_stats['fomo_herding']['sentiment_volume_correlation']:.3f} Exploitation Score: {meta_stats['exploitation']['mean']:.3f} Nash Equilibrium: Price: ${meta_stats['nash_equilibrium']['mean_price']:.2f} Deviation: {meta_stats['nash_equilibrium']['mean_deviation']:.4f} """ ax9.text(0.1, 0.5, summary_text, transform=ax9.transAxes, fontsize=10, verticalalignment='center', family='monospace', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5)) # Plot 10: Strategic Exploitation (moved to new row) ax10 = fig.add_subplot(gs[3, 0]) # Calculate exploitation metric exploitation_scores = [] for sim in results_df['simulation'].unique(): sim_data = results_df[results_df['simulation'] == sim].copy() if len(sim_data) < 10: continue retail_sentiment = sim_data['retail_sentiment'].values big_volume = sim_data['big_player_volume'].values abs_sentiment = np.abs(retail_sentiment) if len(abs_sentiment) > 5 and big_volume.std() > 0 and abs_sentiment.std() > 0: try: corr = np.corrcoef(abs_sentiment, big_volume)[0, 1] if not np.isnan(corr) and not np.isinf(corr): exploitation_scores.append(corr) except: pass if len(exploitation_scores) > 0: exploitation_scores = np.array(exploitation_scores) if len(exploitation_scores) > 5: q1, q3 = np.percentile(exploitation_scores, [10, 90]) exploitation_scores = exploitation_scores[(exploitation_scores >= q1) & (exploitation_scores <= q3)] if len(exploitation_scores) > 0: bins = min(20, max(5, len(exploitation_scores) // 2)) counts, bins_edges, patches = ax10.hist(exploitation_scores, bins=bins, color='orange', alpha=0.7, edgecolor='black') mean_score = np.mean(exploitation_scores) ax10.axvline(mean_score, color='red', linestyle='--', linewidth=2, label=f'Mean: {mean_score:.3f}') ax10.axvline(0, color='black', linestyle=':', linewidth=1, alpha=0.5) ax10.legend(fontsize=8) if len(counts) > 0: ax10.set_ylim([0, max(counts) * 1.15]) else: ax10.text(0.5, 0.5, 'Insufficient data', ha='center', va='center', transform=ax10.transAxes, fontsize=10) ax10.set_xlabel('Exploitation Score') ax10.set_ylabel('Frequency') ax10.set_title('Big Player Exploitation of Retail FOMO') ax10.grid(True, alpha=0.3) plt.suptitle(f'Game Theory Analysis: Retail Traders vs Big Players\n' f'Meta-Analysis of {num_simulations} Games - FOMO, Herding, and Strategic Exploitation', fontsize=16, fontweight='bold', y=0.995) return fig, results_df, nash_df, meta_stats def evaluate_configuration(params, num_simulations=10, num_rounds=100): """ Evaluate a configuration of parameters Returns: (big_player_pnl, retail_pnl, profit_difference) params: dict with keys: - order_book_liquidity - big_sentiment_threshold - big_volume_threshold - big_trade_size_pct - fundamental_reversion - num_big_players """ # Extract parameters order_book_liquidity = params.get('order_book_liquidity', 50) big_sentiment_threshold = params.get('big_sentiment_threshold', 0.6) big_volume_threshold = params.get('big_volume_threshold', 20) big_trade_size_pct = params.get('big_trade_size_pct', 0.20) fundamental_reversion = params.get('fundamental_reversion', 0.01) num_big_players = int(params.get('num_big_players', 5)) # Store original BigPlayer strategic_action for modification # We'll need to modify the TradingGame to accept these parameters all_big_pnl = [] all_retail_pnl = [] for sim in range(num_simulations): # Each simulation gets completely independent random state import time base_seed = int(time.time() * 1000000) % (2**31) game_seed = (base_seed + sim * 7919 + np.random.randint(0, 1000000)) % (2**31) game_rng = np.random.RandomState(game_seed) # Vary initial conditions for diversity initial_price = 100 + game_rng.normal(0, 1) fundamental_value = 100 + game_rng.normal(0, 0.5) # Create game with custom parameters game = TradingGame( num_retail_traders=100, num_big_players=num_big_players, initial_price=initial_price, fundamental_value=fundamental_value, volatility=0.02, order_book_liquidity=order_book_liquidity, fundamental_reversion=fundamental_reversion, big_sentiment_threshold=big_sentiment_threshold, big_volume_threshold=big_volume_threshold, big_trade_size_pct=big_trade_size_pct ) # Override game's RNG with our independent one game.rng = game_rng # Run simulation with random fundamental shocks (unique per game) fundamental_shocks = game_rng.normal(0, 0.01, num_rounds) # Add random large shocks at random times num_shocks = game_rng.randint(0, 3) if num_shocks > 0: shock_times = game_rng.choice(num_rounds, num_shocks, replace=False) shock_sizes = game_rng.normal(0, 0.02, num_shocks) for time, size in zip(shock_times, shock_sizes): fundamental_shocks[time] = size results = game.simulate_game(num_rounds, fundamental_shocks) # Calculate total PnL total_big_pnl = results['big_player_pnl'].sum() total_retail_pnl = results['retail_pnl'].sum() all_big_pnl.append(total_big_pnl) all_retail_pnl.append(total_retail_pnl) mean_big_pnl = np.mean(all_big_pnl) mean_retail_pnl = np.mean(all_retail_pnl) profit_difference = mean_big_pnl - mean_retail_pnl # Big player advantage # Calculate win rates from individual simulations big_win_rate = np.mean(np.array(all_big_pnl) > 0) retail_win_rate = np.mean(np.array(all_retail_pnl) > 0) return mean_big_pnl, mean_retail_pnl, profit_difference, big_win_rate, retail_win_rate, all_big_pnl, all_retail_pnl def genetic_optimization(num_generations=20, population_size=30, num_simulations=5): """ Genetic algorithm to find optimal configuration for big players Objective: Maximize (big_player_pnl - retail_pnl) """ print("\n" + "="*60) print("GENETIC ALGORITHM OPTIMIZATION") print("="*60) print(f"Generations: {num_generations}, Population: {population_size}") print(f"Simulations per evaluation: {num_simulations}") print("="*60) # Parameter bounds bounds = [ (20, 200), # order_book_liquidity (0.3, 0.9), # big_sentiment_threshold (10, 100), # big_volume_threshold (0.05, 0.30), # big_trade_size_pct (0.001, 0.05), # fundamental_reversion (3, 10), # num_big_players ] param_names = [ 'order_book_liquidity', 'big_sentiment_threshold', 'big_volume_threshold', 'big_trade_size_pct', 'fundamental_reversion', 'num_big_players' ] # Objective function (minimize negative profit difference) def objective(x): params = dict(zip(param_names, x)) try: _, _, profit_diff, _, _, _, _ = evaluate_configuration(params, num_simulations=num_simulations, num_rounds=50) return -profit_diff # Negative because we're minimizing except Exception as e: print(f"Error in evaluation: {e}") return 1e10 # Large penalty for invalid configurations # Run differential evolution (genetic algorithm) print("\nStarting optimization...") result = differential_evolution( objective, bounds, maxiter=num_generations, popsize=population_size, seed=42, polish=True, workers=1 ) optimal_params = dict(zip(param_names, result.x)) optimal_params['num_big_players'] = int(optimal_params['num_big_players']) # Evaluate optimal configuration with more simulations print("\nEvaluating optimal configuration with more simulations...") big_pnl, retail_pnl, profit_diff, big_wr, retail_wr, _, _ = evaluate_configuration( optimal_params, num_simulations=20, num_rounds=100 ) print(f"\n{'='*60}") print("OPTIMAL CONFIGURATION FOUND:") print(f"{'='*60}") for key, value in optimal_params.items(): print(f" {key}: {value:.4f}" if isinstance(value, float) else f" {key}: {value}") print(f"\nResults (20 simulations):") print(f" Big Player Mean PnL: ${big_pnl:,.2f}") print(f" Retail Mean PnL: ${retail_pnl:,.2f}") print(f" Profit Difference: ${profit_diff:,.2f}") print(f" Big Player Win Rate: {big_wr:.1%}") print(f" Retail Win Rate: {retail_wr:.1%}") print(f"{'='*60}\n") return optimal_params, result def grid_search_optimization(num_simulations=5): """ Grid search over parameter space (faster but less thorough) Returns top configurations """ print("\n" + "="*60) print("GRID SEARCH OPTIMIZATION") print("="*60) # Define parameter grids param_grids = { 'order_book_liquidity': [30, 50, 100, 150], 'big_sentiment_threshold': [0.4, 0.5, 0.6, 0.7], 'big_volume_threshold': [15, 25, 40, 60], 'big_trade_size_pct': [0.10, 0.15, 0.20, 0.25], 'fundamental_reversion': [0.005, 0.01, 0.02, 0.03], 'num_big_players': [3, 5, 7, 10] } # Generate all combinations (sample to avoid too many) keys = list(param_grids.keys()) values = list(param_grids.values()) # Limit combinations for speed all_combinations = list(itertools.product(*values)) np.random.shuffle(all_combinations) max_combinations = min(50, len(all_combinations)) # Limit to 50 configurations sampled_combinations = all_combinations[:max_combinations] print(f"Testing {len(sampled_combinations)} configurations...") results = [] for i, combo in enumerate(sampled_combinations): params = dict(zip(keys, combo)) try: big_pnl, retail_pnl, profit_diff, big_wr, retail_wr, _, _ = evaluate_configuration( params, num_simulations=num_simulations, num_rounds=50 ) results.append({ **params, 'big_pnl': big_pnl, 'retail_pnl': retail_pnl, 'profit_diff': profit_diff, 'big_win_rate': big_wr, 'retail_win_rate': retail_wr }) if (i + 1) % 10 == 0: print(f" Completed {i+1}/{len(sampled_combinations)} configurations...") except Exception as e: print(f" Error with configuration {i+1}: {e}") continue results_df = pd.DataFrame(results) results_df = results_df.sort_values('profit_diff', ascending=False) optimal = results_df.iloc[0].to_dict() print(f"\n{'='*60}") print("TOP CONFIGURATION FOUND:") print(f"{'='*60}") for key in keys: print(f" {key}: {optimal[key]}") print(f"\nResults:") print(f" Big Player Mean PnL: ${optimal['big_pnl']:,.2f}") print(f" Retail Mean PnL: ${optimal['retail_pnl']:,.2f}") print(f" Profit Difference: ${optimal['profit_diff']:,.2f}") print(f"{'='*60}\n") return results_df, optimal def plot_optimization_results(optimal_params, grid_results_df=None, num_simulations=20): """ Create comprehensive visualization of optimization results Highlights optimal configuration vs others """ print("\nGenerating optimization visualization...") # Evaluate optimal configuration in detail optimal_big_pnl, optimal_retail_pnl, optimal_profit_diff, optimal_big_wr, optimal_retail_wr, _, _ = evaluate_configuration( optimal_params, num_simulations=num_simulations, num_rounds=100 ) # Run optimal configuration for detailed analysis optimal_game = TradingGame( num_retail_traders=100, num_big_players=int(optimal_params['num_big_players']), initial_price=100, fundamental_value=100, volatility=0.02, order_book_liquidity=optimal_params['order_book_liquidity'], fundamental_reversion=optimal_params['fundamental_reversion'], big_sentiment_threshold=optimal_params['big_sentiment_threshold'], big_volume_threshold=optimal_params['big_volume_threshold'], big_trade_size_pct=optimal_params['big_trade_size_pct'] ) optimal_results = optimal_game.simulate_game(100) # Create figure with subplots fig = plt.figure(figsize=(20, 14)) gs = fig.add_gridspec(3, 3, hspace=0.4, wspace=0.3) # Plot 1: Optimal Configuration - Price Evolution ax1 = fig.add_subplot(gs[0, 0]) ax1.plot(optimal_results['round'], optimal_results['price'], 'b-', linewidth=2.5, label='Optimal Config', zorder=3) ax1.axhline(100, color='r', linestyle='--', linewidth=2, label='Fundamental Value', alpha=0.7) ax1.set_xlabel('Game Round') ax1.set_ylabel('Price') ax1.set_title('Optimal Configuration: Price Evolution', fontweight='bold') ax1.legend() ax1.grid(True, alpha=0.3) # Plot 2: Optimal Configuration - PnL Evolution ax2 = fig.add_subplot(gs[0, 1]) retail_cum_pnl = optimal_results['retail_pnl'].cumsum() big_cum_pnl = optimal_results['big_player_pnl'].cumsum() ax2.plot(optimal_results['round'], retail_cum_pnl, 'r-', linewidth=2, label='Retail Traders', alpha=0.7) ax2.plot(optimal_results['round'], big_cum_pnl, 'b-', linewidth=2.5, label='Big Players (Optimal)', zorder=3) ax2.axhline(0, color='black', linestyle=':', linewidth=1, alpha=0.5) ax2.set_xlabel('Game Round') ax2.set_ylabel('Cumulative PnL') ax2.set_title('Optimal Configuration: Cumulative PnL', fontweight='bold') ax2.legend() ax2.grid(True, alpha=0.3) # Plot 3: Optimal Configuration - Sentiment vs Big Player Volume ax3 = fig.add_subplot(gs[0, 2]) scatter = ax3.scatter(optimal_results['retail_sentiment'], optimal_results['big_player_volume'], c=optimal_results['round'], cmap='viridis', alpha=0.6, s=50, edgecolors='black', linewidth=0.5) ax3.axvline(optimal_params['big_sentiment_threshold'], color='red', linestyle='--', linewidth=2, label=f"Threshold: {optimal_params['big_sentiment_threshold']:.2f}") ax3.axvline(-optimal_params['big_sentiment_threshold'], color='red', linestyle='--', linewidth=2) ax3.set_xlabel('Retail Sentiment') ax3.set_ylabel('Big Player Volume') ax3.set_title('Optimal: Exploitation Strategy', fontweight='bold') ax3.legend() ax3.grid(True, alpha=0.3) cbar = plt.colorbar(scatter, ax=ax3) cbar.set_label('Game Round') # Plot 4: Parameter Comparison (if grid results available) if grid_results_df is not None and len(grid_results_df) > 0: ax4 = fig.add_subplot(gs[1, 0]) top_10 = grid_results_df.head(10) y_pos = np.arange(len(top_10)) colors = ['gold' if i == 0 else 'steelblue' for i in range(len(top_10))] ax4.barh(y_pos, top_10['profit_diff'], color=colors, edgecolor='black') ax4.set_yticks(y_pos) ax4.set_yticklabels([f"Config {i+1}" for i in range(len(top_10))]) ax4.set_xlabel('Profit Difference (Big - Retail)') ax4.set_title('Top 10 Configurations (Optimal Highlighted)', fontweight='bold') ax4.axvline(0, color='black', linestyle='--', linewidth=1, alpha=0.5) ax4.grid(True, alpha=0.3, axis='x') else: ax4 = fig.add_subplot(gs[1, 0]) ax4.text(0.5, 0.5, 'Grid search results not available', ha='center', va='center', transform=ax4.transAxes, fontsize=12) ax4.axis('off') # Plot 5: Parameter Space - Order Book Liquidity vs Profit Difference if grid_results_df is not None and len(grid_results_df) > 0: ax5 = fig.add_subplot(gs[1, 1]) scatter = ax5.scatter(grid_results_df['order_book_liquidity'], grid_results_df['profit_diff'], c=grid_results_df['num_big_players'], cmap='coolwarm', s=100, alpha=0.6, edgecolors='black', linewidth=0.5) # Highlight optimal ax5.scatter([optimal_params['order_book_liquidity']], [optimal_profit_diff], s=300, marker='*', color='gold', edgecolors='black', linewidth=2, zorder=5, label='Optimal') ax5.set_xlabel('Order Book Liquidity') ax5.set_ylabel('Profit Difference (Big - Retail)') ax5.set_title('Parameter Space: Liquidity vs Profit', fontweight='bold') ax5.legend() ax5.grid(True, alpha=0.3) cbar = plt.colorbar(scatter, ax=ax5) cbar.set_label('Number of Big Players') else: ax5 = fig.add_subplot(gs[1, 1]) ax5.scatter([optimal_params['order_book_liquidity']], [optimal_profit_diff], s=300, marker='*', color='gold', edgecolors='black', linewidth=2, zorder=5) ax5.set_xlabel('Order Book Liquidity') ax5.set_ylabel('Profit Difference') ax5.set_title('Optimal Configuration', fontweight='bold') ax5.grid(True, alpha=0.3) # Plot 6: Parameter Space - Sentiment Threshold vs Trade Size if grid_results_df is not None and len(grid_results_df) > 0: ax6 = fig.add_subplot(gs[1, 2]) scatter = ax6.scatter(grid_results_df['big_sentiment_threshold'], grid_results_df['big_trade_size_pct'], c=grid_results_df['profit_diff'], cmap='RdYlGn', s=100, alpha=0.6, edgecolors='black', linewidth=0.5) # Highlight optimal ax6.scatter([optimal_params['big_sentiment_threshold']], [optimal_params['big_trade_size_pct']], s=300, marker='*', color='gold', edgecolors='black', linewidth=2, zorder=5, label='Optimal') ax6.set_xlabel('Sentiment Threshold') ax6.set_ylabel('Trade Size (% of Capital)') ax6.set_title('Parameter Space: Strategy Parameters', fontweight='bold') ax6.legend() ax6.grid(True, alpha=0.3) cbar = plt.colorbar(scatter, ax=ax6) cbar.set_label('Profit Difference') else: ax6 = fig.add_subplot(gs[1, 2]) ax6.scatter([optimal_params['big_sentiment_threshold']], [optimal_params['big_trade_size_pct']], s=300, marker='*', color='gold', edgecolors='black', linewidth=2, zorder=5) ax6.set_xlabel('Sentiment Threshold') ax6.set_ylabel('Trade Size (% of Capital)') ax6.set_title('Optimal Configuration', fontweight='bold') ax6.grid(True, alpha=0.3) # Plot 7: Optimal Configuration Summary Table ax7 = fig.add_subplot(gs[2, :]) ax7.axis('off') summary_text = f""" OPTIMAL CONFIGURATION FOR BIG PLAYERS {'='*80} Parameters: Order Book Liquidity: {optimal_params['order_book_liquidity']:.1f} units/level Sentiment Threshold: {optimal_params['big_sentiment_threshold']:.3f} Volume Threshold: {optimal_params['big_volume_threshold']:.1f} units Trade Size (% of Capital): {optimal_params['big_trade_size_pct']:.1%} Fundamental Reversion: {optimal_params['fundamental_reversion']:.4f} Number of Big Players: {int(optimal_params['num_big_players'])} Performance Results ({num_simulations} simulations): Big Player Mean PnL: ${optimal_big_pnl:,.2f} Retail Mean PnL: ${optimal_retail_pnl:,.2f} Profit Difference: ${optimal_profit_diff:,.2f} Big Player Win Rate: {optimal_big_wr:.1%} Retail Win Rate: {optimal_retail_wr:.1%} Strategy Insight: Big players exploit retail FOMO by trading {optimal_params['big_trade_size_pct']:.1%} of capital when retail sentiment exceeds {optimal_params['big_sentiment_threshold']:.2f} and volume > {optimal_params['big_volume_threshold']:.0f}. Lower order book liquidity ({optimal_params['order_book_liquidity']:.0f}) creates more price impact, allowing big players to move markets more effectively. """ ax7.text(0.05, 0.5, summary_text, transform=ax7.transAxes, fontsize=11, verticalalignment='center', family='monospace', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8)) plt.suptitle('Genetic Algorithm Optimization: Optimal Configuration for Big Players\n' f'Maximizing Profit Difference (Big Player PnL - Retail PnL)', fontsize=16, fontweight='bold', y=0.995) return fig, optimal_params, optimal_results def create_comparison_figure(optimal_params, num_simulations=20): """ Create a comparison figure showing Optimal vs Default configuration """ print(" Creating comparison between optimal and default configurations...") # Default configuration default_params = { 'order_book_liquidity': 50, 'big_sentiment_threshold': 0.6, 'big_volume_threshold': 20, 'big_trade_size_pct': 0.20, 'fundamental_reversion': 0.01, 'num_big_players': 5 } # Evaluate both configurations opt_big_pnl, opt_retail_pnl, opt_profit_diff, opt_big_wr, opt_retail_wr, opt_big_pnls, opt_retail_pnls = evaluate_configuration( optimal_params, num_simulations=num_simulations, num_rounds=100 ) def_big_pnl, def_retail_pnl, def_profit_diff, def_big_wr, def_retail_wr, def_big_pnls, def_retail_pnls = evaluate_configuration( default_params, num_simulations=num_simulations, num_rounds=100 ) # Run one detailed simulation of each for trajectory plots opt_game = TradingGame( num_retail_traders=100, num_big_players=int(optimal_params['num_big_players']), initial_price=100, fundamental_value=100, volatility=0.02, order_book_liquidity=optimal_params['order_book_liquidity'], fundamental_reversion=optimal_params['fundamental_reversion'], big_sentiment_threshold=optimal_params['big_sentiment_threshold'], big_volume_threshold=optimal_params['big_volume_threshold'], big_trade_size_pct=optimal_params['big_trade_size_pct'] ) opt_results = opt_game.simulate_game(100) def_game = TradingGame( num_retail_traders=100, num_big_players=int(default_params['num_big_players']), initial_price=100, fundamental_value=100, volatility=0.02, order_book_liquidity=default_params['order_book_liquidity'], fundamental_reversion=default_params['fundamental_reversion'], big_sentiment_threshold=default_params['big_sentiment_threshold'], big_volume_threshold=default_params['big_volume_threshold'], big_trade_size_pct=default_params['big_trade_size_pct'] ) def_results = def_game.simulate_game(100) # Create figure fig = plt.figure(figsize=(18, 12)) gs = fig.add_gridspec(2, 3, hspace=0.35, wspace=0.3) # Plot 1: Price Evolution Comparison ax1 = fig.add_subplot(gs[0, 0]) ax1.plot(opt_results['round'], opt_results['price'], 'b-', linewidth=2.5, label='Optimal Config', zorder=3) ax1.plot(def_results['round'], def_results['price'], 'r--', linewidth=2, label='Default Config', alpha=0.7) ax1.axhline(100, color='gray', linestyle=':', linewidth=1.5, label='Fundamental Value', alpha=0.5) ax1.set_xlabel('Game Round') ax1.set_ylabel('Price') ax1.set_title('Price Evolution: Optimal vs Default', fontweight='bold') ax1.legend() ax1.grid(True, alpha=0.3) # Plot 2: Cumulative PnL Comparison ax2 = fig.add_subplot(gs[0, 1]) opt_retail_cum = opt_results['retail_pnl'].cumsum() opt_big_cum = opt_results['big_player_pnl'].cumsum() def_retail_cum = def_results['retail_pnl'].cumsum() def_big_cum = def_results['big_player_pnl'].cumsum() ax2.plot(opt_results['round'], opt_retail_cum, 'r-', linewidth=2, label='Optimal: Retail', alpha=0.6) ax2.plot(opt_results['round'], opt_big_cum, 'b-', linewidth=2.5, label='Optimal: Big Players', zorder=3) ax2.plot(def_results['round'], def_retail_cum, 'r--', linewidth=1.5, label='Default: Retail', alpha=0.5) ax2.plot(def_results['round'], def_big_cum, 'b--', linewidth=1.5, label='Default: Big Players', alpha=0.5) ax2.axhline(0, color='black', linestyle=':', linewidth=1, alpha=0.5) ax2.set_xlabel('Game Round') ax2.set_ylabel('Cumulative PnL') ax2.set_title('Cumulative PnL: Optimal vs Default', fontweight='bold') ax2.legend(fontsize=8) ax2.grid(True, alpha=0.3) # Plot 3: PnL Distribution Comparison ax3 = fig.add_subplot(gs[0, 2]) ax3.hist(opt_big_pnls, bins=20, alpha=0.6, label='Optimal: Big Players', color='blue', edgecolor='black', density=True) ax3.hist(def_big_pnls, bins=20, alpha=0.4, label='Default: Big Players', color='lightblue', edgecolor='black', linestyle='--', density=True, histtype='step', linewidth=2) ax3.axvline(0, color='black', linestyle='--', linewidth=1, alpha=0.5) ax3.axvline(opt_big_pnl, color='blue', linestyle=':', linewidth=2, alpha=0.7, label=f'Optimal Mean: ${opt_big_pnl:,.0f}') ax3.axvline(def_big_pnl, color='lightblue', linestyle=':', linewidth=2, alpha=0.7, label=f'Default Mean: ${def_big_pnl:,.0f}') ax3.set_xlabel('Total PnL') ax3.set_ylabel('Density') ax3.set_title('Big Player PnL Distribution', fontweight='bold') ax3.legend(fontsize=8) ax3.grid(True, alpha=0.3) # Plot 4: Performance Metrics Comparison ax4 = fig.add_subplot(gs[1, 0]) metrics = ['Mean PnL', 'Win Rate', 'Profit Diff'] optimal_values = [opt_big_pnl / 1000, opt_big_wr * 100, opt_profit_diff / 1000] # Scale for visibility default_values = [def_big_pnl / 1000, def_big_wr * 100, def_profit_diff / 1000] x = np.arange(len(metrics)) width = 0.35 bars1 = ax4.bar(x - width/2, optimal_values, width, label='Optimal', color='blue', alpha=0.7) bars2 = ax4.bar(x + width/2, default_values, width, label='Default', color='red', alpha=0.7) ax4.set_ylabel('Value (Scaled)') ax4.set_title('Big Player Performance: Optimal vs Default', fontweight='bold') ax4.set_xticks(x) ax4.set_xticklabels(metrics) ax4.legend() ax4.grid(True, alpha=0.3, axis='y') ax4.axhline(0, color='black', linestyle='--', linewidth=1) # Add value labels on bars for bars in [bars1, bars2]: for bar in bars: height = bar.get_height() ax4.text(bar.get_x() + bar.get_width()/2., height, f'{height:.1f}', ha='center', va='bottom', fontsize=8) # Plot 5: Parameter Comparison ax5 = fig.add_subplot(gs[1, 1]) param_names = ['Liquidity', 'Sentiment\nThreshold', 'Volume\nThreshold', 'Trade Size\n(%)', 'Reversion', 'Num Players'] optimal_params_list = [ optimal_params['order_book_liquidity'], optimal_params['big_sentiment_threshold'], optimal_params['big_volume_threshold'], optimal_params['big_trade_size_pct'] * 100, optimal_params['fundamental_reversion'] * 1000, optimal_params['num_big_players'] ] default_params_list = [ default_params['order_book_liquidity'], default_params['big_sentiment_threshold'], default_params['big_volume_threshold'], default_params['big_trade_size_pct'] * 100, default_params['fundamental_reversion'] * 1000, default_params['num_big_players'] ] x = np.arange(len(param_names)) bars1 = ax5.bar(x - width/2, optimal_params_list, width, label='Optimal', color='blue', alpha=0.7) bars2 = ax5.bar(x + width/2, default_params_list, width, label='Default', color='red', alpha=0.7) ax5.set_ylabel('Parameter Value') ax5.set_title('Configuration Parameters', fontweight='bold') ax5.set_xticks(x) ax5.set_xticklabels(param_names, fontsize=8) ax5.legend() ax5.grid(True, alpha=0.3, axis='y') # Plot 6: Summary Statistics ax6 = fig.add_subplot(gs[1, 2]) ax6.axis('off') summary_text = f""" PERFORMANCE COMPARISON ({num_simulations} simulations) {'='*50} OPTIMAL CONFIGURATION: Big Player Mean PnL: ${opt_big_pnl:,.2f} Retail Mean PnL: ${opt_retail_pnl:,.2f} Profit Difference: ${opt_profit_diff:,.2f} Big Player Win Rate: {opt_big_wr:.1%} Retail Win Rate: {opt_retail_wr:.1%} DEFAULT CONFIGURATION: Big Player Mean PnL: ${def_big_pnl:,.2f} Retail Mean PnL: ${def_retail_pnl:,.2f} Profit Difference: ${def_profit_diff:,.2f} Big Player Win Rate: {def_big_wr:.1%} Retail Win Rate: {def_retail_wr:.1%} IMPROVEMENT: PnL Improvement: ${opt_profit_diff - def_profit_diff:,.2f} Win Rate Improvement: {opt_big_wr - def_big_wr:+.1%} Relative Improvement: {(opt_profit_diff / def_profit_diff - 1) * 100:+.1f}% """ ax6.text(0.05, 0.5, summary_text, transform=ax6.transAxes, fontsize=10, verticalalignment='center', family='monospace', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8)) plt.suptitle('Optimal vs Default Configuration Comparison\n' f'Genetic Algorithm Optimization Results', fontsize=16, fontweight='bold', y=0.995) return fig def export_results_to_csv(results_df, nash_df, meta_stats, output_dir): """Export comprehensive results to CSV files for LaTeX paper writing""" import os # 1. Full game results results_df.to_csv(os.path.join(output_dir, 'game_theory_full_results.csv'), index=False) # 2. Per-game summary game_summary = [] for sim in results_df['simulation'].unique(): sim_data = results_df[results_df['simulation'] == sim] price_efficiency = 1 - np.abs(sim_data['price'].values - 100).mean() / 100 game_summary.append({ 'simulation': sim, 'final_price': sim_data['price'].iloc[-1], 'total_retail_pnl': sim_data['retail_pnl'].sum(), 'total_big_player_pnl': sim_data['big_player_pnl'].sum(), 'avg_retail_sentiment': sim_data['retail_sentiment'].mean(), 'retail_sentiment_volatility': sim_data['retail_sentiment'].std(), 'retail_volume_volatility': sim_data['retail_volume'].std(), 'sentiment_volume_correlation': sim_data['retail_sentiment'].corr(sim_data['retail_volume']), 'market_efficiency': max(0, price_efficiency), 'equilibrium_price': nash_df[nash_df['simulation'] == sim]['equilibrium_price'].values[0] if len(nash_df[nash_df['simulation'] == sim]) > 0 else np.nan, 'equilibrium_sentiment': nash_df[nash_df['simulation'] == sim]['equilibrium_retail_sentiment'].values[0] if len(nash_df[nash_df['simulation'] == sim]) > 0 else np.nan }) game_summary_df = pd.DataFrame(game_summary) game_summary_df.to_csv(os.path.join(output_dir, 'game_theory_per_game_summary.csv'), index=False) # 3. Meta-analysis summary meta_summary = [] for category, stats in meta_stats.items(): for metric, value in stats.items(): meta_summary.append({ 'category': category, 'metric': metric, 'value': value }) meta_summary_df = pd.DataFrame(meta_summary) meta_summary_df.to_csv(os.path.join(output_dir, 'game_theory_meta_analysis.csv'), index=False) # 4. Nash equilibrium summary nash_df.to_csv(os.path.join(output_dir, 'game_theory_nash_equilibria.csv'), index=False) print(f"\nCSV files exported to {output_dir}:") print(" - game_theory_full_results.csv (all round-by-round data)") print(" - game_theory_per_game_summary.csv (per-game aggregated metrics)") print(" - game_theory_meta_analysis.csv (meta-analysis across all games)") print(" - game_theory_nash_equilibria.csv (Nash equilibrium for each game)") if __name__ == "__main__": import os import sys # Check if optimization mode if len(sys.argv) > 1 and sys.argv[1] == '--optimize': print("=" * 60) print("GENETIC ALGORITHM OPTIMIZATION MODE") print("=" * 60) # Run grid search (faster for initial exploration) print("\n[Step 1] Running grid search optimization...") grid_results_df, optimal_from_grid = grid_search_optimization(num_simulations=5) # Use grid search result as starting point for genetic algorithm print("\n[Step 2] Running genetic algorithm optimization...") optimal_params, ga_result = genetic_optimization( num_generations=15, population_size=25, num_simulations=5 ) # Generate visualization print("\n[Step 3] Generating optimization visualization...") fig, optimal_params_final, optimal_results = plot_optimization_results( optimal_params, grid_results_df=grid_results_df, num_simulations=20 ) # Save figure script_dir = os.path.dirname(os.path.abspath(__file__)) figures_dir = os.path.join(script_dir, '..', 'figures') figures_path = os.path.abspath(figures_dir) os.makedirs(figures_path, exist_ok=True) output_path = os.path.join(figures_path, 'game_theory_optimization.png') plt.savefig(output_path, dpi=300, bbox_inches='tight') print(f"\nāœ“ Optimization figure saved to {output_path}") # Also create a comparison figure: Optimal vs Default configuration print("\n[Step 4] Generating comparison figure (Optimal vs Default)...") fig_comparison = create_comparison_figure(optimal_params_final, num_simulations=20) comparison_path = os.path.join(figures_path, 'game_theory_optimal_vs_default.png') plt.savefig(comparison_path, dpi=300, bbox_inches='tight') print(f"āœ“ Comparison figure saved to {comparison_path}") plt.close('all') # Save optimal configuration import json config_path = os.path.join(script_dir, '..', 'optimal_config.json') with open(config_path, 'w') as f: json.dump(optimal_params_final, f, indent=2) print(f"āœ“ Optimal configuration saved to {config_path}") print("\n" + "=" * 60) print("OPTIMIZATION COMPLETE!") print("=" * 60) print(f"Figures saved:") print(f" - {output_path}") print(f" - {comparison_path}") print(f"Configuration saved: {config_path}") print("=" * 60) else: # Standard analysis mode print("Running Game Theory Trading Simulation...") print("=" * 60) print("Modeling strategic interaction between:") print(" - Retail traders (FOMO-driven, herding behavior)") print(" - Big players (strategic, exploit retail behavior)") print(" - Finite repeated games (not infinite)") print("=" * 60) print("\nNote: Run with --optimize flag to find optimal configuration") print("=" * 60) num_games = 100 fig, results_df, nash_df, meta_stats = plot_game_analysis(num_simulations=num_games, show_random_games=10) # Save figure script_dir = os.path.dirname(os.path.abspath(__file__)) figures_dir = os.path.join(script_dir, '..', 'figures') figures_path = os.path.abspath(figures_dir) os.makedirs(figures_path, exist_ok=True) output_path = os.path.join(figures_path, 'game_theory_trading.png') plt.savefig(output_path, dpi=300, bbox_inches='tight') print(f"\nFigure saved to {output_path}") plt.close() # Export CSV files csv_output_dir = os.path.join(script_dir, '..') csv_output_path = os.path.abspath(csv_output_dir) export_results_to_csv(results_df, nash_df, meta_stats, csv_output_path) # Print meta-analysis summary print("\n=== Meta-Analysis Results (100 Games) ===") print(f"\nRetail Traders Performance:") print(f" Mean Final PnL: ${meta_stats['retail_pnl']['mean']:,.2f}") print(f" Median Final PnL: ${meta_stats['retail_pnl']['median']:,.2f}") print(f" Std Dev: ${meta_stats['retail_pnl']['std']:,.2f}") print(f" Win Rate: {meta_stats['retail_pnl']['win_rate']:.2%}") print(f" Sharpe Ratio: {meta_stats['retail_pnl']['sharpe']:.4f}") print(f"\nBig Players Performance:") print(f" Mean Final PnL: ${meta_stats['big_player_pnl']['mean']:,.2f}") print(f" Median Final PnL: ${meta_stats['big_player_pnl']['median']:,.2f}") print(f" Std Dev: ${meta_stats['big_player_pnl']['std']:,.2f}") print(f" Win Rate: {meta_stats['big_player_pnl']['win_rate']:.2%}") print(f" Sharpe Ratio: {meta_stats['big_player_pnl']['sharpe']:.4f}") print(f"\nNash Equilibrium Analysis:") print(f" Mean Equilibrium Price: ${meta_stats['nash_equilibrium']['mean_price']:.2f}") print(f" Std Dev Price: ${meta_stats['nash_equilibrium']['std_price']:.2f}") print(f" Mean Price Deviation: {meta_stats['nash_equilibrium']['mean_deviation']:.4f}") print(f" Mean Retail Sentiment: {meta_stats['nash_equilibrium']['mean_sentiment']:.4f}") print(f"\nMarket Efficiency:") print(f" Mean: {meta_stats['market_efficiency']['mean']:.4f}") print(f" Median: {meta_stats['market_efficiency']['median']:.4f}") print(f" Std Dev: {meta_stats['market_efficiency']['std']:.4f}") print(f" Range: [{meta_stats['market_efficiency']['min']:.4f}, {meta_stats['market_efficiency']['max']:.4f}]") print(f"\nFOMO and Herding Effects:") print(f" Average Sentiment Volatility: {meta_stats['fomo_herding']['avg_sentiment_volatility']:.4f}") print(f" Average Volume Volatility: {meta_stats['fomo_herding']['avg_volume_volatility']:.4f}") print(f" Sentiment-Volume Correlation: {meta_stats['fomo_herding']['sentiment_volume_correlation']:.4f} Ā± {meta_stats['fomo_herding']['sentiment_volume_correlation_std']:.4f}") print(f"\nExploitation Analysis:") print(f" Mean Exploitation Score: {meta_stats['exploitation']['mean']:.4f}") print(f" Median: {meta_stats['exploitation']['median']:.4f}") print(f" Std Dev: {meta_stats['exploitation']['std']:.4f}") print("\n" + "=" * 60) print("Key Insights:") print("1. Retail traders exhibit FOMO-driven behavior (sentiment-volume correlation)") print("2. Big players strategically exploit retail sentiment extremes") print("3. Games are finite, leading to different equilibria than infinite games") print("4. Market efficiency depends on the balance of power between players") print("5. Meta-analysis across 100 games provides robust statistical evidence") print("=" * 60)