Deploy: Trainer to Root (Retry)

.dockerignore

@@ -0,0 +1,27 @@
+# Exclude Version Control
+.git
+.gitignore
+
+# Exclude Virtual Environment
+venv/
+env/
+.env
+
+# Exclude Python Cache
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Exclude Local Data (Can be huge)
+data/
+start_data/
+ray_results/
+
+# Exclude IDE settings
+.vscode/
+.idea/
+.DS_Store
+
+# Exclude Logs
+*.log

AIDocs/ARCHITECTURE_HT_TRADER.md

@@ -0,0 +1,380 @@
+# 📘 HT-TRADER - Nguyên lý hoạt động chi tiết
+
+## 🎯 Vai trò chính
+`ht-trader` là **execution engine** của HyperTrade - chịu trách nhiệm:
+1. Nhận trading signals từ `ht-brain`
+2. Kiểm tra risk management
+3. Thực thi lệnh trên exchange (hoặc paper trading)
+4. Quản lý positions (mở/đóng/DCA)
+5. Ghi nhận trades vào QuestDB
+
+---
+
+## 🔄 Luồng hoạt động chính
+
+### 1. **Khởi tạo (Initialization)**
+```python
+class Trader:
+    def __init__(self):
+        # Redis Pub/Sub - Lắng nghe 3 channels:
+        self.pubsub.subscribe("signals", "system_commands", "l2_updates")
+        
+        # Components:
+        self.risk_manager = RiskManager()           # Kiểm tra risk
+        self.exchange_client = ExchangeClient()     # Giao tiếp với exchange
+        self.position_manager = PositionManager()   # Quản lý positions
+        self.ab_manager = ABTestManager()           # A/B testing strategies
+        
+        # State:
+        self.trading_enabled = True                 # Master switch
+        self.positions = {}                         # Open positions
+        self.orderbooks = {}                        # Latest L2 data
+```
+
+**Giải thích:**
+- Subscribe 3 channels để nhận:
+  - `signals`: Trading signals từ ht-brain
+  - `system_commands`: Lệnh điều khiển (STOP_TRADING, etc.)
+  - `l2_updates`: Orderbook data cho paper trading
+
+---
+
+### 2. **Main Loop - Lắng nghe messages**
+```python
+def run(self):
+    while self.running:
+        message = self.pubsub.get_message()
+        
+        if channel == 'signals':
+            self.process_signal(signal_data)      # Xử lý signal
+            
+        elif channel == 'system_commands':
+            self.process_command(cmd_data)        # Xử lý lệnh
+            
+        elif channel == 'l2_updates':
+            self.orderbooks[coin] = data          # Cập nhật orderbook
+```
+
+**Giải thích:**
+- Loop chạy liên tục, check messages mỗi 0.01s
+- Phân loại message theo channel và xử lý tương ứng
+
+---
+
+### 3. **Xử lý Signal (process_signal)**
+
+#### **Bước 1: Kiểm tra trading enabled**
+```python
+if not self.trading_enabled:
+    logger.warning("Signal ignored: TRADING DISABLED")
+    return
+```
+
+#### **Bước 2: Parse signal data**
+```python
+coin = signal_data.get("coin")           # BTC, ETH, SOL
+signal = signal_data.get("signal")       # BUY, SELL, HOLD
+confidence = float(signal_data.get("confidence", 0))
+price = float(signal_data.get("price", 0))
+reason = signal_data.get("reason")       # Lý do signal
+features = signal_data.get("features", {})  # Features từ Brain
+```
+
+#### **Bước 3: Check Exit Conditions (Quan trọng!)**
+```python
+should_close, close_reason = self.position_manager.check_exit_condition(coin, signal, price)
+
+if should_close:
+    # Đóng position hiện tại
+    pos = self.position_manager.open_positions.get(coin)
+    qty_to_close = abs(pos['quantity'])
+    close_signal = 'SELL' if pos['side'] == 'LONG' else 'BUY'
+    
+    self.execute_trade(coin, close_signal, price, qty_to_close, close_reason, ...)
+    return
+```
+
+**Exit conditions bao gồm:**
+- ✅ **Take Profit**: PnL > threshold
+- ✅ **Stop Loss**: PnL < -threshold
+- ✅ **Reversal Signal**: Signal ngược chiều + PnL dương
+- ❌ **Hold**: Signal ngược chiều nhưng PnL âm (chờ hồi vốn)
+
+#### **Bước 4: Entry Logic (Nếu không close)**
+```python
+# A/B Testing - Chọn strategy
+strategy_config = self.ab_manager.get_assignment(coin, user_id)
+size_usd = strategy_config.get('size_usd', 1000.0)
+quantity = size_usd / price
+
+# Tính current exposure
+current_exposure = sum(abs(pos['quantity']) * pos_price 
+                      for pos in self.position_manager.open_positions.values())
+
+# Risk Check
+allowed, rejection_reason = self.risk_manager.check_trade(
+    coin, signal, price, quantity, current_exposure
+)
+
+if not allowed:
+    logger.warning(f"Trade Rejected: {rejection_reason}")
+    return
+```
+
+**Risk checks bao gồm:**
+- ✅ Max position size per coin
+- ✅ Max total exposure
+- ✅ Max drawdown
+- ✅ Confidence threshold
+
+#### **Bước 5: Execute Trade**
+```python
+self.execute_trade(coin, signal, price, quantity, reason, features, strategy_id)
+```
+
+---
+
+### 4. **Execute Trade (execute_trade)**
+
+#### **Bước 1: Place order trên exchange**
+```python
+result = self.exchange_client.place_order(coin, signal, quantity, price, orderbook=orderbook)
+```
+
+**Exchange Client modes:**
+- **Paper Trading**: Simulate order với L2 orderbook data
+- **Live Trading**: Gửi order thật lên Hyperliquid
+
+#### **Bước 2: Update Position Manager**
+```python
+trade_id = str(uuid.uuid4())
+self.position_manager.handle_fill(coin, signal, price, quantity, trade_id, features)
+```
+
+**Position Manager tracking:**
+- Open positions: `{coin: {side, quantity, entry_price, pnl, ...}}`
+- Closed positions: Lưu vào QuestDB
+
+#### **Bước 3: Log trade vào QuestDB**
+```python
+self.db_sender.sender.row(
+    'trades_executed',
+    symbols={
+        'trade_id': trade_id,
+        'coin': coin,
+        'side': signal,
+        'status': 'SUBMITTED',
+        'strategy_id': strategy_id,
+        'environment': 'PAPER'
+    },
+    columns={
+        'entry_price': price,
+        'quantity': quantity,
+        'entry_fee': quantity * price * TAKER_FEE_RATE,
+        'current_pnl': 0.0,
+        'features_json': json.dumps(features),
+        'notes': reason
+    }
+)
+```
+
+#### **Bước 4: Publish trade update**
+```python
+update_msg = {
+    'event': 'trade_opened',
+    'trade_id': trade_id,
+    'coin': coin,
+    'side': signal,
+    'price': price,
+    'quantity': quantity
+}
+self.redis_client.publish('trade_updates', json.dumps(update_msg))
+```
+
+---
+
+### 5. **System Commands (process_command)**
+
+```python
+def process_command(self, cmd_data):
+    command = cmd_data.get('command')
+    
+    if command == 'STOP_TRADING':
+        self.trading_enabled = False      # Dừng nhận signals mới
+        
+    elif command == 'START_TRADING':
+        self.trading_enabled = True       # Bật lại trading
+        
+    elif command == 'REDUCE_RISK':
+        # Giảm max position size xuống 50%
+        new_limit = max(current_limit * 0.5, 100.0)
+        self.risk_manager.update_policy('max_position_size_usd', new_limit)
+        
+    elif command == 'INCREASE_RISK':
+        # Tăng max position size lên 150%
+        new_limit = min(current_limit * 1.5, 5000.0)
+        self.risk_manager.update_policy('max_position_size_usd', new_limit)
+        
+    elif command == 'RESET_POSITIONS':
+        # Reset tất cả positions (emergency)
+        self.position_manager.reset()
+```
+
+---
+
+## 📊 Data Flow Diagram
+
+```
+┌─────────────┐
+│  ht-brain   │ ──► signals ──► ┌──────────────┐
+└─────────────┘                 │              │
+                                │  ht-trader   │
+┌─────────────┐                 │              │
+│ ht-manager  │ ──► system_commands ──► │      │
+└─────────────┘                 │              │
+                                │   ┌──────┐   │
+┌─────────────┐                 │   │ Risk │   │
+│ ht-l2-data  │ ──► l2_updates ──► │ Check│   │
+└─────────────┘                 │   └──────┘   │
+                                │      ↓       │
+                                │   Execute    │
+                                │      ↓       │
+                                │  ┌────────┐  │
+                                │  │Exchange│  │
+                                │  └────────┘  │
+                                │      ↓       │
+                                │  ┌────────┐  │
+                                │  │QuestDB │  │
+                                │  └────────┘  │
+                                └──────────────┘
+```
+
+---
+
+## 🎯 Key Features
+
+### 1. **Smart Exit Logic**
+- Không đóng position khi PnL âm (chờ hồi vốn)
+- Tự động take profit khi đạt target
+- Stop loss khi loss quá lớn
+
+### 2. **DCA (Dollar Cost Averaging)**
+- Cho phép add thêm vào position cùng chiều
+- Tính average entry price
+
+### 3. **Risk Management**
+- Max position size per coin
+- Max total exposure
+- Confidence threshold filtering
+
+### 4. **A/B Testing**
+- Test nhiều strategies song song
+- Track performance từng strategy
+
+### 5. **Paper Trading**
+- Simulate trades với L2 orderbook
+- Không cần real money để test
+
+---
+
+## 🔧 Configuration
+
+### Risk Policy (risk_manager.py)
+```python
+{
+    'max_position_size_usd': 1000.0,     # Max $1000/coin
+    'max_total_exposure_usd': 5000.0,    # Max $5000 total
+    'max_drawdown_pct': 20.0,            # Max 20% drawdown
+    'min_confidence': 0.6                # Min 60% confidence
+}
+```
+
+### Strategy Config (ab_testing.py)
+```python
+{
+    'id': 'strategy_A',
+    'size_usd': 1000.0,
+    'take_profit_pct': 2.0,    # 2% TP
+    'stop_loss_pct': 1.0       # 1% SL
+}
+```
+
+---
+
+## 📈 Metrics (Prometheus)
+
+- `trader_signals_received_total`: Tổng signals nhận được
+- `trader_trades_executed_total`: Tổng trades thực thi
+- `trader_trades_rejected_total`: Tổng trades bị reject
+- `trader_position_size`: Position size hiện tại
+
+---
+
+## 🚨 Error Handling
+
+1. **QuestDB connection lost**: Auto-reconnect
+2. **Exchange API error**: Log và skip trade
+3. **Invalid signal**: Deserialize error → skip
+4. **Risk check failed**: Reject trade + log reason
+
+---
+
+## 💡 Best Practices
+
+1. **Luôn check `trading_enabled`** trước khi execute
+2. **Validate signal data** trước khi process
+3. **Log mọi trade** vào QuestDB để audit
+4. **Update metrics** để monitoring
+5. **Handle exceptions** gracefully
+
+---
+
+## 🔄 Lifecycle
+
+```
+START
+  ↓
+Initialize Components
+  ↓
+Subscribe Redis Channels
+  ↓
+┌─────────────────┐
+│  Main Loop      │
+│  ↓              │
+│  Get Message    │
+│  ↓              │
+│  Process        │
+│  ↓              │
+│  Sleep 0.01s    │
+└─────────────────┘
+  ↓
+STOP (KeyboardInterrupt)
+  ↓
+Close Connections
+  ↓
+END
+```
+
+---
+
+## 📝 Summary
+
+**ht-trader** là một **event-driven execution engine** với:
+- ✅ Real-time signal processing
+- ✅ Smart position management
+- ✅ Comprehensive risk checks
+- ✅ Paper & live trading support
+- ✅ Full audit trail (QuestDB)
+- ✅ Prometheus monitoring
+
+**Điểm mạnh:**
+- Tách biệt rõ ràng giữa signal generation (brain) và execution (trader)
+- Risk management chặt chẽ
+- Hỗ trợ A/B testing
+- Dễ mở rộng và maintain
+
+**Điểm cần cải thiện:**
+- Thêm order types (limit, stop-limit)
+- Trailing stop loss
+- Partial position closing
+- Multi-exchange support

AIDocs/HT_TRADER_OPTIMIZATIONS.md

@@ -0,0 +1,591 @@
+# 🚀 HT-TRADER Optimization Opportunities
+
+## 📊 Current Analysis
+
+### Strengths ✅
+- Event-driven architecture
+- Risk management in place
+- Position tracking working
+- QuestDB logging functional
+- Paper trading operational
+
+### Areas for Improvement 🔧
+
+---
+
+## 1. 🎯 Signal Processing Optimization
+
+### Current Issue:
+```python
+# Processes EVERY signal, even low quality ones
+def process_signal(self, signal_data):
+    confidence = float(signal_data.get("confidence", 0))
+    # No early filtering
+    # Continues to risk checks even for low confidence
+```
+
+### Optimization:
+```python
+def process_signal(self, signal_data):
+    confidence = float(signal_data.get("confidence", 0))
+    
+    # ✅ Early rejection for low confidence
+    if confidence < self.min_confidence_threshold:
+        logger.debug(f"Signal rejected: Low confidence {confidence:.2%}")
+        TRADER_SIGNALS_REJECTED_TOTAL.labels(
+            coin=coin, 
+            reason="low_confidence"
+        ).inc()
+        return
+    
+    # Continue processing only high-quality signals
+    ...
+```
+
+**Benefits:**
+- Reduce CPU usage
+- Faster response time
+- Better metrics tracking
+
+---
+
+## 2. 📈 Position Sizing Optimization
+
+### Current Issue:
+```python
+# Fixed position size from strategy config
+size_usd = strategy_config.get('size_usd', 1000.0)
+quantity = size_usd / price
+```
+
+### Optimization: Dynamic Kelly Criterion
+```python
+def calculate_optimal_size(self, coin, confidence, win_rate, avg_win, avg_loss):
+    """
+    Kelly Criterion: f* = (p*b - q) / b
+    where:
+    - p = win probability
+    - q = loss probability (1-p)
+    - b = win/loss ratio
+    """
+    if win_rate <= 0.5 or avg_loss == 0:
+        return self.min_size_usd
+    
+    p = win_rate
+    q = 1 - p
+    b = abs(avg_win / avg_loss)
+    
+    kelly_fraction = (p * b - q) / b
+    kelly_fraction = max(0, min(kelly_fraction, 0.25))  # Cap at 25%
+    
+    # Adjust by confidence
+    confidence_multiplier = confidence / 0.8  # Normalize
+    
+    optimal_size = self.base_size_usd * kelly_fraction * confidence_multiplier
+    
+    return max(self.min_size_usd, min(optimal_size, self.max_size_usd))
+```
+
+**Benefits:**
+- Maximize long-term growth
+- Risk-adjusted position sizing
+- Confidence-weighted allocation
+
+---
+
+## 3. 🔄 Smart Order Execution
+
+### Current Issue:
+```python
+# Executes immediately at market price
+result = self.exchange_client.place_order(coin, signal, quantity, price)
+```
+
+### Optimization: TWAP (Time-Weighted Average Price)
+```python
+async def execute_twap(self, coin, signal, total_quantity, duration_seconds=60):
+    """
+    Split large orders into smaller chunks over time
+    to reduce market impact and get better average price
+    """
+    num_chunks = 10
+    chunk_size = total_quantity / num_chunks
+    interval = duration_seconds / num_chunks
+    
+    fills = []
+    for i in range(num_chunks):
+        # Get current best price
+        current_price = self.get_current_price(coin)
+        
+        # Execute chunk
+        result = self.exchange_client.place_order(
+            coin, signal, chunk_size, current_price
+        )
+        
+        if result:
+            fills.append({
+                'price': current_price,
+                'quantity': chunk_size,
+                'timestamp': time.time()
+            })
+        
+        await asyncio.sleep(interval)
+    
+    # Calculate average fill price
+    total_cost = sum(f['price'] * f['quantity'] for f in fills)
+    total_qty = sum(f['quantity'] for f in fills)
+    avg_price = total_cost / total_qty if total_qty > 0 else 0
+    
+    return avg_price, total_qty
+```
+
+**Benefits:**
+- Better average price
+- Reduced slippage
+- Lower market impact
+
+---
+
+## 4. 🎲 Advanced Exit Strategy
+
+### Current Issue:
+```python
+# Simple TP/SL based on percentage
+should_close = (pnl_pct > take_profit_pct) or (pnl_pct < -stop_loss_pct)
+```
+
+### Optimization: Trailing Stop + Dynamic TP
+```python
+class SmartExitManager:
+    def __init__(self):
+        self.trailing_stops = {}  # {trade_id: trailing_stop_price}
+        self.peak_prices = {}     # {trade_id: highest_price_seen}
+    
+    def check_exit(self, trade_id, current_price, entry_price, side):
+        """
+        Advanced exit logic:
+        1. Trailing stop: Lock in profits as price moves favorably
+        2. Dynamic TP: Adjust based on volatility
+        3. Time-based exit: Close stale positions
+        """
+        # Initialize tracking
+        if trade_id not in self.peak_prices:
+            self.peak_prices[trade_id] = current_price
+            self.trailing_stops[trade_id] = None
+        
+        # Update peak price
+        if side == 'LONG':
+            self.peak_prices[trade_id] = max(self.peak_prices[trade_id], current_price)
+        else:
+            self.peak_prices[trade_id] = min(self.peak_prices[trade_id], current_price)
+        
+        # Calculate PnL
+        if side == 'LONG':
+            pnl_pct = (current_price - entry_price) / entry_price * 100
+            peak_pnl_pct = (self.peak_prices[trade_id] - entry_price) / entry_price * 100
+        else:
+            pnl_pct = (entry_price - current_price) / entry_price * 100
+            peak_pnl_pct = (entry_price - self.peak_prices[trade_id]) / entry_price * 100
+        
+        # 1. Trailing Stop (activate after 1% profit)
+        if peak_pnl_pct > 1.0:
+            trailing_distance = 0.5  # Trail by 0.5%
+            
+            if side == 'LONG':
+                trailing_stop = self.peak_prices[trade_id] * (1 - trailing_distance/100)
+                if current_price < trailing_stop:
+                    return True, f"Trailing stop hit (locked {peak_pnl_pct:.2f}%)"
+            else:
+                trailing_stop = self.peak_prices[trade_id] * (1 + trailing_distance/100)
+                if current_price > trailing_stop:
+                    return True, f"Trailing stop hit (locked {peak_pnl_pct:.2f}%)"
+        
+        # 2. Dynamic Take Profit (based on volatility)
+        volatility = self.get_recent_volatility(coin)
+        dynamic_tp = 1.5 + (volatility * 2)  # Higher TP in volatile markets
+        
+        if pnl_pct > dynamic_tp:
+            return True, f"Dynamic TP hit ({pnl_pct:.2f}% > {dynamic_tp:.2f}%)"
+        
+        # 3. Stop Loss
+        if pnl_pct < -1.0:
+            return True, f"Stop loss hit ({pnl_pct:.2f}%)"
+        
+        # 4. Time-based exit (close after 4 hours)
+        hold_time = time.time() - entry_time
+        if hold_time > 4 * 3600 and pnl_pct > 0:
+            return True, f"Time exit (held {hold_time/3600:.1f}h, profit {pnl_pct:.2f}%)"
+        
+        return False, "Hold"
+```
+
+**Benefits:**
+- Lock in profits automatically
+- Adapt to market volatility
+- Prevent stale positions
+
+---
+
+## 5. 💾 Performance Caching
+
+### Current Issue:
+```python
+# Recalculates exposure every signal
+for p_coin, p_data in self.position_manager.open_positions.items():
+    current_exposure += abs(p_data['quantity']) * p_price
+```
+
+### Optimization: Cache frequently accessed data
+```python
+class PerformanceCache:
+    def __init__(self, ttl=1.0):  # 1 second TTL
+        self.cache = {}
+        self.ttl = ttl
+    
+    def get_or_compute(self, key, compute_func):
+        now = time.time()
+        
+        if key in self.cache:
+            value, timestamp = self.cache[key]
+            if now - timestamp < self.ttl:
+                return value
+        
+        # Compute and cache
+        value = compute_func()
+        self.cache[key] = (value, now)
+        return value
+
+# Usage:
+self.cache = PerformanceCache(ttl=1.0)
+
+def get_current_exposure(self):
+    return self.cache.get_or_compute(
+        'total_exposure',
+        lambda: sum(abs(p['quantity']) * p['price'] 
+                   for p in self.position_manager.open_positions.values())
+    )
+```
+
+**Benefits:**
+- Reduce redundant calculations
+- Faster signal processing
+- Lower CPU usage
+
+---
+
+## 6. 🔔 Smart Alerting
+
+### Current Issue:
+```python
+# No alerts for important events
+# Trader operates silently
+```
+
+### Optimization: Event-based notifications
+```python
+class TraderAlertManager:
+    def __init__(self, telegram_bot):
+        self.telegram = telegram_bot
+        self.alert_cooldown = {}
+    
+    async def alert_large_win(self, coin, pnl_usd):
+        """Alert on significant wins"""
+        if pnl_usd > 100:  # $100+ win
+            await self.telegram.send_message(
+                f"🎉 Large Win!\n"
+                f"Coin: {coin}\n"
+                f"PnL: ${pnl_usd:.2f}"
+            )
+    
+    async def alert_large_loss(self, coin, pnl_usd):
+        """Alert on significant losses"""
+        if pnl_usd < -50:  # $50+ loss
+            await self.telegram.send_message(
+                f"⚠️ Large Loss!\n"
+                f"Coin: {coin}\n"
+                f"PnL: ${pnl_usd:.2f}\n"
+                f"Action: Review strategy"
+            )
+    
+    async def alert_streak(self, streak_type, count):
+        """Alert on win/loss streaks"""
+        if count >= 5:
+            emoji = "🔥" if streak_type == "win" else "❄️"
+            await self.telegram.send_message(
+                f"{emoji} {streak_type.upper()} Streak: {count}\n"
+                f"Consider: {'Increase size' if streak_type == 'win' else 'Reduce size'}"
+            )
+```
+
+**Benefits:**
+- Real-time awareness
+- Quick response to issues
+- Better monitoring
+
+---
+
+## 7. 📊 Advanced Metrics
+
+### Current Issue:
+```python
+# Only basic metrics tracked
+TRADER_TRADES_EXECUTED_TOTAL.inc()
+```
+
+### Optimization: Comprehensive metrics
+```python
+# Add new metrics
+from prometheus_client import Histogram, Gauge
+
+# Latency tracking
+SIGNAL_TO_EXECUTION_LATENCY = Histogram(
+    'trader_signal_execution_latency_seconds',
+    'Time from signal received to order executed',
+    buckets=[0.01, 0.05, 0.1, 0.5, 1.0, 2.0, 5.0]
+)
+
+# Slippage tracking
+EXECUTION_SLIPPAGE = Histogram(
+    'trader_execution_slippage_percent',
+    'Slippage between signal price and fill price',
+    buckets=[0.01, 0.05, 0.1, 0.2, 0.5, 1.0]
+)
+
+# Current PnL
+CURRENT_PNL_USD = Gauge(
+    'trader_current_pnl_usd',
+    'Current unrealized PnL in USD',
+    ['coin']
+)
+
+# Win rate (rolling)
+ROLLING_WIN_RATE = Gauge(
+    'trader_rolling_win_rate',
+    'Win rate over last N trades',
+    ['window']
+)
+
+# Usage in code:
+with SIGNAL_TO_EXECUTION_LATENCY.time():
+    self.execute_trade(...)
+
+slippage_pct = abs(fill_price - signal_price) / signal_price * 100
+EXECUTION_SLIPPAGE.observe(slippage_pct)
+```
+
+**Benefits:**
+- Better observability
+- Performance insights
+- Easier debugging
+
+---
+
+## 8. 🔄 Async Processing
+
+### Current Issue:
+```python
+# Synchronous processing blocks on I/O
+def run(self):
+    while self.running:
+        message = self.pubsub.get_message()  # Blocking
+        if message:
+            self.process_signal(signal_data)  # Blocking
+        time.sleep(0.01)
+```
+
+### Optimization: Async/await pattern
+```python
+async def run(self):
+    """Async main loop for better concurrency"""
+    
+    # Create async tasks
+    tasks = [
+        asyncio.create_task(self.process_signals()),
+        asyncio.create_task(self.update_positions()),
+        asyncio.create_task(self.monitor_health())
+    ]
+    
+    await asyncio.gather(*tasks)
+
+async def process_signals(self):
+    """Process signals asynchronously"""
+    while self.running:
+        message = await self.pubsub.get_message_async()
+        if message:
+            # Process in background
+            asyncio.create_task(self.process_signal_async(message))
+        
+        await asyncio.sleep(0.01)
+
+async def process_signal_async(self, signal_data):
+    """Non-blocking signal processing"""
+    # Risk checks (fast)
+    if not await self.check_risk_async(signal_data):
+        return
+    
+    # Execute trade (I/O bound)
+    await self.execute_trade_async(signal_data)
+```
+
+**Benefits:**
+- Handle multiple signals concurrently
+- Better throughput
+- Non-blocking I/O
+
+---
+
+## 9. 🧠 Machine Learning Integration
+
+### Optimization: ML-based trade filtering
+```python
+class MLTradeFilter:
+    def __init__(self):
+        self.model = self.load_model('trade_filter_v1.pkl')
+    
+    def should_execute(self, signal_data, market_state):
+        """
+        Use ML to predict if trade will be profitable
+        Based on:
+        - Signal features
+        - Market conditions
+        - Recent performance
+        - Time of day
+        - Volatility
+        """
+        features = self.extract_features(signal_data, market_state)
+        
+        # Predict win probability
+        win_prob = self.model.predict_proba(features)[0][1]
+        
+        # Only execute if high probability
+        return win_prob > 0.65
+    
+    def extract_features(self, signal_data, market_state):
+        return {
+            'confidence': signal_data['confidence'],
+            'volatility': market_state['volatility'],
+            'spread': market_state['spread'],
+            'volume': market_state['volume'],
+            'time_of_day': datetime.now().hour,
+            'recent_win_rate': self.get_recent_win_rate(),
+            'market_regime': market_state['regime']
+        }
+```
+
+**Benefits:**
+- Filter out low-quality trades
+- Improve win rate
+- Adaptive to market conditions
+
+---
+
+## 10. 🎯 Priority Queue for Signals
+
+### Current Issue:
+```python
+# Processes signals in order received
+# High-confidence signals may wait behind low-confidence ones
+```
+
+### Optimization: Priority queue
+```python
+import heapq
+from dataclasses import dataclass, field
+from typing import Any
+
+@dataclass(order=True)
+class PrioritizedSignal:
+    priority: float = field(compare=True)
+    signal_data: Any = field(compare=False)
+    timestamp: float = field(compare=False)
+
+class SignalQueue:
+    def __init__(self):
+        self.queue = []
+    
+    def add_signal(self, signal_data):
+        # Higher confidence = higher priority
+        confidence = signal_data.get('confidence', 0)
+        priority = -confidence  # Negative for max-heap behavior
+        
+        item = PrioritizedSignal(
+            priority=priority,
+            signal_data=signal_data,
+            timestamp=time.time()
+        )
+        
+        heapq.heappush(self.queue, item)
+    
+    def get_next_signal(self):
+        if self.queue:
+            return heapq.heappop(self.queue).signal_data
+        return None
+
+# Usage:
+self.signal_queue = SignalQueue()
+
+# Add signals to queue
+self.signal_queue.add_signal(signal_data)
+
+# Process highest priority first
+while True:
+    signal = self.signal_queue.get_next_signal()
+    if signal:
+        self.process_signal(signal)
+```
+
+**Benefits:**
+- Process best signals first
+- Better capital utilization
+- Improved performance
+
+---
+
+## 📋 Implementation Priority
+
+### High Priority (Implement First):
+1. ✅ **Signal Filtering** - Quick win, reduces noise
+2. ✅ **Performance Caching** - Easy, immediate impact
+3. ✅ **Smart Alerting** - Better monitoring
+4. ✅ **Advanced Metrics** - Visibility
+
+### Medium Priority:
+5. ⚠️ **Dynamic Position Sizing** - Requires backtesting
+6. ⚠️ **Advanced Exit Strategy** - Needs validation
+7. ⚠️ **Priority Queue** - Moderate complexity
+
+### Low Priority (Future):
+8. 🔮 **TWAP Execution** - Complex, for large orders
+9. 🔮 **Async Processing** - Major refactor
+10. 🔮 **ML Trade Filter** - Requires training data
+
+---
+
+## 🎯 Expected Impact
+
+| Optimization | CPU ↓ | Latency ↓ | Win Rate ↑ | Complexity |
+|--------------|-------|-----------|------------|------------|
+| Signal Filtering | 20% | 30% | 2-3% | Low |
+| Performance Cache | 15% | 25% | 0% | Low |
+| Smart Alerting | 0% | 0% | 0% | Low |
+| Advanced Metrics | 5% | 0% | 0% | Low |
+| Dynamic Sizing | 0% | 0% | 3-5% | Medium |
+| Advanced Exit | 0% | 0% | 5-8% | Medium |
+| Priority Queue | 0% | 15% | 1-2% | Medium |
+| TWAP | 0% | -10% | 1-2% | High |
+| Async Processing | 10% | 40% | 0% | High |
+| ML Filter | 0% | 5% | 8-12% | High |
+
+---
+
+## 🚀 Quick Wins (Can implement now)
+
+1. **Signal Filtering** - 30 minutes
+2. **Performance Caching** - 1 hour
+3. **Smart Alerting** - 2 hours
+4. **Advanced Metrics** - 2 hours
+
+**Total time: ~6 hours for 4 optimizations**
+**Expected improvement: +5-8% Win Rate, -50% CPU, -50% Latency**
+
+Would you like me to implement any of these optimizations?

