Rename ml_engine/titan_engine.py to ml_engine/pattern_engine.py

ml_engine/{titan_engine.py → pattern_engine.py}

@@ -1,9 +1,9 @@
 # ==============================================================================
-# 🛡️ ml_engine/titan_engine.py (V3.1 - Fix List vs DataFrame Issue)
+# 🧠 ml_engine/pattern_engine.py (Formerly Titan)
 # ==============================================================================
 # GEM-Architect Approved
-# - Fixes AttributeError: 'list' object has no attribute 'empty'
-# - Auto-converts raw list data to Pandas DataFrame with correct columns.
+# - Renamed from TitanEngine to PatternEngine (Semantic Consistency).
+# - Logic: ResNet-1D for Pattern Recognition (Neural Network).
 # ==============================================================================
 
 import os
@@ -18,7 +18,7 @@ import warnings
 warnings.filterwarnings('ignore')
 
 # ------------------------------------------------------------------------------
-# 1. Model Architecture (Must match training EXACTLY)
+# 1. Model Architecture (ResNet-1D)
 # ------------------------------------------------------------------------------
 class ResidualBlock(nn.Module):
     def __init__(self, channels, kernel_size=3, dropout=0.2):
@@ -42,7 +42,7 @@ class ResidualBlock(nn.Module):
         out = self.relu(out)
         return out
 
