ins-pricing 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

ins_pricing/modelling/core/bayesopt/trainers/trainer_glm.py

@@ -6,10 +6,11 @@ import numpy as np
 import optuna
 import pandas as pd
 import statsmodels.api as sm
-from sklearn.metrics import log_loss, mean_tweedie_deviance
+from sklearn.metrics import log_loss
 
 from .trainer_base import TrainerBase
 from ..utils import EPS
+from ..utils.losses import regression_loss
 
 class GLMTrainer(TrainerBase):
     def __init__(self, context: "BayesOptModel") -> None:
@@ -19,10 +20,13 @@ class GLMTrainer(TrainerBase):
     def _select_family(self, tweedie_power: Optional[float] = None):
         if self.ctx.task_type == 'classification':
             return sm.families.Binomial()
-        if self.ctx.obj == 'count:poisson':
+        loss_name = getattr(self.ctx, "loss_name", "tweedie")
+        if loss_name == "poisson":
             return sm.families.Poisson()
-        if self.ctx.obj == 'reg:gamma':
+        if loss_name == "gamma":
             return sm.families.Gamma()
+        if loss_name in {"mse", "mae"}:
+            return sm.families.Gaussian()
         power = tweedie_power if tweedie_power is not None else 1.5
         return sm.families.Tweedie(var_power=power, link=sm.families.links.log())
 
@@ -45,7 +49,8 @@ class GLMTrainer(TrainerBase):
             "alpha": lambda t: t.suggest_float('alpha', 1e-6, 1e2, log=True),
             "l1_ratio": lambda t: t.suggest_float('l1_ratio', 0.0, 1.0)
         }
-        if self.ctx.task_type == 'regression' and self.ctx.obj == 'reg:tweedie':
+        loss_name = getattr(self.ctx, "loss_name", "tweedie")
+        if self.ctx.task_type == 'regression' and loss_name == 'tweedie':
             param_space["tweedie_power"] = lambda t: t.suggest_float(
                 'tweedie_power', 1.0, 2.0)
 
@@ -87,13 +92,12 @@ class GLMTrainer(TrainerBase):
             if self.ctx.task_type == 'classification':
                 y_pred_clipped = np.clip(y_pred, EPS, 1 - EPS)
                 return log_loss(y_true, y_pred_clipped, sample_weight=weight)
