Sync from GitHub (tests passed)

app/quality_gate.py

@@ -51,6 +51,8 @@ def evaluate_quality_gate(
         reasons.append("Missing weekly_magnitude_ratio")
     elif weekly_magnitude_ratio < 0.65 or weekly_magnitude_ratio > 1.35:
         reasons.append(f"WeeklyMagnitudeRatio={weekly_magnitude_ratio:.4f} outside [0.65, 1.35]")
+        if weekly_magnitude_ratio > 3.0:
+            reasons.append(f"WeeklyMagnitudeExplosion={weekly_magnitude_ratio:.4f} > 3.0")
 
     if weekly_tail_capture_rate is None:
         reasons.append("Missing weekly_tail_capture_rate")

deep_learning/config.py

@@ -136,11 +136,13 @@ class ASROConfig:
 
 @dataclass(frozen=True)
 class WeeklyLossConfig:
-    lambda_weekly_quantile: float = 0.35
-    lambda_t1_quantile: float = 0.15
-    lambda_directional: float = 0.25
-    lambda_magnitude: float = 0.15
-    lambda_vol: float = 0.05
+    lambda_weekly_quantile: float = 0.55
+    lambda_t1_quantile: float = 0.10
+    lambda_directional: float = 0.15
+    lambda_magnitude: float = 0.35
+    lambda_vol: float = 0.15
+    lambda_crossing: float = 5.0
+    lambda_sanity: float = 0.10
 
 
 @dataclass(frozen=True)

deep_learning/models/tft_copper.py

@@ -131,13 +131,16 @@ try:
         def __init__(
             self,
             quantiles: list,
-            lambda_weekly_quantile: float = 0.35,
-            lambda_t1_quantile: float = 0.15,
-            lambda_directional: float = 0.25,
-            lambda_magnitude: float = 0.15,
-            lambda_vol: float = 0.05,
-            lambda_crossing: float = 1.0,
+            lambda_weekly_quantile: float = 0.55,
+            lambda_t1_quantile: float = 0.10,
+            lambda_directional: float = 0.15,
+            lambda_magnitude: float = 0.35,
+            lambda_vol: float = 0.15,
+            lambda_crossing: float = 5.0,
+            lambda_sanity: float = 0.10,
             sharpe_eps: float = 1e-6,
+            daily_log_return_bound: float = 0.08,
+            weekly_log_return_bound: float = 0.20,
         ):
             super().__init__(quantiles=quantiles)
             self.lambda_weekly_quantile = lambda_weekly_quantile
@@ -146,7 +149,10 @@ try:
             self.lambda_magnitude = lambda_magnitude
             self.lambda_vol = lambda_vol
             self.lambda_crossing = lambda_crossing
+            self.lambda_sanity = lambda_sanity
             self.sharpe_eps = sharpe_eps
+            self.daily_log_return_bound = daily_log_return_bound
+            self.weekly_log_return_bound = weekly_log_return_bound
             self.median_idx = len(quantiles) // 2
             q = list(quantiles)
             self._q10_idx = q.index(0.10) if 0.10 in q else 1
@@ -196,7 +202,17 @@ try:
             )
             target_spread = 2.0 * actual_weekly.std()
             vol_loss = torch.abs(weekly_spread.mean() - target_spread)
-            crossing_loss = quantile_crossing_penalty(y_pred)
+            daily_crossing_loss = quantile_crossing_penalty(y_pred)
+            weekly_crossing_loss = quantile_crossing_penalty(pred_weekly_quantiles.unsqueeze(1))
+            crossing_loss = daily_crossing_loss + weekly_crossing_loss
+
+            daily_bound_loss = torch.relu(
+                median_path.abs() - self.daily_log_return_bound
+            ).pow(2).mean()
+            weekly_bound_loss = torch.relu(
+                pred_weekly_median.abs() - self.weekly_log_return_bound
+            ).pow(2).mean()
+            sanity_loss = daily_bound_loss + weekly_bound_loss
 
             def _to_scalar(x: torch.Tensor) -> torch.Tensor:
                 # pytorch_forecasting metrics can return per-sample tensors;
