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

ins_pricing/modelling/plotting/importance.py

@@ -1,121 +1,121 @@
-from __future__ import annotations
-
-from typing import Mapping, Optional, Sequence, Tuple
-
-import numpy as np
-import pandas as pd
-
-from .common import PlotStyle, finalize_figure, plt
-
-
-def _to_series(
-    importance: Mapping[str, float]
-    | Sequence[Tuple[str, float]]
-    | pd.Series
-    | np.ndarray,
-    feature_names: Optional[Sequence[str]] = None,
-) -> pd.Series:
-    if isinstance(importance, pd.Series):
-        return importance.copy()
-    if isinstance(importance, Mapping):
-        return pd.Series(dict(importance))
-    if isinstance(importance, np.ndarray):
-        if feature_names is None:
-            raise ValueError("feature_names is required when importance is an array.")
-        return pd.Series(importance, index=list(feature_names))
-    return pd.Series(dict(importance))
-
-
-def shap_importance(
-    shap_values: np.ndarray,
-    feature_names: Sequence[str],
-) -> pd.Series:
-    if shap_values.ndim == 3:
-        shap_values = shap_values[0]
-    if shap_values.ndim != 2:
-        raise ValueError("shap_values should be 2d (n_samples, n_features).")
-    scores = np.abs(shap_values).mean(axis=0)
-    return pd.Series(scores, index=list(feature_names))
-
-
-def plot_feature_importance(
-    importance: Mapping[str, float]
-    | Sequence[Tuple[str, float]]
-    | pd.Series
-    | np.ndarray,
-    *,
-    feature_names: Optional[Sequence[str]] = None,
-    top_n: int = 30,
-    title: str = "Feature Importance",
-    sort_by: str = "abs",
-    descending: bool = True,
-    show_values: bool = False,
-    ax: Optional[plt.Axes] = None,
-    show: bool = False,
-    save_path: Optional[str] = None,
-    style: Optional[PlotStyle] = None,
-) -> plt.Figure:
-    style = style or PlotStyle()
-    series = _to_series(importance, feature_names=feature_names)
-    series = series.replace([np.inf, -np.inf], np.nan).dropna()
-
-    if sort_by not in {"abs", "value"}:
-        raise ValueError("sort_by must be 'abs' or 'value'.")
-    sort_key = series.abs() if sort_by == "abs" else series
-    series = series.loc[sort_key.sort_values(ascending=not descending).index]
-
-    if top_n > 0:
-        series = series.head(int(top_n))
-
-    created_fig = ax is None
-    if created_fig:
-        height = max(3.0, 0.3 * len(series))
-        fig, ax = plt.subplots(figsize=(style.figsize[0], height))
-    else:
-        fig = ax.figure
-
-    y_pos = np.arange(len(series))
-    ax.barh(y_pos, series.values, color=style.palette[0])
-    ax.set_yticks(y_pos)
-    ax.set_yticklabels(series.index, fontsize=style.tick_size)
-    ax.invert_yaxis()
-    ax.set_title(title, fontsize=style.title_size)
-    ax.tick_params(axis="x", labelsize=style.tick_size)
-    if style.grid:
-        ax.grid(True, axis="x", linestyle=style.grid_style, alpha=style.grid_alpha)
-
-    if show_values:
-        for idx, val in enumerate(series.values):
-            ax.text(val, idx, f" {val:.3f}", va="center", fontsize=style.tick_size)
-
-    if created_fig:
-        finalize_figure(fig, save_path=save_path, show=show, style=style)
-
-    return fig
-
-
-def plot_shap_importance(
-    shap_values: np.ndarray,
-    feature_names: Sequence[str],
-    *,
-    top_n: int = 30,
-    title: str = "SHAP Importance",
-    show_values: bool = False,
-    ax: Optional[plt.Axes] = None,
-    show: bool = False,
-    save_path: Optional[str] = None,
-    style: Optional[PlotStyle] = None,
-) -> plt.Figure:
-    series = shap_importance(shap_values, feature_names)
-    return plot_feature_importance(
-        series,
-        top_n=top_n,
-        title=title,
-        sort_by="abs",
-        descending=True,
-        show_values=show_values,
-        ax=ax,
-        show=show,
-        save_path=save_path,
-        style=style,
-    )
+from __future__ import annotations
+
+from typing import Mapping, Optional, Sequence, Tuple
+
+import numpy as np
+import pandas as pd
+
+from ins_pricing.modelling.plotting.common import PlotStyle, finalize_figure, plt
+
+
+def _to_series(
+    importance: Mapping[str, float]
+    | Sequence[Tuple[str, float]]
+    | pd.Series
+    | np.ndarray,
+    feature_names: Optional[Sequence[str]] = None,
+) -> pd.Series:
+    if isinstance(importance, pd.Series):
+        return importance.copy()
+    if isinstance(importance, Mapping):
+        return pd.Series(dict(importance))
+    if isinstance(importance, np.ndarray):
+        if feature_names is None:
+            raise ValueError("feature_names is required when importance is an array.")
+        return pd.Series(importance, index=list(feature_names))
+    return pd.Series(dict(importance))
+
+
+def shap_importance(
+    shap_values: np.ndarray,
+    feature_names: Sequence[str],
+) -> pd.Series:
+    if shap_values.ndim == 3:
+        shap_values = shap_values[0]
+    if shap_values.ndim != 2:
+        raise ValueError("shap_values should be 2d (n_samples, n_features).")
+    scores = np.abs(shap_values).mean(axis=0)
+    return pd.Series(scores, index=list(feature_names))
+
+
+def plot_feature_importance(
+    importance: Mapping[str, float]
+    | Sequence[Tuple[str, float]]
+    | pd.Series
+    | np.ndarray,
+    *,
+    feature_names: Optional[Sequence[str]] = None,
+    top_n: int = 30,
+    title: str = "Feature Importance",
+    sort_by: str = "abs",
+    descending: bool = True,
+    show_values: bool = False,
+    ax: Optional[plt.Axes] = None,
+    show: bool = False,
+    save_path: Optional[str] = None,
+    style: Optional[PlotStyle] = None,
+) -> plt.Figure:
+    style = style or PlotStyle()
+    series = _to_series(importance, feature_names=feature_names)
+    series = series.replace([np.inf, -np.inf], np.nan).dropna()
+
+    if sort_by not in {"abs", "value"}:
+        raise ValueError("sort_by must be 'abs' or 'value'.")
+    sort_key = series.abs() if sort_by == "abs" else series
+    series = series.loc[sort_key.sort_values(ascending=not descending).index]
+
+    if top_n > 0:
+        series = series.head(int(top_n))
+
+    created_fig = ax is None
+    if created_fig:
+        height = max(3.0, 0.3 * len(series))
+        fig, ax = plt.subplots(figsize=(style.figsize[0], height))
+    else:
+        fig = ax.figure
+
+    y_pos = np.arange(len(series))
+    ax.barh(y_pos, series.values, color=style.palette[0])
+    ax.set_yticks(y_pos)
+    ax.set_yticklabels(series.index, fontsize=style.tick_size)
+    ax.invert_yaxis()
+    ax.set_title(title, fontsize=style.title_size)
+    ax.tick_params(axis="x", labelsize=style.tick_size)
+    if style.grid:
+        ax.grid(True, axis="x", linestyle=style.grid_style, alpha=style.grid_alpha)
+
+    if show_values:
+        for idx, val in enumerate(series.values):
+            ax.text(val, idx, f" {val:.3f}", va="center", fontsize=style.tick_size)
+
+    if created_fig:
+        finalize_figure(fig, save_path=save_path, show=show, style=style)
+
+    return fig
+
+
+def plot_shap_importance(
+    shap_values: np.ndarray,
+    feature_names: Sequence[str],
+    *,
+    top_n: int = 30,
+    title: str = "SHAP Importance",
+    show_values: bool = False,
+    ax: Optional[plt.Axes] = None,
+    show: bool = False,
+    save_path: Optional[str] = None,
+    style: Optional[PlotStyle] = None,
+) -> plt.Figure:
+    series = shap_importance(shap_values, feature_names)
+    return plot_feature_importance(
+        series,
+        top_n=top_n,
+        title=title,
+        sort_by="abs",
+        descending=True,
+        show_values=show_values,
+        ax=ax,
+        show=show,
+        save_path=save_path,
+        style=style,
+    )

