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

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."""

ins_pricing/production/predict.py

@@ -23,6 +23,11 @@ from .preprocess import (
 from .scoring import batch_score
 from ..modelling.core.bayesopt.models.model_gnn import GraphNeuralNetSklearn
 from ..modelling.core.bayesopt.models.model_resn import ResNetSklearn
+from ..modelling.core.bayesopt.utils.losses import (
+    infer_loss_name_from_model_name,
+    normalize_loss_name,
+    resolve_tweedie_power,
+)
 from ins_pricing.utils import DeviceManager, get_logger
 from ins_pricing.utils.torch_compat import torch_load
 
@@ -50,6 +55,15 @@ def _default_tweedie_power(model_name: str, task_type: str) -> Optional[float]:
     return 1.5
 
 
+def _resolve_loss_name(cfg: Dict[str, Any], model_name: str, task_type: str) -> str:
+    normalized = normalize_loss_name(cfg.get("loss_name"), task_type)
+    if task_type == "classification":
+        return "logloss" if normalized == "auto" else normalized
+    if normalized == "auto":
+        return infer_loss_name_from_model_name(model_name)
+    return normalized
+
+
 def _resolve_value(
     value: Any,
     *,
@@ -182,11 +196,14 @@ def _build_resn_model(
     task_type: str,
     epochs: int,
     resn_weight_decay: float,
+    loss_name: str,
     params: Dict[str, Any],
 ) -> ResNetSklearn:
-    power = params.get("tw_power", _default_tweedie_power(model_name, task_type))
-    if power is not None:
-        power = float(power)
+    if loss_name == "tweedie":
+        power = params.get("tw_power", _default_tweedie_power(model_name, task_type))
+        power = float(power) if power is not None else None
+    else:
+        power = resolve_tweedie_power(loss_name, default=1.5)
     weight_decay = float(params.get("weight_decay", resn_weight_decay))
     return ResNetSklearn(
         model_nme=model_name,
@@ -205,6 +222,7 @@ def _build_resn_model(
         weight_decay=weight_decay,
         use_data_parallel=False,
         use_ddp=False,
+        loss_name=loss_name,
     )
 
 
@@ -215,9 +233,15 @@ def _build_gnn_model(
     task_type: str,
     epochs: int,
     cfg: Dict[str, Any],
+    loss_name: str,
     params: Dict[str, Any],
 ) -> GraphNeuralNetSklearn:
     base_tw = _default_tweedie_power(model_name, task_type)
+    if loss_name == "tweedie":
+        tw_power = params.get("tw_power", base_tw)
+        tw_power = float(tw_power) if tw_power is not None else None
+    else:
+        tw_power = resolve_tweedie_power(loss_name, default=1.5)
     return GraphNeuralNetSklearn(
         model_nme=f"{model_name}_gnn",
         input_dim=input_dim,
@@ -229,7 +253,7 @@ def _build_gnn_model(
         epochs=int(params.get("epochs", epochs)),
         patience=int(params.get("patience", 5)),
         task_type=task_type,
-        tweedie_power=float(params.get("tw_power", base_tw or 1.5)),
+        tweedie_power=tw_power,
         weight_decay=float(params.get("weight_decay", 0.0)),
         use_data_parallel=False,
         use_ddp=False,
@@ -239,6 +263,7 @@ def _build_gnn_model(
         max_gpu_knn_nodes=cfg.get("gnn_max_gpu_knn_nodes"),
         knn_gpu_mem_ratio=cfg.get("gnn_knn_gpu_mem_ratio", 0.9),
         knn_gpu_mem_overhead=cfg.get("gnn_knn_gpu_mem_overhead", 2.0),
+        loss_name=loss_name,
     )
 
 
@@ -273,6 +298,9 @@ def load_saved_model(
                 from ..modelling.core.bayesopt.models.model_ft_components import FTTransformerCore
 
                 # Reconstruct model from config
+                resolved_loss = model_config.get("loss_name")
+                if not resolved_loss:
+                    resolved_loss = _resolve_loss_name(cfg, model_name, task_type)
                 model = FTTransformerSklearn(
                     model_nme=model_config.get("model_nme", ""),
                     num_cols=model_config.get("num_cols", []),
@@ -282,6 +310,7 @@ def load_saved_model(
                     n_layers=model_config.get("n_layers", 4),
                     dropout=model_config.get("dropout", 0.1),
                     task_type=model_config.get("task_type", "regression"),
+                    loss_name=resolved_loss,
                     tweedie_power=model_config.get("tw_power", 1.5),
                     num_numeric_tokens=model_config.get("num_numeric_tokens"),
                     use_data_parallel=False,
@@ -337,12 +366,14 @@ def load_saved_model(
             params = load_best_params(output_dir, model_name, model_key)
         if params is None:
             raise RuntimeError("Best params not found for resn")
+        loss_name = _resolve_loss_name(cfg, model_name, task_type)
         model = _build_resn_model(
             model_name=model_name,
             input_dim=input_dim,
             task_type=task_type,
             epochs=int(cfg.get("epochs", 50)),
             resn_weight_decay=float(cfg.get("resn_weight_decay", 1e-4)),
+            loss_name=loss_name,
             params=params,
         )
         model.resnet.load_state_dict(state_dict)
@@ -357,12 +388,14 @@ def load_saved_model(
             raise ValueError(f"Invalid GNN checkpoint: {model_path}")
         params = payload.get("best_params") or {}
         state_dict = payload.get("state_dict")
+        loss_name = _resolve_loss_name(cfg, model_name, task_type)
         model = _build_gnn_model(
             model_name=model_name,
             input_dim=input_dim,
             task_type=task_type,
             epochs=int(cfg.get("epochs", 50)),
             cfg=cfg,
+            loss_name=loss_name,
             params=params,
         )
         model.set_params(dict(params))
@@ -628,8 +661,4 @@ def predict_from_config(
     if output_path:
         output_path = Path(output_path)
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        if output_path.suffix.lower() in {".parquet", ".pq"}:
-            result.to_parquet(output_path, index=False)
-        else:
-            result.to_csv(output_path, index=False)
-    return result
+        if output_path.suffix.lower

ins_pricing/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="ins_pricing",
-    version="0.3.3",
+    version="0.3.4",
     description="Reusable modelling, pricing, governance, and reporting utilities.",
     author="meishi125478",
     license="Proprietary",

ins_pricing/utils/metrics.py

@@ -22,9 +22,16 @@ import numpy as np
 import pandas as pd
 
 try:
-    from sklearn.metrics import log_loss, mean_tweedie_deviance
+    from sklearn.metrics import (
+        log_loss,
+        mean_absolute_error,
+        mean_squared_error,
+        mean_tweedie_deviance,
+    )
 except ImportError:
     log_loss = None
+    mean_absolute_error = None
+    mean_squared_error = None
     mean_tweedie_deviance = None
 
 
@@ -198,6 +205,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,
     ):
@@ -206,11 +214,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
 
@@ -240,14 +250,28 @@ 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 mean_squared_error is None or mean_absolute_error is None:
+                raise ImportError("sklearn is required for metric computation")
+            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,
             )
         )