ins-pricing 0.1.6__py3-none-any.whl

ins_pricing v2/pricing/rate_table.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+import numpy as np
+import pandas as pd
+
+
+def compute_base_rate(
+    df: pd.DataFrame,
+    *,
+    loss_col: str,
+    exposure_col: str,
+    weight_col: Optional[str] = None,
+) -> float:
+    """Compute base rate as loss / exposure."""
+    loss = df[loss_col].to_numpy(dtype=float, copy=False)
+    exposure = df[exposure_col].to_numpy(dtype=float, copy=False)
+    if weight_col and weight_col in df.columns:
+        weight = df[weight_col].to_numpy(dtype=float, copy=False)
+        loss = loss * weight
+        exposure = exposure * weight
+    total_exposure = float(np.sum(exposure))
+    if total_exposure <= 0:
+        return 0.0
+    return float(np.sum(loss) / total_exposure)
+
+
+def apply_factor_tables(
+    df: pd.DataFrame,
+    factor_tables: Dict[str, pd.DataFrame],
+    *,
+    default_relativity: float = 1.0,
+) -> np.ndarray:
+    """Apply factor relativities and return a multiplicative factor."""
+    multiplier = np.ones(len(df), dtype=float)
+    for factor, table in factor_tables.items():
+        if factor not in df.columns:
+            raise ValueError(f"Missing factor column: {factor}")
+        if "level" not in table.columns or "relativity" not in table.columns:
+            raise ValueError("Factor table must include 'level' and 'relativity'.")
+        mapping = table.set_index("level")["relativity"]
+        rel = df[factor].map(mapping).fillna(default_relativity).to_numpy(dtype=float)
+        multiplier *= rel
+    return multiplier
+
+
+def rate_premium(
+    df: pd.DataFrame,
+    *,
+    exposure_col: str,
+    base_rate: float,
+    factor_tables: Dict[str, pd.DataFrame],
+    default_relativity: float = 1.0,
+) -> np.ndarray:
+    """Compute premium using base rate and factor tables."""
+    exposure = df[exposure_col].to_numpy(dtype=float, copy=False)
+    factors = apply_factor_tables(
+        df, factor_tables, default_relativity=default_relativity
+    )
+    return exposure * float(base_rate) * factors
+
+
+@dataclass
+class RateTable:
+    base_rate: float
+    factor_tables: Dict[str, pd.DataFrame]
+    default_relativity: float = 1.0
+
+    def score(self, df: pd.DataFrame, *, exposure_col: str) -> np.ndarray:
+        return rate_premium(
+            df,
+            exposure_col=exposure_col,
+            base_rate=self.base_rate,
+            factor_tables=self.factor_tables,
+            default_relativity=self.default_relativity,
+        )

ins_pricing v2/production/__init__.py

@@ -0,0 +1,21 @@
+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
+
+__all__ = [
+    "psi_report",
+    "classification_metrics",
+    "group_metrics",
+    "loss_ratio",
+    "metrics_report",
+    "regression_metrics",
+    "batch_score",
+]

ins_pricing v2/production/drift.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Iterable, Optional
+
+import pandas as pd
+
+try:
+    from ins_pricing.pricing.monitoring import psi_report as _psi_report
+except Exception:  # pragma: no cover - optional import
+    _psi_report = None
+
+
+def psi_report(
+    expected_df: pd.DataFrame,
+    actual_df: pd.DataFrame,
+    *,
+    features: Optional[Iterable[str]] = None,
+    bins: int = 10,
+    strategy: str = "quantile",
+) -> pd.DataFrame:
+    """Population Stability Index report for drift monitoring."""
+    if _psi_report is None:
+        raise RuntimeError("psi_report requires ins_pricing.pricing.monitoring.")
+    return _psi_report(
+        expected_df,
+        actual_df,
+        features=features,
+        bins=bins,
+        strategy=strategy,
+    )