ins_pricing/pricing/__init__.py

@@ -1,27 +1,27 @@
-from __future__ import annotations
-
-from .calibration import apply_calibration, fit_calibration_factor
-from .data_quality import detect_leakage, profile_columns, validate_schema
-from .exposure import aggregate_policy_level, build_frequency_severity, compute_exposure
-from .factors import bin_numeric, build_factor_table
-from .monitoring import population_stability_index, psi_report
-from .rate_table import RateTable, apply_factor_tables, compute_base_rate, rate_premium
-
-__all__ = [
-    "apply_calibration",
-    "fit_calibration_factor",
-    "detect_leakage",
-    "profile_columns",
-    "validate_schema",
-    "aggregate_policy_level",
-    "build_frequency_severity",
-    "compute_exposure",
-    "bin_numeric",
-    "build_factor_table",
-    "population_stability_index",
-    "psi_report",
-    "RateTable",
-    "apply_factor_tables",
-    "compute_base_rate",
-    "rate_premium",
-]
+from __future__ import annotations
+
+from ins_pricing.pricing.calibration import apply_calibration, fit_calibration_factor
+from ins_pricing.pricing.data_quality import detect_leakage, profile_columns, validate_schema
+from ins_pricing.pricing.exposure import aggregate_policy_level, build_frequency_severity, compute_exposure
+from ins_pricing.pricing.factors import bin_numeric, build_factor_table
+from ins_pricing.pricing.monitoring import population_stability_index, psi_report
+from ins_pricing.pricing.rate_table import RateTable, apply_factor_tables, compute_base_rate, rate_premium
+
+__all__ = [
+    "apply_calibration",
+    "fit_calibration_factor",
+    "detect_leakage",
+    "profile_columns",
+    "validate_schema",
+    "aggregate_policy_level",
+    "build_frequency_severity",
+    "compute_exposure",
+    "bin_numeric",
+    "build_factor_table",
+    "population_stability_index",
+    "psi_report",
+    "RateTable",
+    "apply_factor_tables",
+    "compute_base_rate",
+    "rate_premium",
+]