@@ -211,6 +227,7 @@ try:
                 + self.lambda_magnitude * _to_scalar(magnitude_loss)
                 + self.lambda_vol * _to_scalar(vol_loss)
                 + self.lambda_crossing * _to_scalar(crossing_loss)
+                + self.lambda_sanity * _to_scalar(sanity_loss)
             )
 
 except ImportError:
@@ -250,16 +267,18 @@ def create_tft_model(
             lambda_directional=cfg.weekly_loss.lambda_directional,
             lambda_magnitude=cfg.weekly_loss.lambda_magnitude,
             lambda_vol=cfg.weekly_loss.lambda_vol,
-            lambda_crossing=cfg.asro.lambda_crossing,
+            lambda_crossing=cfg.weekly_loss.lambda_crossing,
+            lambda_sanity=cfg.weekly_loss.lambda_sanity,
         )
         logger.info(
-            "Using weekly ASRO loss | weekly_q=%.2f t1_q=%.2f dir=%.2f mag=%.2f vol=%.2f crossing=%.2f",
+            "Using weekly ASRO loss | weekly_q=%.2f t1_q=%.2f dir=%.2f mag=%.2f vol=%.2f crossing=%.2f sanity=%.2f",
             cfg.weekly_loss.lambda_weekly_quantile,
             cfg.weekly_loss.lambda_t1_quantile,
             cfg.weekly_loss.lambda_directional,
             cfg.weekly_loss.lambda_magnitude,
             cfg.weekly_loss.lambda_vol,
-            cfg.asro.lambda_crossing,
+            cfg.weekly_loss.lambda_crossing,
+            cfg.weekly_loss.lambda_sanity,
         )
     elif use_asro and ASROPFLoss is not None:
         loss = ASROPFLoss(

deep_learning/training/hyperopt.py

@@ -32,6 +32,7 @@ from deep_learning.config import (
     TFTASROConfig,
     TFTModelConfig,
     TrainingConfig,
+    WeeklyLossConfig,
     get_tft_config,
 )
 
@@ -53,6 +54,11 @@ KNOWN_GOOD_TRIAL_PARAMS = {
     "lambda_vol": 0.30,
     "lambda_quantile": 0.25,
     "lambda_madl": 0.40,
+    "lambda_weekly_quantile": 0.55,
+    "lambda_t1_quantile": 0.10,
+    "lambda_directional": 0.15,
+    "lambda_magnitude": 0.35,
+    "weekly_lambda_vol": 0.15,
     "batch_size": 32,
 }
 
@@ -121,6 +127,7 @@ def _build_prune_diagnostics(study) -> tuple[dict[str, int], list[dict]]:
         "median_prune": 0,
         "fold_sharpe_prune": 0,
         "weekly_magnitude_collapse": 0,
+        "weekly_magnitude_explosion": 0,
         "error": 0,
     }
     fold_diagnostics: list[dict] = []
@@ -242,6 +249,16 @@ def create_trial_config(trial, base_cfg: TFTASROConfig) -> TFTASROConfig:
         risk_free_rate=0.0,
     )
 
+    weekly_loss_cfg = WeeklyLossConfig(
+        lambda_weekly_quantile=trial.suggest_float("lambda_weekly_quantile", 0.45, 0.65, step=0.05),
+        lambda_t1_quantile=trial.suggest_float("lambda_t1_quantile", 0.10, 0.20, step=0.05),
+        lambda_directional=trial.suggest_float("lambda_directional", 0.10, 0.25, step=0.05),
+        lambda_magnitude=trial.suggest_float("lambda_magnitude", 0.25, 0.50, step=0.05),
+        lambda_vol=trial.suggest_float("weekly_lambda_vol", 0.10, 0.25, step=0.05),
+        lambda_crossing=base_cfg.weekly_loss.lambda_crossing,
+        lambda_sanity=base_cfg.weekly_loss.lambda_sanity,
+    )
+
     training_cfg = TrainingConfig(
         # CI budget: 3h limit @ CPU-only.
         # 15 trials × 3 folds × 25 epochs ≈ 108 min → leaves 70 min for final trainer.
@@ -270,7 +287,7 @@ def create_trial_config(trial, base_cfg: TFTASROConfig) -> TFTASROConfig:
         training=training_cfg,
         feature_store=base_cfg.feature_store,
         forecast=base_cfg.forecast,
-        weekly_loss=base_cfg.weekly_loss,
+        weekly_loss=weekly_loss_cfg,
     )
 
 
