ins-pricing 0.1.6__py3-none-any.whl

ins_pricing/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/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/reporting/README.md

@@ -0,0 +1,20 @@
+# reporting
+
+Report builder and scheduler for model monitoring.
+
+Example:
+
+```python
+from ins_pricing.reporting import ReportPayload, write_report, schedule_daily
+
+payload = ReportPayload(
+    model_name="pricing_ft",
+    model_version="v1",
+    metrics={"rmse": 0.12, "loss_ratio": 0.63},
+    risk_trend=risk_df,
+    drift_report=psi_df,
+)
+write_report(payload, "Reports/model_report.md")
+
+schedule_daily(lambda: write_report(payload, "Reports/model_report.md"), run_time="02:00")
+```

ins_pricing/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/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/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

ins_pricing/setup.py

@@ -0,0 +1,41 @@
+from setuptools import setup, find_packages
+
+
+def _discover_packages() -> list[str]:
+    root_packages = ["modelling", "pricing", "production", "governance", "reporting"]
+    packages = ["ins_pricing"]
+    for root in root_packages:
+        found = find_packages(where=".", include=[root, f"{root}.*"])
+        for pkg in found:
+            packages.append(f"ins_pricing.{pkg}")
+    return packages
+
+
+setup(
+    name="ins_pricing",
+    version="0.1.6",
+    description="Reusable modelling, pricing, governance, and reporting utilities.",
+    author="meishi125478",
+    license="Proprietary",
+    python_requires=">=3.9",
+    package_dir={"ins_pricing": "."},
+    packages=_discover_packages(),
+    install_requires=[
+        "numpy>=1.20",
+        "pandas>=1.4",
+        "torch>=1.13",
+        "optuna>=3.0",
+        "xgboost>=1.6",
+        "scikit-learn>=1.1",
+        "statsmodels>=0.13",
+        "joblib>=1.2",
+        "matplotlib>=3.5",
+        "shap>=0.41",
+        "contextily>=1.3",
+        "pynndescent>=0.5",
+        "torch-geometric>=2.3",
+    ],
+    include_package_data=True,
+    package_data={"ins_pricing": ["**/*.json", "**/*.md"]},
+    exclude_package_data={"ins_pricing": ["modelling/demo/*", "modelling/demo/**/*"]},
+)

ins_pricing v2/__init__.py

@@ -0,0 +1,23 @@
+"""Root package for ins_pricing."""
+
+from __future__ import annotations
+from importlib import import_module
+import sys
+
+# Root subpackages
+_ROOT_SUBPACKAGES = {
+    "modelling": "ins_pricing.modelling",
+    "pricing": "ins_pricing.pricing",
+    "production": "ins_pricing.production",
+    "governance": "ins_pricing.governance",
+    "reporting": "ins_pricing.reporting",
+}
+
+__all__ = sorted(list(_ROOT_SUBPACKAGES.keys()))
+
+def __getattr__(name: str):
+    if name in _ROOT_SUBPACKAGES:
+        module = import_module(_ROOT_SUBPACKAGES[name])
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

ins_pricing v2/governance/__init__.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from .approval import ApprovalAction, ApprovalRequest, ApprovalStore
+from .audit import AuditEvent, AuditLogger
+from .registry import ModelArtifact, ModelRegistry, ModelVersion
+from .release import DeploymentState, ModelRef, ReleaseManager
+
+__all__ = [
+    "ApprovalAction",
+    "ApprovalRequest",
+    "ApprovalStore",
+    "AuditEvent",
+    "AuditLogger",
+    "ModelArtifact",
+    "ModelRegistry",
+    "ModelVersion",
+    "DeploymentState",
+    "ModelRef",
+    "ReleaseManager",
+]

ins_pricing v2/governance/approval.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+
+@dataclass
+class ApprovalAction:
+    actor: str
+    decision: str
+    timestamp: str
+    comment: Optional[str] = None
+
+
+@dataclass
+class ApprovalRequest:
+    model_name: str
+    model_version: str
+    requested_by: str
+    requested_at: str
+    status: str = "pending"
+    actions: List[ApprovalAction] = field(default_factory=list)
+
+
+class ApprovalStore:
+    """Simple approval workflow stored as JSON."""
+
+    def __init__(self, store_path: str | Path):
+        self.store_path = Path(store_path)
+        self.store_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def _load(self) -> List[dict]:
+        if not self.store_path.exists():
+            return []
+        with self.store_path.open("r", encoding="utf-8") as fh:
+            return json.load(fh)
+
+    def _save(self, payload: List[dict]) -> None:
+        with self.store_path.open("w", encoding="utf-8") as fh:
+            json.dump(payload, fh, indent=2, ensure_ascii=True)
+
+    def request(self, model_name: str, model_version: str, requested_by: str) -> ApprovalRequest:
+        payload = self._load()
+        req = ApprovalRequest(
+            model_name=model_name,
+            model_version=model_version,
+            requested_by=requested_by,
+            requested_at=datetime.utcnow().isoformat(),
+        )
+        payload.append(asdict(req))
+        self._save(payload)
+        return req
+
+    def list_requests(self, model_name: Optional[str] = None) -> List[ApprovalRequest]:
+        payload = self._load()
+        requests = [ApprovalRequest(**entry) for entry in payload]
+        if model_name is None:
+            return requests
+        return [req for req in requests if req.model_name == model_name]
+
+    def act(
+        self,
+        model_name: str,
+        model_version: str,
+        *,
+        actor: str,
+        decision: str,
+        comment: Optional[str] = None,
+    ) -> ApprovalRequest:
+        payload = self._load()
+        found = None
+        for entry in payload:
+            if entry["model_name"] == model_name and entry["model_version"] == model_version:
+                found = entry
+                break
+        if found is None:
+            raise ValueError("Approval request not found.")
+        action = ApprovalAction(
+            actor=actor,
+            decision=decision,
+            timestamp=datetime.utcnow().isoformat(),
+            comment=comment,
+        )
+        found["actions"].append(asdict(action))
+        if decision.lower() in {"approve", "approved"}:
+            found["status"] = "approved"
+        elif decision.lower() in {"reject", "rejected"}:
+            found["status"] = "rejected"
+        self._save(payload)
+        return ApprovalRequest(**found)

ins_pricing v2/governance/audit.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class AuditEvent:
+    action: str
+    actor: str
+    timestamp: str
+    metadata: Dict[str, Any]
+    note: Optional[str] = None
+
+
+class AuditLogger:
+    """Append-only JSONL audit log."""
+
+    def __init__(self, log_path: str | Path):
+        self.log_path = Path(log_path)
+        self.log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def log(self, action: str, actor: str, *, metadata: Optional[Dict[str, Any]] = None,
+            note: Optional[str] = None) -> AuditEvent:
+        event = AuditEvent(
+            action=action,
+            actor=actor,
+            timestamp=datetime.utcnow().isoformat(),
+            metadata=metadata or {},
+            note=note,
+        )
+        with self.log_path.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(asdict(event), ensure_ascii=True) + "\n")
+        return event

ins_pricing v2/governance/registry.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+@dataclass
+class ModelArtifact:
+    path: str
+    description: Optional[str] = None
+
+
+@dataclass
+class ModelVersion:
+    name: str
+    version: str
+    created_at: str
+    metrics: Dict[str, float] = field(default_factory=dict)
+    tags: Dict[str, str] = field(default_factory=dict)
+    artifacts: List[ModelArtifact] = field(default_factory=list)
+    status: str = "candidate"
+    notes: Optional[str] = None
+
+
+class ModelRegistry:
+    """Lightweight JSON-based model registry."""
+
+    def __init__(self, registry_path: str | Path):
+        self.registry_path = Path(registry_path)
+        self.registry_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def _load(self) -> Dict[str, List[dict]]:
+        if not self.registry_path.exists():
+            return {}
+        with self.registry_path.open("r", encoding="utf-8") as fh:
+            return json.load(fh)
+
+    def _save(self, payload: Dict[str, List[dict]]) -> None:
+        with self.registry_path.open("w", encoding="utf-8") as fh:
+            json.dump(payload, fh, indent=2, ensure_ascii=True)
+
+    def register(
+        self,
+        name: str,
+        version: str,
+        *,
+        metrics: Optional[Dict[str, float]] = None,
+        tags: Optional[Dict[str, str]] = None,
+        artifacts: Optional[List[ModelArtifact]] = None,
+        status: str = "candidate",
+        notes: Optional[str] = None,
+    ) -> ModelVersion:
+        payload = self._load()
+        created_at = datetime.utcnow().isoformat()
+        entry = ModelVersion(
+            name=name,
+            version=version,
+            created_at=created_at,
+            metrics=metrics or {},
+            tags=tags or {},
+            artifacts=artifacts or [],
+            status=status,
+            notes=notes,
+        )
+        payload.setdefault(name, []).append(asdict(entry))
+        self._save(payload)
+        return entry
+
+    def list_versions(self, name: str) -> List[ModelVersion]:
+        payload = self._load()
+        versions = payload.get(name, [])
+        return [ModelVersion(**v) for v in versions]
+
+    def get_version(self, name: str, version: str) -> Optional[ModelVersion]:
+        for entry in self.list_versions(name):
+            if entry.version == version:
+                return entry
+        return None
+
+    def promote(
+        self, name: str, version: str, *, new_status: str = "production"
+    ) -> None:
+        payload = self._load()
+        if name not in payload:
+            raise ValueError("Model not found in registry.")
+        updated = False
+        for entry in payload[name]:
+            if entry["version"] == version:
+                entry["status"] = new_status
+                updated = True
+            elif new_status == "production":
+                if entry.get("status") == "production":
+                    entry["status"] = "archived"
+        if not updated:
+            raise ValueError("Version not found in registry.")
+        self._save(payload)