ins_pricing/pricing/factors.py

@@ -1,43 +1,46 @@
 from __future__ import annotations
 
-from functools import lru_cache
+from collections import OrderedDict
+import hashlib
 from typing import Optional, Tuple
 
 import numpy as np
 import pandas as pd
 
 
-@lru_cache(maxsize=128)
-def _compute_bins_cached(
-    data_hash: int,
-    n_bins: int,
-    method: str,
-    min_val: float,
-    max_val: float,
-    n_unique: int
-) -> Tuple[tuple, int]:
-    """Cache bin edge computation based on data characteristics.
+_BIN_CACHE_MAXSIZE = 128
+_BIN_CACHE: "OrderedDict[tuple, np.ndarray]" = OrderedDict()
+_BIN_CACHE_HITS = 0
+_BIN_CACHE_MISSES = 0
 
-    Args:
-        data_hash: Hash of sorted unique values for cache key
-        n_bins: Number of bins to create
-        method: Binning method ('quantile' or 'uniform')
-        min_val: Minimum value in data
-        max_val: Maximum value in data
-        n_unique: Number of unique values
 
-    Returns:
-        Tuple of (bin_edges_tuple, actual_bins)
+def _cache_key(series: pd.Series, n_bins: int, method: str) -> Optional[tuple]:
+    try:
+        values = series.dropna().to_numpy(dtype=float, copy=False)
+        if values.size == 0:
+            return None
+        values = np.sort(values)
+        digest = hashlib.blake2b(values.tobytes(), digest_size=16).hexdigest()
+        return (digest, int(values.size), int(n_bins), str(method))
+    except Exception:
+        return None
+
+
+def _cache_get(key: tuple) -> Optional[np.ndarray]:
+    global _BIN_CACHE_HITS, _BIN_CACHE_MISSES
+    if key in _BIN_CACHE:
+        _BIN_CACHE_HITS += 1
+        _BIN_CACHE.move_to_end(key)
+        return _BIN_CACHE[key].copy()
+    _BIN_CACHE_MISSES += 1
+    return None
 
-    Note:
-        This function caches bin computation for identical data distributions.
-        The cache key includes data_hash to ensure correctness while enabling
-        reuse when the same column is binned multiple times.
-    """
-    # This function is called after validation, so we can safely compute
-    # The actual binning is done in the calling function
-    # This just provides a cache key mechanism
-    return (data_hash, n_bins, method, min_val, max_val, n_unique), n_bins
+
+def _cache_set(key: tuple, edges: np.ndarray) -> None:
+    _BIN_CACHE[key] = np.asarray(edges, dtype=float)
+    _BIN_CACHE.move_to_end(key)
+    if len(_BIN_CACHE) > _BIN_CACHE_MAXSIZE:
+        _BIN_CACHE.popitem(last=False)
 
 
 def bin_numeric(
@@ -66,34 +69,40 @@ def bin_numeric(
         When use_cache=True, identical distributions will reuse cached bin edges,
         improving performance when the same column is binned multiple times.
     """
-    # Create cache key from data characteristics if caching enabled
-    if use_cache:
-        # Compute data characteristics for cache key
-        unique_vals = series.dropna().unique()
-        unique_sorted = np.sort(unique_vals)
-        data_hash = hash(unique_sorted.tobytes())
-        min_val = float(series.min())
-        max_val = float(series.max())
-        n_unique = len(unique_vals)
-
-        # Check cache (the function call acts as cache lookup)
-        try:
-            _compute_bins_cached(data_hash, bins, method, min_val, max_val, n_unique)
-        except Exception:
-            # If hashing fails, proceed without cache
-            pass
+    cache_key = _cache_key(series, bins, method) if use_cache else None
+    bin_edges_full: Optional[np.ndarray] = None
+
+    if cache_key is not None:
+        bin_edges_full = _cache_get(cache_key)
+
+    if bin_edges_full is not None:
+        binned = pd.cut(series, bins=bin_edges_full, include_lowest=True, labels=labels)
+        return binned, np.asarray(bin_edges_full[:-1], dtype=float)
 
     # Perform actual binning
     if method == "quantile":
-        binned = pd.qcut(series, q=bins, duplicates="drop", labels=labels)
-        bin_edges = binned.cat.categories.left.to_numpy()
+        binned, bin_edges_full = pd.qcut(
+            series,
+            q=bins,
+            duplicates="drop",
+            labels=labels,
+            retbins=True,
+        )
     elif method == "uniform":
-        binned = pd.cut(series, bins=bins, include_lowest=include_lowest, labels=labels)
-        bin_edges = binned.cat.categories.left.to_numpy()
+        binned, bin_edges_full = pd.cut(
+            series,
+            bins=bins,
+            include_lowest=include_lowest,
+            labels=labels,
+            retbins=True,
+        )
     else:
         raise ValueError("method must be one of: quantile, uniform.")
 
-    return binned, bin_edges
+    if cache_key is not None and bin_edges_full is not None:
+        _cache_set(cache_key, np.asarray(bin_edges_full, dtype=float))
+
+    return binned, np.asarray(bin_edges_full[:-1], dtype=float)
 
 
 def clear_binning_cache() -> None:
@@ -108,7 +117,10 @@ def clear_binning_cache() -> None:
         >>> # After processing many different columns
         >>> clear_binning_cache()
     """
-    _compute_bins_cached.cache_clear()
+    global _BIN_CACHE_HITS, _BIN_CACHE_MISSES
+    _BIN_CACHE.clear()
+    _BIN_CACHE_HITS = 0
+    _BIN_CACHE_MISSES = 0
 
 
 def get_cache_info() -> dict:
@@ -126,12 +138,11 @@ def get_cache_info() -> dict:
         >>> info = get_cache_info()
         >>> print(f"Cache hit rate: {info['hits'] / (info['hits'] + info['misses']):.2%}")
     """
-    cache_info = _compute_bins_cached.cache_info()
     return {
-        'hits': cache_info.hits,
-        'misses': cache_info.misses,
-        'maxsize': cache_info.maxsize,
-        'currsize': cache_info.currsize
+        "hits": _BIN_CACHE_HITS,
+        "misses": _BIN_CACHE_MISSES,
+        "maxsize": _BIN_CACHE_MAXSIZE,
+        "currsize": len(_BIN_CACHE),
     }
 
 

ins_pricing/production/__init__.py

@@ -1,35 +1,45 @@
-from __future__ import annotations
-
-from .drift import psi_report
-from .monitoring import (
-    classification_metrics,
-    group_metrics,
-    loss_ratio,
-    metrics_report,
-    regression_metrics,
-)
-from .scoring import batch_score
-from .preprocess import apply_preprocess_artifacts, load_preprocess_artifacts, prepare_raw_features
-from .predict import (
+from __future__ import annotations
+
+from ins_pricing.production.drift import psi_report
+from ins_pricing.production.monitoring import (
+    classification_metrics,
+    group_metrics,
+    loss_ratio,
+    metrics_report,
+    regression_metrics,
+)
+from ins_pricing.production.scoring import batch_score
+from ins_pricing.production.preprocess import apply_preprocess_artifacts, load_preprocess_artifacts, prepare_raw_features
+from ins_pricing.production.inference import (
+    Predictor,
+    ModelSpec,
+    PredictorRegistry,
+    register_model_loader,
+    load_predictor,
     SavedModelPredictor,
     load_best_params,
     load_predictor_from_config,
     load_saved_model,
     predict_from_config,
 )
-
-__all__ = [
-    "psi_report",
-    "classification_metrics",
-    "group_metrics",
-    "loss_ratio",
-    "metrics_report",
-    "regression_metrics",
-    "batch_score",
-    "apply_preprocess_artifacts",
-    "load_preprocess_artifacts",
-    "prepare_raw_features",
+
+__all__ = [
+    "psi_report",
+    "classification_metrics",
+    "group_metrics",
+    "loss_ratio",
+    "metrics_report",
+    "regression_metrics",
+    "batch_score",
+    "apply_preprocess_artifacts",
+    "load_preprocess_artifacts",
+    "prepare_raw_features",
     "SavedModelPredictor",
+    "Predictor",
+    "ModelSpec",
+    "PredictorRegistry",
+    "register_model_loader",
+    "load_predictor",
     "load_best_params",
     "load_predictor_from_config",
     "load_saved_model",