-class TitanResNet(nn.Module):
+class PatternResNet(nn.Module):
     def __init__(self, in_ch):
         super().__init__()
         self.entry = nn.Sequential(
@@ -86,17 +86,17 @@ class TitanResNet(nn.Module):
 # ------------------------------------------------------------------------------
 # 2. Production Engine Class
 # ------------------------------------------------------------------------------
-class TitanEngine:
+class PatternEngine:
     def __init__(self, model_dir="ml_models/Unified_Models_V1"):
+        # We assume the model file name remains 'cnn_best.pt' inside the folder
         self.model_path = os.path.join(model_dir, "cnn_best.pt")
         self.scaler_path = os.path.join(model_dir, "seq_scaler.pkl")
         
         self.model = None
         self.scaler = None
-        self.device = torch.device("cpu") # Inference on CPU is safer for web apps
+        self.device = torch.device("cpu") 
         self.initialized = False
         
-        # Exact Features used in Training
         self.features_list = [
             "log_ret","vol_spike","taker_buy_ratio","proxy_spread","amihud","avg_ticket_usd",
             "upper_wick_ratio","lower_wick_ratio","body_to_range","atr_pct_signal"
@@ -104,41 +104,33 @@ class TitanEngine:
         self.WINDOW_SIZE = 64
 
     async def initialize(self):
-        """Load Model and Scaler"""
         if self.initialized: return True
         
-        print(f"🛡️ [Titan] Initializing PyTorch Engine from {self.model_path}...")
+        print(f"🧠 [PatternNet] Initializing Neural Network from {self.model_path}...")
         try:
             if not os.path.exists(self.model_path) or not os.path.exists(self.scaler_path):
-                print(f"❌ [Titan] Artifacts missing in {self.model_path}")
+                print(f"❌ [PatternNet] Artifacts missing in {self.model_path}")
                 return False
 
-            # 1. Load Scaler
             self.scaler = joblib.load(self.scaler_path)
+            self.model = PatternResNet(in_ch=len(self.features_list)).to(self.device)
             
-            # 2. Load Model
-            # We initialize the architecture first
-            self.model = TitanResNet(in_ch=len(self.features_list)).to(self.device)
-            
-            # Safe loading for CPU
             checkpoint = torch.load(self.model_path, map_location=self.device)
             if isinstance(checkpoint, dict) and 'model' in checkpoint:
                 self.model.load_state_dict(checkpoint['model'])
             else:
                 self.model.load_state_dict(checkpoint)
             
-            self.model.eval() # Set to evaluation mode
-            
+            self.model.eval()
             self.initialized = True
-            print(f"✅ [Titan] Online. ResNet-1D Loaded successfully.")
+            print(f"✅ [PatternNet] Online. ResNet-1D Ready for Pattern Recognition.")
             return True
             
         except Exception as e:
-            print(f"❌ [Titan] Init Error: {e}")
+            print(f"❌ [PatternNet] Init Error: {e}")
             traceback.print_exc()
             return False
 
-    # --- Feature Engineering Helpers (MATCHING TRAINING LOGIC) ---
     def _wilder_rma(self, x, n):
         x = np.asarray(x, dtype=float)
         return pd.Series(x).ewm(alpha=1.0/n, adjust=False).mean().values
@@ -150,123 +142,80 @@ class TitanEngine:
         return pd.Series(x).rolling(w, min_periods=1).median().values
 
     def preprocess_live_data(self, df):
-        """
-        Turns raw OHLCV DataFrame into the exact Feature Matrix used for training.
-        Assuming 'df' has at least 100 rows.
-        """
         try:
             df = df.copy()
-            # Ensure sorting if timestamp exists, else assume ordered list
-            if 'timestamp' in df.columns:
-                df = df.sort_values('timestamp')
+            if 'timestamp' in df.columns: df = df.sort_values('timestamp')
             
-            # Basic conversions
             close = df['close'].values.astype(float)
             high = df['high'].values.astype(float)
             low = df['low'].values.astype(float)
             open_ = df['open'].values.astype(float)
-            # Use quote volume if available (better for vol_usd), else close * vol
-            if 'quote_volume' in df.columns:
-                vol_usd = df['quote_volume'].values.astype(float)
-            else:
-                vol_usd = (close * df['volume'].values).astype(float)
+            
+            if 'quote_volume' in df.columns: vol_usd = df['quote_volume'].values.astype(float)
+            else: vol_usd = (close * df['volume'].values).astype(float)
                 
             vol_usd = np.maximum(vol_usd, 1.0)
             
-            # 1. ATR (14)
             prev_close = np.roll(close, 1); prev_close[0] = close[0]
             tr = np.maximum(high - low, np.maximum(np.abs(high - prev_close), np.abs(low - prev_close)))
             atr = self._wilder_rma(tr, 14)
             atr_safe = np.maximum(atr, 1e-9)
             
-            # 2. Features Calculation
             df['log_ret'] = np.log(close / np.maximum(prev_close, 1e-9))
-            
             vol_ma = self._rolling_mean(vol_usd, 20)
             df['vol_spike'] = vol_usd / np.maximum(vol_ma, 1e-9)
             
-            # Taker buy ratio (if available, else 0.5 default)
             if 'taker_buy_base_asset_volume' in df.columns:
                 taker_vol = df['taker_buy_base_asset_volume'].values * close
                 df['taker_buy_ratio'] = taker_vol / vol_usd
-            else:
-                df['taker_buy_ratio'] = 0.5
+            else: df['taker_buy_ratio'] = 0.5
                 
             raw_spread = (high - low) / np.maximum(close, 1e-9)
             df['proxy_spread'] = self._rolling_median(raw_spread, 14) * 0.5
-            
             df['amihud'] = np.abs(df['log_ret']) / vol_usd
             
-            # Num trades proxy (if not available)
-            if 'num_trades' in df.columns:
-                num_trades = df['num_trades'].values
-            else:
-                num_trades = vol_usd / 1000.0 # Rough estimate
+            if 'num_trades' in df.columns: num_trades = df['num_trades'].values
+            else: num_trades = vol_usd / 1000.0 
             df['avg_ticket_usd'] = vol_usd / np.maximum(num_trades, 1.0)
             
             rng = np.maximum(high - low, 1e-9)
             df['upper_wick_ratio'] = (high - np.maximum(open_, close)) / rng
             df['lower_wick_ratio'] = (np.minimum(open_, close) - low) / rng
             df['body_to_range'] = np.abs(close - open_) / rng
-            
             df['atr_pct_signal'] = atr_safe / close
             
-            # Filter NaNs
             df = df.replace([np.inf, -np.inf], np.nan).fillna(0)
             
-            # Extract only the needed window (last 64 candles)
-            if len(df) < self.WINDOW_SIZE:
-                return None
-                
-            # Get the feature matrix for the LAST window
-            # We take the last 64 rows of the required features
+            if len(df) < self.WINDOW_SIZE: return None
             feature_matrix = df[self.features_list].iloc[-self.WINDOW_SIZE:].values.astype(np.float32)
-            
             return feature_matrix
             
         except Exception as e:
-            print(f"❌ [Titan] Preprocessing Error: {e}")
+            print(f"❌ [PatternNet] Preprocessing Error: {e}")
             return None
 
     def predict(self, ohlcv_data: dict) -> dict:
-        """
-        Main Interface used by Processor.
-        Handles both List and DataFrame inputs robustly.
-        """
         if not self.initialized: return {'score': 0.0, 'error': 'Not Initialized'}
         
         try:
-            # We use 15m data as the main driver
             target_tf = '15m'
             raw_data = ohlcv_data.get(target_tf)
-            
-            if raw_data is None:
-                return {'score': 0.0, 'error': 'No 15m Data'}
+            if raw_data is None: return {'score': 0.0, 'error': 'No 15m Data'}
 
-            # ✅ FIX: Auto-detect List vs DataFrame
             if isinstance(raw_data, list):
-                # Standard CCXT OHLCV structure: [timestamp, open, high, low, close, volume]
                 df = pd.DataFrame(raw_data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
             elif isinstance(raw_data, pd.DataFrame):
                 df = raw_data
-            else:
-                return {'score': 0.0, 'error': f'Invalid Data Type: {type(raw_data)}'}
+            else: return {'score': 0.0, 'error': f'Invalid Data Type'}
             
-            if df.empty:
-                return {'score': 0.0, 'error': 'Empty Data'}
+            if df.empty: return {'score': 0.0, 'error': 'Empty Data'}
             
-            # Preprocess
             X_raw = self.preprocess_live_data(df)
-            if X_raw is None:
-                return {'score': 0.0, 'error': 'Not enough data for window'}
+            if X_raw is None: return {'score': 0.0, 'error': 'Not enough data'}
             
-            # Scale
             X_scaled = self.scaler.transform(X_raw)
-            
-            # Prepare Tensor
             X_tensor = torch.tensor(X_scaled.T).unsqueeze(0).to(self.device)
             
-            # Inference
             with torch.no_grad():
                 logits = self.model(X_tensor)
                 probs = torch.softmax(logits, dim=1).cpu().numpy()[0]
@@ -278,6 +227,6 @@ class TitanEngine:
             }
 
         except Exception as e:
-            print(f"❌ [Titan] Inference Error: {e}")
+            print(f"❌ [PatternNet] Inference Error: {e}")
             traceback.print_exc()
             return {'score': 0.0, 'error': str(e)}