Update Quasar_axrvi_ranker.py

Quasar_axrvi_ranker.py

@@ -176,7 +176,7 @@ class PortfolioRiskConfig:
     kelly_fraction:      float = 0.5
     max_portfolio_risk:  float = 0.02
     drawdown_halt_pct:   float = 0.10
-    halt_duration_secs:  float = 180.0   # 3-minute automatic cooldown
+    halt_duration_secs:  float = 5.0   # 3-minute automatic cooldown
     drawdown_reduce_pct: float = 0.05
     cvar_floor:          float = -0.02
     min_notional:        float = 1.0
@@ -1744,6 +1744,13 @@ class AXRVINet(nn.Module):
         mean_quantiles = torch.stack(mc_quantiles, dim=0).mean(dim=0)
         mean_regime    = torch.stack(mc_regime,    dim=0).mean(dim=0)
 
+        # Recompute value and cvar_05 from mean quantiles so downstream
+        # Kelly sizing and optimal-stopping always have a proper value estimate.
+        mid   = mean_quantiles.shape[-1] // 2
+        n_tail = max(1, mean_quantiles.shape[-1] // 5)
+        mean_value  = mean_quantiles[..., mid].unsqueeze(-1)           # (1, N, 1)
+        mean_cvar05 = mean_quantiles[..., :n_tail].mean(dim=-1)        # (1, N)
+
         return {
             "significance_weight": mean_sig,
             "epistemic_variance":  epistemic_var,
@@ -1751,6 +1758,10 @@ class AXRVINet(nn.Module):
             "log_var":             mean_log_var.unsqueeze(-1),
             "quantiles":           mean_quantiles,
             "regime_probs":        mean_regime,
+            # Added: required by rank_and_gate for Kelly sizing [S1/S6] and
+            # optimal-stopping continuation value C_t [S8].
+            "value":               mean_value,
+            "cvar_05":             mean_cvar05,
         }
 
 
@@ -2728,12 +2739,28 @@ class PortfolioRiskManager:
         if current_price <= 0:
             return 0.0, "Invalid price"
 
-        # ── Layer 3: circuit breaker — DISABLED for training data collection ──
-        dd = self._current_drawdown()
+        # ── Layer 3: circuit breaker ──────────────────────────────────────────
+        dd  = self._current_drawdown()
+        now = time.time()
+
+        # Auto-expiring halt: set _halt_until when drawdown first breaches threshold.
         if dd >= self.cfg.drawdown_halt_pct:
-            logger.info(
-                f"[PortfolioRiskManager] ⚠️ Drawdown={dd:.1%} (circuit breaker disabled — training mode)"
-            )
+            if self._halt_until is None:
+                self._halt_until = now + self.cfg.halt_duration_secs
+                logger.warning(
+                    f"[PortfolioRiskManager] 🛑 Circuit breaker TRIGGERED "
+                    f"drawdown={dd:.1%} — halting for {self.cfg.halt_duration_secs:.0f}s"
+                )
+            if now < self._halt_until:
+                remaining = self._halt_until - now
+                return 0.0, (
+                    f"Drawdown halt active: dd={dd:.1%} ≥ halt={self.cfg.drawdown_halt_pct:.1%}. "
+                    f"Auto-resumes in {remaining:.0f}s"
+                )
+            else:
+                # Halt expired — reset so the breaker can re-trigger next time
+                self._halt_until = None
+                logger.info("[PortfolioRiskManager] ✅ Circuit breaker auto-resumed")
 
         # Drawdown reduce (halve sizes)
         dd_adj = 0.5 if dd >= self.cfg.drawdown_reduce_pct else 1.0
@@ -3526,12 +3553,11 @@ class QuasarAXRVIBridge:
             aleatoric_std_arr = np.full(len(active_ids), 0.1)
 
         # [S1] Extract value-head estimates (V̂_t = Ê[R_{t+τ} | F_t] proxy)
-        value_t = out.get("log_var")   # log_var shape: (1, N, 1) — use value instead
-        # Prefer the actual value head if available (non-MC path has it)
+        # "value" is now always present — MC path computes it from mean_quantiles.
         if "value" in out:
             v_arr = out["value"].squeeze(0).squeeze(-1).detach().numpy()
         else:
-            v_arr = significance_arr   # fallback: use significance as proxy
+            v_arr = significance_arr   # last-resort fallback
 
         significance_map: Dict[str, float] = {}
         epistemic_map:    Dict[str, float] = {}
@@ -3635,13 +3661,13 @@ class QuasarAXRVIBridge:
                 logger.debug(f"[{asset_id}] SKIP — hub_confidence=0.00")
                 continue
 
-            # Gate C — disabled for training data collection
-            # if sig_w < self.config.score_threshold:
-            #     logger.info(
-            #         f"[{asset_id}] SKIP — significance={sig_w:.3f} "
-            #         f"< threshold={self.config.score_threshold:.3f}"
-            #     )
-            #     continue
+            # Gate C — significance threshold
+            if sig_w < self.config.score_threshold:
+                logger.info(
+                    f"[{asset_id}] SKIP Gate C — significance={sig_w:.3f} "
+                    f"< threshold={self.config.score_threshold:.3f}"
+                )
+                continue
 
             # Gate D + E — DynamicExecutionGate (includes martingale null-hypothesis [S7])
             buf              = self.asset_buffers.get(asset_id)
@@ -3661,8 +3687,8 @@ class QuasarAXRVIBridge:
                 martingale_deviation = mart_dev_raw,   # [S7]
             )
             if not execute:
-                logger.info(f"[{asset_id}] Gate D/E warn (training mode): {reason}")
-                # continue  ← disabled for training data collection
+                logger.info(f"[{asset_id}] Gate D/E BLOCKED: {reason}")
+                continue
 
             logger.info(
                 f"[{asset_id}] EXECUTE {snap.dominant_signal} | "
@@ -3672,7 +3698,12 @@ class QuasarAXRVIBridge:
             await self.process_axrvi_signal(
                 asset          = asset_id,
                 action         = snap.dominant_signal,
-                value_estimate = value_map.get(asset_id, 0.001),
+                # Floor at 1e-4: an untrained distributional head can produce
+                # negative median quantiles; passing a negative value_estimate
+                # into Kelly sizing immediately triggers "No positive edge" and
+                # vetoes every trade.  The 1e-4 floor lets the system collect
+                # experience while the model is still learning. [S1/Kelly]
+                value_estimate = max(value_map.get(asset_id, 0.001), 1e-4),
                 realized_vol   = realized_vol,
                 significance   = sig_w,
                 cvar_05        = cvar_map.get(asset_id, 0.0),
@@ -4533,6 +4564,8 @@ async def run_live_trading_system(
     hub_ws_url:      str  = "ws://localhost:7860/ws/subscribe",
     enable_logging:  bool = True,
     shreve_config:   Optional[ShreveConfig] = None,
+    checkpoint_dir:  str  = "./Ranker",
+    resume:          bool = True,
 ) -> None:
     config = AssetRankerConfig(
         asset_symbols    = asset_symbols or list(ASSET_REGISTRY.keys()),
@@ -4546,6 +4579,8 @@ async def run_live_trading_system(
         reward_strategy = reward_strategy,
         hub_ws_url      = hub_ws_url,
         enable_logging  = enable_logging,
+        checkpoint_dir  = checkpoint_dir,
+        resume          = resume,
     )
     await bridge.run()