ins_pricing v2/production/monitoring.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from typing import Dict, Iterable, Optional
+
+import numpy as np
+import pandas as pd
+
+
+def _safe_div(numer: float, denom: float, default: float = 0.0) -> float:
+    if denom == 0:
+        return default
+    return numer / denom
+
+
+def regression_metrics(
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    *,
+    weight: Optional[np.ndarray] = None,
+) -> Dict[str, float]:
+    y_true = np.asarray(y_true, dtype=float).reshape(-1)
+    y_pred = np.asarray(y_pred, dtype=float).reshape(-1)
+    if weight is not None:
+        weight = np.asarray(weight, dtype=float).reshape(-1)
+        if weight.shape[0] != y_true.shape[0]:
+            raise ValueError("weight length must match y_true.")
+    err = y_true - y_pred
+    if weight is None:
+        mse = float(np.mean(err ** 2))
+        mae = float(np.mean(np.abs(err)))
+    else:
+        w_sum = float(np.sum(weight))
+        mse = float(np.sum(weight * (err ** 2)) / max(w_sum, 1.0))
+        mae = float(np.sum(weight * np.abs(err)) / max(w_sum, 1.0))
+    rmse = float(np.sqrt(mse))
+    denom = float(np.mean(y_true)) if np.mean(y_true) != 0 else 1.0
+    mape = float(np.mean(np.abs(err) / np.clip(np.abs(y_true), 1e-9, None)))
+    ss_tot = float(np.sum((y_true - np.mean(y_true)) ** 2))
+    ss_res = float(np.sum(err ** 2))
+    r2 = 1.0 - _safe_div(ss_res, ss_tot, default=0.0)
+    return {"rmse": rmse, "mae": mae, "mape": mape, "r2": r2}
+
+
+def loss_ratio(
+    actual_loss: np.ndarray,
+    predicted_premium: np.ndarray,
+    *,
+    weight: Optional[np.ndarray] = None,
+) -> float:
+    actual_loss = np.asarray(actual_loss, dtype=float).reshape(-1)
+    predicted_premium = np.asarray(predicted_premium, dtype=float).reshape(-1)
+    if weight is not None:
+        weight = np.asarray(weight, dtype=float).reshape(-1)
+        actual_loss = actual_loss * weight
+        predicted_premium = predicted_premium * weight
+    return _safe_div(float(np.sum(actual_loss)), float(np.sum(predicted_premium)), default=0.0)
+
+
+def classification_metrics(
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    *,
+    threshold: float = 0.5,
+) -> Dict[str, float]:
+    y_true = np.asarray(y_true, dtype=float).reshape(-1)
+    y_pred = np.asarray(y_pred, dtype=float).reshape(-1)
+    pred_label = (y_pred >= threshold).astype(float)
+    acc = float(np.mean(pred_label == y_true))
+    precision = _safe_div(float(np.sum((pred_label == 1) & (y_true == 1))),
+                          float(np.sum(pred_label == 1)), default=0.0)
+    recall = _safe_div(float(np.sum((pred_label == 1) & (y_true == 1))),
+                       float(np.sum(y_true == 1)), default=0.0)
+    return {"accuracy": acc, "precision": precision, "recall": recall}
+
+
+def metrics_report(
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    *,
+    task_type: str = "regression",
+    weight: Optional[np.ndarray] = None,
+) -> Dict[str, float]:
+    if task_type == "classification":
+        metrics = classification_metrics(y_true, y_pred)
+    else:
+        metrics = regression_metrics(y_true, y_pred, weight=weight)
+    return metrics
+
+
+def group_metrics(
+    df: pd.DataFrame,
+    *,
+    actual_col: str,
+    pred_col: str,
+    group_cols: Iterable[str],
+    weight_col: Optional[str] = None,
+) -> pd.DataFrame:
+    group_cols = list(group_cols)
+    work = df[group_cols].copy()
+    y_true = df[actual_col].to_numpy(dtype=float)
+    y_pred = df[pred_col].to_numpy(dtype=float)
+    err = y_true - y_pred
+    work["_y_true"] = y_true
+    work["_y_pred"] = y_pred
+    work["_err"] = err
+    work["_abs_err"] = np.abs(err)
+    work["_err_sq"] = err ** 2
+    work["_abs_ratio"] = work["_abs_err"] / np.clip(np.abs(work["_y_true"]), 1e-9, None)
+    work["_y_true_sq"] = work["_y_true"] ** 2
+
+    if weight_col:
+        w = df[weight_col].to_numpy(dtype=float)
+        work["_w"] = w
+        work["_w_err_sq"] = w * work["_err_sq"]
+        work["_w_abs_err"] = w * work["_abs_err"]
+
+    grouped = work.groupby(group_cols, dropna=False)
+    count = grouped["_y_true"].count().replace(0, 1.0)
+    sum_y = grouped["_y_true"].sum()
+    sum_y2 = grouped["_y_true_sq"].sum()
+    ss_tot = sum_y2 - (sum_y ** 2) / count
+    ss_tot = ss_tot.clip(lower=0.0)
+    ss_res = grouped["_err_sq"].sum()
+    r2 = 1.0 - (ss_res / ss_tot.replace(0.0, np.nan))
+    r2 = r2.fillna(0.0)
+
+    mape = grouped["_abs_ratio"].mean()
+    if weight_col:
+        sum_w = grouped["_w"].sum().replace(0, 1.0)
+        mse = grouped["_w_err_sq"].sum() / sum_w
+        mae = grouped["_w_abs_err"].sum() / sum_w
+    else:
+        mse = grouped["_err_sq"].sum() / count
+        mae = grouped["_abs_err"].sum() / count
+
+    rmse = np.sqrt(mse)
+    result = pd.DataFrame({
+        "rmse": rmse.astype(float),
+        "mae": mae.astype(float),
+        "mape": mape.astype(float),
+        "r2": r2.astype(float),
+    })
+    return result.reset_index()