AIDocs/ML_TRADE_FILTER_ROADMAP.md

@@ -0,0 +1,182 @@
+# 🧠 ML Trade Filter - Roadmap & Status
+
+## 📅 Current Status (2025-12-02)
+
+### ✅ Completed:
+- [x] Created ML Trade Filter infrastructure
+- [x] Trained initial Random Forest model (v1)
+- [x] Integrated ML Filter into ht-trader
+- [x] Model successfully loaded and filtering signals
+
+### 📊 Current Model Performance:
+- **Model:** Random Forest Classifier
+- **Version:** trade_filter_v1.pkl
+- **Training Accuracy:** 78.31%
+- **Threshold:** 60% (Win Probability)
+- **Status:** ACTIVE & FILTERING
+
+### 🎯 Current Behavior:
+- Model is **rejecting most signals** (Win Prob ~20.91%)
+- This is **GOOD** - protecting capital from low-quality trades
+- System is conservative and safe
+
+---
+
+## 🔮 Next Steps - Choose One:
+
+### **Option 1: Wait & Retrain (RECOMMENDED) ⭐**
+
+**Timeline:** 1-2 weeks
+
+**Action Plan:**
+1. Let system run Paper Trading and collect more data
+2. Target: 500-1000 additional trades in QuestDB
+3. Retrain model with larger dataset
+4. Expected improvement: Accuracy 85%+
+
+**How to execute:**
+```bash
+# After 1-2 weeks, run:
+docker exec ht-trader python train_trade_filter.py
+
+# If accuracy > current (78.31%), model will auto-save
+# Then restart ht-trader:
+docker-compose restart ht-trader
+```
+
+**Pros:**
+- ✅ More data = Better model
+- ✅ Higher accuracy
+- ✅ More confident predictions
+- ✅ Better Win Rate in production
+
+**Cons:**
+- ⏳ Need to wait 1-2 weeks
+- ⏳ Fewer trades executed during this period
+
+---
+
+### **Option 2: Lower Threshold (QUICK FIX) ⚡**
+
+**Timeline:** Immediate
+
+**Action Plan:**
+1. Edit `services/ht-trader/optimization_utils.py`
+2. Change line in `MLTradeFilter.should_execute()`:
+   ```python
+   # Current:
+   return prob > 0.6, prob  # Threshold 0.6 (60%)
+   
+   # Change to:
+   return prob > 0.5, prob  # Threshold 0.5 (50%)
+   ```
+3. Restart ht-trader
+
+**How to execute:**
+```bash
+# Edit the file (change threshold from 0.6 to 0.5)
+# Then restart:
+docker-compose restart ht-trader
+```
+
+**Pros:**
+- ✅ Immediate effect
+- ✅ More trades will execute
+- ✅ Faster data collection
+
+**Cons:**
+- ⚠️ Higher risk (allowing lower quality signals)
+- ⚠️ Potentially lower Win Rate
+- ⚠️ More losses possible
+
+---
+
+## 📈 Recommended Strategy:
+
+### **Phase 1: Current (Week 1-2)**
+- Keep threshold at 60%
+- Let model filter aggressively
+- Collect high-quality data
+- Monitor Win Rate on executed trades
+
+### **Phase 2: Evaluation (Week 2)**
+- Check total trades executed
+- If < 50 trades/week → Consider lowering threshold to 55%
+- If ≥ 50 trades/week → Keep at 60% and wait for retrain
+
+### **Phase 3: Retrain (Week 3-4)**
+- Run training script
+- If new accuracy > 80% → Deploy new model
+- If accuracy < 80% → Collect more data
+
+### **Phase 4: Production Ready (Month 2)**
+- Model accuracy > 85%
+- Win Rate > 60% on paper trading
+- Ready to move to Testnet
+
+---
+
+## 🔧 Quick Commands Reference:
+
+### Check current model performance:
+```bash
+# View recent rejections
+docker logs ht-trader --tail 50 | grep "ML Filter"
+
+# Count rejections vs executions
+docker logs ht-trader --tail 1000 | grep -c "rejected by ML Filter"
+docker logs ht-trader --tail 1000 | grep -c "EXECUTED"
+```
+
+### Retrain model:
+```bash
+docker exec ht-trader python train_trade_filter.py
+docker-compose restart ht-trader
+```
+
+### Check data availability:
+```bash
+# Query QuestDB for trade count
+curl "http://localhost:9000/exec?query=SELECT count() FROM closed_positions WHERE environment='PAPER'"
+```
+
+---
+
+## 📊 Success Metrics:
+
+### Before moving to Testnet:
+- [ ] ML Model Accuracy > 85%
+- [ ] Paper Trading Win Rate > 60%
+- [ ] Total trades collected > 1000
+- [ ] Model stable for 2+ weeks
+- [ ] Max Drawdown < 15%
+
+### Before moving to Live:
+- [ ] Testnet Win Rate > 55%
+- [ ] Sharpe Ratio > 1.5
+- [ ] ML Model validated on out-of-sample data
+- [ ] All risk limits tested and working
+
+---
+
+## 🎯 Decision Point:
+
+**Choose your path:**
+
+1. **Conservative (Recommended):** Wait 1-2 weeks, collect data, retrain → Higher quality
+2. **Aggressive:** Lower threshold to 50-55% now → More trades, faster iteration
+
+**Current Recommendation:** **Option 1 (Wait & Retrain)**
+
+The model is working correctly by filtering low-quality signals. This is protecting your capital. Be patient and let it collect good data for a better v2 model.
+
+---
+
+## 📝 Notes:
+
+- Model was trained on: 2025-12-02
+- Next retrain scheduled: 2025-12-16 (2 weeks)
+- Current threshold: 60%
+- Current behavior: Filtering aggressively (good!)
+
+**Remember:** A conservative model that protects capital is better than an aggressive model that loses money. Quality > Quantity.

AIDocs/PAPER_TRADING_STRATEGY.md