@@ -410,14 +427,16 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
                 pred_np = np.array(pred_tensor)
 
             median_idx = len(trial_cfg.model.quantiles) // 2
-            if pred_np.ndim == 3:
-                pred_t1 = pred_np[:, 0, :]
-                y_pred = pred_t1[:, median_idx]
-                fold_crossing_rate = quantile_crossing_rate(pred_t1)
-                _, fold_median_gap = quantile_median_sort_gap(pred_t1, median_idx)
-            else:
-                pred_t1 = None
-                y_pred = pred_np.flatten()
+            if pred_np.ndim != 3:
+                raise ValueError(f"Expected quantile prediction tensor [n,horizon,q], got {pred_np.shape}")
+            if pred_np.shape[1] < trial_cfg.forecast.primary_horizon_days:
+                raise ValueError(
+                    f"Prediction horizon too short: {pred_np.shape[1]} < {trial_cfg.forecast.primary_horizon_days}"
+                )
+            pred_t1 = pred_np[:, 0, :]
+            y_pred = pred_t1[:, median_idx]
+            fold_crossing_rate = quantile_crossing_rate(pred_t1)
+            _, fold_median_gap = quantile_median_sort_gap(pred_t1, median_idx)
 
             y_actual_parts = []
             for batch in fold_val_dl:
@@ -446,32 +465,32 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
             sr_std = float(strategy_returns.std()) + 1e-9
             fold_sharpe = sr_mean / sr_std
 
-            if pred_np.ndim == 3:
-                n_path = min(len(y_actual_path), len(pred_np))
-                weekly = compute_weekly_metrics(
-                    y_actual_path[:n_path],
-                    pred_np[:n_path],
-                    quantiles=trial_cfg.model.quantiles,
-                    horizon=trial_cfg.forecast.primary_horizon_days,
-                )
-                weekly_pinball = _weekly_pinball_loss(
-                    y_actual_path[:n_path],
-                    pred_np[:n_path],
-                    tuple(trial_cfg.model.quantiles),
-                    horizon=trial_cfg.forecast.primary_horizon_days,
-                )
-                fold_weekly_mr = float(weekly.get("weekly_magnitude_ratio", 1.0))
-                fold_weekly_objective = (
-                    0.35 * weekly_pinball
-                    + 0.20 * (1.0 - float(weekly.get("weekly_directional_accuracy", 0.5)))
-                    + 0.20 * abs(np.log(fold_weekly_mr + 1e-8))
-                    + 0.15 * max(0.0, abs(float(weekly.get("weekly_pi80_coverage", 0.0)) - 0.80) - 0.06)
-                    + 0.10 * float(weekly.get("weekly_quantile_crossing_rate", 0.0))
-                )
+            n_path = min(len(y_actual_path), len(pred_np))
+            weekly = compute_weekly_metrics(
+                y_actual_path[:n_path],
+                pred_np[:n_path],
+                quantiles=trial_cfg.model.quantiles,
+                horizon=trial_cfg.forecast.primary_horizon_days,
+            )
+            weekly_pinball = _weekly_pinball_loss(
+                y_actual_path[:n_path],
+                pred_np[:n_path],
+                tuple(trial_cfg.model.quantiles),
+                horizon=trial_cfg.forecast.primary_horizon_days,
+            )
+            fold_weekly_mr = float(weekly.get("weekly_magnitude_ratio", 1.0))
+            fold_weekly_objective = (
+                0.40 * weekly_pinball
+                + 0.15 * (1.0 - float(weekly.get("weekly_directional_accuracy", 0.5)))
+                + 0.35 * abs(np.log(fold_weekly_mr + 1e-8))
+                + 0.20 * max(0.0, abs(float(weekly.get("weekly_pi80_coverage", 0.0)) - 0.80) - 0.06)
+                + 0.20 * float(weekly.get("weekly_quantile_crossing_rate", 0.0))
+            )
         except Exception as exc:
-            logger.debug(
+            logger.warning(
                 "Trial %d fold %d metrics failed: %s", trial.number, fold_idx, exc
             )
+            return float("inf")
 
         fold_vr_list.append(fold_vr)
         fold_da_list.append(fold_da)
@@ -524,6 +543,14 @@ def _objective(trial, base_cfg: TFTASROConfig, master_data: tuple) -> float:
             trial.set_user_attr("prune_reason", "weekly_magnitude_collapse")
             raise optuna.exceptions.TrialPruned()
 
+        if fold_weekly_mr > 3.0 and fold_idx >= 1 and not protect_trial:
+            logger.warning(
+                "Trial %d PRUNED at fold %d: weekly_magnitude_ratio=%.4f > 3.0",
+                trial.number, fold_idx + 1, fold_weekly_mr,
+            )
+            trial.set_user_attr("prune_reason", "weekly_magnitude_explosion")
+            raise optuna.exceptions.TrialPruned()
+
         # Report running average so MedianPruner can kill bad trials early
         running_avg = float(np.mean(fold_scores))
         trial.report(running_avg, fold_idx)

deep_learning/training/trainer.py

@@ -250,6 +250,11 @@ def train_tft_model(
             cfg.weekly_loss.lambda_magnitude,
             cfg.weekly_loss.lambda_vol,
         )
+        logger.info(
+            "Weekly guards | crossing=%.2f sanity=%.2f",
+            cfg.weekly_loss.lambda_crossing,
+            cfg.weekly_loss.lambda_sanity,
+        )
     else:
         logger.info(
             "Training data  | samples=%d batch_size=%d batches/epoch=%d "
@@ -403,6 +408,13 @@ def train_tft_model(
             "lambda_quantile": cfg.asro.lambda_quantile,
             "lambda_madl": cfg.asro.lambda_madl,
             "lambda_crossing": cfg.asro.lambda_crossing,
+            "lambda_weekly_quantile": cfg.weekly_loss.lambda_weekly_quantile,
+            "lambda_t1_quantile": cfg.weekly_loss.lambda_t1_quantile,
+            "lambda_directional": cfg.weekly_loss.lambda_directional,
+            "lambda_magnitude": cfg.weekly_loss.lambda_magnitude,
+            "weekly_lambda_vol": cfg.weekly_loss.lambda_vol,
+            "weekly_lambda_crossing": cfg.weekly_loss.lambda_crossing,
+            "lambda_sanity": cfg.weekly_loss.lambda_sanity,
             "max_encoder_length": cfg.model.max_encoder_length,
             "max_prediction_length": cfg.model.max_prediction_length,
             "forecast_contract_version": FORECAST_CONTRACT_VERSION,
@@ -603,11 +615,24 @@ def _overlay_training_config(cfg: TFTASROConfig, params: dict) -> TFTASROConfig:
     training_overrides = {
         k: params[k] for k in ("batch_size",) if k in params
     }
+    weekly_loss_overrides = {
+        k: params[k] for k in (
+            "lambda_weekly_quantile", "lambda_t1_quantile", "lambda_directional",
+            "lambda_magnitude", "lambda_crossing", "lambda_sanity",
+        ) if k in params
+    }
+    if "weekly_lambda_vol" in params:
+        weekly_loss_overrides["lambda_vol"] = params["weekly_lambda_vol"]
 
     new_model = replace(cfg.model, **model_overrides) if model_overrides else cfg.model
     new_asro = replace(cfg.asro, **asro_overrides) if asro_overrides else cfg.asro
+    new_weekly_loss = (
+        replace(cfg.weekly_loss, **weekly_loss_overrides)
+        if weekly_loss_overrides
+        else cfg.weekly_loss
+    )
     new_training = replace(cfg.training, **training_overrides) if training_overrides else cfg.training
-    return replace(cfg, model=new_model, asro=new_asro, training=new_training)
+    return replace(cfg, model=new_model, asro=new_asro, weekly_loss=new_weekly_loss, training=new_training)
 
 
 def _persist_tft_metadata(symbol: str, result: dict) -> None: