Update ml_engine/hybrid_guardian.py

ml_engine/hybrid_guardian.py

@@ -1,5 +1,5 @@
 # ml_engine/hybrid_guardian.py
-# (V75.0 - GEM-Architect: Exact V3 Feature Match)
+# (V80.0 - GEM-Architect: Full V3 Feature Parity)
 
 import os
 import json
@@ -25,6 +25,7 @@ class HybridDeepSteward:
         self.model_v3 = None
         self.v3_feature_names = []
         self.initialized = False
+        self.verbose = True
         
         # Legacy V2 Features
         self.FEATS_1M = ['log_ret_1m', 'rsi_1m', 'fib_pos_1m', 'volatility_1m']
@@ -39,7 +40,7 @@ class HybridDeepSteward:
 
     def initialize(self):
         try:
-            print(f"🕸️ [Hybrid] Initializing Precision Guardians...")
+            if self.verbose: print(f"🕸️ [Hybrid] Initializing Precision Guardians...")
             if os.path.exists(self.v2_path):
                 self.model_v2 = xgb.Booster()
                 self.model_v2.load_model(self.v2_path)
@@ -51,7 +52,7 @@ class HybridDeepSteward:
             if os.path.exists(self.v3_features_path):
                 with open(self.v3_features_path, 'r') as f: 
                     self.v3_feature_names = json.load(f)
-                print(f"   -> Loaded V3 Map: {len(self.v3_feature_names)} features.")
+                if self.verbose: print(f"   -> Loaded V3 Map: {len(self.v3_feature_names)} features.")
             
             self.initialized = True
             return True
@@ -75,7 +76,7 @@ class HybridDeepSteward:
         except: return pd.DataFrame()
 
     # ==========================================================================
-    # 📐 V2 LEGACY FEATURE ENGINEERING
+    # 📐 V2 LEGACY FEATURE ENGINEERING (Keep working logic)
     # ==========================================================================
     def _calc_legacy_row(self, df, suffix):
         if len(df) < 15: return pd.Series()
@@ -130,15 +131,20 @@ class HybridDeepSteward:
         """Calculates Monte Carlo like stats on historical returns"""
         if len(returns_series) < 10: return 0, 0, 0, 0, 0
         r = returns_series.dropna()
-        skew_val = skew(r)
-        kurt_val = kurtosis(r)
-        prob_gain = (r > 0).mean()
-        var_95 = np.percentile(r, 5) # 5th percentile as VaR proxy
-        shock = (r.min() - r.mean()) / (r.std() + 1e-9)
-        return skew_val, kurt_val, prob_gain, var_95, shock
+        if len(r) < 5: return 0, 0, 0, 0, 0
+        
+        try:
+            skew_val = skew(r)
+            kurt_val = kurtosis(r)
+            prob_gain = (r > 0).mean()
+            var_95 = np.percentile(r, 5) # 5th percentile as VaR proxy
+            shock = (r.min() - r.mean()) / (r.std() + 1e-9)
+            return skew_val, kurt_val, prob_gain, var_95, shock
+        except:
+            return 0, 0, 0, 0, 0
 
     def _enrich_dataframe(self, df):
-        if len(df) < 50: return df
+        if len(df) < 30: return df
         c = df['close']
         
         # 1. Basic Indicators
@@ -146,53 +152,56 @@ class HybridDeepSteward:
         df['rsi_slope'] = self._calc_slope(df['rsi'])
         
         # 2. MACD
-        macd = ta.macd(c)
-        if macd is not None:
-            df['macd_h'] = macd.iloc[:, 1].fillna(0) # Histogram
-            df['macd_h_slope'] = self._calc_slope(df['macd_h'])
-        else:
-            df['macd_h'] = 0; df['macd_h_slope'] = 0
+        try:
+            macd = ta.macd(c)
+            if macd is not None and not macd.empty:
+                df['macd_h'] = macd.iloc[:, 1].fillna(0) # Histogram is usually 2nd column
+                df['macd_h_slope'] = self._calc_slope(df['macd_h'])
+            else:
+                df['macd_h'] = 0.0; df['macd_h_slope'] = 0.0
+        except:
+             df['macd_h'] = 0.0; df['macd_h_slope'] = 0.0
 
         # 3. ADX & Trend