@@ -0,0 +1,535 @@
+# 📄 Paper Trading Strategy - HyperTrade
+
+## 🎯 Mục tiêu của Paper Trading
+
+Paper Trading là **giai đoạn quan trọng** trong quá trình phát triển HyperTrade, cho phép hệ thống:
+- ✅ Test strategies với **ZERO RISK**
+- ✅ Validate AI models trước khi dùng tiền thật
+- ✅ Thu thập performance metrics để cải thiện
+- ✅ Tạo training data cho AI models
+
+---
+
+## 🔄 Continuous Learning Loop
+
+```
+┌──────────┐
+│  Brain   │ ──► Generate Signal (AI-based)
+└──────────┘
+     │
+     ▼
+┌──────────┐
+│  Trader  │ ──► Execute (Paper Trading)
+└──────────┘
+     │
+     ▼
+┌──────────┐
+│ QuestDB  │ ──► Store Results (Trades, PnL, Features)
+└──────────┘
+     │
+     ▼
+┌──────────┐
+│ Manager  │ ──► Analyze Performance (Win Rate, Sharpe)
+└──────────┘
+     │
+     ▼
+┌──────────┐
+│  Brain   │ ──► Retrain Models (Improve) ──┐
+└──────────┘                                │
+     ▲                                      │
+     └──────────────────────────────────────┘
+              (Feedback Loop)
+```
+
+### Giải thích vòng lặp:
+
+1. **Brain** tạo trading signals dựa trên:
+   - Multi-Task CNN predictions
+   - Confidence scores
+   - Market regime detection
+   - Feature engineering
+
+2. **Trader** thực thi signals trong môi trường **simulated**:
+   - Sử dụng L2 orderbook data thực
+   - Tính slippage và fees
+   - Track positions và PnL
+
+3. **QuestDB** lưu trữ:
+   - Mỗi trade (entry/exit)
+   - Features tại thời điểm trade
+   - Market conditions
+   - Outcomes (profit/loss)
+
+4. **Manager** phân tích performance:
+   - Win Rate
+   - Average PnL per trade
+   - Sharpe Ratio
+   - Max Drawdown
+   - Trade frequency
+
+5. **Brain** học từ kết quả:
+   - Retrain models khi performance giảm
+   - Cải thiện signal quality
+   - Adapt to new market conditions
+   - Optimize confidence thresholds
+
+6. **Vòng lặp lại** - Hệ thống tự cải thiện liên tục
+
+---
+
+## 🎓 7 Mục tiêu chính của Paper Trading
+
+### 1. **Testing & Validation (Kiểm thử chiến lược)**
+
+**Mục đích:**
+- Test strategies mới mà không rủi ro mất tiền
+- Validate AI models trước khi deploy live
+- Measure performance metrics chính xác
+
+**Ví dụ:**
+```
+Signal: BUY BTC @ $95,000 (Confidence: 78%)
+Paper Execution:
+  - Entry: $95,050 (simulated slippage)
+  - Exit: $96,200 (TP hit)
+  - PnL: +$1,150 (simulated)
+  - Fee: -$47.50
+  - Net: +$1,102.50
+  
+Result: WIN ✅
+```
+
+**Metrics tracked:**
+- Entry/Exit prices
+- Slippage
+- Fees
+- Hold time
+- PnL
+- Win/Loss
+
+---
+
+### 2. **Continuous Learning Loop (Vòng lặp học tập)**
+
+**Quy trình:**
+```
+Day 1-7:   Paper Trading → Collect 500 trades
+Day 8:     Analyze → Win Rate 58%, Sharpe 1.2
+Day 9:     Retrain Brain → Improve confidence scorer
+Day 10-16: Paper Trading → Collect 500 more trades
+Day 17:    Analyze → Win Rate 62%, Sharpe 1.5 ✅
+```
+
+**Feedback loop:**
+- Mỗi trade = 1 training example
+- Brain học từ successes và failures
+- Continuous improvement without risk
+
+---
+
+### 3. **Safe Development Environment**
+
+**Development Stages:**
+
+#### **Stage 1: PAPER TRADING (Current)**
+```
+┌─────────────────────────────────────────┐
+│ ✅ Test all features                     │
+│ ✅ Debug issues                          │
+│ ✅ Optimize strategies                   │
+│ ✅ Collect performance data              │
+│ ✅ Zero financial risk                   │
+│ ✅ Unlimited experimentation             │
+└─────────────────────────────────────────┘
+```
+
+**Checklist trước khi chuyển Stage 2:**
+- [ ] Win Rate > 55% (sustained over 1000+ trades)
+- [ ] Sharpe Ratio > 1.5
+- [ ] Max Drawdown < 15%
+- [ ] No critical bugs
+- [ ] Stable across market conditions
+- [ ] Backtesting confirms results
+
+#### **Stage 2: LIVE TRADING (Future)**
+```
+┌─────────────────────────────────────────┐
+│ ⚠️ Real money at risk                   │
+│ ⚠️ Need proven Win Rate > 55%           │
+│ ⚠️ Need stable Sharpe Ratio > 1.5       │
+│ ⚠️ Start with small position sizes      │
+│ ⚠️ Gradual scaling based on performance │
+└─────────────────────────────────────────┘
+```
+
+---
+
+### 4. **A/B Testing Strategies**
+
+Paper Trading cho phép test **nhiều strategies song song** mà không rủi ro:
+
+**Example Strategies:**
+
+```python
+# Strategy A: Conservative
+{
+    'id': 'conservative_v1',
+    'size_usd': 500,
+    'take_profit_pct': 1.5,
+    'stop_loss_pct': 0.8,
+    'min_confidence': 0.7
+}
+
+# Strategy B: Aggressive  
+{
+    'id': 'aggressive_v1',
+    'size_usd': 1500,
+    'take_profit_pct': 3.0,
+    'stop_loss_pct': 1.5,
+    'min_confidence': 0.6
+}
+
+# Strategy C: AI-Optimized
+{
+    'id': 'ai_dynamic_v1',
+    'size_usd': 'dynamic',  # Based on confidence
+    'take_profit_pct': 'ai_predicted',
+    'stop_loss_pct': 'ai_predicted',
+    'min_confidence': 0.65
+}
+```
+
+**Performance Comparison (After 1000 trades each):**
+
+| Strategy | Win Rate | Avg PnL | Sharpe | Max DD | Winner? |
+|----------|----------|---------|--------|--------|---------|
+| Conservative | 58% | $8.50 | 1.2 | -6% | ❌ |
+| Aggressive | 52% | $15.20 | 0.9 | -18% | ❌ |
+| AI-Optimized | **65%** | **$12.80** | **1.8** | **-8%** | ✅ |
+
+**Decision:** Deploy AI-Optimized strategy to live trading
+
+---
+
+### 5. **Risk-Free Model Training Data**
+
+**Data Generated by Paper Trading:**
+
+```
+┌────────────────────────────────────────┐
+│ Per Trade Data:                        │
+│ • Entry/Exit timestamps                │
+│ • Entry/Exit prices                    │
+│ • Position size                        │
+│ • Features at trade time (50+ dims)    │
+│ • Market regime                        │
+│ • Confidence score                     │
+│ • PnL outcome                          │
+│ • Win/Loss label                       │
+│ • Slippage                             │
+│ • Fees                                 │
+└────────────────────────────────────────┘
+         │
+         ▼
+┌────────────────────────────────────────┐
+│ Brain uses this data to:               │
+│ ✅ Train Confidence Scorer              │
+│    - Learn which features predict wins │
+│    - Calibrate confidence thresholds   │
+│                                        │
+│ ✅ Improve Signal Quality               │
+│    - Filter low-quality signals        │
+│    - Boost high-quality patterns       │
+│                                        │
+│ ✅ Learn optimal entry/exit timing      │
+│    - When to enter positions           │
+│    - When to take profit               │
+│    - When to cut losses                │
+│                                        │
+│ ✅ Adapt to market regimes              │
+│    - Bull/Bear/Sideways detection      │
+│    - Regime-specific strategies        │
+└────────────────────────────────────────┘
+```
+
+**Example Training Workflow:**
+
+```python
+# 1. Collect Paper Trading Data
+trades_df = query_questdb("""
+    SELECT * FROM trades_executed 
+    WHERE environment = 'PAPER'
+    AND timestamp > dateadd('d', -30, now())
+""")
+
+# 2. Extract Features & Labels
+X = trades_df[feature_columns]  # 50+ features
+y = trades_df['pnl'] > 0        # Win/Loss label
+
+# 3. Retrain Confidence Scorer
+confidence_model.fit(X, y)
+
+# 4. Evaluate
+new_accuracy = confidence_model.score(X_test, y_test)
+print(f"Confidence Model Accuracy: {new_accuracy:.2%}")
+
+# 5. Deploy if improved
+if new_accuracy > previous_accuracy:
+    save_model(confidence_model, 'confidence_v2.pkl')
+    deploy_to_brain()
+```
+
+---
+
+### 6. **Performance Metrics Collection**
+
+**Key Metrics Tracked:**
+
+| Metric | Formula | Target | Purpose |
+|--------|---------|--------|---------|
+| **Win Rate** | Wins / Total Trades | > 55% | Basic profitability |
+| **Avg PnL** | Total PnL / Total Trades | > $10 | Per-trade profit |
+| **Sharpe Ratio** | (Return - RiskFree) / StdDev | > 1.5 | Risk-adjusted returns |
+| **Max Drawdown** | Max(Peak - Trough) / Peak | < 15% | Worst losing streak |
+| **Profit Factor** | Gross Profit / Gross Loss | > 1.5 | Profitability ratio |
+| **Trade Frequency** | Trades / Day | 10-50 | Signal quality |
+| **Avg Hold Time** | Exit Time - Entry Time | < 2h | Capital efficiency |
+
+**Example Dashboard:**
+
+```
+📊 Paper Trading Performance (Last 30 Days)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Total Trades:        1,247
+Winning Trades:      777 (62.3%) ✅
+Losing Trades:       470 (37.7%)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Avg Win:             +$18.50
+Avg Loss:            -$12.30
+Avg PnL/Trade:       +$12.50 ✅
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Total PnL:           +$15,587 (simulated)
+Gross Profit:        +$14,380
+Gross Loss:          -$5,781
+Profit Factor:       2.49 ✅
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Sharpe Ratio:        1.65 ✅
+Max Drawdown:        -8.2% ✅
+Avg Hold Time:       1.2 hours
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Status: READY FOR LIVE TRADING ✅
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+### 7. **Debugging & Monitoring**
+
+**Common Issues Detected:**
+
+#### **Issue 1: High Slippage**
+```
+Signal: BUY BTC @ $95,000
+Expected Fill: $95,000
+Actual Fill: $95,500 (0.53% slippage) ⚠️
+
+Root Cause: Orderbook too thin
+Fix: Improve orderbook simulation, add liquidity checks
+```
+
+#### **Issue 2: Risk Limit Rejections**
+```
+Signal: SELL ETH @ $3,500
+Result: REJECTED (max exposure exceeded)
+
+Root Cause: Too many open positions
+Fix: Adjust risk parameters, implement position limits
+```
+
+#### **Issue 3: Signal Quality**
+```
+Signals Generated: 500/day
+Trades Executed: 50/day (10% acceptance)
+
+Root Cause: Low confidence threshold
+Fix: Increase min_confidence from 0.5 to 0.65
+```
+
+#### **Issue 4: Model Drift**
+```
+Week 1: Win Rate 65%
+Week 2: Win Rate 62%
+Week 3: Win Rate 58% ⚠️
+Week 4: Win Rate 54% 🚨
+
+Root Cause: Market regime changed
+Fix: Trigger model retraining, update features
+```
+
+---
+
+## 📈 Current Status
+
+**HyperTrade Development Progress:**
+
+```
+[████████████░░░░░░░░] 60% Complete
+
+Stage 1: Paper Trading ──► Stage 2: Live Trading
+         (CURRENT)              (FUTURE)
+```
+
+**Achievements:**
+- ✅ Paper trading infrastructure complete
+- ✅ L2 orderbook simulation working
+- ✅ Position management implemented
+- ✅ Risk management active
+- ✅ Performance tracking in place
+- ✅ AI feedback loop operational
+
+**Next Steps:**
+- [ ] Achieve Win Rate > 55% sustained
+- [ ] Achieve Sharpe Ratio > 1.5
+- [ ] Collect 5,000+ paper trades
+- [ ] Validate across market conditions
+- [ ] Implement live trading safeguards
+- [ ] Start with $100 live positions
+
+---
+
+### 8. **Machine Learning Integration (Trade Filter)**
+
+**Mục tiêu:**
+Tạo một lớp bảo vệ thứ hai (Gatekeeper) sử dụng Machine Learning để lọc các tín hiệu trading, chỉ cho phép thực thi các lệnh có xác suất thắng cao nhất.
+
+**Quy trình:**
+1.  **Data Collection (Hiện tại):** `ht-trader` chạy Paper Trading và lưu trữ mọi tín hiệu, ngữ cảnh thị trường (features), và kết quả (PnL) vào QuestDB.
+2.  **Model Training:** Khi đủ dữ liệu (ví dụ: >500 trades), hệ thống sẽ tự động train model `trade_filter_v1.pkl` (Random Forest hoặc XGBoost).
+    *   **Input:** Signal confidence, Market volatility, Spread, Volume, Time of day, Recent win rate.
+    *   **Output:** Xác suất thắng (Win Probability).
+3.  **Integration:** `ht-trader` load model này và dùng nó để lọc tín hiệu trước khi execute.
+    *   Nếu `Win Prob > Threshold` (ví dụ 0.65) → **EXECUTE**.
+    *   Nếu thấp hơn → **REJECT**.
+
+---
+
+## 🚀 Transition to Live Trading
+
+### Prerequisites Checklist
+
+#### **Performance Requirements:**
+- [ ] Win Rate > 55% (over 1000+ trades)
+- [ ] Sharpe Ratio > 1.5
+- [ ] Max Drawdown < 15%
+- [ ] Profit Factor > 1.5
+- [ ] Stable performance for 30+ days
+
+#### **ML Readiness:**
+- [ ] Collected > 1000 labeled trades in QuestDB
+- [ ] Trained `trade_filter` model with Accuracy > 60%
+- [ ] Validated model on out-of-sample data
+
+#### **Technical Requirements:**
+- [ ] No critical bugs
+- [ ] Error handling robust
+- [ ] Monitoring dashboards ready
+- [ ] Alert system functional (Telegram)
+- [ ] Emergency stop mechanism tested
+
+#### **Risk Management:**
+- [ ] Position size limits configured
+- [ ] Max exposure limits set
+- [ ] Stop loss logic validated
+- [ ] Circuit breakers implemented
+- [ ] Manual override available
+
+### Gradual Rollout Plan
+
+**Phase 1: Paper Trading + ML Training (Current)**
+```
+Goal: Collect data, train ML Trade Filter, optimize strategies.
+Environment: Simulated (Paper)
+```
+
+**Phase 2: Testnet Validation (Next)**
+```
+Goal: Validate execution logic, slippage, and ML model performance in a realistic environment.
+Environment: Hyperliquid Testnet (Real matching, fake money)
+Condition to start: ML Model Accuracy > 60% on Paper data.
+```
+
+**Phase 3: Micro Live (Week 1-2 of Live)**
+```
+Position Size: $100/trade
+Max Exposure: $500
+Coins: BTC only
+Goal: Validate live execution with real money.
+```
+
+**Phase 4: Small Live (Week 3-4)**
+```
+Position Size: $250/trade
+Max Exposure: $1,500
+Coins: BTC, ETH
+Goal: Test multi-asset trading.
+```
+
+**Phase 5: Full Live (Month 2+)**
+```
+Position Size: $1,000/trade
+Max Exposure: $5,000
+Coins: All supported
+Goal: Production trading.
+```
+
+---
+
+## 💡 Best Practices
+
+### 1. **Always Validate in Paper First**
+- Never deploy untested strategies to live
+- Run paper trading for minimum 1000 trades
+- Verify performance across market conditions
+
+### 2. **Monitor Continuously**
+- Check Win Rate daily
+- Track Sharpe Ratio weekly
+- Review Max Drawdown monthly
+- Set up alerts for anomalies
+
+### 3. **Iterate Based on Data**
+- Retrain models when performance drops
+- A/B test new strategies in paper
+- Use feedback loop to improve
+
+### 4. **Risk Management is Key**
+- Start small in live trading
+- Scale gradually based on results
+- Always have stop losses
+- Never risk more than you can afford to lose
+
+### 5. **Document Everything**
+- Log all trades
+- Record all model versions
+- Track all configuration changes
+- Maintain audit trail
+
+---
+
+## 📊 Summary
+
+**Paper Trading in HyperTrade serves as:**
+
+1. **🧪 Testing Lab**: Test strategies without risk
+2. **📚 Training Ground**: Generate data for AI models
+3. **📊 Analytics Engine**: Collect performance metrics
+4. **🔍 Debug Tool**: Find bugs before live trading
+5. **🎯 Optimization Platform**: A/B test strategies
+6. **🛡️ Safety Net**: Validate before using real money
+7. **🔄 Learning Loop**: Continuous improvement cycle
+
+**The goal:** Build confidence in the system through extensive paper trading before risking real capital.
+
+**Current focus:** Optimize Win Rate and Sharpe Ratio to meet live trading thresholds.
+
+**Timeline:** Estimated 2-3 months of paper trading before live deployment.

AIDocs/SIGNAL_GENERATION_v3.md

@@ -0,0 +1,121 @@
+# HyperTrade Signal Generation & Risk Management v3.0
+
+## 1. Overview
+This document details the advanced signal generation pipeline and risk management protocols implemented in the HyperTrade system (v3.0). The system transitions from a naive "trigger-happy" approach to a sophisticated "Sniper" logic, utilizing Causal AI, Regime Detection, and Multi-Layer Filters.
+
+## 2. Signal Generation Pipeline
+
+The pipeline consists of 6 distinct stages, ensuring only high-quality, high-probability signals are executed.
+
+### Stage 1: Data Ingestion (Input)
+- **Source**: `ht-feature-engine` -> Redis Channel `features_updates`
+- **Frequency**: Real-time (Tick-level)
+- **Key Features**:
+  - `Mid-Price`: Current market midpoint.
+  - `CVD (Cumulative Volume Delta)`: Aggressive buying/selling pressure.
+  - `Imbalance`: Orderbook depth skew (Bid vs Ask).
+  - `OFI (Order Flow Imbalance)`: Net order flow velocity.
+  - `Volatility`: Standard deviation of returns.
+
+### Stage 2: Regime Detection (Context)
+Before processing features, the system identifies the current market state using a hybrid AI approach:
+
+1.  **Primary: TRM (Tiny Recursive Model)**
+    *   A recursive neural network that "thinks" for multiple steps to infer hidden market states.
+    *   Input: `[Volatility, Imbalance, CVD, Spread, Momentum]`
+    *   Output: `TREND`, `SIDEWAY`, `VOLATILE`
+
+2.  **Fallback: Hidden Markov Model (HMM)**
+    *   Used if TRM is uncertain or unavailable.
+    *   Unsupervised learning on `Returns`, `Volatility`, `Imbalance`.
+
+**Regimes**:
+- **TREND**: Directional movement. Ideal for momentum strategies.
+- **SIDEWAY**: Range-bound. High noise, requires strict filtering.
+- **VOLATILE**: High risk/uncertainty. Requires maximum safety margins.
+
+### Stage 3: Causal-Weighted Confidence Scoring & AI Verification
+The system combines Causal AI with a Recursive Reasoning Engine to score signals.
+
+#### A. Causal Weighting
+**Causal AI** dynamically weights indicators based on their proven impact:
+- **Causal Discovery**: Background process identifies causal links (e.g., `CVD -> Price`).
+- **Dynamic Weighting**:
+  - If `CVD` is a proven driver -> Weight boosted by **1.5x**.
+  - If `Imbalance` has weak causality -> Weight reduced by **0.5x**.
+
+**Heuristic Formula**:
+```python
+Base_Score = (Norm_CVD * W_CVD) + (Norm_Imbalance * W_Imb) + (Norm_OFI * W_OFI)
+```
+
+#### B. TRM Verification (AI Score)
+The **TRM (Tiny Recursive Model)** verifies the signal by predicting the probability of success based on the full feature set.
+- **Input**: Full feature vector.
+- **Output**: Probability (0.0 - 1.0).
+- **Role**: Contributes 20% to the final ensemble confidence score.
+
+### Stage 4: Advanced Filtering (The "Sniper" Scope)
+This is the core of v3.0, filtering out false positives.
+
+#### A. Confluence Check (Consensus)
+- **Logic**: `CVD` and `Imbalance` MUST align in direction.
+- **Action**: If Divergence detected (e.g., CVD Buy + Imbalance Sell) -> **Confidence penalized by 50%**.
+- **Why**: Prevents falling into liquidity traps or absorption walls.
+
+#### B. Regime-Based Thresholds
+- **TREND**: Threshold > **0.60** (Aggressive)
+- **SIDEWAY**: Threshold > **0.75** (Conservative)
+- **VOLATILE**: Threshold > **0.80** (Safety First)
+
+#### C. Volatility Filter
+- **Logic**: If `Volatility < 0.0001` (Dead Market) -> **Signal Suppressed**.
+- **Why**: Prevents trading in stagnation where spread costs exceed potential profit.
+
+### Stage 5: Cooldown (Rate Limiting)
+- **Mechanism**: **5-second cooldown** per asset after a signal is generated.
+- **Why**: Prevents order spamming, reduces API load, and protects Margin.
+
+### Stage 6: Execution (Output)
+- **Final Output**: JSON payload sent to `ht-nautilus`.
+  ```json
+  {
+    "coin": "BTC",
+    "signal": "BUY",
+    "confidence": 0.78,
+    "regime": "TREND",
+    "causal_score": 0.15
+  }
+  ```
+
+## 3. Risk Management Layers
+
+### Layer 1: Strategy Level (ht-brain)
+- **Cooldowns**: Prevent spam.
+- **Confidence Thresholds**: Ensure high probability.
+
+### Layer 2: Execution Level (ht-nautilus)
+- **Rate Limiter**: Max 1 order per 2 seconds (Internal safety net).
+- **Spread Filter**: Rejects orders if Bid-Ask spread is too wide.
+- **Position Sizing**: Dynamic sizing based on volatility (planned).
+
+### Layer 3: System Level (Safety Circuit Breaker)
+- **SafetyLogHandler**: Monitors system logs in real-time.
+- **Trigger**: 3 consecutive Critical Errors (e.g., Margin Insufficient, API Disconnect).
+- **Action**: 
+  1. **Immediate Shutdown** of Trading Node.
+  2. **Telegram Alert** to admin.
+  3. **Cancel All Orders** (via cleanup script).
+
+## 4. Summary of v3.0 Improvements
+
+| Feature | Old Version (v2) | New Version (v3.0) |
+| :--- | :--- | :--- |
+| **Trigger Logic** | Naive Sum of Scores | **Causal-Weighted + Confluence** |
+| **Thresholds** | Static (0.65) | **Dynamic (Regime-based)** |
+| **Filters** | None | **Volatility & Divergence Checks** |
+| **Rate Limit** | None (Spam prone) | **5s Cooldown (Source) + 2s (Sink)** |
+| **Safety** | Manual Monitoring | **Automated Circuit Breaker** |
+
+---
+*Generated by HyperTrade AI Assistant*

AIDocs/SYSTEM_WORKFLOW.md

@@ -0,0 +1,729 @@
+# 🔄 LUỒNG CÔNG VIỆC HYPERTRADE - TỪ DATA ĐẾN EXECUTION
+
+> **Tài liệu này mô tả chi tiết luồng xử lý dữ liệu từ khi thu thập đến khi thực thi lệnh giao dịch trong hệ thống HyperTrade.**
+
+---
+
+## 📊 GIAI ĐOẠN 1: THU THẬP DỮ LIỆU (DATA COLLECTION)
+
+### Service: `ht-collector`
+**Input:** Kết nối WebSocket với Hyperliquid API  
+
+**Process:**
+- Lắng nghe **L2 Orderbook** (20 levels bid/ask) real-time
+- Lắng nghe **Trades** (giao dịch đã khớp)
+- Lắng nghe **Candles** (nến 1 phút)
+
+**Output:**
+- Publish vào Redis channel `market_data_updates` (JSON format)
+- Ghi vào QuestDB table `l2_orderbook_raw` (lưu trữ lâu dài)
+
+**Code Location:** `services/ht-collector/main.py`
+
+---
+
+## 🔧 GIAI ĐOẠN 2: FEATURE ENGINEERING
+
+### Service: `ht-feature-engine`
+**Input:** Subscribe Redis channel `market_data_updates`  
+
+**Process:** Tính toán các chỉ số kỹ thuật từ L2 Orderbook:
+- **Mid Price** = (Best Bid + Best Ask) / 2
+- **Weighted Mid Price** (WMP)
+- **Spread** = Best Ask - Best Bid
+- **Volatility** = Standard Deviation của mid prices (60s rolling window)
+- **Order Book Imbalance (OBI)** - Top 1, 5, 10, 20 levels
+- **Order Flow Imbalance (OFI)** - Thay đổi giữa 2 snapshots
+- **Cumulative Volume Delta (CVD)** - Buy volume - Sell volume
+
+**Output:**
+- Publish vào Redis channel `features_updates` (JSON với ~17 features)
+- Ghi vào QuestDB table `features_microstructure`
+
+**Code Location:** `services/ht-feature-engine/main.py`
+
+**Features Dictionary Example:**
+```json
+{
+  "mid_price": 96500.0,
+  "weighted_mid_price": 96501.2,
+  "bid_ask_spread": 0.1,
+  "current_volatility": 0.0234,
+  "imbalance_ratio": 0.15,
+  "imbalance_ratio_top5": 0.12,
+  "imbalance_ratio_top10": 0.10,
+  "imbalance_ratio_top20": 0.08,
+  "ofi": 125.5,
+  "cvd": 1500.0,
+  "buy_volume_1s": 850.0,
+  "sell_volume_1s": 650.0,
+  "bid_qty_at_level_1": 10.5,
+  "ask_qty_at_level_1": 9.2,
+  "bid_qty_top_5": 52.3,
+  "ask_qty_top_5": 48.7,
+  "obs_count": 20
+}
+```
+
+---
+
+## 🧠 GIAI ĐOẠN 3: AI SIGNAL GENERATION
+
+### Service: `ht-brain`
+**Input:** Subscribe Redis channel `features_updates`  
+
+**Process:** Multi-Model Ensemble AI System
+
+### 3.1. Regime Detection (Phát hiện trạng thái thị trường)
+**Model:** Hidden Markov Model (HMM)  
+**Input:** OBI, OFI, CVD time series  
+**Output:** Market regime classification
+- `TRENDING_UP`: Thị trường tăng mạnh
+- `TRENDING_DOWN`: Thị trường giảm mạnh
+- `SIDEWAY`: Thị trường đi ngang
+
+**Code:** `services/ht-brain/regime_detector.py`
+
+### 3.2. Confidence Scoring (Tính độ tin cậy)
+**Model:** Logistic Regression  
+**Input:** OBI, OFI, CVD, Spread, Volatility  
+**Output:** Confidence score (0.0 - 1.0)
+
+**Code:** `services/ht-brain/confidence_scorer.py`
+
+### 3.3. AI Magnitude Prediction (Dự đoán biên độ giá)
+**Model:** Multi-Task CNN (DeepLOB Architecture)  
+**Input:** L2 Orderbook snapshot (20 levels × 2 sides)  
+**Output:** 
+- Direction probabilities: [P(down), P(stationary), P(up)]
+- Magnitude predictions for multiple horizons: [10s, 30s, 1m, 2m, 5m]
+
+**Code:** `services/ht-brain/models/deep_lob_multi_task.py`
+
+**Training:** Được train bởi `ht-ai-inference` service
+
+### 3.4. Causal Discovery (Tìm mối quan hệ nhân quả)
+**Algorithm:** PC Algorithm (Peter-Clark)  
+**Purpose:** Xác định features nào có ảnh hưởng nhân quả đến price movement  
+**Output:** Causal graph, feature importance scores
+
+**Code:** `services/ht-brain/causal_discovery.py`
+
+### 3.5. Final Decision Logic (Logic quyết định cuối cùng)
+
+**Pseudo Code:**
+```python
+# 1. Get predictions from all models
+regime = hmm_model.predict(features)
+confidence = logistic_model.predict_proba(features)
+cnn_direction, cnn_magnitude = cnn_model.predict(orderbook)
+
+# 2. Combine predictions
+if cnn_direction == UP and confidence > 0.6 and regime != SIDEWAY:
+    signal = "BUY"
+    final_confidence = confidence * 0.7 + cnn_confidence * 0.3
+elif cnn_direction == DOWN and confidence > 0.6 and regime != SIDEWAY:
+    signal = "SELL"
+    final_confidence = confidence * 0.7 + cnn_confidence * 0.3
+else:
+    signal = "HOLD"
+    final_confidence = confidence
+
+# 3. Feature Normalization & Injection
+features['volatility'] = features.get('current_volatility', 0.002)
+features['spread'] = features.get('bid_ask_spread', 0.0002)
+
+# 4. Create Signal Message
+signal_msg = {
+    "coin": coin,
+    "signal": signal,
+    "confidence": final_confidence,
+    "price": features['mid_price'],
+    "features": features,  # Full features dict
+    "regime": regime,
+    "predicted_magnitude": cnn_magnitude
+}
+```
+
+**Code Location:** `services/ht-brain/main.py` - method `analyze()`
+
+### 3.6. Signal Publishing & Persistence
+
+**Output 1: Redis Channel `signals`**
+```python
+redis_client.publish("signals", signal_msg)
+```
+- Format: JSON (SignalMessage schema)
+- Subscribers: `ht-trader`, `ht-nautilus-paper`
+
+**Output 2: QuestDB Table `signals_generated`** ✅
+```python
+db_sender.sender.row(
+    'signals_generated',
+    symbols={
+        'coin': coin,
+        'signal': signal,
+        'regime': regime
+    },
+    columns={
+        'confidence': confidence,
+        'price': price,
+        'predicted_magnitude': cnn_magnitude,
+        'predicted_price': predicted_price,
+        'reason': reason_str,
+        'features_json': json.dumps(features)
+    },
+    at=TimestampNanos.now()
+)
+```
+
+**Lưu ý quan trọng:**
+- ✅ **CÓ LƯU VÀO DATABASE** (QuestDB table `signals_generated`)
+- Mục đích: Tracking, backtesting, phân tích hiệu quả AI
+- Chỉ lưu signals BUY/SELL (không lưu HOLD để tránh spam)
+
+**Code Location:** `services/ht-brain/main.py` - method `send_signal()`
+
+---
+
+## 🤖 AI MODELS SUMMARY (Trả lời câu hỏi 3)
+
+### Signal được tạo bởi **ENSEMBLE của 4 AI Models:**
+
+| Model | Vai trò | Output | Training Frequency |
+|-------|---------|--------|-------------------|
+| **HMM** | Regime Detection | TRENDING_UP/DOWN/SIDEWAY | Mỗi 15 phút |
+| **Logistic Regression** | Confidence Scoring | 0.0 - 1.0 | Mỗi 30 phút |
+| **Multi-Task CNN** | Direction + Magnitude | [Direction, Magnitude] | Mỗi 1 giờ |
+| **PC Algorithm** | Feature Selection | Causal Graph | Mỗi 6 giờ |
+
+**Final Signal = Weighted Combination:**
+```
+Signal Direction: CNN (primary) + Regime (filter)
+Confidence: 70% Logistic + 30% CNN
+Magnitude: CNN prediction
+```
+
+**Training Data Source:** QuestDB tables
+- `features_microstructure`: Input features
+- `trades_executed`: Labels (win/loss)
+- `l2_orderbook_raw`: Raw data for CNN
+
+**Training Orchestration:** `ht-manager` service (scheduled jobs)
+
+---
+
+## 🛡️ GIAI ĐOẠN 4: ML TRADE FILTER (Lọc tín hiệu)
+
+### Service: `ht-trader` (MLTradeFilter component)
+**Input:** Signal từ Redis channel `signals`  
+
+**Process:**
+1. Extract features từ signal:
+   - `confidence` (từ ht-brain)
+   - `volatility` (từ ht-feature-engine, normalized by ht-brain)
+   - `spread` (từ ht-feature-engine, normalized by ht-brain)
+   - `hour` (thời gian trong ngày - 0-23)
+
+2. ML Model (Random Forest Classifier):
+   ```python
+   features = [confidence, volatility, spread, hour]
+   win_probability = model.predict_proba(features)[0][1]
+   
+   if win_probability > 0.6:  # Threshold
+       return ACCEPT
+   else:
+       return REJECT
+   ```
+
+**Model Training:**
+- Script: `services/ht-trader/train_trade_filter.py`
+- Data Source: QuestDB table `trades_executed`
+- Features: `confidence`, `volatility`, `spread`, `hour`
+- Label: `pnl > 0` (win) or `pnl <= 0` (loss)
+- Algorithm: Random Forest (100 trees)
+- Training Frequency: **Mỗi 24 giờ** (automated by `ht-manager`)
+
+**Output:** Decision: ACCEPT hoặc REJECT signal
+
+**Code Location:** `services/ht-trader/optimization_utils.py` - class `MLTradeFilter`
+
+---
+
+## 💼 GIAI ĐOẠN 5A: PAPER TRADING (ht-trader)
+
+### Service: `ht-trader` (Mode: PAPER)
+**Input:** Signals đã qua ML Filter  
+
+**Process:**
+
+### 5A.1. Risk Management
+**Component:** `RiskManager`  
+**Checks:**
+- Max position size per coin (default: $5000)
+- Max total exposure across all positions (default: $15000)
+- Max daily loss (default: $500)
+- Max hourly loss (default: $200)
+- Max drawdown percentage (default: 15%)
+
+**Code:** `services/ht-trader/risk_manager.py`
+
+### 5A.2. Position Sizing
+**Algorithm:** Dynamic sizing dựa trên confidence
+```python
+base_size_usd = 1000  # Base position size
+confidence_multiplier = 1 + (confidence - 0.6) * 2  # Range: 1.0 - 1.8
+optimal_size = base_size_usd * confidence_multiplier
+```
+
+**Code:** `services/ht-trader/main.py` - method `calculate_optimal_size()`
+
+### 5A.3. Simulated Execution
+**Process:**
+1. Lấy orderbook từ Redis (nếu có)
+2. Match order với orderbook levels:
+   - BUY: Match với asks (ascending)
+   - SELL: Match với bids (descending)
+3. Tính average fill price và slippage
+4. Tính fee: `size * price * 0.00035` (0.035% taker fee)
+
+**Code:** `services/ht-trader/exchange_client.py` - method `place_order()`
+
+### 5A.4. Position Management
+**Component:** `PositionManager`  
+**Features:**
+- Track open positions (in-memory dict)
+- Check exit conditions:
+  - Stop-loss (default: -2%)
+  - Take-profit (default: +5%)
+  - Reversal signal (opposite direction signal)
+- Smart Exit với trailing stop (optional)
+
+**Code:** `services/ht-trader/position_manager.py`
+
+### 5A.5. Logging & Metrics
+**QuestDB Table:** `trades_executed`
+```sql
+CREATE TABLE trades_executed (
+    trade_id SYMBOL,
+    coin SYMBOL,
+    side SYMBOL,
+    status SYMBOL,
+    exit_reason SYMBOL,
+    strategy_id SYMBOL,
+    environment SYMBOL,
+    entry_price DOUBLE,
+    exit_price DOUBLE,
+    quantity DOUBLE,
+    entry_fee DOUBLE,
+    exit_fee DOUBLE,
+    current_pnl DOUBLE,
+    features_json STRING,
+    notes STRING,
+    timestamp TIMESTAMP
+) TIMESTAMP(timestamp) PARTITION BY DAY;
+```
+
+**Prometheus Metrics:**
+- `trader_signals_received_total`
+- `trader_signals_rejected_total`
+- `trader_trades_executed_total`
+- `trader_pnl_total`
+
+**Code:** `services/ht-trader/main.py`
+
+---
+
+## 🚀 GIAI ĐOẠN 5B: TESTNET TRADING (ht-nautilus-paper)
+
+### Service: `ht-nautilus-paper` (Mode: TESTNET)
+**Input:** Signals từ Redis channel `signals`  
+
+**Process:**
+
+### 5B.1. NautilusTrader Strategy
+**Component:** `RedisSignalStrategy`  
+**Process:**
+1. Subscribe Redis channel `signals`
+2. Deserialize SignalMessage
+3. Convert sang Nautilus Order objects:
+   ```python
+   order = LimitOrder(
+       instrument_id=InstrumentId.from_str(f"{coin}.HL"),
+       order_side=OrderSide.BUY/SELL,
+       quantity=Quantity(size, precision=4),
+       price=Price(price, precision=2),
+       time_in_force=TimeInForce.IOC
+   )
+   ```
+4. Submit order qua ExecutionEngine
+
+**Code:** `services/ht-nautilus/strategies/redis_listener.py`
+
+### 5B.2. Risk Engine (NautilusTrader Built-in)
+**Features:**
+- Max order submit rate: 5 orders/second
+- Position limits (configurable)
+- Exposure checks
+- Pre-trade risk validation
+
+**Config:** `services/ht-nautilus/paper.py` - `LiveRiskEngineConfig`
+
+### 5B.3. Execution Client (Hyperliquid Adapter)
+**Component:** `HyperliquidExecutionClient`  
+**Connection:**
+- API: Hyperliquid Testnet (`https://api.hyperliquid-testnet.xyz`)
+- Wallet: `0x5bf7135bBd778f4c4A9D1e0C9dD79c1348968c4D`
+- Private Key: From env var `HYPERLIQUID_TESTNET_PK`
+
+**Process:**
+1. Receive `SubmitOrder` command từ ExecutionEngine
+2. Map Nautilus Order → Hyperliquid SDK format:
+   ```python
+   result = exchange.order(
+       name=coin,
+       is_buy=is_buy,
+       sz=size_rounded,
+       limit_px=price_rounded,
+       order_type={"limit": {"tif": "Ioc"}},
+       reduce_only=False
+   )
+   ```
+3. Parse response từ Hyperliquid:
+   - `filled`: Instant fill → Publish `FillReport`
+   - `resting`: Order đang chờ → Publish `OrderStatusReport(ACCEPTED)`
+   - Error: Publish `OrderStatusReport(REJECTED)`
+
+**Code:** `services/ht-nautilus/hyperliquid_adapter.py`
+
+### 5B.4. Order Lifecycle
+```
+SubmitOrder (Strategy)
+    ↓
+ExecutionEngine (Risk Check)
+    ↓
+HyperliquidExecutionClient
+    ↓
+Hyperliquid Testnet API
+    ↓
+OrderStatusReport(ACCEPTED) → MessageBus
+    ↓
+FillReport → MessageBus
+    ↓
+OrderStatusReport(FILLED) → MessageBus
+    ↓
+Portfolio Update (PnL calculation)
+```
+
+### 5B.5. Event Handling & Portfolio
+**NautilusTrader MessageBus:**
+- Topics: `execution`, `orders`, `fills`, `positions`
+- Subscribers: Portfolio, Strategy, Logger
+
+**Portfolio Component:**
+- Automatic PnL calculation
+- Position tracking (real-time)
+- Margin calculations
+- Performance metrics
+
+**Output:**
+- **Lệnh thật** trên Hyperliquid Testnet (tiền giả, execution thật)
+- Real fills với actual slippage
+- Portfolio state trong Nautilus Cache
+
+---
+
+## 📈 GIAI ĐOẠN 6: MONITORING & ORCHESTRATION
+
+### Service: `ht-manager`
+
+### 6.1. System Health Monitoring (Mỗi 5 phút)
+**Component:** `SystemHealthLoop`  
+**11 Diagnostic Tasks:**
+1. Infrastructure Health (Redis, QuestDB)
+2. Data Flow Validation (L2 updates, features, signals)
+3. Trading System Status (ht-trader, ht-nautilus)
+4. Resource Monitoring (CPU, RAM, Disk)
+5. Error Rate Checking
+6. PnL Monitoring
+7. Model Performance Tracking
+8. Data Quality Checks
+9. Alert System Validation
+10. Database Integrity
+11. Periodic Summary Reports
+
+**Code:** `services/ht-manager/health_loop.py`
+
+### 6.2. AI Orchestrator
+**Modes:**
+- **High CPU (>70%):** Rule-Based Orchestrator (ultra-fast)
+- **Low CPU (<70%):** Qwen LLM Orchestrator (intelligent)
+
+**Actions:**
+- `wait`: Do nothing
+- `check_service_health`: Verify service status
+- `get_pnl_status`: Query current PnL
+- `restart_service`: Restart failed service
+- `emergency_stop`: Stop all trading
+- `trigger_brain_training`: Retrain AI models
+
+**Code:** 
+- `services/ht-manager/orchestrator.py` (Qwen LLM)
+- `services/ht-manager/orchestrator_rules.py` (Rule-based)
+
+### 6.3. Scheduled Training (Automation)
+**Training Schedule:**
+
+| Model | Frequency | Command | Target Service |
+|-------|-----------|---------|----------------|
+| HMM | 15 phút | `TRAIN_HMM` | ht-brain |
+| Confidence Scorer | 30 phút | `TRAIN_CONFIDENCE` | ht-brain |
+| Causal Discovery | 6 giờ | `TRAIN_CAUSAL` | ht-brain |
+| CNN Model | 1 giờ | `TRAIN_CNN` | ht-brain |
+| ML Trade Filter | **24 giờ** | `TRAIN_TRADE_FILTER` | ht-trader |
+
+**Persistent Scheduling:**
+- Lưu timestamp vào Redis: `scheduler:last_run:{model_name}`
+- Đảm bảo lịch không bị reset khi restart service
+- Đọc từ Redis khi khởi động để tiếp tục schedule
+
+**Code:** `services/ht-manager/main.py` - main loop
+
+### 6.4. Training Execution Flow (ML Trade Filter Example)
+```
+ht-manager (scheduler check)
+    ↓
+Publish Redis: {"command": "TRAIN_TRADE_FILTER"}
+    ↓
+ht-trader (subscribe system_commands)
+    ↓
+Run subprocess: python train_trade_filter.py
+    ↓
+Query QuestDB: SELECT * FROM trades_executed
+    ↓
+Train Random Forest model
+    ↓
+Save model: models/trade_filter_v{version}.pkl
+    ↓
+Reload model in MLTradeFilter
+    ↓
+Update Redis: scheduler:last_run:trade_filter = current_time
+```
+
+**Code:** 
+- Scheduler: `services/ht-manager/main.py`
+- Handler: `services/ht-trader/main.py` - method `process_command()`
+- Training: `services/ht-trader/train_trade_filter.py`
+
+---
+
+## 🔄 FEEDBACK LOOP (Self-Learning)
+
+### Service: `ht-brain` (Experience Replay)
+
+**Process:**
+1. **Lưu predictions:**
+   ```python
+   self.predictions[coin].append({
+       'timestamp': current_time,
+       'price': current_price,
+       'direction': predicted_direction,
+       'magnitude': predicted_magnitude,
+       'horizon': 60  # seconds
+   })
+   ```
+
+2. **Kiểm tra matured predictions:**
+   ```python
+   for pred in predictions:
+       if current_time - pred['timestamp'] >= pred['horizon']:
+           actual_price = get_price_at(pred['timestamp'] + horizon)
+           actual_direction = sign(actual_price - pred['price'])
+           actual_magnitude = (actual_price - pred['price']) / pred['price']
+           
+           # Calculate accuracy
+           direction_correct = (actual_direction == pred['direction'])
+           magnitude_error = abs(actual_magnitude - pred['magnitude'])
+   ```
+
+3. **Update metrics:**
+   - Direction accuracy
+   - Magnitude MAE (Mean Absolute Error)
+   - Horizon-specific performance
+
+4. **Trigger retrain:**
+   ```python
+   if len(validated_predictions) >= 1000:
+       trigger_cnn_training()
+   ```
+
+**Code:** `services/ht-brain/main.py` - Experience Replay section
+
+---
+
+## 📊 VISUALIZATION & ANALYSIS
+
+### Service: `ht-dashboard` (Streamlit)
+
+**Pages:**
+1. **Overview:**
+   - Real-time PnL chart
+   - Win rate by coin
+   - Total trades executed
+   - Current positions
+
+2. **Signal Analysis:**
+   - Signal distribution (BUY/SELL/HOLD)
+   - Confidence histogram
+   - Regime distribution
+   - Signal frequency by hour
+
+3. **Model Performance:**
+   - CNN accuracy by horizon
+   - Confidence scorer calibration
+   - HMM regime accuracy
+   - ML Trade Filter win rate
+
+4. **System Health:**
+   - Service status (Docker containers)
+   - CPU/RAM usage
+   - Database size
+   - Error logs
+
+5. **Backtest Results:**
+   - Strategy comparison
+   - Parameter optimization results
+   - Equity curve
+   - Drawdown analysis
+
+**Code:** `services/ht-dashboard/app.py`
+
+---
+
+## 🎯 LUỒNG TỔNG QUAN (SIMPLIFIED)
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    HYPERLIQUID EXCHANGE                         │
+│                    (WebSocket API)                              │
+└────────────────────────┬────────────────────────────────────────┘
+                         │
+                         ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  GIAI ĐOẠN 1: DATA COLLECTION                                  │
+│  Service: ht-collector                                          │
+│  Output: Redis (market_data_updates) + QuestDB (l2_orderbook)  │
+└────────────────────────┬────────────────────────────────────────┘
+                         │
+                         ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  GIAI ĐOẠN 2: FEATURE ENGINEERING                              │
+│  Service: ht-feature-engine                                     │
+│  Output: Redis (features_updates) + QuestDB (features_micro)   │
+│  Features: 17 indicators (OBI, OFI, CVD, Volatility, etc.)     │
+└────────────────────────��────────────────────────────────────────┘
+                         │
+                         ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  GIAI ĐOẠN 3: AI SIGNAL GENERATION                             │
+│  Service: ht-brain                                              │
+│  AI Models:                                                     │
+│    1. HMM (Regime Detection)                                    │
+│    2. Logistic Regression (Confidence Scoring)                 │
+│    3. Multi-Task CNN (Direction + Magnitude)                   │
+│    4. PC Algorithm (Causal Discovery)                          │
+│  Output: Redis (signals) + QuestDB (signals_generated) ✅      │
+└────────────────────────┬────────────────────────────────────────┘
+                         │
+                         ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  GIAI ĐOẠN 4: ML TRADE FILTER                                  │
+│  Service: ht-trader (MLTradeFilter)                             │
+│  Model: Random Forest Classifier                               │
+│  Decision: ACCEPT (win_prob > 60%) or REJECT                   │
+└────────────────────────┬────────────────────────────────────────┘
+                         │
+                         ▼
+         ┌───────────────┴───────────────┐
+         │                               │
+         ▼                               ▼
+┌──────────────────────┐      ┌──────────────────────┐
+│  GIAI ĐOẠN 5A:       │      │  GIAI ĐOẠN 5B:       │
+│  PAPER TRADING       │      │  TESTNET TRADING     │
+│  Service: ht-trader  │      │  Service:            │
+│  Mode: PAPER         │      │  ht-nautilus-paper   │
+│  Execution:          │      │  Mode: TESTNET       │
+│  Simulated           │      │  Execution:          │
+│                      │      │  Hyperliquid API     │
+│  Output:             │      │  (Real orders)       │
+│  - QuestDB           │      │                      │
+│  - Metrics           │      │  Output:             │
+│                      │      │  - Real fills        │
+│                      │      │  - Portfolio state   │
+└──────────────────────┘      └──────────────────────┘
+         │                               │
+         └───────────────┬───────────────┘
+                         │
+                         ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  GIAI ĐOẠN 6: MONITORING & ORCHESTRATION                       │
+│  Service: ht-manager                                            │
+│  Functions:                                                     │
+│    - System Health Monitoring (11 tasks)                       │
+│    - AI Orchestrator (Rule-based / Qwen LLM)                   │
+│    - Scheduled Training (5 models, automated)                  │
+│    - Persistent Scheduling (Redis-backed)                      │
+│    - Telegram Alerts                                            │
+└────────────────────────┬────────────────────────────────────────┘
+                         │
+                         ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  FEEDBACK LOOP: SELF-LEARNING                                  │
+│  Service: ht-brain (Experience Replay)                          │
+│  Process: Validate predictions → Update metrics → Retrain      │
+└─────────────────────────────────────────────────────────────────┘
+                         │
+                         ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  VISUALIZATION: ht-dashboard (Streamlit)                        │
+│  Real-time charts, metrics, backtest results                   │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🔑 KEY POINTS
+
+### 1. Signals CÓ được lưu vào database
+- **Table:** `signals_generated` trong QuestDB
+- **Mục đích:** Tracking, backtesting, phân tích hiệu quả AI
+- **Lọc:** Chỉ lưu BUY/SELL (không lưu HOLD)
+
+### 2. Signal được tạo bởi ENSEMBLE AI
+- **4 Models:** HMM + Logistic Regression + Multi-Task CNN + PC Algorithm
+- **Weighted Combination:** 70% Logistic + 30% CNN cho confidence
+- **Primary Direction:** CNN model (DeepLOB architecture)
+- **Filter:** Regime (HMM) để tránh trade trong sideway market
+
+### 3. Dual Execution Engines
+- **ht-trader (Paper):** Giả lập nhanh, thu thập data cho ML
+- **ht-nautilus-paper (Testnet):** Execution thật, test chiến lược thực tế
+
+### 4. Automated Training Pipeline
+- **5 Models** được train tự động theo lịch
+- **Persistent scheduling** qua Redis (không bị reset khi restart)
+- **Self-learning** qua Experience Replay
+
+---
+
+## 📚 RELATED DOCUMENTATION
+
+- [Architecture Overview](./ARCHITECTURE_HT_TRADER.md)
+- [Paper Trading Strategy](./PAPER_TRADING_STRATEGY.md)
+- [ML Trade Filter Roadmap](./ML_TRADE_FILTER_ROADMAP.md)
+- [Trader Optimizations](./HT_TRADER_OPTIMIZATIONS.md)
+
+---
+
+**Last Updated:** 2025-12-02  
+**Version:** 1.0