ins_pricing v2/production/scoring.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable, Optional
+
+import numpy as np
+import pandas as pd
+
+
+def batch_score(
+    predict_fn: Callable[[pd.DataFrame], np.ndarray],
+    data: pd.DataFrame,
+    *,
+    output_col: str = "prediction",
+    batch_size: int = 10000,
+    output_path: Optional[str | Path] = None,
+    keep_input: bool = True,
+) -> pd.DataFrame:
+    """Batch scoring for large datasets."""
+    if batch_size <= 0:
+        raise ValueError("batch_size must be positive.")
+    n_rows = len(data)
+    prediction = np.empty(n_rows, dtype=float)
+    for start in range(0, n_rows, batch_size):
+        end = min(start + batch_size, n_rows)
+        chunk = data.iloc[start:end]
+        pred = np.asarray(predict_fn(chunk)).reshape(-1)
+        if pred.shape[0] != (end - start):
+            raise ValueError("predict_fn output length must match batch size.")
+        prediction[start:end] = pred
+    result = data.copy() if keep_input else pd.DataFrame(index=data.index)
+    result[output_col] = prediction
+    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

ins_pricing v2/reporting/__init__.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from .report_builder import ReportPayload, build_report, write_report
+from .scheduler import schedule_daily
+
+__all__ = [
+    "ReportPayload",
+    "build_report",
+    "write_report",
+    "schedule_daily",
+]

ins_pricing v2/reporting/report_builder.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional
+
+import pandas as pd
+
+
+def _df_to_markdown(df: pd.DataFrame, max_rows: int = 20) -> str:
+    if df is None or df.empty:
+        return "_(no data)_"
+    data = df.copy()
+    if len(data) > max_rows:
+        data = data.head(max_rows)
+    headers = list(data.columns)
+    rows = data.astype(str).values.tolist()
+    lines = []
+    lines.append("| " + " | ".join(headers) + " |")
+    lines.append("| " + " | ".join(["---"] * len(headers)) + " |")
+    for row in rows:
+        lines.append("| " + " | ".join(row) + " |")
+    return "\n".join(lines)
+
+
+@dataclass
+class ReportPayload:
+    model_name: str
+    model_version: str
+    metrics: Dict[str, float]
+    risk_trend: Optional[pd.DataFrame] = None
+    drift_report: Optional[pd.DataFrame] = None
+    validation_table: Optional[pd.DataFrame] = None
+    extra_notes: Optional[str] = None
+
+
+def build_report(payload: ReportPayload) -> str:
+    now = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC")
+    metrics_lines = [f"- {k}: {v:.6f}" for k, v in payload.metrics.items()]
+    metrics_block = "\n".join(metrics_lines) if metrics_lines else "_(no metrics)_"
+
+    report = [
+        f"# Model Report: {payload.model_name} ({payload.model_version})",
+        "",
+        f"Generated at: {now}",
+        "",
+        "## Model Validation",
+        metrics_block,
+    ]
+
+    if payload.validation_table is not None:
+        report.extend(["", "### Validation Details", _df_to_markdown(payload.validation_table)])
+
+    report.extend(["", "## Drift / Stability"])
+    report.append(_df_to_markdown(payload.drift_report))
+
+    report.extend(["", "## Risk Trend"])
+    report.append(_df_to_markdown(payload.risk_trend))
+
+    if payload.extra_notes:
+        report.extend(["", "## Notes", payload.extra_notes])
+
+    return "\n".join(report).strip() + "\n"
+
+
+def write_report(payload: ReportPayload, output_path: str | Path) -> Path:
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    content = build_report(payload)
+    output_path.write_text(content, encoding="utf-8")
+    return output_path

ins_pricing v2/reporting/scheduler.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import threading
+import time
+from datetime import datetime, timedelta
+from typing import Callable, Optional
+
+
+def _next_run(run_time: str, now: Optional[datetime] = None) -> datetime:
+    if now is None:
+        now = datetime.now()
+    hour, minute = [int(x) for x in run_time.split(":")]
+    candidate = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+    if candidate <= now:
+        candidate = candidate + timedelta(days=1)
+    return candidate
+
+
+def schedule_daily(
+    job_fn: Callable[[], None],
+    *,
+    run_time: str = "01:00",
+    stop_event: Optional[threading.Event] = None,
+) -> threading.Thread:
+    """Run job_fn daily at local time HH:MM in a background thread."""
+    if stop_event is None:
+        stop_event = threading.Event()
+
+    def _loop():
+        while not stop_event.is_set():
+            next_time = _next_run(run_time)
+            sleep_seconds = (next_time - datetime.now()).total_seconds()
+            if sleep_seconds > 0:
+                stop_event.wait(timeout=sleep_seconds)
+            if stop_event.is_set():
+                break
+            try:
+                job_fn()
+            except Exception:
+                pass
+            time.sleep(1)
+
+    thread = threading.Thread(target=_loop, daemon=True)
+    thread.start()
+    return thread