-        adx = ta.adx(df['high'], df['low'], c)
-        if adx is not None:
-            df['adx'] = adx.iloc[:, 0].fillna(0)
-            df['dmp'] = adx.iloc[:, 1].fillna(0)
-            df['dmn'] = adx.iloc[:, 2].fillna(0)
-        else:
-            df['adx'] = 0; df['dmp'] = 0; df['dmn'] = 0
+        try:
+            adx = ta.adx(df['high'], df['low'], c)
+            if adx is not None and not adx.empty:
+                df['adx'] = adx.iloc[:, 0].fillna(0)
+                df['dmp'] = adx.iloc[:, 1].fillna(0)
+                df['dmn'] = adx.iloc[:, 2].fillna(0)
+            else:
+                df['adx'] = 0.0; df['dmp'] = 0.0; df['dmn'] = 0.0
+        except:
+            df['adx'] = 0.0; df['dmp'] = 0.0; df['dmn'] = 0.0
             
-        # Trend Net Force: (Close - EMA50) normalized by volatility or price
+        # Trend Net Force: (Close - EMA50) normalized
         ema50 = ta.ema(c, 50).fillna(c)
-        df['trend_net_force'] = (c - ema50) / c
+        df['trend_net_force'] = (c - ema50) / (c + 1e-9)
         
         # 4. EMAs
         df['ema_20'] = ta.ema(c, 20).fillna(c)
         df['ema_50'] = ema50
         df['ema_200'] = ta.ema(c, 200).fillna(c)
         
-        df['dist_ema20'] = (c - df['ema_20']) / c
-        df['dist_ema50'] = (c - df['ema_50']) / c
-        df['dist_ema200'] = (c - df['ema_200']) / c
+        df['dist_ema20'] = (c - df['ema_20']) / (c + 1e-9)
+        df['dist_ema50'] = (c - df['ema_50']) / (c + 1e-9)
+        df['dist_ema200'] = (c - df['ema_200']) / (c + 1e-9)
         df['slope_ema50'] = self._calc_slope(df['ema_50'], 5)
         
         # 5. Volatility & Volume
         df['atr'] = ta.atr(df['high'], df['low'], c, 14).fillna(0)
-        df['atr_rel'] = df['atr'] / c
+        df['atr_rel'] = df['atr'] / (c + 1e-9)
         
-        df['obv'] = ta.obv(c, df['volume']).fillna(0)
-        df['obv_slope'] = self._calc_slope(df['obv'], 5)
-        
-        df['cmf'] = ta.cmf(df['high'], df['low'], c, df['volume'], 20).fillna(0)
+        try:
+            df['obv'] = ta.obv(c, df['volume']).fillna(0)
+            df['obv_slope'] = self._calc_slope(df['obv'], 5)
+            df['cmf'] = ta.cmf(df['high'], df['low'], c, df['volume'], 20).fillna(0)
+        except:
+             df['obv'] = 0.0; df['obv_slope'] = 0.0; df['cmf'] = 0.0
         
-        # 6. Returns & MC Stats
+        # 6. Returns
         df['log_ret'] = np.log(c / c.shift(1)).fillna(0)
         
-        # Rolling MC Stats (Window 50)
-        rolling_rets = df['log_ret'].rolling(50)
-        # Note: Rolling apply is slow, using simplified approach for performance
-        # We calculate MC stats ONLY for the last row in _engineer_v3
-        
         return df
 
     def _engineer_v3_dataframe(self, ohlcv_1m, ohlcv_5m, ohlcv_15m):