AIDocs/TRAINING_STRATEGY_v2.md

@@ -0,0 +1,75 @@
+# AI Training Strategy v2.0 (Hyperliquid L2 Data)
+
+This document outlines the optimal training strategy for the HyperTrade AI engine using the valid `gionuibk/hyperliquidL2Book-v2` dataset.
+
+## 1. Data Foundation
+
+We have three verified data sources in the v2 dataset:
+1.  **L2 Order Book (`data/l2book/*.parquet`)**: High-fidelity snapshots (20 levels).
+    *   *Usage*: **DeepLOB** (CNNs for spatial feature extraction).
+2.  **Trades (`data/l4_node_trades*/*.parquet`)**: Executed trade flow.
+    *   *Usage*: **TRM** (Regime detection via CVD & OFI).
+3.  **Candles (`data/candles/*.parquet`)**: Aggregated OHLCV bars.
+    *   *Usage*: **LSTM** (Temporal sequence modeling for trend).
+
+## 2. Model-Specific Training Recipes
+
+### A. DeepLOB (The "Sniper" Scope)
+**Objective**: Detect short-term directional moves based on order book pressure.
+
+*   **Input**: Rolling window of L2 Book (100 ticks x 40 features).
+*   **Target**: Triple Barrier (Profit Take vs Stop Loss within 100 ticks).
+*   **Strategy**:
+    1.  **Curriculum Learning**:
+        *   *Phase 1*: Train on **High Volatility** days first. (The model learns faster when signal-to-noise is high).
+        *   *Phase 2*: Train on **Sideways** days. (Fine-tune to reduce false positives).
+    2.  **class_weights**: The market is mostly noise (Hold). Use `class_weights=[1.0, 5.0, 5.0]` to force the model to care about Buy/Sell signals.
+    3.  **Learning Rate**: Start `1e-4`, decay by 0.5 every 5 epochs.
+
+### B. TRM (The "General")
+**Objective**: Identify Market Regimes (Trend vs Sideways).
+
+*   **Input**: Features (`Volatility`, `Imbalance`, `Spread`, `CVD`, `OFI`).
+    *   *Note*: Requires merging L2 Book timestamps with Trade timestamps to compute accurate CVD/OFI.
+*   **Strategy**:
+    *   **Unsupervised Pre-training**: Use a Hidden Markov Model (HMM) first to label data as "High Vol", "Low Vol", "Trend".
+    *   **Supervised Fine-tuning**: Train TRM to predict these HMM states + Next 5-min Return.
+    *   **Reasoning**: TRM needs to understand *context*, not just price.
+
+### C. LSTM (The "Scout")
+**Objective**: Predict medium-term trend (Next 1-5 minutes).
+
+*   **Input**: Sequence of 60 Candle Bars (1s or 1m resolution).
+*   **Strategy**:
+    *   **Normalization**: Use **Log Returns** (not Price). Price is non-stationary; Log Returns are stationary.
+    *   **Regularization**: High Dropout (0.3 - 0.5) to prevent memorizing absolute price levels.
+
+## 3. "Smarter AI": What does it mean?
+
+When we say "making the AI smarter", we refer to optimizing three categories of parameters:
+
+### 1. Weights & Biases (The "Brain Cells")
+*   **Definition**: The billions of floating-point numbers inside the neural network matrices.
+*   **How to improve**:
+    *   **More Data**: Training on the full `hyperliquidL2Book-v2` dataset (millions of rows) refines these weights.
+    *   **Better Labels**: Using "Triple Barrier" labeling (dynamic targets based on volatility) instead of fixed targets makes the weights learn *risk-adjusted* moves.
+
+### 2. Hyperparameters (The "Configuration")
+*   **Definition**: Settings chosen *before* training.
+*   **Key Controls**:
+    *   **Lookback Window (T)**: Currently 100. Increasing to 200 may capture longer patterns but adds noise.
+    *   **Batch Size**: Large batches (64/128) provide stable gradients. Small batches (16/32) add noise that can help generalization (escape local minima).
+    *   **Model Depth**: Adding specific layers (e.g., Attention Heads) can help the model focus on critical events.
+
+### 3. Feature Engineering (The "Eyes")
+*   **Definition**: What the AI actually *sees*.
+*   **Improvement**:
+    *   **OFI (Order Flow Imbalance)**: We just added this. It tells the AI *who* is aggressive (Makers vs Takers).
+    *   **Micro-Structure**: Bid-Ask Bounce, Queue Position (requires L3 data, but L2 approximation helps).
+
+## 4. Execution Plan (Recommended)
+
+1.  **Data Prep**: Run the `streaming_loader` update (Done).
+2.  **Dry Run**: Train DeepLOB for 1 epoch on a small subset to verify convergence (Loss decreases).
+3.  **Scale Up**: Run `auto_train.py` on a GPU instance (e.g., RunPod/Lambda) for 24-48 hours.
+4.  **Evaluate**: Check "Precision" (Win Rate) on specific regimes using the Dashboard.

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+ENV PYTHONUNBUFFERED=1
+
+
+# System dependencies (Minimal)
+RUN apt-get update && apt-get install -y \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python deps (Fast)
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy Trainer Code
+COPY . .
+
+# Install Schedule for looping
+RUN pip install schedule
+
+CMD ["python", "scheduler.py"]

app.py

@@ -0,0 +1,166 @@
+import gradio as gr
+import time
+import os
+import json
+import pandas as pd
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+# Status file path
+STATUS_FILE = "./status.json"
+
+def read_status():
+    """Read training status from JSON file."""
+    if not os.path.exists(STATUS_FILE):
+        return {
+            "current_model": None,
+            "status": "idle",
+            "epoch": 0,
+            "total_epochs": 0,
+            "last_loss": None,
+            "last_accuracy": None,
+            "started_at": None,
+            "last_update": None,
+            "logs": []
+        }
+    
+    try:
+        with open(STATUS_FILE, 'r') as f:
+            return json.load(f)
+    except:
+        return {"status": "error", "logs": ["Could not read status file"]}
+
+def get_status_display():
+    """Format status for display."""
+    status = read_status()
+    
+    model = status.get("current_model", "None")
+    state = status.get("status", "idle").upper()
+    epoch = status.get("epoch", 0)
+    total = status.get("total_epochs", 0)
+    loss = status.get("last_loss")
+    acc = status.get("last_accuracy")
+    updated = status.get("last_update", "Never")
+    
+    # Status emoji
+    emoji = {"idle": "⏸️", "training": "🔄", "completed": "✅", "error": "❌"}.get(status.get("status", "idle"), "❓")
+    
+    info = f"""
+## {emoji} Training Status: {state}
+
+**Model:** {model or 'None'}  
+**Progress:** {epoch}/{total} epochs  
+**Last Loss:** {f'{loss:.4f}' if loss else 'N/A'}  
+**Accuracy:** {f'{acc:.2f}%' if acc else 'N/A'}  
+**Updated:** {updated}
+"""
+    return info
+
+def get_logs():
+    """Get training logs."""
+    status = read_status()
+    logs = status.get("logs", [])
+    return "\n".join(logs[-30:]) if logs else "No logs yet."
+
+def plot_metrics():
+    """Plot training metrics (if available)."""
+    # This could be enhanced to read from a metrics history file
+    status = read_status()
+    
+    if status.get("status") == "idle":
+        return None
+    
+    # Simple placeholder - in production, would read from metrics file
+    fig = plt.figure(figsize=(10, 4))
+    plt.text(0.5, 0.5, "Metrics will appear during training", 
+             ha='center', va='center', fontsize=14)
+    plt.axis('off')
+    return fig
+
+def refresh_all():
+    """Refresh all dashboard components."""
+    return get_status_display(), get_logs(), plot_metrics()
+
+# --- Dashboard UI ---
+with gr.Blocks(title="NautilusAI Dashboard") as app:
+    gr.Markdown("# 🧠 NautilusAI Training Dashboard")
+    gr.Markdown("*Monitoring dashboard with manual training trigger*")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            status_md = gr.Markdown(get_status_display())
+            with gr.Row():
+                refresh_btn = gr.Button("🔄 Refresh", variant="secondary")
+                train_btn = gr.Button("🚀 Start Training", variant="primary")
+            train_output = gr.Textbox(label="Training Output", lines=3, interactive=False)
+        
+        with gr.Column(scale=2):
+            logs_box = gr.Textbox(
+                label="Training Logs", 
+                value=get_logs(),
+                lines=15, 
+                max_lines=20, 
+                interactive=False
+            )
+    
+    with gr.Row():
+        plot_box = gr.Plot(label="Training Metrics")
+    
+# Global flag
+TRAINING_STARTED = False
+
+def trigger_training():
+    """Trigger training in background thread."""
+    global TRAINING_STARTED
+    if TRAINING_STARTED:
+        return "⚠️ Training already active."
+        
+    TRAINING_STARTED = True
+    import threading
+    import sys
+    
+    def run_training():
+        print("🚀 Auto-Training Pipeline Started...", flush=True)
+        try:
+            from auto_train import main
+            # Redirect stdout to capture logs in real-time if needed, but flush=True should suffice for container logs
+            main()
+        except Exception as e:
+            print(f"❌ Training error: {e}", flush=True)
+        finally:
+            global TRAINING_STARTED
+            TRAINING_STARTED = False
+            print("🏁 Training Pipeline Finished.", flush=True)
+            sys.stdout.flush()
+    
+    t = threading.Thread(target=run_training, daemon=True)
+    t.start()
+    return "🔄 Training started! Check logs for progress..."
+
+    # Actions
+    train_btn.click(trigger_training, outputs=[train_output])
+    
+    # Refresh action
+    refresh_btn.click(refresh_all, outputs=[status_md, logs_box, plot_box])
+    
+    # Auto-refresh every 5 seconds
+    timer = gr.Timer(5)
+    timer.tick(refresh_all, outputs=[status_md, logs_box, plot_box])
+
+    # --- API ---
+    # Hidden JSON component for programmatic access
+    api_status_box = gr.JSON(label="Status API", visible=False)
+    
+    # Expose this function as an API named '/get_status'
+    # We use a dummy button or just a direct event. 
+    # In Gradio 4.x, just defining a function for a component update can work, 
+    # but explicit api_name is best on a click or load.
+    api_btn = gr.Button("API Trigger", visible=False)
+    api_btn.click(read_status, outputs=[api_status_box], api_name="get_status")
+
+if __name__ == "__main__":
+    # Auto-start training on launch
+    print("System Startup: Triggering Auto-Train...")
+    trigger_training()
+    
+    app.launch(server_name="0.0.0.0", server_port=7860)

auto_train.py

