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

ins_pricing/production/{predict.py → inference.py}

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import json
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Iterable, List, Optional, Sequence, TYPE_CHECKING
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, TYPE_CHECKING
 
 import joblib
 import numpy as np
@@ -14,25 +15,25 @@ except Exception as exc:  # pragma: no cover - optional dependency
     sm = None  # type: ignore[assignment]
     _SM_IMPORT_ERROR = exc
 
-from .preprocess import (
+from ins_pricing.production.preprocess import (
     apply_preprocess_artifacts,
     load_preprocess_artifacts,
     prepare_raw_features,
 )
-from .scoring import batch_score
-from ..modelling.core.bayesopt.utils.losses import (
+from ins_pricing.production.scoring import batch_score
+from ins_pricing.utils.losses import (
     infer_loss_name_from_model_name,
     normalize_loss_name,
     resolve_tweedie_power,
 )
-from ins_pricing.utils.logging import get_logger
+from ins_pricing.utils import get_logger, load_dataset
 
-_logger = get_logger("ins_pricing.production.predict")
+_logger = get_logger("ins_pricing.production.inference")
 
 
 if TYPE_CHECKING:
-    from ..modelling.core.bayesopt.models.model_gnn import GraphNeuralNetSklearn
-    from ..modelling.core.bayesopt.models.model_resn import ResNetSklearn
+    from ins_pricing.modelling.bayesopt.models.model_gnn import GraphNeuralNetSklearn
+    from ins_pricing.modelling.bayesopt.models.model_resn import ResNetSklearn
 
 
 def _torch_load(*args, **kwargs):
@@ -43,6 +44,14 @@ def _get_device_manager():
     from ins_pricing.utils.device import DeviceManager
     return DeviceManager
 
+
+def _normalize_device(device: Optional[Any]) -> Optional[Any]:
+    if device is None:
+        return None
+    if isinstance(device, str) and device.strip().lower() in {"auto", "best"}:
+        return None
+    return device
+
 MODEL_PREFIX = {
     "xgb": "Xgboost",
     "glm": "GLM",
@@ -54,6 +63,54 @@ MODEL_PREFIX = {
 OHT_MODELS = {"resn", "gnn", "glm"}
 
 
+class Predictor:
+    """Minimal predictor interface for production inference."""
+
+    def predict(self, df: pd.DataFrame) -> np.ndarray:  # pragma: no cover - protocol-like
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class ModelSpec:
+    model_key: str
+    model_name: str
+    task_type: str
+    cfg: Dict[str, Any]
+    output_dir: Path
+    artifacts: Optional[Dict[str, Any]]
+    device: Optional[Any] = None
+
+
+ModelLoader = Callable[[ModelSpec], Predictor]
+
+
+class PredictorRegistry:
+    """Registry for mapping model keys to predictor loaders."""
+
+    def __init__(self) -> None:
+        self._loaders: Dict[str, ModelLoader] = {}
+        self._default_loader: Optional[ModelLoader] = None
+
+    def register(self, model_key: str, loader: ModelLoader, *, overwrite: bool = False) -> None:
+        if model_key == "*":
+            if self._default_loader is not None and not overwrite:
+                raise ValueError("Default loader already registered.")
+            self._default_loader = loader
+            return
+        if model_key in self._loaders and not overwrite:
+            raise ValueError(f"Loader already registered for model_key={model_key!r}.")
+        self._loaders[model_key] = loader
+
+    def load(self, spec: ModelSpec) -> Predictor:
+        loader = self._loaders.get(spec.model_key) or self._default_loader
+        if loader is None:
+            raise KeyError(f"No loader registered for model_key={spec.model_key!r}.")
+        return loader(spec)
+
+
+_DEFAULT_REGISTRY = PredictorRegistry()
+
+
 def _default_tweedie_power(model_name: str, task_type: str) -> Optional[float]:
     if task_type == "classification":
         return None
@@ -100,39 +157,6 @@ def _load_json(path: Path) -> Dict[str, Any]:
     return json.loads(path.read_text(encoding="utf-8"))
 
 
-def _infer_format(path: Path) -> str:
-    suffix = path.suffix.lower()
-    if suffix in {".parquet", ".pq"}:
-        return "parquet"
-    if suffix in {".feather", ".ft"}:
-        return "feather"
-    return "csv"
-
-
-def _load_dataset(path: Path, chunksize: Optional[int] = None) -> pd.DataFrame:
-    """Load dataset with optional chunked reading for large CSV files.
-
-    Args:
-        path: Path to the dataset file
-        chunksize: If specified for CSV files, reads in chunks and concatenates.
-                   Useful for large files that may not fit in memory at once.
-
-    Returns:
-        DataFrame containing the full dataset
-    """
-    fmt = _infer_format(path)
-    if fmt == "parquet":
-        return pd.read_parquet(path)
-    if fmt == "feather":
-        return pd.read_feather(path)
-
-    # For CSV, support chunked reading for large files
-    if chunksize is not None:
-        chunks = []
-        for chunk in pd.read_csv(path, low_memory=False, chunksize=chunksize):
-            chunks.append(chunk)
-        return pd.concat(chunks, ignore_index=True)
-    return pd.read_csv(path, low_memory=False)
 
 
 def _model_file_path(output_dir: Path, model_name: str, model_key: str) -> Path:
@@ -160,10 +184,10 @@ def _load_preprocess_from_model_file(
     return None
 
 
-def _move_to_device(model_obj: Any) -> None:
+def _move_to_device(model_obj: Any, device: Optional[Any] = None) -> None:
     """Move model to best available device using shared DeviceManager."""
     DeviceManager = _get_device_manager()
-    DeviceManager.move_to_device(model_obj)
+    DeviceManager.move_to_device(model_obj, device=device)
     if hasattr(model_obj, "eval"):
         model_obj.eval()
 
@@ -209,7 +233,7 @@ def _build_resn_model(
     loss_name: str,
     params: Dict[str, Any],
 ) -> ResNetSklearn:
-    from ..modelling.core.bayesopt.models.model_resn import ResNetSklearn
+    from ins_pricing.modelling.bayesopt.models.model_resn import ResNetSklearn
     if loss_name == "tweedie":
         power = params.get(
             "tw_power", _default_tweedie_power(model_name, task_type))
@@ -248,7 +272,7 @@ def _build_gnn_model(
     loss_name: str,
     params: Dict[str, Any],
 ) -> GraphNeuralNetSklearn:
-    from ..modelling.core.bayesopt.models.model_gnn import GraphNeuralNetSklearn
+    from ins_pricing.modelling.bayesopt.models.model_gnn import GraphNeuralNetSklearn
     base_tw = _default_tweedie_power(model_name, task_type)
     if loss_name == "tweedie":
         tw_power = params.get("tw_power", base_tw)
@@ -288,6 +312,7 @@ def load_saved_model(
     task_type: str,
     input_dim: Optional[int],
     cfg: Dict[str, Any],
+    device: Optional[Any] = None,
 ) -> Any:
     model_path = _model_file_path(Path(output_dir), model_name, model_key)
     if not model_path.exists():
@@ -308,8 +333,8 @@ def load_saved_model(
                 state_dict = payload.get("state_dict")
                 model_config = payload.get("model_config", {})
 
-                from ..modelling.core.bayesopt.models import FTTransformerSklearn
-                from ..modelling.core.bayesopt.models.model_ft_components import FTTransformerCore
+                from ins_pricing.modelling.bayesopt.models import FTTransformerSklearn
+                from ins_pricing.modelling.bayesopt.models.model_ft_components import FTTransformerCore
 
                 # Reconstruct model from config
                 resolved_loss = model_config.get("loss_name")
@@ -359,15 +384,15 @@ def load_saved_model(
                     model.ft = core
                     model.ft.load_state_dict(state_dict)
 
-                _move_to_device(model)
+                _move_to_device(model, device=device)
                 return model
             elif "model" in payload:
                 # Legacy format: full model object
                 model = payload.get("model")
-                _move_to_device(model)
+                _move_to_device(model, device=device)
                 return model
         # Very old format: direct model object
-        _move_to_device(payload)
+        _move_to_device(payload, device=device)
         return payload
 
     if model_key == "resn":
@@ -395,7 +420,7 @@ def load_saved_model(
             params=params,
         )
         model.resnet.load_state_dict(state_dict)
-        _move_to_device(model)
+        _move_to_device(model, device=device)
         return model
 
     if model_key == "gnn":
@@ -420,7 +445,7 @@ def load_saved_model(
         base_gnn = getattr(model, "_unwrap_gnn", lambda: None)()
         if base_gnn is not None and state_dict is not None:
             base_gnn.load_state_dict(state_dict, strict=False)
-        _move_to_device(model)
+        _move_to_device(model, device=device)
         return model
 
     raise ValueError(f"Unsupported model key: {model_key}")
@@ -484,7 +509,7 @@ def _predict_with_model(
     return model.predict(features)
 
 
-class SavedModelPredictor:
+class SavedModelPredictor(Predictor):
     def __init__(
         self,
         *,
@@ -494,6 +519,7 @@ class SavedModelPredictor:
         cfg: Dict[str, Any],
         output_dir: Path,
         artifacts: Optional[Dict[str, Any]],
+        device: Optional[Any] = None,
     ) -> None:
         self.model_key = model_key
         self.model_name = model_name
@@ -501,6 +527,7 @@ class SavedModelPredictor:
         self.cfg = cfg
         self.output_dir = output_dir
         self.artifacts = artifacts
+        self.device = _normalize_device(device)
 
         if model_key == "ft" and str(cfg.get("ft_role", "model")) != "model":
             raise ValueError("FT predictions require ft_role == 'model'.")
@@ -520,6 +547,7 @@ class SavedModelPredictor:
             task_type=task_type,
             input_dim=input_dim,
             cfg=cfg,
+            device=self.device,
         )
 
     def predict(self, df: pd.DataFrame) -> np.ndarray:
@@ -537,6 +565,35 @@ class SavedModelPredictor:
         )
 
 
+def _default_loader(spec: ModelSpec) -> SavedModelPredictor:
+    return SavedModelPredictor(
+        model_key=spec.model_key,
+        model_name=spec.model_name,
+        task_type=spec.task_type,
+        cfg=spec.cfg,
+        output_dir=spec.output_dir,
+        artifacts=spec.artifacts,
+        device=spec.device,
+    )
+
+
+_DEFAULT_REGISTRY.register("*", _default_loader)
+
+
+def register_model_loader(
+    model_key: str,
+    loader: ModelLoader,
+    *,
+    overwrite: bool = False,
+    registry: Optional[PredictorRegistry] = None,
+) -> None:
+    (registry or _DEFAULT_REGISTRY).register(model_key, loader, overwrite=overwrite)
+
+
+def load_predictor(spec: ModelSpec, *, registry: Optional[PredictorRegistry] = None) -> Predictor:
+    return (registry or _DEFAULT_REGISTRY).load(spec)
+
+
 def load_predictor_from_config(
     config_path: str | Path,
     model_key: str,
@@ -544,7 +601,9 @@ def load_predictor_from_config(
     model_name: Optional[str] = None,
     output_dir: Optional[str | Path] = None,
     preprocess_artifact_path: Optional[str | Path] = None,
-) -> SavedModelPredictor:
+    device: Optional[Any] = None,
+    registry: Optional[PredictorRegistry] = None,
+) -> Predictor:
     config_path = Path(config_path).resolve()
     cfg = _load_json(config_path)
     base_dir = config_path.parent
@@ -589,15 +648,17 @@ def load_predictor_from_config(
             resolved_output, model_name, model_key
         )
 
-    predictor = SavedModelPredictor(
+    device = _normalize_device(device)
+    spec = ModelSpec(
         model_key=model_key,
         model_name=model_name,
         task_type=str(cfg.get("task_type", "regression")),
         cfg=cfg,
         output_dir=resolved_output,
         artifacts=artifacts,
+        device=device,
     )
-    return predictor
+    return load_predictor(spec, registry=registry)
 
 
 def predict_from_config(
@@ -612,6 +673,8 @@ def predict_from_config(
     chunksize: Optional[int] = None,
     parallel_load: bool = False,
     n_jobs: int = -1,
+    device: Optional[Any] = None,
+    registry: Optional[PredictorRegistry] = None,
 ) -> pd.DataFrame:
     """Predict from multiple models with optional parallel loading.
 
@@ -626,12 +689,14 @@ def predict_from_config(
         chunksize: Optional chunk size for CSV reading
         parallel_load: If True, load models in parallel (faster for multiple models)
         n_jobs: Number of parallel jobs for model loading (-1 = all cores)
+        device: Optional torch device or string override (e.g., "cuda", "mps", "cpu")
+        registry: Optional predictor registry override
 
     Returns:
         DataFrame with predictions from all models
     """
     input_path = Path(input_path).resolve()
-    data = _load_dataset(input_path, chunksize=chunksize)
+    data = load_dataset(input_path, data_format="auto", low_memory=False, chunksize=chunksize)
 
     result = data.copy()
 
@@ -644,6 +709,8 @@ def predict_from_config(
                 config_path,
                 key,
                 model_name=model_name,
+                device=device,
+                registry=registry,
             )
             output_col = f"{output_col_prefix}{key}"
             scored = batch_score(
@@ -668,6 +735,8 @@ def predict_from_config(
                 config_path,
                 key,
                 model_name=model_name,
+                device=device,
+                registry=registry,
             )
             output_col = f"{output_col_prefix}{key}"
             scored = batch_score(
@@ -691,3 +760,17 @@ def predict_from_config(
             result.to_csv(output_path, index=False)
 
     return result
+
+
+__all__ = [
+    "Predictor",
+    "ModelSpec",
+    "PredictorRegistry",
+    "register_model_loader",
+    "load_predictor",
+    "SavedModelPredictor",
+    "load_best_params",
+    "load_saved_model",
+    "load_predictor_from_config",
+    "predict_from_config",
+]

ins_pricing/production/monitoring.py

@@ -5,6 +5,8 @@ from typing import Dict, Iterable, Optional
 import numpy as np
 import pandas as pd
 
+from ins_pricing.utils.metrics import mae, mape, r2_score, rmse
+
 
 def _safe_div(numer: float, denom: float, default: float = 0.0) -> float:
     if denom == 0:
@@ -18,27 +20,12 @@ def regression_metrics(
     *,
     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}
+    return {
+        "rmse": rmse(y_true, y_pred, sample_weight=weight),
+        "mae": mae(y_true, y_pred, sample_weight=weight),
+        "mape": mape(y_true, y_pred, sample_weight=weight),
+        "r2": r2_score(y_true, y_pred, sample_weight=weight),
+    }
 
 
 def loss_ratio(

ins_pricing/reporting/__init__.py

@@ -1,11 +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",
-]
+from __future__ import annotations
+
+from ins_pricing.reporting.report_builder import ReportPayload, build_report, write_report
+from ins_pricing.reporting.scheduler import schedule_daily
+
+__all__ = [
+    "ReportPayload",
+    "build_report",
+    "write_report",
+    "schedule_daily",
+]

ins_pricing/setup.py

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

ins_pricing/tests/production/test_inference.py

@@ -0,0 +1,90 @@
+"""Tests for production inference module (lightweight API checks)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+pytest.importorskip("ins_pricing.production.inference", reason="inference module not available")
+
+from ins_pricing.production.inference import (
+    ModelSpec,
+    Predictor,
+    PredictorRegistry,
+    load_predictor,
+    register_model_loader,
+)
+
+
+@dataclass
+class _DummyPredictor(Predictor):
+    value: float = 1.0
+
+    def predict(self, df):  # type: ignore[override]
+        return np.full(len(df), self.value)
+
+
+def test_registry_loads_custom_predictor():
+    registry = PredictorRegistry()
+    captured = {}
+
+    def _loader(spec: ModelSpec) -> Predictor:
+        captured["spec"] = spec
+        return _DummyPredictor(value=3.0)
+
+    register_model_loader("xgb", _loader, registry=registry)
+    spec = ModelSpec(
+        model_key="xgb",
+        model_name="demo",
+        task_type="regression",
+        cfg={},
+        output_dir=Path("."),
+        artifacts=None,
+    )
+    predictor = load_predictor(spec, registry=registry)
+    assert isinstance(predictor, _DummyPredictor)
+    assert captured["spec"] is spec
+
+
+def test_registry_missing_key_raises():
+    registry = PredictorRegistry()
+    spec = ModelSpec(
+        model_key="glm",
+        model_name="demo",
+        task_type="regression",
+        cfg={},
+        output_dir=Path("."),
+        artifacts=None,
+    )
+    with pytest.raises(KeyError):
+        load_predictor(spec, registry=registry)
+
+
+def test_register_overwrite_controls():
+    registry = PredictorRegistry()
+
+    def _loader_one(spec: ModelSpec) -> Predictor:
+        return _DummyPredictor(value=1.0)
+
+    def _loader_two(spec: ModelSpec) -> Predictor:
+        return _DummyPredictor(value=2.0)
+
+    register_model_loader("ft", _loader_one, registry=registry)
+    with pytest.raises(ValueError):
+        register_model_loader("ft", _loader_two, registry=registry, overwrite=False)
+
+    register_model_loader("ft", _loader_two, registry=registry, overwrite=True)
+    spec = ModelSpec(
+        model_key="ft",
+        model_name="demo",
+        task_type="regression",
+        cfg={},
+        output_dir=Path("."),
+        artifacts=None,
+    )
+    predictor = load_predictor(spec, registry=registry)
+    assert isinstance(predictor, _DummyPredictor)
+    assert predictor.value == 2.0