Update backtest.py

backtest.py

@@ -24,18 +24,12 @@ def load_universe():
             df = df[df['ListDate'] < pd.to_datetime("2010-01-01")]
             
         tickers = [f"{x}.NS" for x in df['SYMBOL'].tolist()]
-        print(f"✅ Loaded {len(tickers)} historical tickers for Market-Wide AI Evaluation.")
+        print(f"✅ Loaded {len(tickers)} historical tickers for Pure Alpha Engine.")
         random.shuffle(tickers)
         return tickers[:250] 
     except:
         return ["RELIANCE.NS", "TCS.NS", "INFY.NS", "SBIN.NS", "HDFCBANK.NS", "ITC.NS"]
 
-def simulate_options(nifty_ret, trend_strength):
-    leverage = 1.0
-    if trend_strength > 0.05: leverage = 2.0 
-    elif trend_strength < -0.05: leverage = -2.0 
-    return (nifty_ret * leverage) - 0.0005 
-
 def run_strategy_genome(data, genome):
     if data.empty: return -1.0, []
     
@@ -50,9 +44,10 @@ def run_strategy_genome(data, genome):
     top_n = int(genome['top_n'])
     rebalance_days = int(genome['rebalance'])
     stop_loss = float(genome['stop_loss'])
+    trend_filter_days = int(genome['trend_filter']) # AI chosen crash detector
     
     momentum = stocks.pct_change(lookback)
-    nifty_ma = nifty.rolling(200).mean()
+    nifty_ma = nifty.rolling(trend_filter_days).mean()
     
     curve = [INITIAL_CAPITAL]
     curr_val = INITIAL_CAPITAL
@@ -66,33 +61,33 @@ def run_strategy_genome(data, genome):
         nxt = dates[min(i+rebalance_days, len(dates)-1)]
         
         try:
-            trend_strength = (nifty.loc[curr] / nifty_ma.loc[curr]) - 1
-            is_bull = trend_strength > 0
+            # 1.0x Maximum Capital Exposure Rule Enforced Here
+            is_bull = nifty.loc[curr] > nifty_ma.loc[curr]
             period_ret = 0.0
             
             if is_bull:
+                # ZERO LEVERAGE: 100% Cash Equities
                 if curr in momentum.index:
                     scores = momentum.loc[curr]
-                    scores = scores[scores > 0]
+                    scores = scores[scores > 0] # Must have positive absolute momentum
                     picks = scores.sort_values(ascending=False).head(top_n).index.tolist()
                     
                     if len(picks) > 0:
                         p1 = stocks.loc[curr, picks]
                         p2 = stocks.loc[nxt, picks]
+                        
+                        # 100% of money split evenly among the tight basket
                         stock_ret = ((p2 - p1) / p1).mean()
                         if pd.isna(stock_ret): stock_ret = 0.0
                         
-                        n_ret = (nifty.loc[nxt] - nifty.loc[curr]) / nifty.loc[curr]
-                        opt_ret = simulate_options(n_ret, trend_strength)
-                        
-                        period_ret = (0.8 * stock_ret) + (0.2 * opt_ret)
+                        period_ret = stock_ret 
             else:
+                # ZERO LEVERAGE BEAR HEDGE: 100% Gold (Safe Haven Investing)
                 g_ret = (gold.loc[nxt] - gold.loc[curr]) / gold.loc[curr]
-                n_ret = (nifty.loc[nxt] - nifty.loc[curr]) / nifty.loc[curr]
-                put_ret = simulate_options(n_ret, trend_strength)
-                period_ret = (0.5 * g_ret) + (0.5 * put_ret)
+                if pd.isna(g_ret): g_ret = 0.0
+                period_ret = g_ret
             
-            if pd.isna(period_ret): period_ret = 0.0
+            # Stop Loss Execution
             if period_ret < -stop_loss: period_ret = -stop_loss
                 
             curr_val = curr_val * (1 + period_ret)
@@ -112,7 +107,7 @@ def run_strategy_genome(data, genome):
     return cagr, pd.Series(curve, index=sim_dates)
 
 def backtest_engine():
-    print(f"⚙️ Initializing Hyper-Evolution Market Simulator...")
+    print(f"⚙️ Initializing Zero-Leverage 'Pure Alpha' Simulator...")
     start_time = time.time()
     
     tickers = load_universe()
@@ -126,23 +121,24 @@ def backtest_engine():
         data = data.ffill().bfill()
         if data.empty: return None
 
+        # --- AI GENOME EXPANSION ---
         population = []
         for _ in range(30):
             population.append({
-                'lookback': random.choice([10, 20, 30, 45, 60, 90, 120]), 
-                'top_n': random.choice([5, 8, 10, 15, 20]), 
-                'rebalance': random.choice([3, 5, 7, 10, 14, 21]), 
-                'stop_loss': random.choice([0.02, 0.04, 0.06, 0.08, 0.10])
+                'lookback': random.choice([5, 10, 15, 20, 30, 45, 60]), # Faster signal
+                'top_n': random.choice([2, 3, 4, 5]), # Tight Sector Basket
+                'rebalance': random.choice([2, 3, 5, 7, 10]), # High Velocity
+                'stop_loss': random.choice([0.02, 0.04, 0.06]), # Tight Risk
+                'trend_filter': random.choice([30, 50, 100, 200]) # AI decides crash sensitivity
             })
             
         best_cagr = -1.0