@@ -0,0 +1,763 @@
+#!/usr/bin/env python3
+"""
+Auto Training Pipeline for NautilusAI
+Runs scheduled training for DeepLOB, TRM, and Ensemble models.
+Writes status to status.json for Dashboard monitoring.
+"""
+import os
+import json
+import time
+from datetime import datetime
+from pathlib import Path
+from huggingface_hub import HfApi
+import joblib
+import pickle
+
+
+
+# Configuration
+REPO_ID = "gionuibk/hyperliquidL2Book-v2"
+DATA_DIR = "./data"
+MODEL_DIR = "./models"
+STATUS_FILE = "./status.json"
+HF_MODEL_REPO = "gionuibk/NautilusModels"
+REPO_ID_LOGS = "gionuibk/NautilusLogs"
+
+# Ensure directories exist
+Path(MODEL_DIR).mkdir(exist_ok=True)
+Path(DATA_DIR).mkdir(exist_ok=True)
+
+class StatusWriter:
+    """Writes training status to JSON file for Dashboard."""
+    
+    def __init__(self, filepath=STATUS_FILE):
+        self.filepath = filepath
+        self.logs = []
+        
+        # Ensure Log Repo exists
+        try:
+            from huggingface_hub import HfApi, create_repo
+            import os
+            token = os.environ.get("HF_TOKEN")
+            if token:
+                create_repo("gionuibk/NautilusLogs", repo_type="dataset", exist_ok=True, token=token, private=True)
+        except: pass
+        
+        self.last_upload_time = 0
+        self.reset()
+    
+    def reset(self):
+        self.status = {
+            "current_model": None,
+            "status": "idle",
+            "epoch": 0,
+            "total_epochs": 0,
+            "last_loss": None,
+            "last_accuracy": None,
+            "started_at": None,
+            "last_update": None,
+            "logs": []
+        }
+        self._save()
+    
+    def start(self, model_name: str, total_epochs: int):
+        self.logs = []
+        self.status = {
+            "current_model": model_name,
+            "status": "training",
+            "epoch": 0,
+            "total_epochs": total_epochs,
+            "last_loss": None,
+            "last_accuracy": None,
+            "started_at": datetime.now().isoformat(),
+            "last_update": datetime.now().isoformat(),
+            "logs": []
+        }
+        self.log(f"Started training {model_name}")
+        self._save()
+    
+    def update(self, epoch: int, loss: float, accuracy: float = None):
+        self.status["epoch"] = epoch
+        self.status["last_loss"] = loss
+        self.status["last_accuracy"] = accuracy
+        self.status["last_update"] = datetime.now().isoformat()
+        self.log(f"Epoch {epoch}: Loss={loss:.4f}" + (f", Acc={accuracy:.2f}%" if accuracy else ""))
+        self._save()
+    
+    def complete(self, model_name: str):
+        self.status["status"] = "completed"
+        self.status["last_update"] = datetime.now().isoformat()
+        self.log(f"Completed training {model_name}")
+        self._save()
+    
+    def error(self, message: str):
+        self.status["status"] = "error"
+        self.status["last_update"] = datetime.now().isoformat()
+        self.log(f"ERROR: {message}")
+        self._save()
+    
+    def log(self, message: str):
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        log_entry = f"[{timestamp}] {message}"
+        self.logs.append(log_entry)
+        self.status["logs"] = self.logs[-50:]  # Keep last 50 logs
+        print(log_entry)
+    
+    def _save(self):
+        # Save locally
+        with open(self.filepath, 'w') as f:
+            json.dump(self.status, f, indent=2)
+            
+        # Upload to HF Dataset for remote monitoring
+        # Throttle: Only upload every 10 minutes (600s) OR if status is final
+        import time
+        current_time = time.time()
+        is_final = self.status["status"] in ["completed", "error"]
+        
+        if (current_time - self.last_upload_time >= 600) or is_final:
+            try:
+                from huggingface_hub import HfApi
+                api = HfApi()
+                token = os.environ.get("HF_TOKEN")
+                if token:
+                    LOG_REPO = "gionuibk/NautilusLogs"
+                    
+                    api.upload_file(
+                        path_or_fileobj=self.filepath,
+                        path_in_repo="status.json",
+                        repo_id=LOG_REPO,
+                        repo_type="dataset",
+                        token=token
+                    )
+                    self.last_upload_time = current_time
+                    print(f"📡 Status uploaded to HF (Next update in 10 mins).")
+            except Exception as e:
+                pass
+
+class HistoryWriter:
+    """Writes permanent training history to CSV."""
+    def __init__(self, filepath="training_history.csv"):
+        self.filepath = filepath
+        self.last_upload_time = 0
+        self._ensure_header()
+        
+    def _ensure_header(self):
+        if not os.path.exists(self.filepath):
+            with open(self.filepath, 'w') as f:
+                f.write("timestamp,model_name,metrics,filename,hf_url\n")
+    
+    def log_model(self, model_name: str, metrics: str, filename: str):
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        hf_url = f"https://huggingface.co/{HF_MODEL_REPO}/blob/main/{filename}"
+        
+        # Validation
+        if not metrics: metrics = "N/A"
+        
+        # Append to CSV
+        with open(self.filepath, 'a') as f:
+            f.write(f"{timestamp},{model_name},{metrics},{filename},{hf_url}\n")
+            
+        print(f"📜 Logged to history: {filename}")
+        self.upload_history() # Auto-upload with throttle
+        
+    def upload_history(self):
+        """Uploads the history CSV to HuggingFace Logs Repo (Throttled 10m)."""
+        import time
+        current_time = time.time()
+        
+        if current_time - self.last_upload_time < 600:
+             return # Skip if too frequent
+             
+        print("📤 Uploading Training History Log...")
+        try:
+             token = os.environ.get("HF_TOKEN")
+             if token:
+                 from huggingface_hub import HfApi
+                 api = HfApi(token=token)
+                 api.upload_file(
+                     path_or_fileobj=self.filepath,
+                     path_in_repo="training_history.csv",
+                     repo_id=REPO_ID_LOGS,
+                     repo_type="dataset"
+                 )
+                 self.last_upload_time = current_time
+        except Exception as e:
+            print(f"⚠️ History Upload Failed: {e}")
+
+
+def train_deeplob(status: StatusWriter, api: HfApi, history, epochs: int = 1):
+    """Train DeepLOB model using Streaming Data."""
+    print("⏳ Loading DeepLOB Dependencies (Torch)...")
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    from models.deeplob import DeepLOB
+    from streaming_loader import StreamingDataLoader
+    
+    # Note: Epochs in streaming context usually means passes over the stream.
+    # Since stream is huge/infinite, we might define 'epoch' as N steps or 1 full pass.
+    # We will stick to 1 full pass per 'epoch' call effectively, or simple consistency.
+    status.start("DeepLOB", epochs)
+    
+    try:
+        # Initialize Streaming Loader
+        loader = StreamingDataLoader(
+            repo_id=REPO_ID,
+            model_type="deeplob",
+            batch_size=32,
+            chunk_size=5000 # Process 5000 rows at a time
+        )
+        
+        # Initialize Model
+        # We need a sample batch to verify shapes if needed, or just init blindly
+        model = DeepLOB(y_len=3)
+        
+        # Loss & Optimizer
+        # Note: Class weights difficult to pre-calc in streaming. Using standard CELoss
+        criterion = nn.CrossEntropyLoss()
+        optimizer = optim.Adam(model.parameters(), lr=0.0001)
+        
+        step = 0
+        total_loss = 0
+        correct = 0
+        total_samples = 0
+        
+        model.train()
+        print("🚀 Starting Streaming Training loop...")
+        
+        # Stream Loop
+        # We iterate through the ENTIRE dataset stream once per 'epoch' logic
+        # For multi-epoch, we'd need to re-create the loader or reset it.
+        # HF streaming datasets are iterators.
+        
+        for batch_X, batch_y in loader:
+            optimizer.zero_grad()
+            outputs = model(batch_X)
+            loss = criterion(outputs, batch_y)
+            loss.backward()
+            optimizer.step()
+            
+            # Metrics
+            total_loss += loss.item()
+            _, predicted = torch.max(outputs.data, 1)
+            total_samples += batch_y.size(0)
+            correct += (predicted == batch_y).sum().item()
+            
+            step += 1
+            if step % 10 == 0:
+                print(f"Step {step}: Loss={loss.item():.4f}", flush=True)
+                
+            # Update status occasionally
+            if step % 50 == 0:
+                acc = 100 * correct / total_samples
+                avg_loss = total_loss / step
+                status.update(1, avg_loss, acc) # Report as Epoch 1 for now
+        
+        # Save Native PyTorch Model (Reliable Fallback)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        model_filename = f"deeplob_{timestamp}.pt"
+        save_path = f"{MODEL_DIR}/{model_filename}"
+        
+        torch.save(model.state_dict(), save_path)
+        print(f"Reference PyTorch model saved: {save_path} (Trained on {step} batches)")
+        
+        # Upload model to HF Model Hub (User Request)
+        try:
+            from huggingface_hub import create_repo
+            token = os.environ.get("HF_TOKEN")
+            # Ensure Model Repo exists
+            create_repo(HF_MODEL_REPO, repo_type="model", exist_ok=True, token=token)
+            
+            print(f"Uploading {model_filename} to Model Repo: {HF_MODEL_REPO}...")
+            api.upload_file(
+                path_or_fileobj=save_path,
+                path_in_repo=model_filename,
+                repo_id=HF_MODEL_REPO,
+                repo_type="model"
+            )
+            print(f"✅ {model_filename} uploaded to HF Models successfully.")
+        except Exception as e:
+            print(f"⚠️ Model Upload Failed: {e}") 
+            
+        # Redundant upload to Logs Dataset (Optional, keeping for legacy dashboards if any)
+        # ... (Removed to avoid duplication and save bandwidth, user asked for Models tab)
+
+
+        # Save ONNX (Disabled due to Environment Incompatibility)
+        # try:
+        #     print("Exporting DeepLOB to ONNX...")
+        #     dummy = torch.randn(1, 2, 100, 40)
+        #     torch.onnx.export(model, dummy, f"{MODEL_DIR}/deeplob_v1.onnx",
+        #                     input_names=['input'], output_names=['output'],
+        #                     opset_version=12)
+        #     print("ONNX Export Success.")
+        # except Exception as e:
+        #     print(f"⚠️ ONNX Export Failed: {e}") 
+        print("ONNX Export Skipped (Using .pt checkpoint).")
+            # Continue pipeline despite export failure
+
+        
+        status.complete("DeepLOB")
+        # Log to History
+        acc_str = f"Acc={acc:.2f}%" if 'acc' in locals() else "N/A"
+        try: history.log_model("DeepLOB", acc_str, model_filename) 
+        except: pass
+        return True
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        status.error(str(e))
+        return False
+
+def train_trm(status: StatusWriter, api: HfApi, history, epochs: int = 1):
+    """Train TRM model using Streaming Data."""
+    print("⏳ Loading TRM Dependencies (Torch)...")
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    from models.trm import TRM
+    from streaming_loader import StreamingDataLoader
+    
+    status.start("TRM", epochs)
+    
+    try:
+        loader = StreamingDataLoader(
+            repo_id=REPO_ID,
+            model_type="trm",
+            batch_size=64,
+            chunk_size=5000
+        )
+        
+        model = TRM(input_size=6, num_classes=3)
+        criterion = nn.CrossEntropyLoss()
+        optimizer = optim.Adam(model.parameters(), lr=0.001)
+        
+        step = 0
+        total_loss = 0
+        model.train()
+        
+        for batch_X, batch_y in loader:
+            optimizer.zero_grad()
+            out = model(batch_X)
+            loss = criterion(out, batch_y)
+            loss.backward()
+            optimizer.step()
+            
+            total_loss += loss.item()
+            step += 1
+            
+            if step % 50 == 0:
+                status.update(1, total_loss / step)
+
+        # Save Native PyTorch Model
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        model_filename = f"trm_{timestamp}.pt"
+        save_path = f"{MODEL_DIR}/{model_filename}"
+
+        torch.save(model.state_dict(), save_path)
+        print(f"Reference PyTorch model saved: {save_path} (Trained on {step} batches)")
+
+        # Upload model to HF Model Hub
+        try:
+            print(f"Uploading {model_filename} to Model Repo: {HF_MODEL_REPO}...")
+            api.upload_file(
+                path_or_fileobj=save_path,
+                path_in_repo=model_filename,
+                repo_id=HF_MODEL_REPO,
+                repo_type="model"
+            )
+            print(f"✅ {model_filename} uploaded to HF Models successfully.")
+        except Exception as e:
+            print(f"⚠️ Model Upload Failed: {e}")
+
+        # Save ONNX (Disabled due to Environment Incompatibility)
+        # try:
+        #     print("Exporting TRM to ONNX...")
+        #     dummy = torch.randn(1, 60, 6)
+        #     torch.onnx.export(model, dummy, f"{MODEL_DIR}/trm_v1.onnx",
+        #                     input_names=['input'], output_names=['output'],
+        #                     opset_version=12)
+        #     print("ONNX Export Success.")
+        # except Exception as e:
+        #      print(f"⚠️ ONNX Export Failed: {e}")
+        print("ONNX Export Skipped (Using .pt checkpoint).")
+             # Continue pipeline
+        
+        status.complete("TRM")
+        return True
+        
+        status.complete("TRM")
+        return True
+        
+    except Exception as e:
+        status.error(str(e))
+        return False
+
+def train_lstm(status: StatusWriter, api: HfApi, history, epochs: int = 1):
+    """Train LSTM model using Streaming Data (Bar Data)."""
+    print("⏳ Loading LSTM Dependencies (Torch)...")
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    from models.lstm import AlphaLSTM
+    from streaming_loader import StreamingDataLoader
+    
+    status.start("LSTM", epochs)
+    
+    try:
+        loader = StreamingDataLoader(
+            repo_id=REPO_ID,
+            model_type="lstm",
+            batch_size=64,
+            chunk_size=5000
+        )
+        
+        # Input Size = 5 (log_ret, log_vol, hl_range, co_range, vol)
+        model = AlphaLSTM(input_size=5, hidden_size=64)
+        
+        # Regression Loss (Mean Squared Error)
+        criterion = nn.MSELoss()
+        optimizer = optim.Adam(model.parameters(), lr=0.001)
+        
+        step = 0
+        total_loss = 0
+        model.train()
+        
+        print(f"🚀 Starting LSTM Training loop (Target: Next Return)...")
+        
+        for batch_X, batch_y in loader:
+            optimizer.zero_grad()
+            out = model(batch_X)
+            # batch_y is (Batch, 1), out is (Batch, 1)
+            loss = criterion(out, batch_y)
+            loss.backward()
+            optimizer.step()
+            
+            total_loss += loss.item()
+            step += 1
+            
+            if step % 50 == 0:
+                print(f"Step {step}: Loss={loss.item():.6f}", flush=True)
+                status.update(1, total_loss / step)
+
+        # Save Native PyTorch Model
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        model_filename = f"lstm_{timestamp}.pt"
+        save_path = f"{MODEL_DIR}/{model_filename}"
+
+        torch.save(model.state_dict(), save_path)
+        print(f"Reference PyTorch model saved: {save_path} (Trained on {step} batches)")
+
+        # Upload model
+        try:
+            print(f"Uploading {model_filename} to Model Repo: {HF_MODEL_REPO}...")
+            api.upload_file(
+                path_or_fileobj=save_path,
+                path_in_repo=model_filename,
+                repo_id=HF_MODEL_REPO,
+                repo_type="model"
+            )
+            print(f"✅ {model_filename} uploaded to HF Models successfully.")
+        except Exception as e:
+            print(f"⚠️ Model Upload Failed: {e}")
+            
+        status.complete("LSTM")
+        try: history.log_model("LSTM", "N/A", model_filename)
+        except: pass
+        return True
+        
+    except Exception as e:
+        status.error(str(e))
+        print(f"❌ LSTM Training Error: {e}")
+        return False
+
+def train_classic_and_causal(status: StatusWriter, api: HfApi, history):
+    """Train Classic ML and Causal Discovery models using Bar Data."""
+    print("⏳ Loading Classic/Causal Dependencies (Pandas/Sklearn)...")
+    import pandas as pd
+    import numpy as np
+    from models.classic_ml import get_hmm_pipeline, get_rf_pipeline
+    from models.causal_discovery import get_causal_model
+    from streaming_loader import StreamingDataLoader
+    
+    status.start("ClassicML & Causal", 1)
+    
+    try:
+        # Load a chunk
+        from huggingface_hub import hf_hub_download
+        api_hf = HfApi(token=os.environ.get("HF_TOKEN"))
+        files = api_hf.list_repo_files(repo_id=REPO_ID, repo_type="dataset")
+        # Support V2 'data/candles/' and V1 'data/bar/'
+        bar_files = [f for f in files if (f.startswith("data/candles/") or f.startswith("data/bar/")) and f.endswith(".parquet")]
+        
+        if not bar_files:
+             print("❌ No bar files found for ClassicML.")
+             return False
+             
+        # Aggregate multiple files until we have enough rows (e.g., 2000)
+        target_rows = 2000
+        aggregated_dfs = []
+        total_rows = 0
+        
+        print(f"📥 Aggregating bar files (Target: {target_rows} rows)...")
+        
+        for file_info in bar_files:
+            if total_rows >= target_rows:
+                break
+                
+            try:
+                local_path = hf_hub_download(repo_id=REPO_ID, filename=file_info, repo_type="dataset", token=os.environ.get("HF_TOKEN"))
+                chunk_df = pd.read_parquet(local_path)
+                if not chunk_df.empty:
+                    aggregated_dfs.append(chunk_df)
+                    total_rows += len(chunk_df)
+                    print(f"  + Added {len(chunk_df)} rows from {file_info} (Total: {total_rows})")
+            except Exception as e:
+                print(f"  ⚠️ Failed to load {file_info}: {e}")
+                
+        if not aggregated_dfs:
+            print("❌ Failed to load any valid bar data.")
+            return False
+            
+        df = pd.concat(aggregated_dfs, ignore_index=True)
+        print(f"✅ Final Dataset Size: {len(df)} rows")
+        
+        # Preprocess
+        df['log_ret'] = np.log(df['close'] / df['close'].shift(1)).fillna(0)
+        clean_df = df.dropna().select_dtypes(include=[np.number]).iloc[:10000]
+        X = clean_df.values
+        
+        # 1. Classic ML (Random Forest)
+        print("🧠 Training ClassicML (Random Forest)...")
+        rf_model = get_rf_pipeline()
+        y = (df['log_ret'].shift(-1).fillna(0) > 0).astype(int).iloc[:10000]
+        rf_model.fit(X, y)
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        rf_filename = f"classic_ml_{timestamp}.joblib"
+        joblib.dump(rf_model, f"{MODEL_DIR}/{rf_filename}")
+        
+        api.upload_file(
+            path_or_fileobj=f"{MODEL_DIR}/{rf_filename}",
+            path_in_repo=rf_filename,
+            repo_id=HF_MODEL_REPO,
+            repo_type="model"
+        )
+        print(f"✅ {rf_filename} uploaded.")
+        
+        # 2. Causal Discovery
+        print("🕸️ Running Causal Discovery...")
+        causal_model = get_causal_model()
+        causal_model.fit(clean_df)
+        
+        causal_filename = f"causal_discovery_{timestamp}.pkl"
+        with open(f"{MODEL_DIR}/{causal_filename}", 'wb') as f:
+            pickle.dump(causal_model, f)
+            
+        api.upload_file(
+           path_or_fileobj=f"{MODEL_DIR}/{causal_filename}",
+           path_in_repo=causal_filename,
+           repo_id=HF_MODEL_REPO,
+           repo_type="model"
+        )
+        print(f"✅ {causal_filename} uploaded.")
+        
+        status.complete("ClassicML & Causal")
+        try: history.log_model("ClassicML", "N/A", rf_filename)
+        except: pass
+        try: history.log_model("CausalDiscovery", "N/A", causal_filename)
+        except: pass
+        return True
+        
+    except Exception as e:
+        status.error(f"Classic/Causal Fail: {e}")
+        print(f"❌ Classic/Causal Error: {e}")
+        return False
+
+def train_agents(status: StatusWriter, api: HfApi, history):
+    """Initialize, Validate, and Save RL & Rule-Based Agents."""
+    print("⏳ Loading Agent Dependencies (Torch/RL)...")
+    import torch
+    from models.execution_agent import PPOActorCritic
+    from models.meta_controller import DQN
+    from models.risk_agent import RiskAgent
+    from models.arbitrage_agent import ArbitrageAgent
+    
+    status.start("Agents (RL & Rule)", 1)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    try:
+        # 1. Execution Agent (PPO)
+        print("🤖 Initializing Execution Agent (PPO)...")
+        exec_agent = PPOActorCritic(input_dim=5, action_dim=3)
+        dummy_in = torch.randn(1, 5)
+        exec_agent(dummy_in)
+        
+        exec_filename = f"execution_agent_{timestamp}.pt"
+        torch.save(exec_agent.state_dict(), f"{MODEL_DIR}/{exec_filename}")
+        api.upload_file(
+            path_or_fileobj=f"{MODEL_DIR}/{exec_filename}",
+            path_in_repo=exec_filename,
+            repo_id=HF_MODEL_REPO,
+            repo_type="model"
+        )
+        print(f"✅ {exec_filename} uploaded.")
+
+        # 2. Meta Controller (DQN)
+        print("🧠 Initializing Meta Controller (DQN)...")
+        meta_agent = DQN(input_dim=5, output_dim=3)
+        meta_agent(dummy_in) 
+        
+        meta_filename = f"meta_controller_{timestamp}.pt"
+        torch.save(meta_agent.state_dict(), f"{MODEL_DIR}/{meta_filename}")
+        api.upload_file(
+            path_or_fileobj=f"{MODEL_DIR}/{meta_filename}",
+            path_in_repo=meta_filename,
+            repo_id=HF_MODEL_REPO,
+            repo_type="model"
+        )
+        print(f"✅ {meta_filename} uploaded.")
+        
+        # 3. Risk Agent (Rule-Based)
+        print("🛡️ Initializing Risk Agent...")
+        risk_agent = RiskAgent(max_dd=0.15)
+        risk_filename = f"risk_agent_{timestamp}.pkl"
+        with open(f"{MODEL_DIR}/{risk_filename}", 'wb') as f:
+             pickle.dump(risk_agent, f)
+        
+        api.upload_file(
+            path_or_fileobj=f"{MODEL_DIR}/{risk_filename}",
+            path_in_repo=risk_filename,
+            repo_id=HF_MODEL_REPO,
+            repo_type="model"
+        )
+        print(f"✅ {risk_filename} uploaded.")
+        
+        # 4. Arbitrage Agent (Rule-Based)
+        print("⚖️ Initializing Arbitrage Agent...")
+        arb_agent = ArbitrageAgent(threshold=0.005)
+        # Synthetic Test
+        arb_agent.analyze(100, 101, 0.001)
+        
+        arb_filename = f"arbitrage_agent_{timestamp}.pkl"
+        with open(f"{MODEL_DIR}/{arb_filename}", 'wb') as f:
+             pickle.dump(arb_agent, f)
+             
+        api.upload_file(
+            path_or_fileobj=f"{MODEL_DIR}/{arb_filename}",
+            path_in_repo=arb_filename,
+            repo_id=HF_MODEL_REPO,
+            repo_type="model"
+        )
+        print(f"✅ {arb_filename} uploaded.")
+        
+        status.complete("Agents Completed")
+        try:
+            history.log_model("ExecutionAgent", "Init", exec_filename)
+            history.log_model("MetaController", "Init", meta_filename)
+            history.log_model("RiskAgent", "Init", risk_filename)
+            history.log_model("ArbitrageAgent", "Init", arb_filename)
+        except: pass
+        return True
+
+    except Exception as e:
+        status.error(f"Agents Fail: {e}")
+        print(f"❌ Agents Error: {e}")
+        return False
+
+
+def upload_models():
+    """Upload trained models to HuggingFace."""
+    from huggingface_hub import HfApi
+    
+    api = HfApi()
+    
+    for model_file in Path(MODEL_DIR).glob("*.onnx"):
+        try:
+            api.upload_file(
+                path_or_fileobj=str(model_file),
+                path_in_repo=model_file.name,
+                repo_id=HF_MODEL_REPO,
+                repo_type="model"
+            )
+            print(f"Uploaded: {model_file.name}")
+        except Exception as e:
+            print(f"Upload failed for {model_file.name}: {e}")
+
+def main():
+    print("🚀 Auto-Training Pipeline Started...")
+    
+    # Initialize API for model uploads
+    token = os.environ.get("HF_TOKEN") # Get token from env
+    if not token:
+        print("⚠️ HF_TOKEN not found in environment!")
+    
+    api = HfApi(token=token) 
+    
+    # Init Status Writer & History Writer
+    status = StatusWriter()
+    history = HistoryWriter()
+
+    
+    print("=" * 50)
+    print("NautilusAI Auto Training Pipeline")
+    print(f"Started at: {datetime.now().isoformat()}")
+    print("=" * 50)
+    
+    # 1. Download data
+    # 1. Download data - SKIPPED (Using Streaming)
+    # download_data()
+    print("🌊 Using Streaming Mode (No Download Required)")
+
+    # Force Legacy ONNX
+    os.environ["TORCH_ONNX_USE_DYNAMO"] = "0"
+
+    
+    # 2. Train DeepLOB
+    if not train_deeplob(status, api, history, epochs=1):
+        print("DeepLOB training failed!")
+        return
+    
+    # 3. Train TRM
+    if not train_trm(status, api, history, epochs=1):
+        print("TRM training failed!")
+        # Continue anyway for LSTM
+        pass
+    
+    # 4. Train LSTM
+    if not train_lstm(status, api, history, epochs=1):
+        print("LSTM training failed!")
+        pass
+        
+    # 5. Train Classic ML & Causal
+    train_classic_and_causal(status, api, history)
+    
+    # 6. Train Agents
+    train_agents(status, api, history)
+    
+    # 7. Upload models (Legacy function, mostly redundant now but harmless)
+    upload_models()
+    
+    # 8. Upload History (Batch Upload)
+    history.upload_history()
+    
+    # 5. Final status
+    status.reset()
+    print("=" * 50)
+    print("Training Pipeline Complete!")
+    print("=" * 50)
+
+if __name__ == "__main__":
+    try:
+        print("🔧 Auto-Train Script Initializing...", flush=True)
+        main()
+    except Exception as e:
+        import traceback
+        print(f"❌ CRITICAL ERROR IN AUTO-TRAIN: {e}", flush=True)
+        traceback.print_exc()
+        # Write error to status file too if possible
+        try:
+            with open(STATUS_FILE, 'w') as f:
+                json.dump({"status": "error", "logs": [f"CRITICAL: {str(e)}"]}, f)
+        except: pass

data_processor.py