@@ -201,7 +210,7 @@ class HybridDeepSteward:
             df5 = self._prepare_df(ohlcv_5m)
             df15 = self._prepare_df(ohlcv_15m)
             
-            if len(df1) < 50: return None
+            if len(df1) < 50: return None # V3 Needs more data
             
             # --- Enrich Dataframes ---
             df1 = self._enrich_dataframe(df1)
@@ -213,15 +222,15 @@ class HybridDeepSteward:
             r15 = df15.iloc[-1] if len(df15) > 0 else r1
             
             # --- MC Stats (On 1m History) ---
-            # We calculate this on the fly for the 1m returns window
+            # Calculates on the last 50 candles
             mc_skew, mc_kurt, mc_prob_gain, mc_var_95, mc_shock = self._calc_mc_stats(df1['log_ret'].tail(50))
             
             # --- MC Stats (On 5m History) ---
-            mc_prob_gain_5m = (df5['log_ret'].tail(20) > 0).mean() if len(df5) > 0 else 0
-            mc_shock_5m = (df5['log_ret'].min() - df5['log_ret'].mean()) / df5['log_ret'].std() if len(df5) > 20 else 0
+            mc_prob_gain_5m = (df5['log_ret'].tail(20) > 0).mean() if len(df5) > 20 else 0
+            mc_shock_5m = (df5['log_ret'].min() - df5['log_ret'].mean()) / (df5['log_ret'].std()+1e-9) if len(df5) > 20 else 0
 
             # --- MC Stats (On 15m History) ---
-            mc_prob_gain_15m = (df15['log_ret'].tail(20) > 0).mean() if len(df15) > 0 else 0
+            mc_prob_gain_15m = (df15['log_ret'].tail(20) > 0).mean() if len(df15) > 20 else 0
 
             # --- Construct Feature Map ---
             feats = {}
@@ -255,10 +264,11 @@ class HybridDeepSteward:
             feats['mc_prob_gain_15m'] = float(mc_prob_gain_15m)
             feats['dist_ema200_15m'] = float(r15.get('dist_ema200', 0.0))
 
-            # 4. Numbered Placeholders ("6" to "11")
-            # These are typically lag features or embeddings in V3. 
-            # We initialize them to 0.0 to prevent crash.
-            for i in range(6, 12): feats[str(i)] = 0.0
+            # 4. Numbered Placeholders (Placeholders in JSON)
+            # We initialize them to 0.0 to prevent crash if model uses embeddings
+            for i in range(0, 20): 
+                key = str(i)
+                if key in self.v3_feature_names: feats[key] = 0.0
 
             # --- Final Alignment ---
             df_aligned = pd.DataFrame(columns=self.v3_feature_names)
@@ -290,13 +300,13 @@ class HybridDeepSteward:
         if not self.initialized: return {'action': 'HOLD', 'scores': scores}
 
         try:
-            # V2
+            # V2 (Legacy)
             vec_v2 = self._engineer_legacy_v2_vector(ohlcv_1m, ohlcv_5m, ohlcv_15m)
             if vec_v2 is not None and self.model_v2:
                 pred_v2 = self.model_v2.predict(xgb.DMatrix(vec_v2))
                 scores['v2'] = float(pred_v2[0][2]) if len(pred_v2.shape)>1 else float(pred_v2[2]) if len(pred_v2)>1 else float(pred_v2[0])
 
-            # V3 (Now with Exact Features)
+            # V3 (Precision)
             if self.model_v3 and self.v3_feature_names:
                 df_v3 = self._engineer_v3_dataframe(ohlcv_1m, ohlcv_5m, ohlcv_15m)
                 if df_v3 is not None:
@@ -320,4 +330,5 @@ class HybridDeepSteward:
             return {'action': 'HOLD', 'reason': f'Monitor (V2:{v2:.2f} V3:{v3:.2f})', 'scores': scores}
 
         except Exception as e:
+            # traceback.print_exc()
             return {'action': 'HOLD', 'reason': 'Error', 'scores': scores}