-            y_pred_safe = np.maximum(y_pred, EPS)
-            return mean_tweedie_deviance(
+            return regression_loss(
                 y_true,
-                y_pred_safe,
-                sample_weight=weight,
-                power=self._metric_power(
-                    metric_ctx.get("family"), metric_ctx.get("tweedie_power"))
+                y_pred,
+                weight,
+                loss_name=loss_name,
+                tweedie_power=metric_ctx.get("tweedie_power"),
             )
 
         return self.cross_val_generic(
@@ -192,4 +196,3 @@ class GLMTrainer(TrainerBase):
         preds_test = preds_test_sum / float(split_count)
         self._cache_predictions("glm", preds_train, preds_test)
 
-

ins_pricing/modelling/core/bayesopt/trainers/trainer_gnn.py

@@ -6,11 +6,12 @@ from typing import Any, Dict, List, Optional, Tuple
 import numpy as np
 import optuna
 import torch
-from sklearn.metrics import log_loss, mean_tweedie_deviance
+from sklearn.metrics import log_loss
 
 from .trainer_base import TrainerBase
 from ..models import GraphNeuralNetSklearn
 from ..utils import EPS
+from ..utils.losses import regression_loss
 from ins_pricing.utils import get_logger
 from ins_pricing.utils.torch_compat import torch_load
 
@@ -25,6 +26,15 @@ class GNNTrainer(TrainerBase):
     def _build_model(self, params: Optional[Dict[str, Any]] = None) -> GraphNeuralNetSklearn:
         params = params or {}
         base_tw_power = self.ctx.default_tweedie_power()
+        loss_name = getattr(self.ctx, "loss_name", "tweedie")
+        tw_power = params.get("tw_power")
+        if self.ctx.task_type == "regression":
+            if loss_name == "tweedie":
+                tw_power = base_tw_power if tw_power is None else float(tw_power)
+            elif loss_name in ("poisson", "gamma"):
+                tw_power = base_tw_power
+            else:
+                tw_power = None
         model = GraphNeuralNetSklearn(
             model_nme=f"{self.ctx.model_nme}_gnn",
             input_dim=len(self.ctx.var_nmes),
@@ -36,7 +46,7 @@ class GNNTrainer(TrainerBase):
             epochs=int(params.get("epochs", self.ctx.epochs)),
             patience=int(params.get("patience", 5)),
             task_type=self.ctx.task_type,
-            tweedie_power=float(params.get("tw_power", base_tw_power or 1.5)),
+            tweedie_power=tw_power,
             weight_decay=float(params.get("weight_decay", 0.0)),
             use_data_parallel=bool(self.ctx.config.use_gnn_data_parallel),
             use_ddp=bool(self.ctx.config.use_gnn_ddp),
@@ -47,11 +57,13 @@ class GNNTrainer(TrainerBase):
             knn_gpu_mem_ratio=float(self.ctx.config.gnn_knn_gpu_mem_ratio),
             knn_gpu_mem_overhead=float(
                 self.ctx.config.gnn_knn_gpu_mem_overhead),
+            loss_name=loss_name,
         )
         return model
 
     def cross_val(self, trial: optuna.trial.Trial) -> float:
         base_tw_power = self.ctx.default_tweedie_power()
+        loss_name = getattr(self.ctx, "loss_name", "tweedie")
         metric_ctx: Dict[str, Any] = {}
 
         def data_provider():
@@ -60,8 +72,16 @@ class GNNTrainer(TrainerBase):
             return data[self.ctx.var_nmes], data[self.ctx.resp_nme], data[self.ctx.weight_nme]
 
         def model_builder(params: Dict[str, Any]):
-            tw_power = params.get("tw_power", base_tw_power)
+            if loss_name == "tweedie":
+                tw_power = params.get("tw_power", base_tw_power)
+            elif loss_name in ("poisson", "gamma"):
+                tw_power = base_tw_power
+            else:
+                tw_power = None
             metric_ctx["tw_power"] = tw_power
+            if tw_power is None:
+                params = dict(params)
+                params.pop("tw_power", None)
             return self._build_model(params)
 
         def preprocess_fn(X_train, X_val):
@@ -85,13 +105,12 @@ class GNNTrainer(TrainerBase):
             if self.ctx.task_type == 'classification':
                 y_pred_clipped = np.clip(y_pred, EPS, 1 - EPS)
                 return log_loss(y_true, y_pred_clipped, sample_weight=weight)
-            y_pred_safe = np.maximum(y_pred, EPS)
-            power = metric_ctx.get("tw_power", base_tw_power or 1.5)
-            return mean_tweedie_deviance(
+            return regression_loss(
                 y_true,
-                y_pred_safe,
-                sample_weight=weight,
-                power=power,
+                y_pred,
+                weight,
+                loss_name=loss_name,
+                tweedie_power=metric_ctx.get("tw_power", base_tw_power),
             )
 
         # Keep GNN BO lightweight: sample during CV, use full data for final training.
@@ -106,7 +125,7 @@ class GNNTrainer(TrainerBase):
             "dropout": lambda t: t.suggest_float('dropout', 0.0, 0.3),
             "weight_decay": lambda t: t.suggest_float('weight_decay', 1e-6, 1e-2, log=True),
         }
-        if self.ctx.task_type == 'regression' and self.ctx.obj == 'reg:tweedie':
+        if self.ctx.task_type == 'regression' and loss_name == 'tweedie':
             param_space["tw_power"] = lambda t: t.suggest_float(
                 'tw_power', 1.0, 2.0)
 

ins_pricing/modelling/core/bayesopt/trainers/trainer_resn.py

@@ -6,10 +6,11 @@ from typing import Any, Dict, List, Optional, Tuple
 import numpy as np
 import optuna
 import torch
-from sklearn.metrics import log_loss, mean_tweedie_deviance
+from sklearn.metrics import log_loss
 
 from .trainer_base import TrainerBase
 from ..models import ResNetSklearn
+from ..utils.losses import regression_loss
 
 class ResNetTrainer(TrainerBase):
     def __init__(self, context: "BayesOptModel") -> None:
@@ -28,9 +29,16 @@ class ResNetTrainer(TrainerBase):
 
     def _build_model(self, params: Optional[Dict[str, Any]] = None) -> ResNetSklearn:
         params = params or {}
-        power = params.get("tw_power", self.ctx.default_tweedie_power())
-        if power is not None:
-            power = float(power)
+        loss_name = getattr(self.ctx, "loss_name", "tweedie")
+        power = params.get("tw_power")
+        if self.ctx.task_type == "regression":
+            base_tw = self.ctx.default_tweedie_power()
+            if loss_name == "tweedie":
+                power = base_tw if power is None else float(power)
+            elif loss_name in ("poisson", "gamma"):
+                power = base_tw
+            else:
+                power = None
         resn_weight_decay = float(
             params.get(
                 "weight_decay",
@@ -53,7 +61,8 @@ class ResNetTrainer(TrainerBase):
             stochastic_depth=float(params.get("stochastic_depth", 0.0)),
             weight_decay=resn_weight_decay,
             use_data_parallel=self.ctx.config.use_resn_data_parallel,
-            use_ddp=self.ctx.config.use_resn_ddp
+            use_ddp=self.ctx.config.use_resn_ddp,
+            loss_name=loss_name
         )
 
     # ========= Cross-validation (for BayesOpt) =========
@@ -64,6 +73,7 @@ class ResNetTrainer(TrainerBase):
         #   - Optionally sample part of training data during BayesOpt to reduce memory.
 
         base_tw_power = self.ctx.default_tweedie_power()
+        loss_name = getattr(self.ctx, "loss_name", "tweedie")
 
         def data_provider():
             data = self.ctx.train_oht_data if self.ctx.train_oht_data is not None else self.ctx.train_oht_scl_data
@@ -73,10 +83,16 @@ class ResNetTrainer(TrainerBase):
         metric_ctx: Dict[str, Any] = {}
 
         def model_builder(params):
-            power = params.get("tw_power", base_tw_power)
+            if loss_name == "tweedie":
+                power = params.get("tw_power", base_tw_power)
+            elif loss_name in ("poisson", "gamma"):
+                power = base_tw_power
+            else:
+                power = None
             metric_ctx["tw_power"] = power
             params_local = dict(params)
-            params_local["tw_power"] = power
+            if power is not None:
+                params_local["tw_power"] = power
             return self._build_model(params_local)
 
         def preprocess_fn(X_train, X_val):
@@ -94,11 +110,12 @@ class ResNetTrainer(TrainerBase):
 
         def metric_fn(y_true, y_pred, weight):
             if self.ctx.task_type == 'regression':
-                return mean_tweedie_deviance(
+                return regression_loss(
                     y_true,
                     y_pred,
-                    sample_weight=weight,
-                    power=metric_ctx.get("tw_power", base_tw_power)
+                    weight,
+                    loss_name=loss_name,
+                    tweedie_power=metric_ctx.get("tw_power", base_tw_power),
                 )
             return log_loss(y_true, y_pred, sample_weight=weight)
 
@@ -115,7 +132,7 @@ class ResNetTrainer(TrainerBase):
                 "residual_scale": lambda t: t.suggest_float('residual_scale', 0.05, 0.3, step=0.05),
                 "patience": lambda t: t.suggest_int('patience', 3, 12),
                 "stochastic_depth": lambda t: t.suggest_float('stochastic_depth', 0.0, 0.2, step=0.05),
-                **({"tw_power": lambda t: t.suggest_float('tw_power', 1.0, 2.0)} if self.ctx.task_type == 'regression' and self.ctx.obj == 'reg:tweedie' else {})
+                **({"tw_power": lambda t: t.suggest_float('tw_power', 1.0, 2.0)} if self.ctx.task_type == 'regression' and loss_name == 'tweedie' else {})
             },
             data_provider=data_provider,
             model_builder=model_builder,
@@ -263,4 +280,3 @@ class ResNetTrainer(TrainerBase):
             self.ctx.resn_best = self.model
         else:
             print(f"[ResNetTrainer.load] Model file not found: {path}")
-

ins_pricing/modelling/core/bayesopt/trainers/trainer_xgb.py

@@ -7,10 +7,11 @@ import numpy as np
 import optuna
 import torch
 import xgboost as xgb
-from sklearn.metrics import log_loss, mean_tweedie_deviance
+from sklearn.metrics import log_loss
 
 from .trainer_base import TrainerBase
 from ..utils import EPS
+from ..utils.losses import regression_loss
 
 _XGB_CUDA_CHECKED = False
 _XGB_HAS_CUDA = False
@@ -230,18 +231,17 @@ class XGBTrainer(TrainerBase):
             'reg_alpha': reg_alpha,
             'reg_lambda': reg_lambda
         }
+        loss_name = getattr(self.ctx, "loss_name", "tweedie")
         tweedie_variance_power = None
         if self.ctx.task_type != 'classification':
-            if self.ctx.obj == 'reg:tweedie':
+            if loss_name == "tweedie":
                 tweedie_variance_power = trial.suggest_float(
                     'tweedie_variance_power', 1, 2)
                 params['tweedie_variance_power'] = tweedie_variance_power
-            elif self.ctx.obj == 'count:poisson':
-                tweedie_variance_power = 1
-            elif self.ctx.obj == 'reg:gamma':
-                tweedie_variance_power = 2
-            else:
-                tweedie_variance_power = 1.5
+            elif loss_name == "poisson":
+                tweedie_variance_power = 1.0
+            elif loss_name == "gamma":
+                tweedie_variance_power = 2.0
         X_all = self.ctx.train_data[self.ctx.factor_nmes]
         y_all = self.ctx.train_data[self.ctx.resp_nme].values
         w_all = self.ctx.train_data[self.ctx.weight_nme].values
@@ -272,12 +272,12 @@ class XGBTrainer(TrainerBase):
                 loss = log_loss(y_val, y_pred, sample_weight=w_val)
             else:
                 y_pred = clf.predict(X_val)
-                y_pred_safe = np.maximum(y_pred, EPS)
-                loss = mean_tweedie_deviance(
+                loss = regression_loss(
                     y_val,
-                    y_pred_safe,
-                    sample_weight=w_val,
-                    power=tweedie_variance_power,
+                    y_pred,
+                    w_val,
+                    loss_name=loss_name,
+                    tweedie_power=tweedie_variance_power,
                 )
             losses.append(float(loss))
             self._clean_gpu()
@@ -345,4 +345,3 @@ class XGBTrainer(TrainerBase):
         )
         self.ctx.xgb_best = self.model
 
-

ins_pricing/modelling/core/bayesopt/utils/losses.py

@@ -0,0 +1,129 @@
+"""Loss selection and regression loss utilities."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import numpy as np
+
+from ....explain.metrics import (
+    gamma_deviance,
+    poisson_deviance,
+    tweedie_deviance,
+)
+
+LOSS_ALIASES = {
+    "poisson_deviance": "poisson",
+    "gamma_deviance": "gamma",
+    "tweedie_deviance": "tweedie",
+    "l2": "mse",
+    "l1": "mae",
+    "absolute": "mae",
+    "gaussian": "mse",
+    "normal": "mse",
+}
+
+REGRESSION_LOSSES = {"tweedie", "poisson", "gamma", "mse", "mae"}
+CLASSIFICATION_LOSSES = {"logloss", "bce"}
+
+
+def normalize_loss_name(loss_name: Optional[str], task_type: str) -> str:
+    """Normalize the loss name and validate against supported values."""
+    name = str(loss_name or "auto").strip().lower()
+    if not name or name == "auto":
+        return "auto"
+    name = LOSS_ALIASES.get(name, name)
+    if task_type == "classification":
+        if name not in CLASSIFICATION_LOSSES:
+            raise ValueError(
+                f"Unsupported classification loss '{loss_name}'. "
+                f"Supported: {sorted(CLASSIFICATION_LOSSES)}"
+            )
+    else:
+        if name not in REGRESSION_LOSSES:
+            raise ValueError(
+                f"Unsupported regression loss '{loss_name}'. "
+                f"Supported: {sorted(REGRESSION_LOSSES)}"
+            )
+    return name
+
+
+def infer_loss_name_from_model_name(model_name: str) -> str:
+    """Preserve legacy heuristic for loss selection based on model name."""
+    name = str(model_name or "")
+    if "f" in name:
+        return "poisson"
+    if "s" in name:
+        return "gamma"
+    return "tweedie"
+
+
+def resolve_tweedie_power(loss_name: str, default: float = 1.5) -> Optional[float]:
+    """Resolve Tweedie power based on loss name."""
+    if loss_name == "poisson":
+        return 1.0
+    if loss_name == "gamma":
+        return 2.0
+    if loss_name == "tweedie":
+        return float(default)
+    return None
+
+
+def resolve_xgb_objective(loss_name: str) -> str:
+    """Map regression loss name to XGBoost objective."""
+    name = loss_name if loss_name != "auto" else "tweedie"
+    mapping = {
+        "tweedie": "reg:tweedie",
+        "poisson": "count:poisson",
+        "gamma": "reg:gamma",
+        "mse": "reg:squarederror",
+        "mae": "reg:absoluteerror",
+    }
+    return mapping.get(name, "reg:tweedie")
+
+
+def regression_loss(
+    y_true,
+    y_pred,
+    sample_weight=None,
+    *,
+    loss_name: str,
+    tweedie_power: Optional[float] = 1.5,
+    eps: float = 1e-8,
+) -> float:
+    """Compute weighted regression loss based on configured loss name."""
+    name = normalize_loss_name(loss_name, task_type="regression")
+    if name == "auto":
+        name = "tweedie"
+
+    y_t = np.asarray(y_true, dtype=float).reshape(-1)
+    y_p = np.asarray(y_pred, dtype=float).reshape(-1)
+    w = None if sample_weight is None else np.asarray(sample_weight, dtype=float).reshape(-1)
+
+    if name == "mse":
+        err = (y_t - y_p) ** 2
+        return _weighted_mean(err, w)
+    if name == "mae":
+        err = np.abs(y_t - y_p)
+        return _weighted_mean(err, w)
+    if name == "poisson":
+        return poisson_deviance(y_t, y_p, sample_weight=w, eps=eps)
+    if name == "gamma":
+        return gamma_deviance(y_t, y_p, sample_weight=w, eps=eps)
+
+    power = 1.5 if tweedie_power is None else float(tweedie_power)
+    return tweedie_deviance(y_t, y_p, sample_weight=w, power=power, eps=eps)
+
+
+def loss_requires_positive(loss_name: str) -> bool:
+    """Return True if the loss requires positive predictions."""
+    return loss_name in {"tweedie", "poisson", "gamma"}
+
+
+def _weighted_mean(values: np.ndarray, weight: Optional[np.ndarray]) -> float:
+    if weight is None:
+        return float(np.mean(values))
+    total = float(np.sum(weight))
+    if total <= 0:
+        return float(np.mean(values))
+    return float(np.sum(values * weight) / total)

ins_pricing/modelling/core/bayesopt/utils/metrics_and_devices.py

@@ -24,7 +24,7 @@ import pandas as pd
 import torch
 import torch.nn as nn
 from torch.nn.parallel import DistributedDataParallel as DDP
-from sklearn.metrics import log_loss, mean_tweedie_deviance
+from sklearn.metrics import log_loss, mean_absolute_error, mean_squared_error, mean_tweedie_deviance
 from sklearn.model_selection import KFold, GroupKFold, TimeSeriesSplit, StratifiedKFold
 
 # Try to import plotting dependencies
@@ -112,6 +112,7 @@ class MetricFactory:
         self,
         task_type: str = "regression",
         tweedie_power: float = 1.5,
+        loss_name: str = "tweedie",
         clip_min: float = 1e-8,
         clip_max: float = 1 - 1e-8,
     ):
@@ -120,11 +121,13 @@ class MetricFactory:
         Args:
             task_type: Either 'regression' or 'classification'
             tweedie_power: Power parameter for Tweedie deviance (1.0-2.0)
+            loss_name: Regression loss name ('tweedie', 'poisson', 'gamma', 'mse', 'mae')
             clip_min: Minimum value for clipping predictions
             clip_max: Maximum value for clipping predictions (for classification)
         """
         self.task_type = task_type
         self.tweedie_power = tweedie_power
+        self.loss_name = loss_name
         self.clip_min = clip_min
         self.clip_max = clip_max
 
@@ -151,13 +154,25 @@ class MetricFactory:
             y_pred_clipped = np.clip(y_pred, self.clip_min, self.clip_max)
             return float(log_loss(y_true, y_pred_clipped, sample_weight=sample_weight))
 
-        # Regression: use Tweedie deviance
+        loss_name = str(self.loss_name or "tweedie").strip().lower()
+        if loss_name in {"mse", "mae"}:
+            if loss_name == "mse":
+                return float(mean_squared_error(
+                    y_true, y_pred, sample_weight=sample_weight))
+            return float(mean_absolute_error(
+                y_true, y_pred, sample_weight=sample_weight))
+
         y_pred_safe = np.maximum(y_pred, self.clip_min)
+        power = self.tweedie_power
+        if loss_name == "poisson":
+            power = 1.0
+        elif loss_name == "gamma":
+            power = 2.0
         return float(mean_tweedie_deviance(
             y_true,
             y_pred_safe,
             sample_weight=sample_weight,
-            power=self.tweedie_power,
+            power=power,
         ))
 
     def update_power(self, power: float) -> None:

ins_pricing/modelling/core/bayesopt/utils/torch_trainer_mixin.py

@@ -52,6 +52,12 @@ except Exception:
 
 # Import from other utils modules
 from .constants import EPS, compute_batch_size, tweedie_loss, ensure_parent_dir
+from .losses import (
+    infer_loss_name_from_model_name,
+    loss_requires_positive,
+    normalize_loss_name,
+    resolve_tweedie_power,
+)
 from .distributed_utils import DistributedUtils
 
 
@@ -359,11 +365,26 @@ class TorchTrainerMixin:
         if task == 'classification':
             loss_fn = nn.BCEWithLogitsLoss(reduction='none')
             return loss_fn(y_pred, y_true).view(-1)
+        loss_name = normalize_loss_name(
+            getattr(self, "loss_name", None), task_type="regression"
+        )
+        if loss_name == "auto":
+            loss_name = infer_loss_name_from_model_name(getattr(self, "model_nme", ""))
         if apply_softplus:
             y_pred = F.softplus(y_pred)
-        y_pred = torch.clamp(y_pred, min=1e-6)
-        power = getattr(self, "tw_power", 1.5)
-        return tweedie_loss(y_pred, y_true, p=power).view(-1)
+        if loss_requires_positive(loss_name):
+            y_pred = torch.clamp(y_pred, min=1e-6)
+            power = resolve_tweedie_power(
+                loss_name, default=float(getattr(self, "tw_power", 1.5) or 1.5)
+            )
+            if power is None:
+                power = float(getattr(self, "tw_power", 1.5) or 1.5)
+            return tweedie_loss(y_pred, y_true, p=power).view(-1)
+        if loss_name == "mse":
+            return (y_pred - y_true).pow(2).view(-1)
+        if loss_name == "mae":
+            return (y_pred - y_true).abs().view(-1)
+        raise ValueError(f"Unsupported loss_name '{loss_name}' for regression.")
 
     def _compute_weighted_loss(self, y_pred, y_true, weights, apply_softplus: bool = False):
         """Compute weighted loss."""