ins-pricing 0.4.5__py3-none-any.whl → 0.5.1__py3-none-any.whl

ins_pricing/modelling/{core/evaluation.py → evaluation.py}

@@ -1,107 +1,107 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Callable, Dict, Optional
-
-import numpy as np
-
-from ...production.monitoring import (
-    classification_metrics,
-    regression_metrics,
-)
-
-
-@dataclass
-class CalibrationResult:
-    method: str
-    calibrator: Any
-
-    def predict(self, scores: np.ndarray) -> np.ndarray:
-        if self.method == "sigmoid":
-            return self.calibrator.predict_proba(scores.reshape(-1, 1))[:, 1]
-        return self.calibrator.transform(scores)
-
-
-def select_threshold(
-    y_true: np.ndarray,
-    y_pred: np.ndarray,
-    *,
-    metric: str = "f1",
-    min_positive_rate: Optional[float] = None,
-    grid: int = 99,
-) -> Dict[str, float]:
-    y_true = np.asarray(y_true, dtype=float).reshape(-1)
-    y_pred = np.asarray(y_pred, dtype=float).reshape(-1)
-    thresholds = np.linspace(0.01, 0.99, max(2, int(grid)))
-    best = {"threshold": 0.5, "score": -1.0}
-    for thr in thresholds:
-        pred_label = (y_pred >= thr).astype(float)
-        pos_rate = float(np.mean(pred_label))
-        if min_positive_rate is not None and pos_rate < float(min_positive_rate):
-            continue
-        metrics = classification_metrics(y_true, y_pred, threshold=float(thr))
-        precision = metrics.get("precision", 0.0)
-        recall = metrics.get("recall", 0.0)
-        f1 = 0.0 if (precision + recall) == 0 else 2 * precision * recall / (precision + recall)
-        score = f1 if metric == "f1" else metrics.get(metric, f1)
-        if score > best["score"]:
-            best = {"threshold": float(thr), "score": float(score)}
-    return best
-
-
-def calibrate_predictions(
-    y_true: np.ndarray,
-    y_pred: np.ndarray,
-    *,
-    method: str = "sigmoid",
-) -> CalibrationResult:
-    from sklearn.isotonic import IsotonicRegression
-    from sklearn.linear_model import LogisticRegression
-
-    y_true = np.asarray(y_true, dtype=float).reshape(-1)
-    y_pred = np.asarray(y_pred, dtype=float).reshape(-1)
-    method = str(method or "sigmoid").strip().lower()
-    if method in {"platt", "sigmoid", "logistic"}:
-        model = LogisticRegression(max_iter=200)
-        model.fit(y_pred.reshape(-1, 1), y_true)
-        return CalibrationResult(method="sigmoid", calibrator=model)
-    if method in {"isotonic"}:
-        model = IsotonicRegression(out_of_bounds="clip")
-        model.fit(y_pred, y_true)
-        return CalibrationResult(method="isotonic", calibrator=model)
-    raise ValueError(f"Unsupported calibration method: {method}")
-
-
-def bootstrap_ci(
-    metric_fn: Callable[[np.ndarray, np.ndarray, Optional[np.ndarray]], float],
-    y_true: np.ndarray,
-    y_pred: np.ndarray,
-    *,
-    weight: Optional[np.ndarray] = None,
-    n_samples: int = 200,
-    ci: float = 0.95,
-    seed: Optional[int] = None,
-) -> Dict[str, float]:
-    rng = np.random.default_rng(seed)
-    y_true = np.asarray(y_true).reshape(-1)
-    y_pred = np.asarray(y_pred).reshape(-1)
-    if weight is not None:
-        weight = np.asarray(weight).reshape(-1)
-    n = len(y_true)
-    stats = []
-    for _ in range(max(1, int(n_samples))):
-        idx = rng.integers(0, n, size=n)
-        y_t = y_true[idx]
-        y_p = y_pred[idx]
-        w_t = weight[idx] if weight is not None else None
-        stats.append(float(metric_fn(y_t, y_p, w_t)))
-    stats = np.asarray(stats, dtype=float)
-    alpha = (1.0 - float(ci)) / 2.0
-    low = float(np.quantile(stats, alpha))
-    high = float(np.quantile(stats, 1.0 - alpha))
-    return {"mean": float(np.mean(stats)), "low": low, "high": high}
-
-
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Optional
+
+import numpy as np
+
+from ins_pricing.production.monitoring import (
+    classification_metrics,
+    regression_metrics,
+)
+
+
+@dataclass
+class CalibrationResult:
+    method: str
+    calibrator: Any
+
+    def predict(self, scores: np.ndarray) -> np.ndarray:
+        if self.method == "sigmoid":
+            return self.calibrator.predict_proba(scores.reshape(-1, 1))[:, 1]
+        return self.calibrator.transform(scores)
+
+
+def select_threshold(
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    *,
+    metric: str = "f1",
+    min_positive_rate: Optional[float] = None,
+    grid: int = 99,
+) -> Dict[str, float]:
+    y_true = np.asarray(y_true, dtype=float).reshape(-1)
+    y_pred = np.asarray(y_pred, dtype=float).reshape(-1)
+    thresholds = np.linspace(0.01, 0.99, max(2, int(grid)))
+    best = {"threshold": 0.5, "score": -1.0}
+    for thr in thresholds:
+        pred_label = (y_pred >= thr).astype(float)
+        pos_rate = float(np.mean(pred_label))
+        if min_positive_rate is not None and pos_rate < float(min_positive_rate):
+            continue
+        metrics = classification_metrics(y_true, y_pred, threshold=float(thr))
+        precision = metrics.get("precision", 0.0)
+        recall = metrics.get("recall", 0.0)
+        f1 = 0.0 if (precision + recall) == 0 else 2 * precision * recall / (precision + recall)
+        score = f1 if metric == "f1" else metrics.get(metric, f1)
+        if score > best["score"]:
+            best = {"threshold": float(thr), "score": float(score)}
+    return best
+
+
+def calibrate_predictions(
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    *,
+    method: str = "sigmoid",
+) -> CalibrationResult:
+    from sklearn.isotonic import IsotonicRegression
+    from sklearn.linear_model import LogisticRegression
+
+    y_true = np.asarray(y_true, dtype=float).reshape(-1)
+    y_pred = np.asarray(y_pred, dtype=float).reshape(-1)
+    method = str(method or "sigmoid").strip().lower()
+    if method in {"platt", "sigmoid", "logistic"}:
+        model = LogisticRegression(max_iter=200)
+        model.fit(y_pred.reshape(-1, 1), y_true)
+        return CalibrationResult(method="sigmoid", calibrator=model)
+    if method in {"isotonic"}:
+        model = IsotonicRegression(out_of_bounds="clip")
+        model.fit(y_pred, y_true)
+        return CalibrationResult(method="isotonic", calibrator=model)
+    raise ValueError(f"Unsupported calibration method: {method}")
+
+
+def bootstrap_ci(
+    metric_fn: Callable[[np.ndarray, np.ndarray, Optional[np.ndarray]], float],
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    *,
+    weight: Optional[np.ndarray] = None,
+    n_samples: int = 200,
+    ci: float = 0.95,
+    seed: Optional[int] = None,
+) -> Dict[str, float]:
+    rng = np.random.default_rng(seed)
+    y_true = np.asarray(y_true).reshape(-1)
+    y_pred = np.asarray(y_pred).reshape(-1)
+    if weight is not None:
+        weight = np.asarray(weight).reshape(-1)
+    n = len(y_true)
+    stats = []
+    for _ in range(max(1, int(n_samples))):
+        idx = rng.integers(0, n, size=n)
+        y_t = y_true[idx]
+        y_p = y_pred[idx]
+        w_t = weight[idx] if weight is not None else None
+        stats.append(float(metric_fn(y_t, y_p, w_t)))
+    stats = np.asarray(stats, dtype=float)
+    alpha = (1.0 - float(ci)) / 2.0
+    low = float(np.quantile(stats, alpha))
+    high = float(np.quantile(stats, 1.0 - alpha))
+    return {"mean": float(np.mean(stats)), "low": low, "high": high}
+
+
 def metrics_report(
     y_true: np.ndarray,
     y_pred: np.ndarray,
@@ -113,3 +113,12 @@ def metrics_report(
     if str(task_type) == "classification":
         return classification_metrics(y_true, y_pred, threshold=threshold)
     return regression_metrics(y_true, y_pred, weight=weight)
+
+
+__all__ = [
+    "CalibrationResult",
+    "select_threshold",
+    "calibrate_predictions",
+    "bootstrap_ci",
+    "metrics_report",
+]

ins_pricing/modelling/explain/__init__.py

@@ -1,55 +1,55 @@
-from __future__ import annotations
-
-from .gradients import (
-    ft_integrated_gradients,
-    gradient_x_input_torch,
-    integrated_gradients_multi_input_torch,
-    integrated_gradients_torch,
-    resnet_integrated_gradients,
-    summarize_attributions,
-)
-from .metrics import (
-    auc_score,
-    logloss,
-    mae,
-    mape,
-    gamma_deviance,
-    poisson_deviance,
-    r2_score,
-    rmse,
-    tweedie_deviance,
-    resolve_metric,
-)
-from .permutation import permutation_importance
-from .shap_utils import (
-    compute_shap_core,
-    compute_shap_ft,
-    compute_shap_glm,
-    compute_shap_resn,
-    compute_shap_xgb,
-)
-
-__all__ = [
-    "auc_score",
-    "logloss",
-    "mae",
-    "mape",
-    "gamma_deviance",
-    "poisson_deviance",
-    "tweedie_deviance",
-    "r2_score",
-    "rmse",
-    "resolve_metric",
-    "permutation_importance",
-    "gradient_x_input_torch",
-    "integrated_gradients_torch",
-    "integrated_gradients_multi_input_torch",
-    "summarize_attributions",
-    "resnet_integrated_gradients",
-    "ft_integrated_gradients",
-    "compute_shap_core",
-    "compute_shap_glm",
-    "compute_shap_xgb",
-    "compute_shap_resn",
-    "compute_shap_ft",
-]
+from __future__ import annotations
+
+from ins_pricing.modelling.explain.gradients import (
+    ft_integrated_gradients,
+    gradient_x_input_torch,
+    integrated_gradients_multi_input_torch,
+    integrated_gradients_torch,
+    resnet_integrated_gradients,
+    summarize_attributions,
+)
+from ins_pricing.modelling.explain.metrics import (
+    auc_score,
+    logloss,
+    mae,
+    mape,
+    gamma_deviance,
+    poisson_deviance,
+    r2_score,
+    rmse,
+    tweedie_deviance,
+    resolve_metric,
+)
+from ins_pricing.modelling.explain.permutation import permutation_importance
+from ins_pricing.modelling.explain.shap_utils import (
+    compute_shap_core,
+    compute_shap_ft,
+    compute_shap_glm,
+    compute_shap_resn,
+    compute_shap_xgb,
+)
+
+__all__ = [
+    "auc_score",
+    "logloss",
+    "mae",
+    "mape",
+    "gamma_deviance",
+    "poisson_deviance",
+    "tweedie_deviance",
+    "r2_score",
+    "rmse",
+    "resolve_metric",
+    "permutation_importance",
+    "gradient_x_input_torch",
+    "integrated_gradients_torch",
+    "integrated_gradients_multi_input_torch",
+    "summarize_attributions",
+    "resnet_integrated_gradients",
+    "ft_integrated_gradients",
+    "compute_shap_core",
+    "compute_shap_glm",
+    "compute_shap_xgb",
+    "compute_shap_resn",
+    "compute_shap_ft",
+]

ins_pricing/modelling/explain/metrics.py

@@ -1,176 +1,29 @@
-from __future__ import annotations
-
-from typing import Callable, Optional, Tuple
-
-import numpy as np
-
-try:
-    from sklearn.metrics import roc_auc_score
-except Exception:  # pragma: no cover
-    roc_auc_score = None
-
-
-def _to_numpy(arr) -> np.ndarray:
-    out = np.asarray(arr, dtype=float)
-    return out.reshape(-1)
-
-
-def _align(y_true, y_pred, sample_weight=None) -> Tuple[np.ndarray, np.ndarray, Optional[np.ndarray]]:
-    y_t = _to_numpy(y_true)
-    y_p = _to_numpy(y_pred)
-    if y_t.shape[0] != y_p.shape[0]:
-        raise ValueError("y_true and y_pred must have the same length.")
-    if sample_weight is None:
-        return y_t, y_p, None
-    w = _to_numpy(sample_weight)
-    if w.shape[0] != y_t.shape[0]:
-        raise ValueError("sample_weight must have the same length as y_true.")
-    return y_t, y_p, w
-
-
-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)
-
-
-def rmse(y_true, y_pred, sample_weight=None) -> float:
-    y_t, y_p, w = _align(y_true, y_pred, sample_weight)
-    err = (y_t - y_p) ** 2
-    return float(np.sqrt(_weighted_mean(err, w)))
-
-
-def mae(y_true, y_pred, sample_weight=None) -> float:
-    y_t, y_p, w = _align(y_true, y_pred, sample_weight)
-    err = np.abs(y_t - y_p)
-    return _weighted_mean(err, w)
-
-
-def mape(y_true, y_pred, sample_weight=None, eps: float = 1e-8) -> float:
-    y_t, y_p, w = _align(y_true, y_pred, sample_weight)
-    denom = np.maximum(np.abs(y_t), eps)
-    err = np.abs((y_t - y_p) / denom)
-    return _weighted_mean(err, w)
+"""Thin wrappers for shared metric utilities."""
 
+from __future__ import annotations
 
-def r2_score(y_true, y_pred, sample_weight=None) -> float:
-    y_t, y_p, w = _align(y_true, y_pred, sample_weight)
-    if w is None:
-        y_mean = float(np.mean(y_t))
-        sse = float(np.sum((y_t - y_p) ** 2))
-        sst = float(np.sum((y_t - y_mean) ** 2))
-    else:
-        w_sum = float(np.sum(w))
-        if w_sum <= 0:
-            y_mean = float(np.mean(y_t))
-        else:
-            y_mean = float(np.sum(w * y_t) / w_sum)
-        sse = float(np.sum(w * (y_t - y_p) ** 2))
-        sst = float(np.sum(w * (y_t - y_mean) ** 2))
-    if sst <= 0:
-        return 0.0
-    return 1.0 - sse / sst
-
-
-def logloss(y_true, y_pred, sample_weight=None, eps: float = 1e-8) -> float:
-    y_t, y_p, w = _align(y_true, y_pred, sample_weight)
-    p = np.clip(y_p, eps, 1 - eps)
-    loss = -(y_t * np.log(p) + (1 - y_t) * np.log(1 - p))
-    return _weighted_mean(loss, w)
-
-
-def tweedie_deviance(
-    y_true,
-    y_pred,
-    sample_weight=None,
-    *,
-    power: float = 1.5,
-    eps: float = 1e-8,
-) -> float:
-    """Tweedie deviance (power=1 -> Poisson, power=2 -> Gamma, power=0 -> Normal)."""
-    if power < 0:
-        raise ValueError("power must be >= 0.")
-    y_t, y_p, w = _align(y_true, y_pred, sample_weight)
-    y_p = np.clip(y_p, eps, None)
-    y_t_safe = np.clip(y_t, eps, None)
-
-    if power == 0:
-        dev = (y_t - y_p) ** 2
-    elif power == 1:
-        dev = 2 * (y_t_safe * np.log(y_t_safe / y_p) - (y_t_safe - y_p))
-    elif power == 2:
-        ratio = y_t_safe / y_p
-        dev = 2 * ((ratio - 1) - np.log(ratio))
-    else:
-        term1 = np.power(y_t_safe, 2 - power) / ((1 - power) * (2 - power))
-        term2 = y_t_safe * np.power(y_p, 1 - power) / (1 - power)
-        term3 = np.power(y_p, 2 - power) / (2 - power)
-        dev = 2 * (term1 - term2 + term3)
-    return _weighted_mean(dev, w)
-
-
-def poisson_deviance(y_true, y_pred, sample_weight=None, eps: float = 1e-8) -> float:
-    return tweedie_deviance(
-        y_true,
-        y_pred,
-        sample_weight=sample_weight,
-        power=1.0,
-        eps=eps,
-    )
-
-
-def gamma_deviance(y_true, y_pred, sample_weight=None, eps: float = 1e-8) -> float:
-    return tweedie_deviance(
-        y_true,
-        y_pred,
-        sample_weight=sample_weight,
-        power=2.0,
-        eps=eps,
-    )
-
-
-def auc_score(y_true, y_pred, sample_weight=None) -> float:
-    if roc_auc_score is None:
-        raise RuntimeError("auc requires scikit-learn.")
-    y_t, y_p, w = _align(y_true, y_pred, sample_weight)
-    return float(roc_auc_score(y_t, y_p, sample_weight=w))
-
-
-def resolve_metric(
-    metric: str | Callable,
-    *,
-    task_type: Optional[str] = None,
-    higher_is_better: Optional[bool] = None,
-) -> Tuple[Callable, bool, str]:
-    if callable(metric):
-        if higher_is_better is None:
-            raise ValueError("higher_is_better must be provided for custom metric.")
-        return metric, bool(higher_is_better), getattr(metric, "__name__", "custom")
-
-    name = str(metric or "auto").lower()
-    if name == "auto":
-        if task_type == "classification":
-            name = "logloss"
-        else:
-            name = "rmse"
-
-    mapping = {
-        "rmse": (rmse, False),
-        "mae": (mae, False),
-        "mape": (mape, False),
-        "r2": (r2_score, True),
-        "logloss": (logloss, False),
-        "poisson": (poisson_deviance, False),
-        "gamma": (gamma_deviance, False),
-        "tweedie": (tweedie_deviance, False),
-        "auc": (auc_score, True),
-    }
-    if name not in mapping:
-        raise ValueError(f"Unsupported metric: {metric}")
-    fn, hib = mapping[name]
-    if higher_is_better is not None:
-        hib = bool(higher_is_better)
-    return fn, hib, name
+from ins_pricing.utils.metrics import (
+    auc_score,
+    gamma_deviance,
+    logloss,
+    mae,
+    mape,
+    poisson_deviance,
+    r2_score,
+    resolve_metric,
+    rmse,
+    tweedie_deviance,
+)
+
+__all__ = [
+    "rmse",
+    "mae",
+    "mape",
+    "r2_score",
+    "logloss",
+    "tweedie_deviance",
+    "poisson_deviance",
+    "gamma_deviance",
+    "auc_score",
+    "resolve_metric",
+]