Sync from GitHub (tests passed)

deep_learning/config.py

@@ -136,10 +136,12 @@ class ASROConfig:
 
 @dataclass(frozen=True)
 class WeeklyLossConfig:
-    lambda_weekly_quantile: float = 0.55
-    lambda_t1_quantile: float = 0.15
-    lambda_dispersion: float = 0.20
-    lambda_directional: float = 0.10
+    lambda_weekly_quantile: float = 0.70
+    lambda_t1_quantile: float = 0.20
+    lambda_dispersion: float = 0.35
+    lambda_magnitude: float = 0.50
+    lambda_naive: float = 0.50
+    lambda_directional: float = 0.00
 
 
 @dataclass(frozen=True)

deep_learning/models/monotonic_quantiles.py

@@ -4,11 +4,14 @@ import torch
 import torch.nn.functional as F
 
 
+DEFAULT_MONOTONIC_GAP_SCALE = 0.02
+
+
 def enforce_monotonic_quantiles(
     y_pred: torch.Tensor,
     median_idx: int = 3,
     min_gap: float = 1e-5,
-    gap_scale: float = 0.01,
+    gap_scale: float = DEFAULT_MONOTONIC_GAP_SCALE,
     init_bias: float = -3.0,
 ) -> torch.Tensor:
     """

deep_learning/models/tft_copper.py

@@ -21,6 +21,7 @@ import numpy as np
 from deep_learning.contract import RETURN_SPACE, log_to_simple_return
 from deep_learning.config import TFTASROConfig, get_tft_config
 from deep_learning.models.monotonic_quantiles import (
+    DEFAULT_MONOTONIC_GAP_SCALE,
     enforce_monotonic_quantiles,
     validate_monotonicity,
 )
@@ -136,10 +137,12 @@ try:
         def __init__(
             self,
             quantiles: list,
-            lambda_weekly_quantile: float = 0.55,
-            lambda_t1_quantile: float = 0.15,
-            lambda_dispersion: float = 0.20,
-            lambda_directional: float = 0.10,
+            lambda_weekly_quantile: float = 0.70,
+            lambda_t1_quantile: float = 0.20,
+            lambda_dispersion: float = 0.35,
+            lambda_directional: float = 0.00,
+            lambda_magnitude: float = 0.50,
+            lambda_naive: float = 0.50,
             sharpe_eps: float = 1e-8,
             debug_mode: bool = False,
         ):
@@ -148,6 +151,8 @@ try:
             self.lambda_t1_quantile = lambda_t1_quantile
             self.lambda_dispersion = lambda_dispersion
             self.lambda_directional = lambda_directional
+            self.lambda_magnitude = lambda_magnitude
+            self.lambda_naive = lambda_naive
             self.sharpe_eps = sharpe_eps
             self.debug_mode = debug_mode
             self.median_idx = len(quantiles) // 2
@@ -158,6 +163,8 @@ try:
                 "weekly_q": 0.0,
                 "t1_q": 0.0,
                 "dispersion": 0.0,
+                "magnitude": 0.0,
+                "naive": 0.0,
                 "directional": 0.0,
                 "total": 0.0,
             }
@@ -168,12 +175,16 @@ try:
             weekly_q_loss: torch.Tensor,
             t1_q_loss: torch.Tensor,
             dispersion_loss: torch.Tensor,
+            magnitude_loss: torch.Tensor,
+            naive_relative_loss: torch.Tensor,
             directional_loss: torch.Tensor,
             total_loss: torch.Tensor,
         ) -> None:
             self._component_sums["weekly_q"] += float(weekly_q_loss.detach().mean().cpu())
             self._component_sums["t1_q"] += float(t1_q_loss.detach().mean().cpu())
             self._component_sums["dispersion"] += float(dispersion_loss.detach().mean().cpu())
+            self._component_sums["magnitude"] += float(magnitude_loss.detach().mean().cpu())
+            self._component_sums["naive"] += float(naive_relative_loss.detach().mean().cpu())
             self._component_sums["directional"] += float(directional_loss.detach().mean().cpu())
             self._component_sums["total"] += float(total_loss.detach().mean().cpu())
             self._component_batches += 1
@@ -186,6 +197,8 @@ try:
                     "weekly_q_loss_mean": 0.0,
                     "t1_q_loss_mean": 0.0,
                     "dispersion_loss_mean": 0.0,
+                    "magnitude_loss_mean": 0.0,
+                    "naive_loss_mean": 0.0,
                     "directional_loss_mean": 0.0,
                     "total_loss_mean": 0.0,
                     "dominant_component": None,
@@ -195,6 +208,8 @@ try:
                 "weekly_q": self._component_sums["weekly_q"],
                 "t1_q": self._component_sums["t1_q"],
                 "dispersion": self._component_sums["dispersion"],
+                "magnitude": self._component_sums["magnitude"],
+                "naive": self._component_sums["naive"],
                 "directional": self._component_sums["directional"],
             }
             return {
@@ -202,6 +217,8 @@ try:
                 "weekly_q_loss_mean": self._component_sums["weekly_q"] / n_batches,
                 "t1_q_loss_mean": self._component_sums["t1_q"] / n_batches,
                 "dispersion_loss_mean": self._component_sums["dispersion"] / n_batches,
+                "magnitude_loss_mean": self._component_sums["magnitude"] / n_batches,
+                "naive_loss_mean": self._component_sums["naive"] / n_batches,
                 "directional_loss_mean": self._component_sums["directional"] / n_batches,
                 "total_loss_mean": self._component_sums["total"] / n_batches,
                 "dominant_component": max(components, key=components.get),
@@ -225,7 +242,7 @@ try:
                 y_pred,
                 median_idx=self.median_idx,
                 min_gap=1e-5,
-                gap_scale=0.01,
+                gap_scale=DEFAULT_MONOTONIC_GAP_SCALE,
                 init_bias=-3.0,
             )
             if self.debug_mode:
@@ -258,7 +275,11 @@ try:
             pred_abs_med = pred_weekly_median.abs().median() + eps
             actual_abs_med = actual_weekly.abs().median() + eps
             magnitude_loss = torch.abs(torch.log(pred_abs_med / actual_abs_med))
-            combined_calibration_loss = 0.5 * dispersion_loss + 0.5 * magnitude_loss
+
+            # Naive-zero baseline loss:
+            model_mae = torch.mean(torch.abs(pred_weekly_median - actual_weekly))
+            zero_mae = torch.mean(torch.abs(actual_weekly)) + eps
+            naive_relative_loss = torch.relu((model_mae / zero_mae) - 1.0)
 
             pred_direction = torch.tanh(median_path * 10.0)
             actual_direction = torch.sign(y_actual)
@@ -272,18 +293,25 @@ try:
 
             weekly_q_loss = _to_scalar(weekly_q_loss)
             t1_q_loss = _to_scalar(t1_q_loss)
-            combined_calibration_loss = _to_scalar(combined_calibration_loss)
+            magnitude_loss = _to_scalar(magnitude_loss)
+            naive_relative_loss = _to_scalar(naive_relative_loss)
             directional_loss = _to_scalar(directional_loss)
+
             total_loss = (
                 self.lambda_weekly_quantile * _to_scalar(weekly_q_loss)
                 + self.lambda_t1_quantile * _to_scalar(t1_q_loss)
-                + self.lambda_dispersion * _to_scalar(combined_calibration_loss)
+                + self.lambda_dispersion * _to_scalar(dispersion_loss)
+                + self.lambda_magnitude * _to_scalar(magnitude_loss)
+                + self.lambda_naive * _to_scalar(naive_relative_loss)
                 + self.lambda_directional * _to_scalar(directional_loss)
             )
+
             self._record_components(
                 weekly_q_loss,
                 t1_q_loss,
-                combined_calibration_loss,
+                dispersion_loss,
+                magnitude_loss,
+                naive_relative_loss,
                 directional_loss,
                 total_loss,
             )
@@ -324,14 +352,20 @@ def create_tft_model(
             lambda_weekly_quantile=cfg.weekly_loss.lambda_weekly_quantile,
             lambda_t1_quantile=cfg.weekly_loss.lambda_t1_quantile,
             lambda_dispersion=cfg.weekly_loss.lambda_dispersion,
+            lambda_magnitude=cfg.weekly_loss.lambda_magnitude,
+            lambda_naive=cfg.weekly_loss.lambda_naive,
             lambda_directional=cfg.weekly_loss.lambda_directional,
         )
         logger.info(
-            "Using weekly ASRO loss | weekly_q=%.2f t1_q=%.2f dispersion=%.2f dir=%.2f monotonic_transform=true",
+            "Using weekly ASRO loss | weekly_q=%.2f t1_q=%.2f dispersion=%.2f "
+            "magnitude=%.2f naive=%.2f dir=%.2f monotonic_transform=true gap_scale=%.3f",
             cfg.weekly_loss.lambda_weekly_quantile,
             cfg.weekly_loss.lambda_t1_quantile,
             cfg.weekly_loss.lambda_dispersion,
+            cfg.weekly_loss.lambda_magnitude,
+            cfg.weekly_loss.lambda_naive,
             cfg.weekly_loss.lambda_directional,
+            DEFAULT_MONOTONIC_GAP_SCALE,
         )
     elif use_asro and ASROPFLoss is not None:
         loss = ASROPFLoss(
@@ -513,7 +547,7 @@ def _format_prediction_legacy_simple_return(
         torch.as_tensor(raw_pred, dtype=torch.float64),
         median_idx=median_idx,
         min_gap=1e-5,
-        gap_scale=0.01,
+        gap_scale=DEFAULT_MONOTONIC_GAP_SCALE,
         init_bias=-3.0,
     )
     pred = ordered_tensor.detach().cpu().numpy()
@@ -674,7 +708,7 @@ def format_prediction(
         torch.as_tensor(raw_pred, dtype=torch.float64),
         median_idx=median_idx,
         min_gap=1e-5,
-        gap_scale=0.01,
+        gap_scale=DEFAULT_MONOTONIC_GAP_SCALE,
         init_bias=-3.0,
     )
     pred = ordered_tensor.detach().cpu().numpy()

deep_learning/training/callbacks.py

@@ -101,11 +101,14 @@ class WeeklyLossComponentLogger(pl.Callback):
         epoch = getattr(trainer, "current_epoch", 0)
         logger.info(
             "Weekly loss components | epoch=%s weekly_q=%.6f t1_q=%.6f "
-            "dispersion=%.6f directional=%.6f total=%.6f dominant=%s",
+            "dispersion=%.6f magnitude=%.6f naive=%.6f directional=%.6f "
+            "total=%.6f dominant=%s",
             epoch,
             stats["weekly_q_loss_mean"],
             stats["t1_q_loss_mean"],
             stats["dispersion_loss_mean"],
+            stats.get("magnitude_loss_mean", 0.0),
+            stats.get("naive_loss_mean", 0.0),
             stats["directional_loss_mean"],
             stats["total_loss_mean"],
             stats["dominant_component"],
@@ -115,7 +118,11 @@ class WeeklyLossComponentLogger(pl.Callback):
                 "Weekly dispersion loss is dominating weekly quantile loss; "
                 "lambda_dispersion may need to be reduced."
             )
-        if stats["directional_loss_mean"] < 0.05 * max(stats["total_loss_mean"], 1e-12):
+        lambda_directional = float(getattr(loss, "lambda_directional", 0.0))
+        directional_is_tiny = (
+            stats["directional_loss_mean"] < 0.05 * max(stats["total_loss_mean"], 1e-12)
+        )
+        if lambda_directional > 0.0 and directional_is_tiny:
             logger.warning(
                 "Weekly directional loss is below 5%% of total loss; "
                 "lambda_directional may need to increase."

deep_learning/training/hyperopt.py

@@ -66,10 +66,12 @@ 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.15,
-    "lambda_dispersion": 0.20,
-    "lambda_directional": 0.10,
+    "lambda_weekly_quantile": 0.70,
+    "lambda_t1_quantile": 0.20,
+    "lambda_dispersion": 0.35,
+    "lambda_magnitude": 0.50,
+    "lambda_naive": 0.50,
+    "lambda_directional": 0.00,
     "batch_size": 32,
 }
 
@@ -287,10 +289,12 @@ def create_trial_config(trial, base_cfg: TFTASROConfig) -> TFTASROConfig:
     )
 
     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.05, 0.20, step=0.05),
-        lambda_dispersion=trial.suggest_float("lambda_dispersion", 0.15, 0.35, step=0.05),
-        lambda_directional=trial.suggest_float("lambda_directional", 0.05, 0.12, step=0.01),
+        lambda_weekly_quantile=trial.suggest_float("lambda_weekly_quantile", 0.60, 0.80, step=0.05),
+        lambda_t1_quantile=trial.suggest_float("lambda_t1_quantile", 0.10, 0.25, step=0.05),
+        lambda_dispersion=trial.suggest_float("lambda_dispersion", 0.25, 0.45, step=0.05),
+        lambda_magnitude=trial.suggest_float("lambda_magnitude", 0.25, 0.75, step=0.05),
+        lambda_naive=trial.suggest_float("lambda_naive", 0.25, 0.75, step=0.05),
+        lambda_directional=trial.suggest_float("lambda_directional", 0.00, 0.08, step=0.02),
     )
 
     training_cfg = TrainingConfig(

deep_learning/training/metrics.py

@@ -15,7 +15,10 @@ import numpy as np
 import pandas as pd
 import torch
 
-from deep_learning.models.monotonic_quantiles import enforce_monotonic_quantiles
+from deep_learning.models.monotonic_quantiles import (
+    DEFAULT_MONOTONIC_GAP_SCALE,
+    enforce_monotonic_quantiles,
+)
 
 
 def select_prediction_horizon(values: np.ndarray, horizon_idx: int = 0) -> np.ndarray:
@@ -71,7 +74,7 @@ def monotonic_quantiles_np(
         tensor,
         median_idx=median_idx,
         min_gap=1e-5,
-        gap_scale=0.01,
+        gap_scale=DEFAULT_MONOTONIC_GAP_SCALE,
         init_bias=-3.0,
     )
     return ordered.detach().cpu().numpy()

deep_learning/training/trainer.py

@@ -57,10 +57,12 @@ KNOWN_GOOD_CONFIG = {
     "lambda_vol": 0.30,
     "lambda_quantile": 0.25,
     "lambda_madl": 0.40,
-    "lambda_weekly_quantile": 0.55,
-    "lambda_t1_quantile": 0.15,
-    "lambda_dispersion": 0.20,
-    "lambda_directional": 0.10,
+    "lambda_weekly_quantile": 0.70,
+    "lambda_t1_quantile": 0.20,
+    "lambda_dispersion": 0.35,
+    "lambda_magnitude": 0.50,
+    "lambda_naive": 0.50,
+    "lambda_directional": 0.00,
     "batch_size": 32,
 }
 
@@ -278,10 +280,13 @@ def train_tft_model(
             cfg.training.early_stopping_patience,
         )
         logger.info(
-            "Weekly loss   | weekly_q=%.2f t1_q=%.2f dispersion=%.2f directional=%.2f monotonic_transform=true",
+            "Weekly loss   | weekly_q=%.2f t1_q=%.2f dispersion=%.2f "
+            "magnitude=%.2f naive=%.2f directional=%.2f monotonic_transform=true",
             cfg.weekly_loss.lambda_weekly_quantile,
             cfg.weekly_loss.lambda_t1_quantile,
             cfg.weekly_loss.lambda_dispersion,
+            cfg.weekly_loss.lambda_magnitude,
+            cfg.weekly_loss.lambda_naive,
             cfg.weekly_loss.lambda_directional,
         )
     else:
@@ -440,8 +445,10 @@ def train_tft_model(
             "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_dispersion": cfg.weekly_loss.lambda_dispersion,
+            "lambda_magnitude": cfg.weekly_loss.lambda_magnitude,
+            "lambda_naive": cfg.weekly_loss.lambda_naive,
+            "lambda_directional": cfg.weekly_loss.lambda_directional,
             "monotonic_quantile_transform": True,
             "max_encoder_length": cfg.model.max_encoder_length,
             "max_prediction_length": cfg.model.max_prediction_length,
@@ -657,6 +664,10 @@ def _apply_optuna_results(cfg: TFTASROConfig) -> TFTASROConfig:
             params["lambda_directional"] = min(float(params["lambda_directional"]), 0.12)
         if "lambda_dispersion" in params:
             params["lambda_dispersion"] = max(float(params["lambda_dispersion"]), 0.20)
+        if "lambda_magnitude" in params:
+            params["lambda_magnitude"] = min(max(float(params["lambda_magnitude"]), 0.0), 0.80)
+        if "lambda_naive" in params:
+            params["lambda_naive"] = min(max(float(params["lambda_naive"]), 0.0), 0.80)
 
         logger.info(
             "Loaded Optuna best params (trial #%d, weekly_objective=%.4f): %s",
@@ -692,7 +703,7 @@ def _overlay_training_config(cfg: TFTASROConfig, params: dict) -> TFTASROConfig:
     weekly_loss_overrides = {
         k: params[k] for k in (
             "lambda_weekly_quantile", "lambda_t1_quantile", "lambda_directional",
-            "lambda_dispersion",
+            "lambda_dispersion", "lambda_magnitude", "lambda_naive",
         ) if k in params
     }