Upload simulate_v14_pendulums.py with huggingface_hub

simulate_v14_pendulums.py

@@ -0,0 +1,245 @@
+import pandas as pd
+import numpy as np
+
+def calculate_adx(df, period=14):
+    df['h_l'] = df['high'] - df['low']
+    df['h_pc'] = (df['high'] - df['close'].shift(1)).abs()
+    df['l_pc'] = (df['low'] - df['close'].shift(1)).abs()
+    df['tr'] = df[['h_l', 'h_pc', 'l_pc']].max(axis=1)
+    
+    df['+dm'] = np.where((df['high'] - df['high'].shift(1)) > (df['low'].shift(1) - df['low']), 
+                         np.maximum(df['high'] - df['high'].shift(1), 0), 0)
+    df['-dm'] = np.where((df['low'].shift(1) - df['low']) > (df['high'] - df['high'].shift(1)), 
+                         np.maximum(df['low'].shift(1) - df['low'], 0), 0)
+    
+    alpha = 1 / period
+    df['tr_smooth'] = df['tr'].ewm(alpha=alpha, adjust=False).mean() * period
+    df['+dm_smooth'] = df['+dm'].ewm(alpha=alpha, adjust=False).mean() * period
+    df['-dm_smooth'] = df['-dm'].ewm(alpha=alpha, adjust=False).mean() * period
+    
+    df['+di'] = 100 * (df['+dm_smooth'] / df['tr_smooth'])
+    df['-di'] = 100 * (df['-dm_smooth'] / df['tr_smooth'])
+    
+    df['dx'] = 100 * (df['+di'] - df['-di']).abs() / (df['+di'] + df['-di']).replace(0, 1)
+    df['adx'] = df['dx'].ewm(alpha=alpha, adjust=False).mean()
+    return df
+
+def run_simulation():
+    print("--- V14.19 Quatum Pendulum Simulator ---")
+    print("Loading OHLC Parquet data...")
+    m1 = pd.read_parquet('native_rates_M1.parquet')
+    m5 = pd.read_parquet('native_rates_M5.parquet')
+    m15 = pd.read_parquet('native_rates_M15.parquet')
+    
+    m1['time_dt'] = pd.to_datetime(m1['time'], unit='s')
+    m5['time_dt'] = pd.to_datetime(m5['time'], unit='s')
+    m15['time_dt'] = pd.to_datetime(m15['time'], unit='s')
+    
+    print("Calculating ADX & DMI Vectors...")
+    m1 = calculate_adx(m1, 14)
+    m5 = calculate_adx(m5, 14)
+    m15 = calculate_adx(m15, 14)
+    
+    m1.set_index('time_dt', inplace=True)
+    m5.set_index('time_dt', inplace=True)
+    m15.set_index('time_dt', inplace=True)
+    
+    df = m1[['open', 'high', 'low', 'close', 'adx', '+di', '-di']].copy()
+    df.rename(columns={'adx': 'adx_M1', '+di': 'di_plus_M1', '-di': 'di_minus_M1'}, inplace=True)
+    
+    m5_cols = m5[['adx', '+di', '-di']].rename(columns={'adx': 'adx_M5', '+di': 'di_plus_M5', '-di': 'di_minus_M5'})
+    df = df.join(m5_cols)
+    df[['adx_M5', 'di_plus_M5', 'di_minus_M5']] = df[['adx_M5', 'di_plus_M5', 'di_minus_M5']].ffill()
+    
+    m15_cols = m15[['adx', '+di', '-di']].rename(columns={'adx': 'adx_M15', '+di': 'di_plus_M15', '-di': 'di_minus_M15'})
+    df = df.join(m15_cols)
+    df[['adx_M15', 'di_plus_M15', 'di_minus_M15']] = df[['adx_M15', 'di_plus_M15', 'di_minus_M15']].ffill()
+    
+    df.dropna(inplace=True)
+    
+    # Static thresholds based on average spread
+    t_M1 = 18.0
+    t_M5 = 18.0 
+    t_M15 = 18.0
+    
+    print("Mapping 8 Quantum Phases...")
+    a1 = (df['adx_M1'] >= t_M1).astype(int)
+    a5 = (df['adx_M5'] >= t_M5).astype(int)
+    a15 = (df['adx_M15'] >= t_M15).astype(int)
+    
+    # 8-Phase Mapping (Binary Logic)
+    df['phase'] = 1
+    df.loc[(a15==0) & (a5==0) & (a1==0), 'phase'] = 1
+    df.loc[(a15==0) & (a5==0) & (a1==1), 'phase'] = 2
+    df.loc[(a15==0) & (a5==1) & (a1==0), 'phase'] = 3
+    df.loc[(a15==1) & (a5==0) & (a1==0), 'phase'] = 4
+    df.loc[(a15==0) & (a5==1) & (a1==1), 'phase'] = 5
+    df.loc[(a15==1) & (a5==0) & (a1==1), 'phase'] = 6
+    df.loc[(a15==1) & (a5==1) & (a1==0), 'phase'] = 7
+    df.loc[(a15==1) & (a5==1) & (a1==1), 'phase'] = 8
+    
+    df['phase_prev'] = df['phase'].shift(1)
+    df['phase_transition'] = df['phase'] != df['phase_prev']
+    
+    # DMI Score (using M15 as commanding direction)
+    sum_di = df['di_plus_M15'] + df['di_minus_M15']
+    df['dmi_dir'] = np.where(df['di_plus_M15'] > df['di_minus_M15'], 1, -1)
+    df['dmi_score'] = (df[['di_plus_M15', 'di_minus_M15']].max(axis=1) / sum_di) * 100
+    
+    # DMI Score M5 (for Death Zone check)
+    sum_di_m5 = df['di_plus_M5'] + df['di_minus_M5']
+    df['dmi_dir_m5'] = np.where(df['di_plus_M5'] > df['di_minus_M5'], 1, -1)
+    df['dmi_score_m5'] = (df[['di_plus_M5', 'di_minus_M5']].max(axis=1) / sum_di_m5) * 100
+
+    # Tick Phase Age
+    age = []
+    current_age = 0
+    curr_p = df['phase'].iloc[0]
+    for p in df['phase']:
+        if p == curr_p:
+            current_age += 1
+        else:
+            current_age = 1
+            curr_p = p
+        age.append(current_age)
+    df['phase_age'] = age
+    
+    print("Executing FULL 4-Pendulum Trigger Matrix V14.19...\n")
+    
+    stats = {
+        'L0_Mega': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 3.0},
+        'L0_Snipe': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 2.0},
+        'L0_Scout': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 1.0},
+        'D0_Grinder': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 1.0},
+        'R0_Fade': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 1.5},
+        'DeathZone_Trap': {'trades': 0, 'wins': 0, 'total_pips': 0.0, 'mult': 1.0}
+    }
+    
+    stats_L0_Trap = {'dodges': 0}
+
+    # Simulate entries
+    tp_pips = 30.0
+    sl_pips = 30.0
+    tp_d0 = 15.0 # D0 takes smaller cuts
+    sl_d0 = 15.0
+    tp_r0 = 20.0 # R0 (Fade) takes quick mean-reversion scalps
+    sl_r0 = 20.0
+    
+    for i in range(1, len(df)-60):
+        if df['phase_transition'].iloc[i]:
+            pf_prev = df['phase_prev'].iloc[i]
+            pf_curr = df['phase'].iloc[i]
+            dmi_score = df['dmi_score'].iloc[i]
+            dir_mult = df['dmi_dir'].iloc[i] 
+            
+            entry_price = df['close'].iloc[i]
+            gun = None
+            is_d0 = False
+            is_r0 = False
+            is_deathzone = False
+            
+            # --- Pendulum 4 (#5 -> #8): Mega & Snipe ---
+            if pf_prev == 5 and pf_curr == 8:
+                if dmi_score > 75:
+                    gun = 'L0_Mega'
+                elif dmi_score > 65:
+                    gun = 'L0_Snipe'
+                    
+            # --- The Return Stroke (#8 -> #7): R0 Fade ---
+            elif pf_prev == 8 and pf_curr == 7:
+                # Trạng thái rớt đài của siêu Trend (M1 rụng), nảy sinh nhịp Pullback ngược hướng
+                gun = 'R0_Fade'
+                is_r0 = True
+                dir_mult = dir_mult * -1  # Bắn ngược lại với hướng Trend chính
+                    
+            # --- Pendulum 2 (#4 -> #7) : Scout ---
+            elif pf_prev == 4 and pf_curr == 7:
+                if dmi_score > 55:
+                    gun = 'L0_Scout'
+                    
+            # --- Pendulum 1 (#1 <-> #2) : D0 Grinder ---
+            elif (pf_prev == 1 and pf_curr == 2) or (pf_prev == 2 and pf_curr == 1):
+                if dmi_score < 60: # Neutral DMI
+                    gun = 'D0_Grinder'
+                    is_d0 = True
+                    dir_mult = 1 if df['close'].iloc[i] < df['open'].iloc[i] else -1
+
+            # --- Pendulum 3 (#3 <-> #6) : DEATH ZONE TRAP ---
+            elif pf_prev == 3 and pf_curr == 6:
+                gun = 'DeathZone_Trap'
+                dir_mult = df['dmi_dir_m5'].iloc[i] 
+                is_deathzone = True
+                
+            if gun is None:
+                continue
+                
+            future_highs = df['high'].iloc[i+1:i+61]
+            future_lows = df['low'].iloc[i+1:i+61]
+            
+            pnl = 0
+            win = 0
+            
+            # Dynamic TP/SL setup
+            t_tp = tp_pips
+            t_sl = sl_pips
+            if is_d0:
+                t_tp, t_sl = tp_d0, sl_d0
+            elif is_r0:
+                t_tp, t_sl = tp_r0, sl_r0
+            
+            if dir_mult == 1: 
+                for h, l in zip(future_highs, future_lows):
+                    if h >= entry_price + (t_tp * 0.01):
+                        pnl = t_tp
+                        win = 1
+                        break
+                    elif l <= entry_price - (t_sl * 0.01):
+                        pnl = -t_sl
+                        win = 0
+                        break
+            else: 
+                for h, l in zip(future_highs, future_lows):
+                    if l <= entry_price - (t_tp * 0.01):
+                        pnl = t_tp
+                        win = 1
+                        break
+                    elif h >= entry_price + (t_sl * 0.01):
+                        pnl = -t_sl
+                        win = 0
+                        break
+                        
+            # If no exit hit in 60 mins (closed by time)
+            if pnl == 0:
+                pnl = ((df['close'].iloc[i+60] - entry_price) / 0.01) * dir_mult
+                if pnl > 0: win = 1
+            
+            stats[gun]['trades'] += 1
+            stats[gun]['wins'] += win
+            stats[gun]['total_pips'] += pnl
+                
+        # --- Trap Dodge Verification ---
+        if df['phase'].iloc[i] == 8 and df['phase_age'].iloc[i] == 50:
+            stats_L0_Trap['dodges'] += 1
+    
+    # Print Dashboard
+    print(f"|=================================================|")
+    print(f"|    FULL 4-PENDULUM MATRIX BACKTEST (10 DAYS)    |")
+    print(f"|=================================================|")
+    
+    for name, s in stats.items():
+        tr = s['trades']
+        if tr == 0:
+            print(f" * {name:<14} | Trades: 0")
+            continue
+        wr = (s['wins']/tr)*100
+        net_profit = s['total_pips'] * s['mult']
+        if "DeathZone" in name:
+            print(f" ☠️ {name:<14} | Trades: {tr:<4} | WinRate: {wr:>5.1f}% | Net Margin Delta: {net_profit:+.1f} units")
+        else:
+            print(f" * {name:<14} | Trades: {tr:<4} | WinRate: {wr:>5.1f}% | Net Margin Delta: {net_profit:+.1f} units")
+        
+    print(f"\\n - L0_Trap (Old L0 Top Execution Prevented): Avoided {stats_L0_Trap['dodges']} exact local tops/bottoms.")
+    print(f"|=================================================|")
+
+if __name__ == '__main__':
+    run_simulation()