@@ -0,0 +1,568 @@
+import pandas as pd
+import numpy as np
+import glob
+import torch
+import ast
+from typing import Tuple
+
+class AlphaDataProcessor:
+    """
+    Processes raw market data (Parquet) into PyTorch Tensors for Alpha Agent training.
+    Upgraded for Deep Optimization (Robust Scaler, Dynamic Labels, Channel Separation, OFI, Triple Barrier).
+    """
+    def __init__(self, data_dir: str = "./data"):
+        self.data_dir = data_dir
+
+    def _rolling_robust_scale(self, data: np.ndarray, window: int = 2000) -> np.ndarray:
+        """
+        Rolling Robust Scaling using Median and IQR.
+        Prevents look-ahead bias (Leakage) by using only past statistics.
+        Computes rolling median/IQR along axis 0.
+        """
+        # Convert to DataFrame for efficient rolling ops
+        df = pd.DataFrame(data)
+        
+        # Min periods = window/10 to avoid NaNs at start (or ffill)
+        rolling = df.rolling(window=window, min_periods=window//10)
+        
+        median = rolling.median()
+        q75 = rolling.quantile(0.75)
+        q25 = rolling.quantile(0.25)
+        iqr = q75 - q25
+        
+        # Replace 0 IQR with 1 to avoid div by zero
+        iqr = iqr.replace(0, 1.0)
+        
+        # Scale: (x_t - median_t) / iqr_t
+        # Note: robust scaling conventionally uses recent stats to normalize CURRENT value.
+        scaled = (df - median) / iqr
+        
+        # Fill mean/zeros for initial unstable window
+        return scaled.fillna(0.0).values
+        
+    def get_deeplob_tensors(self, coin: str = "ETH", T: int = 100, levels: int = 20) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        DeepLOB with Channel Separation and Triple Barrier Labeling.
+        Uses Rolling Robust Scaling.
+        """
+        df = self.load_l2_snapshots(coin)
+        if df.empty:
+            return self._generate_dummy_deeplob(T, levels)
+            
+        prices_list = []
+        volumes_list = []
+        mid_prices = []
+        
+        # Precompute Volatility for Labeling
+        best_bids = df['bids'].apply(lambda x: x[0][0] if len(x)>0 else 0)
+        best_asks = df['asks'].apply(lambda x: x[0][0] if len(x)>0 else 0)
+        mids = (best_bids + best_asks) / 2
+        mids = mids.replace(0, np.nan).ffill().fillna(0)
+        
+        returns = np.diff(np.log(mids.values + 1e-9))
+        returns = np.concatenate(([0], returns))
+        volatility = pd.Series(returns).rolling(window=T).std().fillna(0.001).values
+        
+        mid_prices_arr = mids.values
+
+        for _, row in df.iterrows():
+            bids = row['bids']
+            asks = row['asks']
+            
+            p_feat = []
+            v_feat = []
+            
+            for i in range(levels):
+                if i < len(asks): pa, va = asks[i]
+                else: pa, va = 0, 0
+                if i < len(bids): pb, vb = bids[i]
+                else: pb, vb = 0, 0
+                p_feat.extend([pa, pb])
+                v_feat.extend([va, vb])
+            
+            prices_list.append(p_feat)
+            volumes_list.append(v_feat)
+            
+        prices_data = np.array(prices_list)
+        volumes_data = np.array(volumes_list)
+        
+        # Rolling Robust Scaling (Leakage Free)
+        prices_data = self._rolling_robust_scale(prices_data, window=2000)
+        volumes_data = np.log1p(volumes_data)
+        volumes_data = self._rolling_robust_scale(volumes_data, window=2000)
+        
+        k = 100
+        # Triple Barrier Labels
+        # PT=2, SL=2 (2x Volatility)
+        y_all = self._get_triple_barrier_labels(mid_prices_arr, T, k, volatility, pt=2.0, sl=2.0)
+        
+        # ... (Rest remains same)
+
+
+    def _get_triple_barrier_labels(self, mid_prices: np.ndarray, T: int, horizon: int, volatility: np.ndarray = None, pt: float = 1.0, sl: float = 1.0) -> np.ndarray:
+        """
+        Triple Barrier Labeling Method (Marcos Lopez de Prado).
+        Labels: 0 (SL Hit), 1 (Time Limit), 2 (TP Hit).
+        pt: Profit Taking multiplier (x Volatility).
+        sl: Stop Loss multiplier (x Volatility).
+        """
+        labels = []
+        
+        # If volatility is None, compute standard
+        if volatility is None:
+            # Simple fallback
+            volatility = np.ones(len(mid_prices)) * 0.002 
+            
+        for i in range(T, len(mid_prices) - horizon):
+            current_price = mid_prices[i-1]
+            vol = volatility[i]
+            
+            # Dynamic Barriers
+            upper_barrier = current_price * (1 + vol * pt)
+            lower_barrier = current_price * (1 - vol * sl)
+            
+            # Path within Horizon
+            path = mid_prices[i : i + horizon]
+            
+            # Check First Touch
+            # argmax returns index of first True
+            touch_upper = np.where(path >= upper_barrier)[0]
+            touch_lower = np.where(path <= lower_barrier)[0]
+            
+            t_upper = touch_upper[0] if len(touch_upper) > 0 else horizon + 1
+            t_lower = touch_lower[0] if len(touch_lower) > 0 else horizon + 1
+            
+            if t_upper == horizon + 1 and t_lower == horizon + 1:
+                label = 1 # Vertical Barrier (Time Limit)
+            elif t_upper < t_lower:
+                label = 2 # TP Hit First
+            else:
+                label = 0 # SL Hit First
+                
+            labels.append(label)
+            
+        return np.array(labels)
+
+    def _compute_ofi(self, df: pd.DataFrame, levels: int = 5) -> pd.DataFrame:
+        """
+        Computes Order Flow Imbalance (OFI) for top 'levels'.
+        OFI_i(t) = I(P > P_prev)q - I(P < P_prev)q_prev + I(P == P_prev)(q - q_prev)
+        Summed across levels.
+        """
+        # Explode bids/asks for first few levels
+        # This is expensive on large DFs. We do vectorized check on top 1 level mainly or aggregated.
+        # Efficient OFI: Compute on Best Bid/Ask only for speed in this version.
+        
+        # 1. Shift DataFrame
+        df_prev = df.shift(1)
+        
+        ofi = pd.Series(0.0, index=df.index)
+        
+        # Top 1 Level OFI
+        bb_p = df['best_bid']
+        bb_q = df['best_bid_sz']
+        prev_bb_p = df_prev['best_bid']
+        prev_bb_q = df_prev['best_bid_sz']
+        
+        ba_p = df['best_ask']
+        ba_q = df['best_ask_sz']
+        prev_ba_p = df_prev['best_ask']
+        prev_ba_q = df_prev['best_ask_sz']
+        
+        # Bid OFI
+        bid_ofi = np.where(bb_p > prev_bb_p, bb_q, 
+                           np.where(bb_p < prev_bb_p, -prev_bb_q, bb_q - prev_bb_q))
+        
+        # Ask OFI (Note: Supply side usually negative impact on price? OFI definition:
+        # e_i = e_bid_i - e_ask_i. High Bid demand -> +, High Ask supply -> -)
+        
+        ask_ofi = np.where(ba_p > prev_ba_p, -prev_ba_q,
+                           np.where(ba_p < prev_ba_p, ba_q, ba_q - prev_ba_q)) # Logic check needed here
+                           
+        # Standard Definition (Cont & Kukanov 2017):
+        # e_ask = I(Pa > Pa_prev) * (-qa_prev) + I(Pa < Pa_prev) * qa + I(Pa=Pa_prev)*(qa - qa_prev)
+        # Wait, if Ask Price Increases -> Supply removed (Good for price) -> ???
+        # Actually OFI = Flow at Bid - Flow at Ask.
+        # Let's stick to standard formula for 'Flow Contribution to Price Increase'.
+        # Increase in Ask Size -> Resistance -> Negative pressure.
+        
+        ask_flow = np.where(ba_p > prev_ba_p, 0, # Price moved up (Ask Cleared?) -> No resistance added?
+                            np.where(ba_p < prev_ba_p, ba_q, # Price moved down -> New wall
+                                     ba_q - prev_ba_q)) # Same price -> delta size
+                                     
+        # Improved Ask OFI (Mirroring Bid Logic):
+        # We want "Buying Pressure" - "Selling Pressure"
+        # Bid Increase/Add = Buying Pressure (+)
+        # Ask Decrease/Add = Selling Pressure (-)
+        
+        ask_ofi = np.where(ba_p > prev_ba_p, -prev_ba_q, # Price rose, prev qty consumed/cancelled ?
+                           np.where(ba_p < prev_ba_p, ba_q, # Price fell, new supply at lower price
+                                    ba_q - prev_ba_q))   # Same price, delta
+                                    
+        # Total OFI
+        ofi = bid_ofi - ask_ofi
+        return pd.Series(ofi).fillna(0)
+
+    def load_trades(self, coin: str = "ETH") -> pd.DataFrame:
+        """Loads trade data."""
+        files = glob.glob(f"{self.data_dir}/raw_trade/{coin}/*.parquet")
+        if not files: return pd.DataFrame()
+        
+        try:
+            df = pd.concat([pd.read_parquet(f) for f in files])
+            df = df.sort_values("time")
+            if 'side' in df.columns:
+                df['signed_vol'] = df.apply(lambda x: x['sz'] if x['side'] == 'B' else -x['sz'], axis=1)
+            else:
+                df['signed_vol'] = 0
+            return df
+        except Exception as e:
+            print(f"Error loading trades: {e}")
+            return pd.DataFrame()
+
+    def load_l2_snapshots(self, coin: str = "ETH", limit: int = 10000) -> pd.DataFrame:
+        """Loads L2 Orderbook Snapshots."""
+        files = glob.glob(f"{self.data_dir}/order_book_snapshot/*.parquet")
+        if not files: return pd.DataFrame()
+
+        df_list = []
+        for f in files:
+            try:
+                chunk = pd.read_parquet(f)
+                chunk = chunk[chunk['instrument_id'].str.contains(coin)]
+                if not chunk.empty: df_list.append(chunk)
+            except: pass
+        
+        if not df_list: return pd.DataFrame()
+        
+        df = pd.concat(df_list)
+        df = df.sort_values("ts_event").head(limit)
+        
+        df['bids'] = df['bids'].apply(lambda x: ast.literal_eval(x) if isinstance(x, str) else [])
+        df['asks'] = df['asks'].apply(lambda x: ast.literal_eval(x) if isinstance(x, str) else [])
+        
+        return df
+
+    def get_deeplob_tensors(self, coin: str = "ETH", T: int = 100, levels: int = 20) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        DeepLOB with Channel Separation and Triple Barrier Labeling.
+        """
+        df = self.load_l2_snapshots(coin)
+        if df.empty:
+            return self._generate_dummy_deeplob(T, levels)
+            
+        prices_list = []
+        volumes_list = []
+        mid_prices = []
+        
+        # Precompute Volatility for Labeling
+        # Expand Mid Price first
+        best_bids = df['bids'].apply(lambda x: x[0][0] if len(x)>0 else 0)
+        best_asks = df['asks'].apply(lambda x: x[0][0] if len(x)>0 else 0)
+        mids = (best_bids + best_asks) / 2
+        mids = mids.replace(0, np.nan).ffill().fillna(0)
+        
+        # Rolling Volatility (for Triple Barrier)
+        returns = np.diff(np.log(mids.values + 1e-9))
+        returns = np.concatenate(([0], returns))
+        volatility = pd.Series(returns).rolling(window=T).std().fillna(0.001).values
+        
+        mid_prices_arr = mids.values
+
+        for _, row in df.iterrows():
+            bids = row['bids']
+            asks = row['asks']
+            
+            p_feat = []
+            v_feat = []
+            
+            for i in range(levels):
+                if i < len(asks): pa, va = asks[i]
+                else: pa, va = 0, 0
+                if i < len(bids): pb, vb = bids[i]
+                else: pb, vb = 0, 0
+                p_feat.extend([pa, pb])
+                v_feat.extend([va, vb])
+            
+            prices_list.append(p_feat)
+            volumes_list.append(v_feat)
+            
+
+        prices_data = np.array(prices_list)
+        volumes_data = np.array(volumes_list)
+        
+        # Robust Scaling
+        prices_data = self._robust_scale(prices_data)
+        volumes_data = np.log1p(volumes_data)
+        volumes_data = self._robust_scale(volumes_data)
+        
+        k = 100
+        # Triple Barrier Labels
+        # PT=2, SL=2 (2x Volatility)
+        y_all = self._get_triple_barrier_labels(mid_prices_arr, T, k, volatility, pt=2.0, sl=2.0)
+        
+        X = []
+        y = []
+        valid_indices = range(T, len(mid_prices_arr) - k)
+        
+        for idx, i in enumerate(valid_indices):
+            p_window = prices_data[i-T:i]
+            v_window = volumes_data[i-T:i]
+            
+            sample = np.stack([p_window, v_window], axis=0) # (2, T, 2*Levels)
+            
+            X.append(sample)
+            y.append(y_all[idx])
+            
+        return torch.FloatTensor(np.array(X)), torch.LongTensor(np.array(y))
+
+    def get_deeplob_tensors_from_df(self, df: pd.DataFrame, T: int = 100, levels: int = 20) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Process a pre-loaded DataFrame (chunk) into DeepLOB tensors.
+        Used for Streaming.
+        """
+        if df.empty:
+             return torch.empty(0), torch.empty(0)
+             
+        # Reuse the logic from get_deeplob_tensors, but skipping the load step.
+        # This duplicates some logic but ensures isolation.
+        
+        prices_list = []
+        volumes_list = []
+        
+        # Precompute Volatility for Labeling
+        best_bids = df['bids'].apply(lambda x: x[0][0] if len(x)>0 else 0)
+        best_asks = df['asks'].apply(lambda x: x[0][0] if len(x)>0 else 0)
+        mids = (best_bids + best_asks) / 2
+        mids = mids.replace(0, np.nan).ffill().fillna(0)
+        
+        returns = np.diff(np.log(mids.values + 1e-9))
+        returns = np.concatenate(([0], returns))
+        volatility = pd.Series(returns).rolling(window=T).std().fillna(0.001).values
+        
+        mid_prices_arr = mids.values
+        
+        for _, row in df.iterrows():
+            bids = row['bids']
+            asks = row['asks']
+            
+            p_feat = []
+            v_feat = []
+            
+            for i in range(levels):
+                if i < len(asks): pa, va = asks[i]
+                else: pa, va = 0, 0
+                if i < len(bids): pb, vb = bids[i]
+                else: pb, vb = 0, 0
+                p_feat.extend([pa, pb])
+                v_feat.extend([va, vb])
+            
+            prices_list.append(p_feat)
+            volumes_list.append(v_feat)
+            
+        prices_data = np.array(prices_list)
+        volumes_data = np.array(volumes_list)
+        
+        # Robust Scaling
+        prices_data = self._robust_scale(prices_data)
+        volumes_data = np.log1p(volumes_data)
+        volumes_data = self._robust_scale(volumes_data)
+        
+        k = 100
+        # Triple Barrier Labels
+        y_all = self._get_triple_barrier_labels(mid_prices_arr, T, k, volatility, pt=2.0, sl=2.0)
+        
+        X = []
+        y = []
+        
+        # Since this is a chunk, we might lose the first T rows if not buffered correctly by the caller.
+        # The caller (StreamingDataLoader) is responsible for overlapping chunks.
+        valid_indices = range(T, len(mid_prices_arr) - k)
+        
+        for idx, i in enumerate(valid_indices):
+            p_window = prices_data[i-T:i]
+            v_window = volumes_data[i-T:i]
+            
+            sample = np.stack([p_window, v_window], axis=0)
+            X.append(sample)
+            y.append(y_all[idx])
+            
+        return torch.FloatTensor(np.array(X)), torch.LongTensor(np.array(y))
+
+    def _generate_dummy_deeplob(self, T, levels):
+        return torch.randn(32, 2, T, 2*levels), torch.randint(0, 3, (32,))
+
+    def compute_trm_features(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Computes features including OFI and Real CVD.
+        """
+        df['best_bid'] = df['bids'].apply(lambda x: x[0][0] if len(x)>0 else np.nan)
+        df['best_ask'] = df['asks'].apply(lambda x: x[0][0] if len(x)>0 else np.nan)
+        df['best_bid_sz'] = df['bids'].apply(lambda x: x[0][1] if len(x)>0 else np.nan)
+        df['best_ask_sz'] = df['asks'].apply(lambda x: x[0][1] if len(x)>0 else np.nan)
+        
+        df.dropna(subset=['best_bid', 'best_ask'], inplace=True)
+        
+        df['mid'] = (df['best_bid'] + df['best_ask']) / 2
+        
+        # OFI (New Feature)
+        df['ofi'] = self._compute_ofi(df)
+        
+        df['spread'] = df['best_ask'] - df['best_bid']
+        df['imbalance'] = (df['best_bid_sz'] - df['best_ask_sz']) / (df['best_bid_sz'] + df['best_ask_sz'])
+        df['momentum'] = df['mid'].pct_change(periods=5)
+        df['returns'] = df['mid'].pct_change()
+        df['volatility'] = df['returns'].rolling(10).std()
+        
+        # Real CVD
+        trades = self.load_trades(coin="ETH")
+        if not trades.empty:
+            trades['cumulative_vol'] = trades['signed_vol'].cumsum()
+            df = df.sort_values("ts_event")
+            trades = trades.sort_values("time")
+            
+            df['ts_merge'] = df['ts_event']
+            trades['ts_merge'] = trades['time']
+            
+            merged = pd.merge_asof(df, trades[['ts_merge', 'cumulative_vol']], on='ts_merge', direction='backward')
+            df['cvd'] = merged['cumulative_vol'].ffill().fillna(0)
+        else:
+            df['cvd'] = 0
+            
+        df.dropna(inplace=True)
+        # Return 6 Features now: Vol, Imbal, CVD, Spread, Mom, OFI
+        return df[['volatility', 'imbalance', 'cvd', 'spread', 'momentum', 'ofi', 'mid']]
+
+    def get_trm_tensors(self, coin: str = "ETH", T: int = 60) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Returns TRM Tensors.
+        Input size = 6 (Added OFI).
+        Labels = Triple Barrier.
+        """
+        df = self.load_l2_snapshots(coin, limit=5000)
+        if df.empty:
+            return torch.randn(32, T, 6), torch.randint(0, 3, (32,))
+            
+        feat_df = self.compute_trm_features(df)
+        data = feat_df[['volatility', 'imbalance', 'cvd', 'spread', 'momentum', 'ofi']].values
+        mid = feat_df['mid'].values
+        
+        # Rolling Robust Scale Features (Leakage Free)
+        data = self._rolling_robust_scale(data, window=2000)
+        
+        # Returns for Vol calc
+        rets = np.diff(np.log(mid + 1e-9))
+        rets = np.concatenate(([0], rets))
+        vol = pd.Series(rets).rolling(window=T).std().fillna(0.001).values
+        
+        # Triple Barrier Labels for TRM
+        y_all = self._get_triple_barrier_labels(mid, T, horizon=60, volatility=vol, pt=2.0, sl=2.0)
+        
+        X, y = [], []
+        valid_indices = range(T, len(data) - 60)
+        
+        for idx, i in enumerate(valid_indices):
+            X.append(data[i-T:i])
+            y.append(y_all[idx])
+            
+        return torch.FloatTensor(np.array(X)), torch.LongTensor(np.array(y))
+
+    def get_trm_tensors_from_df(self, df: pd.DataFrame, T: int = 60) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Process a pre-loaded DataFrame (chunk) into TRM tensors.
+        Used for Streaming.
+        """
+        if df.empty:
+            return torch.empty(0), torch.empty(0)
+            
+        feat_df = self.compute_trm_features(df)
+        if feat_df.empty:
+             return torch.empty(0), torch.empty(0)
+
+        data = feat_df[['volatility', 'imbalance', 'cvd', 'spread', 'momentum', 'ofi']].values
+        mid = feat_df['mid'].values
+        
+        data = self._rolling_robust_scale(data, window=2000)
+        
+        rets = np.diff(np.log(mid + 1e-9))
+        rets = np.concatenate(([0], rets))
+        vol = pd.Series(rets).rolling(window=T).std().fillna(0.001).values
+        
+        y_all = self._get_triple_barrier_labels(mid, T, horizon=60, volatility=vol, pt=2.0, sl=2.0)
+        
+        X, y = [], []
+        valid_indices = range(T, len(data) - 60)
+        
+        for idx, i in enumerate(valid_indices):
+            X.append(data[i-T:i])
+            y.append(y_all[idx])
+            
+        return torch.FloatTensor(np.array(X)), torch.LongTensor(np.array(y))
+
+    def get_lstm_tensors_from_df(self, df: pd.DataFrame, T: int = 60, forecast_horizon: int = 1) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Process Bar Data (OHLCV) into LSTM Tensors.
+        Features: Log Returns, Log Volume, High-Low Range, Close-Open Range.
+        Target: Next Log Return (scaled).
+        Output: X (Batch, T, Features), y (Batch, 1)
+        """
+        if df.empty or len(df) < T + forecast_horizon:
+             return torch.empty(0), torch.empty(0)
+             
+        # Ensure numeric
+        cols = ['open', 'high', 'low', 'close', 'volume']
+        for c in cols:
+            if c in df.columns:
+                df[c] = pd.to_numeric(df[c], errors='coerce')
+        df.dropna(subset=cols, inplace=True)
+        
+        # 1. Feature Engineering
+        # Log Returns (Scale Invariant)
+        df['log_ret'] = np.log(df['close'] / df['close'].shift(1)).fillna(0)
+        
+        # Log Volume
+        df['log_vol'] = np.log1p(df['volume'])
+        
+        # High-Low Range (Relative to Close)
+        df['hl_range'] = (df['high'] - df['low']) / df['close']
+        
+        # Close-Open Range (Relative to Open)
+        df['co_range'] = (df['close'] - df['open']) / df['open']
+        
+        # Rolling Volatility (Feature)
+        df['volatility'] = df['log_ret'].rolling(window=20).std().fillna(0)
+        
+        # Features Matrix
+        feature_cols = ['log_ret', 'log_vol', 'hl_range', 'co_range', 'volatility']
+        data = df[feature_cols].values
+        
+        # 2. Robust Scaling (Leakage Free)
+        data = self._rolling_robust_scale(data, window=2000)
+        
+        # 3. Target: Next Log Return (Scalar Regression)
+        # Scaled by 100 to match Tanh output range [-1, 1] for typical volatility
+        # e.g. 1% move = 0.01 * 100 = 1.0
+        target = df['log_ret'].shift(-forecast_horizon).fillna(0).values * 100
+        
+        X, y = [], []
+        valid_indices = range(T, len(data) - forecast_horizon)
+        
+        for i in valid_indices:
+            window = data[i-T:i] # (T, Features)
+            label = target[i]    # (1,)
+            
+            X.append(window)
+            y.append(label)
+            
+        return torch.FloatTensor(np.array(X)), torch.FloatTensor(np.array(y)).unsqueeze(1)
+
+    def _robust_scale(self, data):
+        # Helper for legacy robust scale (non-rolling) if needed, 
+        # or alias to rolling with large window for batch
+        # For now, implementing simple robust scale
+        median = np.median(data, axis=0)
+        q75 = np.percentile(data, 75, axis=0)
+        q25 = np.percentile(data, 25, axis=0)
+        iqr = q75 - q25
+        iqr[iqr == 0] = 1.0
+        return (data - median) / iqr

debug_causal.py

@@ -0,0 +1,26 @@
+import pandas as pd
+import numpy as np
+import pickle
+import os
+import sys
+
+# Add path to find models
+sys.path.append(os.getcwd())
+
+from models.causal_discovery import get_causal_model
+
+# Mock Data
+df = pd.DataFrame(np.random.randn(100, 5), columns=['open', 'high', 'low', 'close', 'volume'])
+clean_df = df
+
+print("Init Causal...")
+model = get_causal_model()
+
+print("Fit Causal...")
+model.fit(clean_df)
+
+print("Pickle Causal...")
+with open("causal_debug.pkl", "wb") as f:
+    pickle.dump(model, f)
+
+print("✅ Success")

debug_logic.py

@@ -0,0 +1,86 @@
+
+import sys
+import types
+from unittest.mock import MagicMock
+
+# 1. Mock PyTorch Class BEFORE importing data_processor
+class MockTorch:
+    def __init__(self):
+        self.float32 = "float32"
+        self.long = "long"
+        
+        # Mock Tensor class for type hints
+        class MockTensor:
+            pass
+        self.Tensor = MockTensor
+    
+    def FloatTensor(self, x): return x # Return numpy array directly
+    def LongTensor(self, x): return x
+    def tensor(self, x): return x
+    def randn(self, *args): 
+        import numpy as np
+        return np.random.randn(*args)
+    def randint(self, low, high, size): 
+        import numpy as np
+        return np.random.randint(low, high, size)
+    def stack(self, tensors, axis=0):
+        import numpy as np
+        return np.stack(tensors, axis=axis)
+
+# 2. Inject into sys.modules
+mock_torch = MockTorch()
+sys.modules['torch'] = mock_torch
+
+# 3. Now safe to import
+import numpy as np
+import pandas as pd
+import os
+
+# Add parent dir
+sys.path.append(os.getcwd())
+
+from data_processor import AlphaDataProcessor
+
+def test_logic():
+    print("✅ Successfully imported data_processor with Mock Torch")
+    
+    # 1. Simulate get_deeplob_tensors return
+    N, T, Levels = 10, 100, 20
+    # DataProcessor returns:
+    # X = stack([p_window, v_window], axis=0) -> (2, T, 2*Levels) for each sample
+    # Then np.array(X) -> (N, 2, T, 2*Levels)
+    
+    # Mock simulating what data_processor actually builds
+    # (N samples, 2 channels, T timesteps, 2*Levels features)
+    mock_X = np.random.randn(N, 2, T, 2*Levels)
+    
+    print(f"Mock DataProcessor Output Shape: {mock_X.shape}")
+    
+    # 2. Verify DeepLOB Input Requirement
+    # DeepLOB Conv2d(2, 16, ...) expects (N, C, H, W) = (N, 2, T, Features)
+    # Our features = 2*Levels = 40
+    
+    # If the shape is 4D: (N, 2, 100, 40) -> IT IS CORRECT
+    # If we unsqueeze(1) -> (N, 1, 2, 100, 40) -> 5D -> INCORRECT
+    
+    if mock_X.ndim == 4 and mock_X.shape[1] == 2:
+        print("✅ Data Shape matches Conv2d Expectation (N, 2, T, F)")
+        print("   -> (N, Channels=2, Height=100, Width=40)")
+        print("   -> NO unsqueeze(1) needed!")
+    else:
+        print(f"❌ Data Shape Mismatch: {mock_X.shape}")
+
+    # 3. Verify TRM logic
+    # TRM needs (N, T, F)
+    # F = 6 (Vol, Imb, CVD, Spr, Mom, OFI)
+    N_trm, T_trm, F_trm = 10, 60, 6
+    mock_X_trm = np.random.randn(N_trm, T_trm, F_trm)
+    
+    print(f"\nMock TRM Output Shape: {mock_X_trm.shape}")
+    if mock_X_trm.ndim == 3 and mock_X_trm.shape[2] == 6:
+        print("✅ TRM Shape matches Transformer Expectation (N, T, F)")
+    else:
+        print(f"❌ TRM Shape Mismatch: {mock_X_trm.shape}")
+
+if __name__ == "__main__":
+    test_logic()

envs/nautilus_env.py

@@ -0,0 +1,78 @@
+import gymnasium as gym
+from gymnasium import spaces
+import numpy as np
+# from nautilus_trader.backtest.engine import BacktestEngine, BacktestEngineConfig
+# from nautilus_trader.model.data import BarType
+# from nautilus_trader.config import InstrumentId
+
+# NOTE: NautilusTrader imports commented out - this is a stub environment
+# Uncomment when implementing full RL environment
+
+class NautilusExecutionEnv(gym.Env):
+    """
+    OpenAI/Gymnasium Environment for NautilusTrader.
+    Wraps the BacktestEngine to provide a step-by-step Interface for RL Agents.
+    """
+    def __init__(self, config: dict):
+        super().__init__()
+        self.config = config
+        self.instrument_id = config.get("instrument_id", "ETH-USDC-PERP")
+        
+        # Define Observation Space (Features)
+        # Example: [RSI, Imbalance, Spread, PositionSize, PnL]
+        self.observation_space = spaces.Box(
+            low=-np.inf, high=np.inf, shape=(10,), dtype=np.float32
+        )
+        
+        # Define Action Space
+        # Example: Discrete(3) -> 0: Hold, 1: Buy, 2: Sell
+        # Or Continuous Box for Order Size / Price Offset
+        self.action_space = spaces.Discrete(3)
+        
+        self.engine = None
+        self._setup_engine()
+
+    def _setup_engine(self):
+        """
+        Initializes the Nautilus Backtest Engine
+        """
+        # TODO: Load Data Catalog here
+        # engine_config = BacktestEngineConfig(strategies=[...])
+        # self.engine = BacktestEngine(config=engine_config)
+        pass
+
+    def reset(self, seed=None, options=None):
+        """
+        Resets the environment (restarts the backtest).
+        """
+        super().reset(seed=seed)
+        self._setup_engine()
+        
+        # Get initial state
+        initial_obs = np.zeros(self.observation_space.shape, dtype=np.float32)
+        info = {}
+        return initial_obs, info
+
+    def step(self, action):
+        """
+        Advances the engine by one step (Bar/Tick).
+        Execute action -> engine.step() -> Get Reward -> Get Next State
+        """
+        # 1. Translate Action to Order
+        # if action == 1: self.strategy.buy()
+        
+        # 2. Step Engine
+        # self.engine.run_next_step() ??? 
+        # Note: Nautilus is event-driven, not strictly step-based.
+        # We need to run the engine until the next 'decision point' (e.g. next bar).
+        
+        # 3. Calculate Reward (PnL Change)
+        reward = 0.0 
+        
+        # 4. Get New State
+        obs = np.zeros(self.observation_space.shape, dtype=np.float32)
+        terminated = False
+        truncated = False
+        info = {}
+        
+        return obs, reward, terminated, truncated, info

models/arbitrage_agent.py

@@ -0,0 +1,30 @@
+class ArbitrageAgent:
+    """
+    Arbitrage Agent (Rule-Based).
+    Monitors Perp vs Spot prices.
+    """
+    def __init__(self, threshold=0.005):
+        self.threshold = threshold
+
+    def analyze(self, spot_price, perp_price, funding_rate):
+        """
+        Returns Action:
+        0: Do Nothing
+        1: Long Spot / Short Perp (Basis > Thresh)
+        2: Short Spot / Long Perp (Basis < -Thresh)
+        """
+        basis = (perp_price - spot_price) / spot_price
+        
+        # Funding Arbitrage
+        # If funding positive -> Shorts pay Longs. We want to be Short Perp.
+        # So we Long Spot, Short Perp.
+        
+        if basis > self.threshold:
+            print(f"Arb Opportunity: Basis {basis:.4f} > {self.threshold}. Action: Long Spot / Short Perp")
+            return 1 # Cash and Carry
+            
+        if basis < -self.threshold:
+             print(f"Arb Opportunity: Basis {basis:.4f} < -{self.threshold}. Action: Short Spot / Long Perp")
+             return 2 # Reverse Carry?
+             
+        return 0

models/causal_discovery.py

@@ -0,0 +1,93 @@
+import numpy as np
+import pandas as pd
+# Wrappers for Tigramite (PCMCI)
+# Note: Tigramite must be installed in environment
+try:
+    from tigramite import data_processing as pp
+    from tigramite.pcmci import PCMCI
+    from tigramite.independence_tests.parcorr import ParCorr
+    TIGRAMITE_AVAILABLE = True
+except ImportError:
+    TIGRAMITE_AVAILABLE = False
+    print("Warning: Tigramite not found. Using Placeholder.")
+
+class CausalDiscovery:
+    """
+    Causal Discovery using Tigramite (PCMCI).
+    Identifies causal links in time-series data using Partial Correlation (ParCorr).
+    Focuses on finding parents of key variables (e.g., Returns).
+    """
+    def __init__(self, alpha=0.05, max_lag=5):
+        self.alpha = alpha
+        self.max_lag = max_lag
+        self.results = None
+        self.graph = None
+
+    def fit(self, df: pd.DataFrame):
+        """
+        Fit PCMCI on the dataframe.
+        df: Pandas DataFrame (Time Series).
+        """
+        if not TIGRAMITE_AVAILABLE:
+            return self
+
+        # 1. Prepare Data
+        # Tigramite requires (T, N) numpy array
+        data = df.values
+        var_names = df.columns.tolist()
+        
+        dataframe = pp.DataFrame(data, 
+                                 var_names=var_names,
+                                 missing_flag=999)
+
+        # 2. Init PCMCI with ParCorr (Linear Partial Correlation)
+        # For non-linear, use GPDC or CMIknn (slower)
+        parcorr = ParCorr(significance='analytic')
+        pcmci = PCMCI(dataframe=dataframe, cond_ind_test=parcorr, verbosity=0)
+
+        # 3. Run PCMCI
+        # PC phase then MCI phase
+        self.results = pcmci.run_pcmci(tau_max=self.max_lag, pc_alpha=self.alpha)
+        
+        # 4. Extract Graph (p_matrix < alpha)
+        # q_matrix handles FDR control, often better
+        q_matrix = self.results['q_matrix']
+        self.graph = q_matrix < self.alpha
+        
+        return self
+
+    def get_feature_weights(self):
+        """
+        Calculate feature importance based on Causal Strength (Val Matrix)
+        or Degree in the Causal Graph.
+        
+        Returns: normalized weights for each feature.
+        """
+        if not TIGRAMITE_AVAILABLE or self.results is None:
+            return np.ones(5) # Fallback
+            
+        # We want to know which features cause 'Volatility' or 'Returns' (if present)
+        # Or simply generalized centrality.
+        
+        val_matrix = np.abs(self.results['val_matrix']) # (N, N, Lags+1)
+        # Sum absolute causal strength across all lags for each link
+        # Shape: (N_features, N_features) - Strength of i -> j
+        strength_matrix = np.sum(val_matrix, axis=2)
+        
+        # Total Outgoing Causal Strength (How much 'i' influences others)
+        out_strength = np.sum(strength_matrix, axis=1) # Sum over j
+        
+        # Total Incoming Causal Strength (How much 'i' is influenced)
+        in_strength = np.sum(strength_matrix, axis=0)
+        
+        # Hybrid Score: Drivers are important
+        score = out_strength + in_strength
+        
+        # Normalize
+        if score.sum() == 0: return np.ones(len(score))
+        
+        weights = score / score.max()
+        return np.maximum(weights, 0.2) # Min weight
+
+def get_causal_model():
+    return CausalDiscovery(alpha=0.05, max_lag=3)

models/classic_ml.py

@@ -0,0 +1,38 @@
+from hmmlearn.hmm import GaussianHMM
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.impute import SimpleImputer
+import numpy as np
+
+# 1. HMM (Regime Detection)
+def get_hmm_pipeline(n_components=3):
+    return Pipeline([
+        ('imputer', SimpleImputer(strategy='mean')),
+        ('scaler', StandardScaler()),
+        ('hmm', GaussianHMM(n_components=n_components, covariance_type="full", n_iter=100))
+    ])
+
+# 2. Logistic Regression (Confidence Scorer)
+def get_logistic_pipeline():
+    return Pipeline([
+        ('imputer', SimpleImputer(strategy='mean')),
+        ('scaler', StandardScaler()),
+        ('clf', LogisticRegression(random_state=42, solver='liblinear'))
+    ])
+
+# 3. Random Forest (Trade Filter)
+def get_rf_pipeline():
+    return Pipeline([
+        ('imputer', SimpleImputer(strategy='mean')),
+        ('scaler', StandardScaler()),
+        ('clf', RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42, class_weight='balanced'))
+    ])
+
+# 4. Causal Discovery (Real PC Algorithm)
+from models.causal_discovery import get_causal_model as get_pc_model
+
+def get_causal_model():
+    return get_pc_model()
+

models/deeplob.py

@@ -0,0 +1,131 @@
+import torch
+import torch.nn as nn
+
+class InceptionModule(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super(InceptionModule, self).__init__()
+        
+        # Parallel Convolutions
+        # Branch 1: 1x1 Conv
+        self.branch1 = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=1),
+            nn.LeakyReLU(negative_slope=0.01),
+            nn.BatchNorm2d(out_channels)
+        )
+        
+        # Branch 2: 1x3 Conv
+        self.branch2 = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=(1,1)), 
+            nn.LeakyReLU(negative_slope=0.01),
+            nn.Conv2d(out_channels, out_channels, kernel_size=(1,3), padding=(0,1)),
+            nn.LeakyReLU(negative_slope=0.01),
+            nn.BatchNorm2d(out_channels)
+        )
+        
+        # Branch 3: 1x5 Conv
+        self.branch3 = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=(1,1)), 
+            nn.LeakyReLU(negative_slope=0.01),
+            nn.Conv2d(out_channels, out_channels, kernel_size=(1,5), padding=(0,2)),
+            nn.LeakyReLU(negative_slope=0.01),
+            nn.BatchNorm2d(out_channels)
+        )
+        
+        # Branch 4: MaxPool + 1x1
+        self.branch4 = nn.Sequential(
+            nn.MaxPool2d(kernel_size=(1,3), stride=1, padding=(0,1)),
+            nn.Conv2d(in_channels, out_channels, kernel_size=1),
+            nn.LeakyReLU(negative_slope=0.01),
+            nn.BatchNorm2d(out_channels)
+        )
+        
+    def forward(self, x):
+        b1 = self.branch1(x)
+        b2 = self.branch2(x)
+        b3 = self.branch3(x)
+        b4 = self.branch4(x)
+        return torch.cat([b1, b2, b3, b4], dim=1)
+
+class SEBlock(nn.Module):
+    """
+    Squeeze-and-Excitation Block (Channel Attention).
+    Recalibrates feature maps adaptively.
+    Hu et al. (2018).
+    """
+    def __init__(self, channels, reduction=16):
+        super(SEBlock, self).__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1) # Squeeze
+        self.fc = nn.Sequential(
+            nn.Linear(channels, channels // reduction, bias=False),
+            nn.ReLU(inplace=True),
+            nn.Linear(channels // reduction, channels, bias=False),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        b, c = x.shape[0], x.shape[1]
+        # b, c, _, _ = x.size() # This tuple unpacking can fail in ONNX tracing
+        y = self.avg_pool(x).view(b, c) # Mean per channel
+        y = self.fc(y).view(b, c, 1, 1) # Attention weights
+        return x * y.expand_as(x) # Scale features
+
+class DeepLOB(nn.Module):
+    """
+    DeepLOB with Inception + SE-Block Attention (Academic Standard).
+    """
+    def __init__(self, y_len=3):
+        super().__init__()
+        self.y_len = y_len
+        
+        # Initial Blocks
+        self.block1 = nn.Sequential(
+            nn.Conv2d(2, 16, kernel_size=(1,2), stride=(1,2)), # Input channels=2 (P, V)
+            nn.LeakyReLU(negative_slope=0.01),
+            nn.BatchNorm2d(16),
+            InceptionModule(16, 8), # Out: 32
+            SEBlock(32) # Attention
+        )
+        
+        self.block2 = nn.Sequential(
+             nn.Conv2d(32, 16, kernel_size=(1,2), stride=(1,2)),
+             nn.LeakyReLU(negative_slope=0.01),
+             nn.BatchNorm2d(16),
+             InceptionModule(16, 8), # Out: 32
+             SEBlock(32) # Attention
+        )
+        
+        self.block3 = nn.Sequential(
+             nn.Conv2d(32, 16, kernel_size=(1,10)), 
+             nn.LeakyReLU(negative_slope=0.01),
+             nn.BatchNorm2d(16),
+             InceptionModule(16, 8), # Out: 32
+             SEBlock(32) # Attention
+        )
+        
+        # LSTM
+        self.lstm = nn.LSTM(input_size=32, hidden_size=64, num_layers=1, batch_first=True)
+        self.fc = nn.Linear(64, y_len)
+
+    def forward(self, x):
+        # x: (N, 2, 100, 40)
+        
+        x = self.block1(x) 
+        x = self.block2(x) 
+        x = self.block3(x) 
+        
+        # Reshape for LSTM: (N, T, Features)
+        x = x.permute(0, 2, 1, 3) 
+        x = x.reshape(x.shape[0], x.shape[1], -1) 
+        
+        if x.dim() == 2:
+           x = x.unsqueeze(0)
+           
+        # Explicit Init for ONNX
+        h0 = torch.zeros(1, x.size(0), 64).to(x.device)
+        c0 = torch.zeros(1, x.size(0), 64).to(x.device)
+        
+        out, _ = self.lstm(x, (h0, c0))
+        out = out[:, -1, :] 
+        out = self.fc(out)
+        
+        return out

models/execution_agent.py

@@ -0,0 +1,49 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class PPOActorCritic(nn.Module):
+    """
+    Execution Agent using PPO (Proximal Policy Optimization).
+    Input: [Signal (1), L2_Imbalance (1), Spread (1), Position_Net (1), Volatility (1)] -> 5 Dim
+    Action Space:
+      - Type: Limit (0) vs Market (1) -> Categorical(2)
+      - Price Offset: Continuous (Gaussian)
+      - Size: Continuous (Gaussian, 0-1 ratio)
+    """
+    def __init__(self, input_dim=5, action_dim=3):
+        super(PPOActorCritic, self).__init__()
+        self.input_dim = input_dim
+        
+        # Shared Feature Extractor
+        self.common = nn.Linear(input_dim, 64)
+        
+        # Actor Heads
+        # 1. Order Type (Discrete)
+        self.actor_type = nn.Sequential(
+            nn.Linear(64, 32),
+            nn.Linear(32, 2),
+            nn.Softmax(dim=-1)
+        )
+        # 2. Price Offset (Continuous) - Mu, Sigma
+        self.actor_offset_mu = nn.Sequential(nn.Linear(64, 32), nn.Linear(32, 1), nn.Tanh())
+        self.actor_offset_sigma = nn.Parameter(torch.zeros(1)) 
+        
+        # 3. Size (Continuous) - Mu, Sigma
+        self.actor_size_mu = nn.Sequential(nn.Linear(64, 32), nn.Linear(32, 1), nn.Sigmoid())
+        
+        # Critic Head (Value Function)
+        self.critic = nn.Sequential(
+            nn.Linear(64, 32),
+            nn.Linear(32, 1)
+        )
+
+    def forward(self, x):
+        x = F.relu(self.common(x))
+        
+        probs_type = self.actor_type(x)
+        mu_offset = self.actor_offset_mu(x)
+        mu_size = self.actor_size_mu(x)
+        value = self.critic(x)
+        
+        return probs_type, mu_offset, mu_size, value

models/lstm.py

@@ -0,0 +1,38 @@
+import torch
+import torch.nn as nn
+
+class AlphaLSTM(nn.Module):
+    """
+    Simple LSTM model for predicting price returns.
+    Input: (Batch, Seq_Len, Features)
+    Output: (Batch, 1) -> Predicted Next Return
+    """
+    def __init__(self, input_size=4, hidden_size=64, num_layers=2, dropout=0.2):
+        super(AlphaLSTM, self).__init__()
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        
+        self.lstm = nn.LSTM(
+            input_size=input_size,
+            hidden_size=hidden_size,
+            num_layers=num_layers,
+            batch_first=True,
+            dropout=dropout
+        )
+        
+        # Fully Connected Layer
+        self.fc = nn.Linear(hidden_size, 1)
+        self.activation = nn.Tanh() # Output range [-1, 1] suited for "Signal"
+
+    def forward(self, x):
+        # Initialize hidden state with zeros
+        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
+        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
+        
+        # Forward propagate LSTM
+        out, _ = self.lstm(x, (h0, c0))
+        
+        # Decode the hidden state of the last time step
+        out = self.fc(out[:, -1, :])
+        out = self.activation(out)
+        return out

models/meta_controller.py

@@ -0,0 +1,25 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class DQN(nn.Module):
+    """
+    Meta-Controller using DQN (Deep Q-Network).
+    Input: [Volatility(1), Market_Regime(3 - OneHot), Global_PnL_Trend(1)] -> 5 Dim
+    Output: Q-Values for Actions (3)
+       0: FollowTrend Agent
+       1: MeanReversion Agent
+       2: Defensive Mode (Cash)
+    """
+    def __init__(self, input_dim=5, output_dim=3):
+        super(DQN, self).__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, 64),
+            nn.LeakyReLU(),
+            nn.Linear(64, 64),
+            nn.LeakyReLU(),
+            nn.Linear(64, output_dim)
+        )
+    
+    def forward(self, x):
+        return self.net(x)

models/risk_agent.py

@@ -0,0 +1,29 @@
+class RiskAgent:
+    """
+    Risk Agent (Guardian).
+    Hard-coded rules to prevent catastrophe.
+    """
+    def __init__(self, max_dd=0.15, max_hourly_loss=200):
+        self.max_dd = max_dd
+        self.max_hourly_loss = max_hourly_loss
+        self.current_dd = 0.0
+        self.hourly_loss = 0.0
+
+    def check_health(self, equity, initial_equity, recent_pnl):
+        """
+        Returns boolean: True (Healthy), False (Stop Trading).
+        """
+        # Update DD
+        peak_equity = max(equity, initial_equity)
+        self.current_dd = (peak_equity - equity) / peak_equity
+        
+        # Check Rules
+        if self.current_dd > self.max_dd:
+            print(f"RISK TRIGGER: Max Drawdown {self.current_dd:.2%} > {self.max_dd:.2%}")
+            return False
+            
+        if recent_pnl < -self.hourly_loss:
+            print(f"RISK TRIGGER: Hourly Loss {recent_pnl} > {self.max_hourly_loss}")
+            return False
+            
+        return True

models/trm.py

@@ -0,0 +1,81 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class TinyRecursiveCore(nn.Module):
+    """
+    The Shared Core Network for TRM.
+    Refines the latent state z_t given the context c.
+    z_{t+1} = f(z_t, c)
+    """
+    def __init__(self, hidden_dim, context_dim):
+        super(TinyRecursiveCore, self).__init__()
+        # Input is concatenation of current state and context
+        self.net = nn.Sequential(
+            nn.Linear(hidden_dim + context_dim, hidden_dim),
+            nn.LeakyReLU(negative_slope=0.01),
+            nn.LayerNorm(hidden_dim),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.LeakyReLU(negative_slope=0.01),
+            nn.LayerNorm(hidden_dim)
+        )
+        
+    def forward(self, z, c):
+        combined = torch.cat([z, c], dim=1)
+        # Residual connection ideally, but raw update usually fine for short loops.
+        delta_z = self.net(combined)
+        return z + delta_z # Residual State Update
+
+class TRM(nn.Module):
+    """
+    Samsung SAIL "Tiny Recursive Model" (TRM).
+    Replaces massive parameter count with a recursive reasoning loop.
+    Architecture:
+    1. Encoder: Maps Input (Batch, Seq, Feat) -> Context Vector 'c'.
+    2. Initialization: init state z_0 = c (or learned).
+    3. Recursion: Apply TinyCore N times: z_{k+1} = Core(z_k, c).
+    4. Decoder: Map z_N -> Output Classes.
+    """
+    def __init__(self, input_size=5, hidden_dim=64, num_classes=3, recur_steps=5):
+        super(TRM, self).__init__()
+        self.recur_steps = recur_steps
+        self.hidden_dim = hidden_dim
+        
+        # Encoder: Flatten sequence? Or use simple LSTM/Linear to get Context?
+        # To keep it "Tiny", let's use a simple Linear projection of the Flattened window.
+        # Assuming T=60, Feat=5 -> 300 dim flat.
+        # We can make it dynamic by using AdaptiveAvgPool or assuming input is (Batch, Seq, Feat)
+        
+        # Simple Encoder: (Batch, Seq, Feat) -> (Batch, Hidden)
+        # Using LSTM to summarize temporal context first is robust.
+        self.encoder = nn.LSTM(input_size, hidden_dim, batch_first=True)
+        
+        # The Tiny Shared Core
+        self.core = TinyRecursiveCore(hidden_dim, hidden_dim) # z_dim=hidden, c_dim=hidden
+        
+        # Decoder (Head)
+        self.decoder = nn.Linear(hidden_dim, num_classes)
+        self.softmax = nn.Softmax(dim=1)
+
+    def forward(self, x):
+        # x: (Batch, Seq, Features)
+        
+        # 1. Encode Context
+        # LSTM output: (Batch, Seq, Hidden), (h_n, c_n)
+        
+        # Explicit Init for ONNX
+        h0 = torch.zeros(1, x.size(0), self.hidden_dim).to(x.device)
+        c0 = torch.zeros(1, x.size(0), self.hidden_dim).to(x.device)
+        
+        _, (h_n, _) = self.encoder(x, (h0, c0))
+        context = h_n[-1] # Shape (Batch, Hidden)
+        
+        # 2. Reasoning Loop
+        z = context.clone() # Initialize state with context
+        
+        for _ in range(self.recur_steps):
+            z = self.core(z, context)
+            
+        # 3. Readout
+        out = self.decoder(z)
+        return self.softmax(out)

nautilus_trader_source

@@ -0,0 +1 @@
+Subproject commit a1adc1b7b44aa620b1191e31547c9a5ac3b82ba2

requirements.txt

@@ -0,0 +1,19 @@
+gradio>=4.0.0
+torch
+gymnasium
+pandas
+numpy
+msgpack
+pyarrow
+scikit-learn
+tensorboard
+matplotlib
+hmmlearn
+scipy
+networkx
+tigramite
+huggingface_hub
+onnx
+onnxscript
+ray[rllib]
+datasets

run_dev_loop.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+# NautilusTrainer Dev Loop Orchestrator
+# Usage: ./run_dev_loop.sh
+
+echo "🔄 Starting NautilusTrainer Dev Loop..."
+echo "----------------------------------------"
+
+# 1. Set Environment
+cd "$(dirname "$0")"
+
+# Activate venv from parent directory if exists
+if [ -d "../.venv" ]; then
+    source ../.venv/bin/activate
+fi
+
+export PYTHONPATH=$PYTHONPATH:$(pwd)
+
+# 2. Run Tests
+python3 tests/test_pipeline.py
+
+EXIT_CODE=$?
+
+echo "----------------------------------------"
+if [ $EXIT_CODE -eq 0 ]; then
+    echo "✅ SUCCESS: Pipeline verified."
+else
+    echo "❌ FAILURE: Pipeline failed."
+fi
+
+exit $EXIT_CODE

run_prod_docker.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# NautilusTrainer Production Simulation
+# Builds the Docker container and runs it exactly as HF Space would.
+
+APP_NAME="nautilus-trainer-prod"
+
+echo "🐳 Building Docker Image..."
+docker build -t $APP_NAME ./NautilusTrainer
+
+if [ $? -ne 0 ]; then
+    echo "❌ Docker Build Failed."
+    exit 1
+fi
+
+echo "✅ Build Success."
+
+# Check for HF_TOKEN
+if [ -z "$HF_TOKEN" ]; then
+    echo "⚠️  WARNING: HF_TOKEN is not set in your environment."
+    echo "   Training will likely fail when trying to stream data."
+    echo "   Usage: HF_TOKEN=hf_... ./run_prod_docker.sh"
+    read -p "   Do you want to continue anyway? (y/n) " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        exit 1
+    fi
+fi
+
+echo "🚀 Running Container on port 7860..."
+echo "   Access Dashboard at: http://localhost:7860"
+echo "   Press Ctrl+C to stop."
+
+docker run --rm -p 7860:7860 \
+    -e HF_TOKEN=$HF_TOKEN \
+    $APP_NAME
+

scheduler.py

@@ -0,0 +1,26 @@
+import time
+import schedule
+from datetime import datetime
+import auto_train
+
+def run_pipeline():
+    print(f"\n⏰ Scheduler: Starting Training Pipeline at {datetime.now().isoformat()}...")
+    try:
+        auto_train.main()
+    except Exception as e:
+        print(f"❌ Scheduler Error: {e}")
+    print(f"💤 Scheduler: Sleeping for 1 hour...")
+
+if __name__ == "__main__":
+    print("🚀 NautilusAI Training Scheduler Started")
+    print("📅 Schedule: Run every 60 minutes")
+    
+    # Run immediately on startup
+    run_pipeline()
+    
+    # Schedule subsequent runs
+    schedule.every(60).minutes.do(run_pipeline)
+    
+    while True:
+        schedule.run_pending()
+        time.sleep(60)

streaming_loader.py

@@ -0,0 +1,204 @@
+import pandas as pd
+import numpy as np
+import torch
+import ast
+import os
+import json
+from typing import Iterator, Tuple
+from datasets import load_dataset
+from data_processor import AlphaDataProcessor
+import gc
+
+class StreamingDataLoader:
+    """
+    Streams training data directly from HuggingFace Datasets without downloading.
+    Buffers chunks to enable rolling window operations.
+    """
+    def __init__(self, 
+                 repo_id: str = "gionuibk/hyperliquid-data",
+                 model_type: str = "deeplob",
+                 batch_size: int = 32,
+                 chunk_size: int = 500,  # Reduced to ensure frequent yields
+                 buffer_size: int = 200): # Reduced buffer
+        """
+        Args:
+            repo_id: HF Dataset ID
+            model_type: 'deeplob' or 'trm'
+            batch_size: Training batch size
+            chunk_size: Rows per processing chunk
+            buffer_size: Overlap size to maintain rolling stats continuity
+        """
+        self.repo_id = repo_id
+        self.model_type = model_type
+        self.batch_size = batch_size
+        self.chunk_size = chunk_size
+        self.buffer_size = buffer_size
+        
+        self.processor = AlphaDataProcessor()
+        
+    def __iter__(self) -> Iterator[Tuple[torch.Tensor, torch.Tensor]]:
+        """
+        Yields batches of (X, y) tensors from the stream.
+        """
+        print(f"📡 Connecting to HF Dataset Stream: {self.repo_id}")
+        token = os.environ.get("HF_TOKEN")
+        
+        try:
+            # MANUAL LOADING Mode (Bypassing datasets library due to Arrow/Parquet errors)
+            from huggingface_hub import HfApi, hf_hub_download
+            api = HfApi(token=token)
+            
+            # 1. List files
+            # 1. List files
+            print("🔍 Listing files...")
+            files = api.list_repo_files(repo_id=self.repo_id, repo_type="dataset")
+            
+            if self.model_type == "lstm":
+                # Use Bar Data for LSTM (Support both v1 'data/bar/' and v2 'data/candles/')
+                target_files = [
+                    f for f in files 
+                    if (f.startswith("data/bar/") or f.startswith("data/candles/")) 
+                    and f.endswith(".parquet")
+                ]
+                print(f"📂 Found {len(target_files)} Bar/Candle files for LSTM.")
+            else:
+                # Use L2 Snapshots for DeepLOB/TRM (Support both v1 'order_book_snapshot' and v2 'l2book')
+                target_files = [
+                    f for f in files 
+                    if ("order_book_snapshot" in f or "l2book" in f) 
+                    and f.endswith(".parquet")
+                ]
+                print(f"📂 Found {len(target_files)} Snapshot/L2Book files for {self.model_type}.")
+            
+            # Buffer for rolling operations
+            buffer_df = pd.DataFrame()
+            chunk_rows = []
+            
+            total_loaded_rows = 0
+            
+            for file_path in target_files:
+                try:
+                    print(f"⬇️ Downloading {file_path}...")
+                    # Download to temp dir to avoid cache filling
+                    temp_dir = "./temp_data"
+                    os.makedirs(temp_dir, exist_ok=True)
+                    
+                    local_path = hf_hub_download(
+                        repo_id=self.repo_id, 
+                        filename=file_path, 
+                        repo_type="dataset",
+                        token=token,
+                        local_dir=temp_dir,
+                        local_dir_use_symlinks=False,
+                        force_download=True  # Ensure we have a fresh copy to delete later
+                    )
+                    
+                    print(f"📖 Reading {file_path}...")
+                    # Read parquet directly using pandas (robust)
+                    try:
+                        df = pd.read_parquet(local_path)
+                    except BaseException as e: # Catch EVERYTHING including OSError
+                         print(f"⚠️ Parquet Read Failed for {file_path}: {e}")
+                         continue
+
+                    rows_in_file = len(df)
+                    print(f"✅ Loaded {rows_in_file} rows from {file_path}")
+                    total_loaded_rows += rows_in_file
+                    
+                    total_loaded_rows += rows_in_file
+                    
+                    # Iterate rows in the dataframe
+                    for i, row in df.iterrows():
+                        # Parse L2 columns (Support both nested lists and flat columns)
+                        if 'bids' in row and isinstance(row['bids'], str):
+                             try: row['bids'] = ast.literal_eval(row['bids'])
+                             except: pass
+                        if 'asks' in row and isinstance(row['asks'], str):
+                             try: row['asks'] = ast.literal_eval(row['asks'])
+                             except: pass
+                        
+                        # Handle Flat Format (bid_px_1, bid_sz_1, ...)
+                        if 'bids' not in row and 'bid_px_1' in row:
+                            bids = []
+                            asks = []
+                            for level in range(1, 21): # Support up to 20 levels
+                                if f'bid_px_{level}' in row:
+                                    bids.append([row[f'bid_px_{level}'], row[f'bid_sz_{level}']])
+                                if f'ask_px_{level}' in row:
+                                    asks.append([row[f'ask_px_{level}'], row[f'ask_sz_{level}']])
+                            row['bids'] = bids
+                            row['asks'] = asks
+
+                        # Pandas iterrows returns (index, Series), we want the Series/dict
+                        # Append as dict for processing
+                        chunk_rows.append(row.to_dict())
+                        
+                        if len(chunk_rows) >= self.chunk_size:
+                            # Process and yield chunk
+                            yield from self._process_chunk(chunk_rows, buffer_df)
+                            
+                            # Update Buffer from new chunk
+                            new_df = pd.DataFrame(chunk_rows)
+                            buffer_df = new_df.tail(self.buffer_size)
+                            chunk_rows = []
+                            gc.collect()
+                            
+                except Exception as e:
+                    print(f"⚠️ Failed to process file {file_path}: {e}")
+                
+                finally:
+                    # CRITICAL: Clean up file immediately to save disk space
+                    if 'local_path' in locals() and os.path.exists(local_path):
+                        try:
+                            # Verify it's a file before removing (safety)
+                            if os.path.isfile(local_path):
+                                os.remove(local_path)
+                        except: pass
+            
+            # Process remaining rows after all files
+            if len(chunk_rows) > 0:
+                print(f"🧹 Processing final residual chunk ({len(chunk_rows)} rows)...")
+                yield from self._process_chunk(chunk_rows, buffer_df)
+
+        except Exception as e:
+            print(f"⚠️ Manual Loading Error: {e}")
+            import traceback
+            traceback.print_exc()
+
+    def _process_chunk(self, chunk_rows, buffer_df):
+        # Helper to process a chunk and yield batches
+        new_df = pd.DataFrame(chunk_rows)
+        
+        # Merge with buffer (previous context)
+        if not buffer_df.empty:
+            combined_df = pd.concat([buffer_df, new_df])
+        else:
+            combined_df = new_df
+            
+        # Process
+        if self.model_type == "deeplob":
+            X, y = self.processor.get_deeplob_tensors_from_df(combined_df)
+        elif self.model_type == "trm":
+            X, y = self.processor.get_trm_tensors_from_df(combined_df)
+        elif self.model_type == "lstm":
+            X, y = self.processor.get_lstm_tensors_from_df(combined_df)
+        else:
+            raise ValueError(f"Unknown model type: {self.model_type}")
+        
+        # Yield batches
+        if len(X) > 0:
+            dataset_size = len(X)
+            indices = torch.randperm(dataset_size)
+            X = X[indices]
+            y = y[indices]
+            
+            for k in range(0, dataset_size, self.batch_size):
+                batch_X = X[k:k+self.batch_size]
+                batch_y = y[k:k+self.batch_size]
+                if len(batch_X) == self.batch_size:
+                    yield batch_X, batch_y
+            
+    def get_sample_batch(self) -> Tuple[torch.Tensor, torch.Tensor]:
+        for batch_X, batch_y in self:
+            return batch_X, batch_y
+        raise RuntimeError("Stream empty or failed")

tests/mock_data.py

@@ -0,0 +1,76 @@
+import pandas as pd
+import numpy as np
+import time
+from typing import List, Dict
+
+class MockDataGenerator:
+    """Generates synthetic L2 Orderbook and Trade data for testing."""
+    
+    @staticmethod
+    def generate_l2_snapshot(num_rows: int = 100, levels: int = 20) -> pd.DataFrame:
+        """
+        Generates a DataFrame mimicking the L2 Snapshot structure.
+        Columns: ts_event, instrument_id, bids, asks
+        """
+        base_price = 2000.0
+        data = []
+        
+        start_time = time.time() * 1000
+        
+        for i in range(num_rows):
+            ts = start_time + i * 1000 # 1 sec intervals
+            
+            # Random Walk Price
+            noise = np.random.normal(0, 1)
+            mid_price = base_price + noise
+            base_price = mid_price
+            
+            # Generate Levels
+            bids = []
+            asks = []
+            
+            for l in range(levels):
+                spread = (l + 1) * 0.5
+                bid_p = mid_price - spread
+                ask_p = mid_price + spread
+                
+                bid_sz = abs(np.random.normal(10, 5)) + 1
+                ask_sz = abs(np.random.normal(10, 5)) + 1
+                
+                bids.append([bid_p, bid_sz])
+                asks.append([ask_p, ask_sz])
+                
+            data.append({
+                "ts_event": ts,
+                "instrument_id": "ETH-USD",
+                "bids": bids, # List of lists format
+                "asks": asks
+            })
+            
+        return pd.DataFrame(data)
+
+    @staticmethod
+    def generate_trades(num_rows: int = 100) -> pd.DataFrame:
+        """
+        Generates synthetic trade data.
+        Columns: time, coin, px, sz, side
+        """
+        base_price = 2000.0
+        data = []
+        start_time = time.time() * 1000
+        
+        for i in range(num_rows):
+            ts = start_time + i * 500
+            px = base_price + np.random.normal(0, 1)
+            sz = abs(np.random.normal(1, 0.5))
+            side = 'B' if np.random.random() > 0.5 else 'A'
+            
+            data.append({
+                "time": ts,
+                "coin": "ETH",
+                "px": px,
+                "sz": sz,
+                "side": side
+            })
+            
+        return pd.DataFrame(data)

tests/test_loader_v2.py

@@ -0,0 +1,47 @@
+
+import sys
+import unittest
+import torch
+# Add parent dir to path to import NautilusTrainer modules
+sys.path.append("..")
+from streaming_loader import StreamingDataLoader
+
+class TestLoaderV2(unittest.TestCase):
+    def test_load_l2_snapshot(self):
+        print("\nTesting L2 Snapshot Load (v2)...")
+        loader = StreamingDataLoader(
+            repo_id="gionuibk/hyperliquidL2Book-v2",
+            model_type="deeplob",
+            batch_size=4,
+            chunk_size=1000,
+            buffer_size=1000
+        )
+        
+        try:
+            batch_X, batch_y = loader.get_sample_batch()
+            print(f"✅ Success! X shape: {batch_X.shape}, y shape: {batch_y.shape}")
+            self.assertIsInstance(batch_X, torch.Tensor)
+            self.assertIsInstance(batch_y, torch.Tensor)
+        except Exception as e:
+            self.fail(f"Failed to load L2 snapshot: {e}")
+
+    def test_load_candles(self):
+        print("\nTesting Candle Load (v2)...")
+        loader = StreamingDataLoader(
+            repo_id="gionuibk/hyperliquidL2Book-v2",
+            model_type="lstm",
+            batch_size=4,
+            chunk_size=1000,
+            buffer_size=1000
+        )
+        
+        try:
+            batch_X, batch_y = loader.get_sample_batch()
+            print(f"✅ Success! X shape: {batch_X.shape}, y shape: {batch_y.shape}")
+            self.assertIsInstance(batch_X, torch.Tensor)
+            self.assertIsInstance(batch_y, torch.Tensor)
+        except Exception as e:
+            self.fail(f"Failed to load Candles: {e}")
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_pipeline.py

@@ -0,0 +1,125 @@
+import sys
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+
+# Add parent directory to path to import modules
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from data_processor import AlphaDataProcessor
+from models.deeplob import DeepLOB
+from tests.mock_data import MockDataGenerator
+
+def test_deeplob_pipeline():
+    print("🧪 Starting DeepLOB Pipeline Test...")
+    
+    # 1. Generate Mock Data
+    print("   Generatng mock data...", end="")
+    df = MockDataGenerator.generate_l2_snapshot(num_rows=2000, levels=20)
+    print("Done.")
+    
+    # 2. Process Data
+    print("   Processing tensors...", end="")
+    processor = AlphaDataProcessor()
+    # T=100 is standard
+    X, y = processor.get_deeplob_tensors_from_df(df, T=100, levels=20)
+    
+    print(f"Done. Shape: X={X.shape}, y={y.shape}")
+    
+    if len(X) == 0:
+        print("❌ Error: No tensors generated from mock data.")
+        sys.exit(1)
+        
+    # 3. Model Init
+    print("   Initializing DeepLOB...", end="")
+    model = DeepLOB(y_len=3)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=0.001)
+    print("Done.")
+    
+    # 4. Training Step (Forward + Backward)
+    print("   Running training step...", end="")
+    try:
+        model.train()
+        
+        # Take a small batch
+        batch_size = 8
+        if len(X) < 8: batch_size = len(X)
+        
+        batch_X = X[:batch_size]
+        batch_y = y[:batch_size]
+        
+        optimizer.zero_grad()
+        outputs = model(batch_X)
+        
+        loss = criterion(outputs, batch_y)
+        loss.backward()
+        optimizer.step()
+        
+        print(f"Done. Loss: {loss.item():.4f}")
+        print("✅ DeepLOB Pipeline Test Passed!")
+        
+    except Exception as e:
+        print(f"\n❌ Error during training step: {e}")
+        import traceback
+        traceback.print_exc()
+from models.trm import TRM
+
+def test_trm_pipeline():
+    print("\n🧪 Starting TRM Pipeline Test...")
+    
+    # 1. Generate Mock Data
+    print("   Generatng mock data...", end="")
+    df = MockDataGenerator.generate_l2_snapshot(num_rows=2000, levels=20)
+    print("Done.")
+    
+    # 2. Process Data
+    print("   Processing transformers...", end="")
+    processor = AlphaDataProcessor()
+    # TRM uses 6 features
+    X, y = processor.get_trm_tensors_from_df(df, T=60)
+    
+    print(f"Done. Shape: X={X.shape}, y={y.shape}")
+    
+    if len(X) == 0:
+        print("❌ Error: No tensors generated for TRM.")
+        return
+        
+    # 3. Model Init
+    print("   Initializing TRM...", end="")
+    # Check TRM signature from file if needed, assuming (input_size=6, num_classes=3) based on auto_train.py
+    model = TRM(input_size=6, num_classes=3)
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=0.001)
+    print("Done.")
+    
+    # 4. Training Step
+    print("   Running training step...", end="")
+    try:
+        model.train()
+        batch_size = 8
+        if len(X) < 8: batch_size = len(X)
+        
+        batch_X = X[:batch_size]
+        batch_y = y[:batch_size]
+        
+        optimizer.zero_grad()
+        outputs = model(batch_X)
+        
+        loss = criterion(outputs, batch_y)
+        loss.backward()
+        optimizer.step()
+        
+        print(f"Done. Loss: {loss.item():.4f}")
+        print("✅ TRM Pipeline Test Passed!")
+        
+    except Exception as e:
+        print(f"\n❌ Error during TRM training step: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    test_deeplob_pipeline()
+    test_trm_pipeline()

train.py

@@ -0,0 +1,45 @@
+import ray
+from ray import tune
+from ray.rllib.algorithms.ppo import PPOConfig
+# from envs.nautilus_env import NautilusExecutionEnv  # Not used in this script
+import os
+
+def train():
+    # 1. Init Ray
+    ray.init(ignore_reinit_error=True)
+    
+    # 2. Register Environment (Using Standard Gym for Health Check)
+    env_name = "CartPole-v1" 
+    
+    # 3. Configure Algorithm
+    config = (
+        PPOConfig()
+        .environment(env_name)
+        .framework("torch")
+        .rollouts(num_rollout_workers=0) # 0 for local test, CPU count for Prod
+        .training(model={"fcnet_hiddens": [64, 64]})
+        .resources(num_gpus=0) # Set to 1 if using GPU Space
+    )
+    
+    # 4. Run Training
+    print("Starting Training...")
+    algo = config.build()
+    
+    for i in range(10):  # 10 Iterations for test
+        result = algo.train()
+        print(f"Iter: {i}, Reward: {result['episode_reward_mean']}")
+        
+        # Save Checkpoint
+        if i % 5 == 0:
+            checkpoint_dir = algo.save(f"./checkpoints/iter_{i}")
+            print(f"Checkpoint saved at {checkpoint_dir}")
+
+    # 5. Export to ONNX (Crucial for Nautilus)
+    print("Exporting to ONNX...")
+    # onnx_path = algorithm.export_model_model(export_dir="./models") 
+    # (Simplified, implementation detail varies by RLLib version)
+    
+    ray.shutdown()
+
+if __name__ == "__main__":
+    train()

train_alpha.py

@@ -0,0 +1,103 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from huggingface_hub import snapshot_download, HfApi
+import os
+from data_processor import AlphaDataProcessor
+from models.lstm import AlphaLSTM
+from torch.utils.tensorboard import SummaryWriter
+import shutil
+
+# Configuration
+REPO_ID = "gionuibk/hyperliquidL2Book-v2"  # Correct dataset repo
+DATA_DIR = "./data"
+MODEL_DIR = "./models"
+EPOCHS = 50
+BATCH_SIZE = 32
+LR = 0.001
+
+def download_data():
+    """Downloads dataset from HuggingFace Hub."""
+    print(f"Downloading data from {REPO_ID}...")
+    try:
+        snapshot_download(
+            repo_id=REPO_ID,
+            repo_type="dataset",
+            local_dir=DATA_DIR,
+            allow_patterns=["raw_trade/*.parquet"] 
+        )
+        print("Download Complete.")
+    except Exception as e:
+        print(f"Warning: Could not download data (Token missing?): {e}")
+
+def train():
+    writer = SummaryWriter(log_dir="./ray_results/alpha_experiment")
+    os.makedirs(MODEL_DIR, exist_ok=True)
+
+    # 1. Prepare Data
+    download_data()
+    processor = AlphaDataProcessor(data_dir=DATA_DIR)
+    
+    # Check if data exists
+    if not os.path.exists(f"{DATA_DIR}/raw_trade"):
+        print("No data found. Ensure 'raw_trade' folder exists in dataset.")
+        # Create dummy data for dry-run
+    
+    print("Processing Features...")
+    X, y = processor.get_tensors(coin="ETH", seq_len=60)
+    
+    # Train/Test Split
+    train_size = int(len(X) * 0.8)
+    X_train, X_test = X[:train_size], X[train_size:]
+    y_train, y_test = y[:train_size], y[train_size:]
+    
+    train_loader = torch.utils.data.DataLoader(
+        torch.utils.data.TensorDataset(X_train, y_train), batch_size=BATCH_SIZE, shuffle=True
+    )
+
+    # 2. Init Model
+    model = AlphaLSTM(input_size=4) # features: log_ret, vol, rsi, volume
+    criterion = nn.MSELoss()
+    optimizer = optim.Adam(model.parameters(), lr=LR)
+
+    # 3. Training Loop
+    print("Starting Training...")
+    for epoch in range(EPOCHS):
+        model.train()
+        total_loss = 0
+        for batch_X, batch_y in train_loader:
+            optimizer.zero_grad()
+            outputs = model(batch_X)
+            loss = criterion(outputs, batch_y)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        
+        avg_loss = total_loss / len(train_loader)
+        writer.add_scalar("Loss/Train", avg_loss, epoch)
+        
+        if epoch % 5 == 0:
+            print(f"Epoch {epoch}/{EPOCHS} | Loss: {avg_loss:.6f}")
+            
+    # 4. Save ONNX
+    print("Exporting to ONNX...")
+    dummy_input = torch.randn(1, 60, 4)
+    onnx_path = f"{MODEL_DIR}/alpha_lstm_v1.onnx"
+    torch.onnx.export(
+        model, 
+        dummy_input, 
+        onnx_path,
+        input_names=['input'], 
+        output_names=['output'],
+        dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}}
+    )
+    print(f"Model Saved: {onnx_path}")
+    
+    # 5. Push Model to HF (Optional - can be done manually or separate script)
+    # api = HfApi()
+    # api.upload_file(...)
+    
+    writer.close()
+
+if __name__ == "__main__":
+    train()

train_deeplob.py

@@ -0,0 +1,125 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from huggingface_hub import snapshot_download
+import os
+import numpy as np
+from data_processor import AlphaDataProcessor
+from models.deeplob import DeepLOB
+from torch.utils.tensorboard import SummaryWriter
+
+# Configuration
+REPO_ID = "gionuibk/hyperliquidL2Book-v2"  # Correct dataset repo
+DATA_DIR = "./data"
+MODEL_DIR = "./models"
+EPOCHS = 20
+BATCH_SIZE = 32
+LR = 0.0001
+T = 100
+LEVELS = 20
+
+def download_data():
+    """Downloads dataset from HuggingFace Hub."""
+    print(f"Downloading data from {REPO_ID}...")
+    try:
+        snapshot_download(
+            repo_id=REPO_ID,
+            repo_type="dataset",
+            local_dir=DATA_DIR,
+            allow_patterns=["order_book_snapshot/*.parquet"] 
+        )
+        print("Download Complete.")
+    except Exception as e:
+        print(f"Warning: Could not download data (Token missing?): {e}")
+
+def train():
+    writer = SummaryWriter(log_dir="./ray_results/deeplob_experiment")
+    os.makedirs(MODEL_DIR, exist_ok=True)
+
+    # 1. Prepare Data
+    download_data()
+    processor = AlphaDataProcessor(data_dir=DATA_DIR)
+    
+    print("Processing DeepLOB Tensors (L2)...")
+    X, y = processor.get_deeplob_tensors(coin="ETH", T=T, levels=LEVELS)
+    
+    # Reshape for CNN: (N, 1, T, Features)
+    # X shape current: (N, T, Features)
+    # X is already (N, 2, T, Features) from DataProcessor
+    # X = X.unsqueeze(1) # Removed: caused 5D tensor error 
+    
+    print(f"Data Shape: {X.shape}")
+    
+    # Train/Test Split
+    train_size = int(len(X) * 0.8)
+    X_train, X_test = X[:train_size], X[train_size:]
+    y_train, y_test = y[:train_size], y[train_size:]
+    
+    train_dataset = torch.utils.data.TensorDataset(X_train, y_train)
+    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
+
+    # Compute Class Weights for Imbalance
+    class_counts = torch.bincount(y_train)
+    total_samples = class_counts.sum()
+    n_classes = len(class_counts)
+    
+    # Weight = Total / (n_classes * count)
+    weights = total_samples / (n_classes * class_counts.float())
+    
+    # Handle if any class has 0 samples (unlikely but safe)
+    if torch.isinf(weights).any():
+        weights[torch.isinf(weights)] = 1.0
+        
+    print(f"Class Weights: {weights}")
+    
+    # 2. Init Model
+    model = DeepLOB(y_len=3)
+    criterion = nn.CrossEntropyLoss(weight=weights) # Weighted Loss
+    optimizer = optim.Adam(model.parameters(), lr=LR)
+
+    # 3. Training Loop
+    print("Starting DeepLOB Training...")
+    for epoch in range(EPOCHS):
+        model.train()
+        total_loss = 0
+        correct = 0
+        total = 0
+        
+        for batch_X, batch_y in train_loader:
+            optimizer.zero_grad()
+            outputs = model(batch_X)
+            loss = criterion(outputs, batch_y)
+            loss.backward()
+            optimizer.step()
+            
+            total_loss += loss.item()
+            _, predicted = torch.max(outputs.data, 1)
+            total += batch_y.size(0)
+            correct += (predicted == batch_y).sum().item()
+        
+        avg_loss = total_loss / len(train_loader)
+        accuracy = 100 * correct / total
+        
+        writer.add_scalar("Loss/Train", avg_loss, epoch)
+        writer.add_scalar("Accuracy/Train", accuracy, epoch)
+        
+        print(f"Epoch {epoch+1}/{EPOCHS} | Loss: {avg_loss:.4f} | Acc: {accuracy:.2f}%")
+            
+    # 4. Save ONNX
+    print("Exporting to ONNX...")
+    dummy_input = torch.randn(1, 2, T, 2*LEVELS) # 2 Channels, 2*Levels features
+    onnx_path = f"{MODEL_DIR}/deeplob_v1.onnx"
+    torch.onnx.export(
+        model, 
+        dummy_input, 
+        onnx_path,
+        input_names=['input'], 
+        output_names=['output'],
+        dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}}
+    )
+    print(f"Model Saved: {onnx_path}")
+    
+    writer.close()
+
+if __name__ == "__main__":
+    train()

train_ensemble.py

@@ -0,0 +1,106 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from huggingface_hub import snapshot_download
+import os
+import numpy as np
+import joblib
+from data_processor import AlphaDataProcessor
+from models.trm import TRM
+from models.classic_ml import get_hmm_pipeline, get_logistic_pipeline, get_rf_pipeline
+from torch.utils.tensorboard import SummaryWriter
+
+# Configuration
+REPO_ID = "gionuibk/hyperliquidL2Book-v2"  # Correct dataset repo
+DATA_DIR = "./data"
+MODEL_DIR = "./models"
+T = 60 # Seq len for TRM
+
+def train():
+    writer = SummaryWriter(log_dir="./ray_results/ensemble_experiment")
+    os.makedirs(MODEL_DIR, exist_ok=True)
+    
+    # 1. Prepare Data
+    print("Loading Ensemble Data...")
+    processor = AlphaDataProcessor(data_dir=DATA_DIR)
+    
+    # Check if data exists; download if needed (assuming train_deeplob or alpha already ran download, but safe to retry usually)
+    # We skip re-download to save time if folder exists.
+    if not os.path.exists(f"{DATA_DIR}/order_book_snapshot"):
+        print("Data missing, attempting download...")
+        snapshot_download(repo_id=REPO_ID, repo_type="dataset", local_dir=DATA_DIR, allow_patterns=["order_book_snapshot/*.parquet"])
+
+    # Get Tensors for TRM (Batch, T, 6) and Labels (Batch,)
+    # Input size increased to 6 due to OFI
+    X_trm, y_trm = processor.get_trm_tensors(coin="ETH", T=T)
+    print(f"TRM Data: {X_trm.shape}")
+    
+    # Compute Class Weights
+    class_counts = torch.bincount(y_trm)
+    total_samples = class_counts.sum()
+    n_classes = len(class_counts)
+    weights = total_samples / (n_classes * class_counts.float())
+    if torch.isinf(weights).any(): weights[torch.isinf(weights)] = 1.0
+    print(f"Class Weights: {weights}")
+    
+    # --- A. Train TRM (PyTorch) ---
+    print("--- Training TRM (Regime Detection) ---")
+    trm_model = TRM(input_size=6, num_classes=3) # input_size=6 (Vol, Imb, CVD, Spr, Mom, OFI)
+    criterion = nn.CrossEntropyLoss(weight=weights)
+    optimizer = optim.Adam(trm_model.parameters(), lr=0.001)
+    
+    dataset = torch.utils.data.TensorDataset(X_trm, y_trm)
+    loader = torch.utils.data.DataLoader(dataset, batch_size=64, shuffle=True)
+    
+    for epoch in range(10): # Quick train
+        trm_model.train()
+        total_loss = 0
+        for bX, by in loader:
+            optimizer.zero_grad()
+            out = trm_model(bX)
+            loss = criterion(out, by)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        print(f"TRM Epoch {epoch} | Loss: {total_loss/len(loader):.4f}")
+        
+    # Save TRM
+    dummy_input = torch.randn(1, T, 6)
+    torch.onnx.export(trm_model, dummy_input, f"{MODEL_DIR}/trm_v1.onnx", input_names=['input'], output_names=['output'])
+    print("TRM Saved.")
+    
+    # --- B. Train Classic ML (Sklearn) ---
+    print("--- Training Classic Models ---")
+    
+    # Flatten/Preprocess for Sklearn
+    # We use the last step features for simple classification
+    X_flat = X_trm[:, -1, :].numpy() # (N, 5)
+    y_flat = y_trm.numpy()
+    
+    # 1. HMM
+    print("Training HMM...")
+    hmm = get_hmm_pipeline(n_components=3)
+    hmm.fit(X_flat)
+    joblib.dump(hmm, f"{MODEL_DIR}/hmm_v1.joblib")
+    
+    # 2. Logistic
+    print("Training Logistic Regression...")
+    lr = get_logistic_pipeline()
+    lr.fit(X_flat, y_flat)
+    joblib.dump(lr, f"{MODEL_DIR}/logistic_v1.joblib")
+    
+    # 3. Random Forest (Trade Filter)
+    # We simulate Trade Filter labels (Win/Loss) using future return sign
+    # y=0 (Down) -> Sell Win? y=2 (Up) -> Buy Win?
+    # Let's simple binary target: 1 if Up, 0 if Down/Sideway
+    y_rf = (y_flat == 2).astype(int) 
+    print("Training Random Forest...")
+    rf = get_rf_pipeline()
+    rf.fit(X_flat, y_rf)
+    joblib.dump(rf, f"{MODEL_DIR}/rf_v1.joblib")
+    
+    print("All Ensemble Models Saved!")
+    writer.close()
+
+if __name__ == "__main__":
+    train()

train_remaining.py

@@ -0,0 +1,92 @@
+import torch
+import torch.optim as optim
+import os
+import numpy as np
+import time
+from models.execution_agent import PPOActorCritic
+from models.meta_controller import DQN
+from models.arbitrage_agent import ArbitrageAgent
+from models.risk_agent import RiskAgent
+from data_processor import AlphaDataProcessor
+from torch.utils.tensorboard import SummaryWriter
+
+# Configuration
+MODEL_DIR = "./models"
+os.makedirs(MODEL_DIR, exist_ok=True)
+
+def train():
+    writer = SummaryWriter(log_dir="./ray_results/agents_experiment")
+    print("Initializing Training for Specialist Agents...")
+    
+    # --- 1. Train Execution Agent (PPO) ---
+    print("\n--- Training Execution Agent (PPO) ---")
+    exec_agent = PPOActorCritic(input_dim=5, action_dim=3)
+    optimizer_exec = optim.Adam(exec_agent.parameters(), lr=0.0003)
+    
+    # Mock Training Loop (Simulating Environment Interaction)
+    for i in range(100):
+        # Fake State: [Signal, Imb, Spread, Position, Vol]
+        state = torch.randn(32, 5)
+        
+        # Forward
+        probs, mu_off, mu_sz, val = exec_agent(state)
+        
+        # Fake Loss (Standard PPO Loss would go here)
+        # We just minimize output to verify gradient flow
+        loss = probs.mean() + (mu_off - 0).pow(2).mean() + (val - 1).pow(2).mean()
+        
+        optimizer_exec.zero_grad()
+        loss.backward()
+        optimizer_exec.step()
+        
+        if i % 10 == 0:
+            print(f"Exec Iter {i} | Loss: {loss.item():.4f}")
+            writer.add_scalar("Execution/Loss", loss.item(), i)
+            
+    # Save ONNX
+    dummy = torch.randn(1, 5)
+    torch.onnx.export(exec_agent, dummy, f"{MODEL_DIR}/execution_agent_ppo.onnx", input_names=['input'], output_names=['type', 'offset', 'size', 'value'])
+    print("Execution Agent Saved.")
+
+    # --- 2. Train Meta-Controller (DQN) ---
+    print("\n--- Training Meta-Controller (DQN) ---")
+    meta_agent = DQN(input_dim=5, output_dim=3)
+    optimizer_meta = optim.Adam(meta_agent.parameters(), lr=0.001)
+    
+    criterion = torch.nn.MSELoss()
+    
+    for i in range(100):
+        # Fake State: [Vol, Regime(3), PnL] -> 5 Dim (Regime is OneHot)
+        state = torch.randn(32, 5)
+        target = torch.randn(32, 3) # Fake Q-Values
+        
+        out = meta_agent(state)
+        loss = criterion(out, target)
+        
+        optimizer_meta.zero_grad()
+        loss.backward()
+        optimizer_meta.step()
+        
+        if i % 10 == 0:
+            print(f"Meta Iter {i} | Loss: {loss.item():.4f}")
+            writer.add_scalar("Meta/Loss", loss.item(), i)
+            
+    # Save ONNX
+    dummy = torch.randn(1, 5)
+    torch.onnx.export(meta_agent, dummy, f"{MODEL_DIR}/meta_controller_dqn.onnx", input_names=['input'], output_names=['q_values'])
+    print("Meta-Controller Saved.")
+
+    # --- 3. Verify Rule-Based Agents ---
+    print("\n--- Verifying Rule-Based Agents ---")
+    arb = ArbitrageAgent()
+    risk = RiskAgent()
+    
+    # Test Logic
+    arb.analyze(spot_price=100, perp_price=101, funding_rate=0.01) # Should trigger Long
+    risk.check_health(equity=9000, initial_equity=10000, recent_pnl=-50) # Should be OK
+    
+    print("All Agents Ready!")
+    writer.close()
+
+if __name__ == "__main__":
+    train()

version.txt

@@ -0,0 +1 @@
+Deploy Full 9 Models Fix at Wed Dec 10 14:02:57 +07 2025