-        prev_cagr = -1.0
         best_curve = None
         stall_count = 0
         generation = 1
         
         while (time.time() - start_time) < (SIMULATION_TIME_MIN * 60):
-            print(f"\n🧬 Generation {generation}: Evaluating Portfolios...")
+            print(f"\n🧬 Generation {generation}: Evaluating Portfolios (Max 1.0x Exposure)...")
             results = []
             
             for genome in population:
@@ -154,7 +150,6 @@ def backtest_engine():
             if results:
                 current_top_cagr = results[0][0]
                 
-                # Stall Detection Logic
                 if current_top_cagr > best_cagr + 0.001: 
                     best_cagr = current_top_cagr
                     best_curve = results[0][1]
@@ -164,17 +159,15 @@ def backtest_engine():
                     stall_count += 1
                 
                 print(f"   🏆 Best: {best_cagr*100:.1f}% CAGR")
-                print(f"   🧬 Structure: Lookback {best_dna['lookback']}d | Basket of {best_dna['top_n']} Stocks | Rebalances Every {best_dna['rebalance']} Days | Stop Loss: {best_dna['stop_loss']*100}%")
+                print(f"   🧬 DNA: Lookback {best_dna['lookback']}d | Holds Top {best_dna['top_n']} Stocks | Rebalance: {best_dna['rebalance']}d | Regime Filter: {best_dna['trend_filter']}d SMA")
                 
                 if stall_count >= 3:
-                    print("   ⚠️ Genetic Bottleneck Detected. Triggering Hyper-Mutation Event!")
+                    print("   ⚠️ Evolution Stalled. Triggering Mass Mutation Event!")
                 
-                survivors = [x[2] for x in results[:6]] # Keep absolute best 6
+                survivors = [x[2] for x in results[:6]] 
                 new_pop = list(survivors) 
                 
-                # --- CROSSOVER & MUTATION ENGINE ---
                 while len(new_pop) < 30:
-                    # Mating: Combine traits from two top strategies
                     p1 = random.choice(survivors)
                     p2 = random.choice(survivors)
                     
@@ -182,20 +175,20 @@ def backtest_engine():
                         'lookback': p1['lookback'] if random.random() > 0.5 else p2['lookback'],
                         'top_n': p1['top_n'] if random.random() > 0.5 else p2['top_n'],
                         'rebalance': p1['rebalance'] if random.random() > 0.5 else p2['rebalance'],
-                        'stop_loss': p1['stop_loss'] if random.random() > 0.5 else p2['stop_loss']
+                        'stop_loss': p1['stop_loss'] if random.random() > 0.5 else p2['stop_loss'],
+                        'trend_filter': p1['trend_filter'] if random.random() > 0.5 else p2['trend_filter']
                     }
                     
-                    # Hyper-Mutation triggers if stuck
                     mutation_rate = 0.8 if stall_count >= 3 else 0.3
                     
-                    if random.random() < mutation_rate: child['lookback'] = random.choice([10, 20, 30, 45, 60, 90, 120])
-                    if random.random() < mutation_rate: child['top_n'] = random.choice([5, 8, 10, 15, 20])
-                    if random.random() < mutation_rate: child['rebalance'] = random.choice([3, 5, 7, 10, 14, 21])
-                    if random.random() < mutation_rate: child['stop_loss'] = random.choice([0.02, 0.04, 0.06, 0.08, 0.10])
+                    if random.random() < mutation_rate: child['lookback'] = random.choice([5, 10, 15, 20, 30, 45, 60])
+                    if random.random() < mutation_rate: child['top_n'] = random.choice([2, 3, 4, 5])
+                    if random.random() < mutation_rate: child['rebalance'] = random.choice([2, 3, 5, 7, 10])
+                    if random.random() < mutation_rate: child['stop_loss'] = random.choice([0.02, 0.04, 0.06])
+                    if random.random() < mutation_rate: child['trend_filter'] = random.choice([30, 50, 100, 200])
                     
                     new_pop.append(child)
                 
-                # If stuck for 4 rounds, wipe the board except for the #1 strategy
                 if stall_count >= 4:
                     stall_count = 0
                     
@@ -209,14 +202,14 @@ def backtest_engine():
         
         if best_curve is not None:
             plt.figure(figsize=(12, 7))
-            plt.plot(best_curve, label=f"Evolved Diversified Strategy ({best_cagr*100:.1f}%)", color='blue', linewidth=2)
+            plt.plot(best_curve, label=f"Zero-Leverage AI Strategy ({best_cagr*100:.1f}%)", color='blue', linewidth=2)
             
             nifty = data["^NSEI"]
             bench = (nifty.loc[best_curve.index] / nifty.loc[best_curve.index[0]]) * INITIAL_CAPITAL
             plt.plot(bench, label="Nifty 50 Index", color='gray', linestyle='--')
             
             plt.yscale('log')
-            plt.title("Renaissance Diversified Engine (Basket Trading)")
+            plt.title("Renaissance Pure Alpha Engine (0x Leverage / 100% Cash)")
             plt.ylabel("Portfolio Value (Log Scale)")
             plt.legend()
             plt.grid(True, alpha=0.3)