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

ins_pricing/README.md

@@ -7,12 +7,13 @@ between modelling, production, governance, and reporting.
 
 ## Architecture
 
-- `cli/`: CLI entry points and shared utilities.
-- `modelling/`
-  - `core/`: BayesOpt training core (GLM / XGB / ResNet / FT / GNN).
-  - `plotting/`: model-agnostic curves and geo visualizations.
-  - `explain/`: permutation, gradients, and SHAP helpers.
-- `examples/`: demo configs and notebooks (repo only; not packaged).
+- `cli/`: CLI entry points and shared utilities.
+- `modelling/`
+  - `bayesopt/`: BayesOpt training core (GLM / XGB / ResNet / FT / GNN).
+  - `plotting/`: model-agnostic curves and geo visualizations.
+  - `explain/`: permutation, gradients, and SHAP helpers.
+  - `evaluation.py`: calibration, metrics, and evaluation utilities.
+- `examples/`: demo configs and notebooks (repo only; not packaged).
 - `pricing/`: factor tables, calibration, exposure, monitoring.
 - `production/`: scoring, metrics, drift/PSI.
 - `governance/`: registry, approval, audit workflows.
@@ -31,29 +32,54 @@ between modelling, production, governance, and reporting.
    - `from ins_pricing.explain import permutation_importance, integrated_gradients_torch`
 4. Pricing loop
    - `from ins_pricing.pricing import build_factor_table, rate_premium`
-5. Production and governance
-   - `from ins_pricing.production import batch_score, psi_report`
-   - `from ins_pricing.governance import ModelRegistry, ReleaseManager`
+5. Production and governance
+   - `from ins_pricing.production import batch_score, psi_report`
+   - Inference: `from ins_pricing.production import load_predictor_from_config`
+   - `from ins_pricing.governance import ModelRegistry, ReleaseManager`
 6. Reporting
    - `from ins_pricing.reporting import build_report, write_report, schedule_daily`
 
-## Import notes
-
-- `ins_pricing` exposes lightweight lazy imports so that pricing/production/governance
-  can be used without installing heavy ML dependencies.
+## Import notes
+
+- `ins_pricing` exposes lightweight lazy imports so that pricing/production/governance
+  can be used without installing heavy ML dependencies.
 - Demo notebooks/configs live in the repo under `examples/` and are not shipped
   in the PyPI package.
-- Heavy dependencies are only required when you import or use the related modules:
-  - BayesOpt: `torch`, `optuna`, `xgboost`, etc.
-  - Explain: `torch` (gradients), `shap` (SHAP).
-  - Geo plotting on basemap: `contextily`.
-  - Plotting: `matplotlib`.
+- Heavy dependencies are only required when you import or use the related modules:
+  - BayesOpt: `torch`, `optuna`, `xgboost`, etc.
+  - Explain: `torch` (gradients), `shap` (SHAP).
+  - Geo plotting on basemap: `contextily`.
+  - Plotting: `matplotlib`.
+  - Inference: `torch` only when loading FT/ResNet/GNN models.
+
+## Inference interface (new)
+
+- `production.inference` provides a small registry-based interface so inference
+  does not hard-code model loaders:
+  - `ModelSpec` describes the saved model location and config.
+  - `PredictorRegistry` lets you plug in custom model loaders.
+  - `load_predictor_from_config` remains backward compatible.
+
+Example:
+
+```
+from ins_pricing.production import load_predictor_from_config
+
+predictor = load_predictor_from_config(
+    "config.json",
+    "resn",
+    device="cuda",  # or "mps"/"cpu"
+)
+preds = predictor.predict(df)
+```
 
-## Multi-platform and GPU notes
+## Multi-platform and GPU notes
 
-- Install the correct PyTorch build for your platform/GPU before installing extras.
-- Torch Geometric requires platform-specific wheels; follow the official PyG install guide.
-- Multi-GPU uses DDP or DataParallel where supported; Windows disables CUDA DDP.
+- Install the correct PyTorch build for your platform/GPU before installing extras.
+- Torch Geometric requires platform-specific wheels; follow the official PyG install guide.
+- Multi-GPU uses DDP or DataParallel where supported; Windows disables CUDA DDP.
+  CLI usage prefers `python -m ins_pricing.cli.BayesOpt_entry ...` but the
+  direct script path (`python ins_pricing/cli/BayesOpt_entry.py ...`) still works.
 
 ## Backward-compatible imports
 

ins_pricing/__init__.py

@@ -1,94 +1,146 @@
-from __future__ import annotations
-
-from importlib import import_module
-from pathlib import Path
-import sys
-import types
-
-_ROOT_SUBPACKAGES = {
-    "modelling": "ins_pricing.modelling",
-    "pricing": "ins_pricing.pricing",
-    "production": "ins_pricing.production",
-    "governance": "ins_pricing.governance",
-    "reporting": "ins_pricing.reporting",
-}
-
-_MODELLING_EXPORTS = {
-    "BayesOptConfig",
-    "BayesOptModel",
-    "IOUtils",
-    "TrainingUtils",
-    "free_cuda",
-}
-
+from __future__ import annotations
+
+from importlib import import_module
+from pathlib import Path
+import sys
+import types
+
+_ROOT_SUBPACKAGES = {
+    "modelling": "ins_pricing.modelling",
+    "pricing": "ins_pricing.pricing",
+    "production": "ins_pricing.production",
+    "governance": "ins_pricing.governance",
+    "reporting": "ins_pricing.reporting",
+}
+
+_MODELLING_EXPORTS = {
+    "BayesOptConfig",
+    "BayesOptModel",
+}
+
+_BAYESOPT_EXPORTS = {
+    "BayesOptConfig",
+    "DatasetPreprocessor",
+    "OutputManager",
+    "VersionManager",
+    "BayesOptModel",
+    "FeatureTokenizer",
+    "FTTransformerCore",
+    "FTTransformerSklearn",
+    "GraphNeuralNetSklearn",
+    "MaskedTabularDataset",
+    "ResBlock",
+    "ResNetSequential",
+    "ResNetSklearn",
+    "ScaledTransformerEncoderLayer",
+    "SimpleGraphLayer",
+    "SimpleGNN",
+    "TabularDataset",
+    "FTTrainer",
+    "GLMTrainer",
+    "GNNTrainer",
+    "ResNetTrainer",
+    "TrainerBase",
+    "XGBTrainer",
+    "_xgb_cuda_available",
+}
+
+_LEGACY_EXPORTS = {
+    "IOUtils": "ins_pricing.utils",
+    "DeviceManager": "ins_pricing.utils",
+    "GPUMemoryManager": "ins_pricing.utils",
+    "MetricFactory": "ins_pricing.utils",
+    "EPS": "ins_pricing.utils",
+    "set_global_seed": "ins_pricing.utils",
+    "compute_batch_size": "ins_pricing.utils",
+    "tweedie_loss": "ins_pricing.utils",
+    "infer_factor_and_cate_list": "ins_pricing.utils",
+    "DistributedUtils": "ins_pricing.modelling.bayesopt.utils",
+    "TrainingUtils": "ins_pricing.modelling.bayesopt.utils",
+    "free_cuda": "ins_pricing.modelling.bayesopt.utils",
+    "TorchTrainerMixin": "ins_pricing.modelling.bayesopt.utils",
+}
+
 _LAZY_SUBMODULES = {
-    "bayesopt": "ins_pricing.modelling.core.bayesopt",
+    "bayesopt": "ins_pricing.modelling.bayesopt",
     "plotting": "ins_pricing.modelling.plotting",
     "explain": "ins_pricing.modelling.explain",
-    "BayesOpt": "ins_pricing.modelling.core.BayesOpt",
-}
-
-_PACKAGE_PATHS = {
-    "bayesopt": Path(__file__).resolve().parent / "modelling" / "core" / "bayesopt",
-    "plotting": Path(__file__).resolve().parent / "modelling" / "plotting",
-    "explain": Path(__file__).resolve().parent / "modelling" / "explain",
 }
-
-__all__ = sorted(
-    set(_ROOT_SUBPACKAGES)
-    | set(_MODELLING_EXPORTS)
-    | set(_LAZY_SUBMODULES)
-)
-
-
-def _lazy_module(name: str, target: str, package_path: Path | None = None) -> types.ModuleType:
-    proxy = types.ModuleType(name)
-    if package_path is not None:
-        proxy.__path__ = [str(package_path)]
-
-    def _load():
-        module = import_module(target)
-        sys.modules[name] = module
-        return module
-
-    def __getattr__(attr: str):
-        module = _load()
-        return getattr(module, attr)
-
-    def __dir__() -> list[str]:
-        module = _load()
-        return sorted(set(dir(module)))
-
-    proxy.__getattr__ = __getattr__  # type: ignore[attr-defined]
-    proxy.__dir__ = __dir__  # type: ignore[attr-defined]
-    return proxy
-
-
-def _install_proxy(alias: str, target: str) -> None:
-    module_name = f"{__name__}.{alias}"
-    if module_name in sys.modules:
-        return
-    proxy = _lazy_module(module_name, target, _PACKAGE_PATHS.get(alias))
-    sys.modules[module_name] = proxy
-    globals()[alias] = proxy
-
-
-for _alias, _target in _LAZY_SUBMODULES.items():
-    _install_proxy(_alias, _target)
-
-
-def __getattr__(name: str):
-    if name in _ROOT_SUBPACKAGES:
-        module = import_module(_ROOT_SUBPACKAGES[name])
-        globals()[name] = module
-        return module
-    if name in _MODELLING_EXPORTS:
-        module = import_module("ins_pricing.modelling")
-        value = getattr(module, name)
-        globals()[name] = value
-        return value
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-
-
-def __dir__() -> list[str]:
-    return sorted(set(__all__) | set(globals().keys()))
+
+_PACKAGE_PATHS = {
+    "bayesopt": Path(__file__).resolve().parent / "modelling" / "bayesopt",
+    "plotting": Path(__file__).resolve().parent / "modelling" / "plotting",
+    "explain": Path(__file__).resolve().parent / "modelling" / "explain",
+}
+
+__all__ = sorted(
+    set(_ROOT_SUBPACKAGES)
+    | set(_MODELLING_EXPORTS)
+    | set(_BAYESOPT_EXPORTS)
+    | set(_LEGACY_EXPORTS)
+    | set(_LAZY_SUBMODULES)
+)
+
+
+def _lazy_module(name: str, target: str, package_path: Path | None = None) -> types.ModuleType:
+    proxy = types.ModuleType(name)
+    if package_path is not None:
+        proxy.__path__ = [str(package_path)]
+
+    def _load():
+        module = import_module(target)
+        sys.modules[name] = module
+        return module
+
+    def __getattr__(attr: str):
+        module = _load()
+        return getattr(module, attr)
+
+    def __dir__() -> list[str]:
+        module = _load()
+        return sorted(set(dir(module)))
+
+    proxy.__getattr__ = __getattr__  # type: ignore[attr-defined]
+    proxy.__dir__ = __dir__  # type: ignore[attr-defined]
+    return proxy
+
+
+def _install_proxy(alias: str, target: str) -> None:
+    module_name = f"{__name__}.{alias}"
+    if module_name in sys.modules:
+        return
+    proxy = _lazy_module(module_name, target, _PACKAGE_PATHS.get(alias))
+    sys.modules[module_name] = proxy
+    globals()[alias] = proxy
+
+
+for _alias, _target in _LAZY_SUBMODULES.items():
+    _install_proxy(_alias, _target)
+
+
+def __getattr__(name: str):
+    if name in _ROOT_SUBPACKAGES:
+        module = import_module(_ROOT_SUBPACKAGES[name])
+        globals()[name] = module
+        return module
+    if name in _MODELLING_EXPORTS:
+        module = import_module("ins_pricing.modelling")
+        value = getattr(module, name)
+        globals()[name] = value
+        return value
+    if name in _BAYESOPT_EXPORTS:
+        module = import_module("ins_pricing.modelling.bayesopt")
+        value = getattr(module, name)
+        globals()[name] = value
+        return value
+    legacy_module = _LEGACY_EXPORTS.get(name)
+    if legacy_module:
+        module = import_module(legacy_module)
+        value = getattr(module, name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(__all__) | set(globals().keys()))

ins_pricing/cli/BayesOpt_entry.py

@@ -1,56 +1,58 @@
-"""Thin wrapper for the BayesOpt CLI entry point.
-
-The main implementation lives in bayesopt_entry_runner.py.
-"""
-
-from __future__ import annotations
-
+"""Thin wrapper for the BayesOpt CLI entry point.
+
+The main implementation lives in bayesopt_entry_runner.py.
+"""
+
+from __future__ import annotations
+
 from pathlib import Path
+import importlib.util
 import json
 import os
 import sys
 
 if __package__ in {None, ""}:
-    repo_root = Path(__file__).resolve().parents[2]
-    if str(repo_root) not in sys.path:
-        sys.path.insert(0, str(repo_root))
-
-def _apply_env_from_config(argv: list[str]) -> None:
-    if "--config-json" not in argv:
-        return
-    idx = argv.index("--config-json")
-    if idx + 1 >= len(argv):
-        return
-    raw_path = argv[idx + 1]
-    try:
-        cfg_path = Path(raw_path).expanduser()
-        if not cfg_path.is_absolute():
-            cfg_path = cfg_path.resolve()
-        if not cfg_path.exists():
-            script_dir = Path(__file__).resolve().parents[1]
-            candidate = (script_dir / raw_path).resolve()
-            if candidate.exists():
-                cfg_path = candidate
-        if not cfg_path.exists():
-            return
-        cfg = json.loads(cfg_path.read_text(encoding="utf-8", errors="replace"))
-        env = cfg.get("env", {})
-        if isinstance(env, dict):
-            for key, value in env.items():
-                if key is None:
-                    continue
-                os.environ.setdefault(str(key), str(value))
-    except Exception:
-        return
-
-_apply_env_from_config(sys.argv)
-
-try:
-    from .bayesopt_entry_runner import main
-except Exception:  # pragma: no cover
-    from ins_pricing.cli.bayesopt_entry_runner import main
-
-__all__ = ["main"]
-
-if __name__ == "__main__":
-    main()
+    if importlib.util.find_spec("ins_pricing") is None:
+        repo_root = Path(__file__).resolve().parents[2]
+        if str(repo_root) not in sys.path:
+            sys.path.insert(0, str(repo_root))
+
+def _apply_env_from_config(argv: list[str]) -> None:
+    if "--config-json" not in argv:
+        return
+    idx = argv.index("--config-json")
+    if idx + 1 >= len(argv):
+        return
+    raw_path = argv[idx + 1]
+    try:
+        cfg_path = Path(raw_path).expanduser()
+        if not cfg_path.is_absolute():
+            cfg_path = cfg_path.resolve()
+        if not cfg_path.exists():
+            script_dir = Path(__file__).resolve().parents[1]
+            candidate = (script_dir / raw_path).resolve()
+            if candidate.exists():
+                cfg_path = candidate
+        if not cfg_path.exists():
+            return
+        cfg = json.loads(cfg_path.read_text(encoding="utf-8", errors="replace"))
+        env = cfg.get("env", {})
+        if isinstance(env, dict):
+            for key, value in env.items():
+                if key is None:
+                    continue
+                os.environ.setdefault(str(key), str(value))
+    except Exception:
+        return
+
+_apply_env_from_config(sys.argv)
+
+try:
+    from ins_pricing.cli.bayesopt_entry_runner import main
+except Exception:  # pragma: no cover
+    from ins_pricing.cli.bayesopt_entry_runner import main
+
+__all__ = ["main"]
+
+if __name__ == "__main__":
+    main()

ins_pricing/cli/BayesOpt_incremental.py

@@ -1,5 +1,4 @@
-"""Incremental training harness built on top of ``ins_pricing.bayesopt``
-(compat via ``BayesOpt.py``).
+"""Incremental training harness built on top of ``ins_pricing.bayesopt``.
 
 This utility lets you append new observations to an existing dataset,
 reuse previously tuned hyperparameters and retrain a subset of models
@@ -17,13 +16,15 @@ Example:
 
 from __future__ import annotations
 
-from pathlib import Path
-import sys
-
-if __package__ in {None, ""}:
-    repo_root = Path(__file__).resolve().parents[2]
-    if str(repo_root) not in sys.path:
-        sys.path.insert(0, str(repo_root))
+from pathlib import Path
+import importlib.util
+import sys
+
+if __package__ in {None, ""}:
+    if importlib.util.find_spec("ins_pricing") is None:
+        repo_root = Path(__file__).resolve().parents[2]
+        if str(repo_root) not in sys.path:
+            sys.path.insert(0, str(repo_root))
 
 import argparse
 import json
@@ -31,102 +32,35 @@ from dataclasses import asdict
 from datetime import datetime
 from typing import Any, Dict, List, Optional, Sequence, Tuple
 
-import pandas as pd
-
-try:
-    from .. import bayesopt as ropt  # type: ignore
-    from .utils.cli_common import (  # type: ignore
-        PLOT_MODEL_LABELS,
-        PYTORCH_TRAINERS,
-        build_model_names,
-        dedupe_preserve_order,
-        load_dataset,
-        parse_model_pairs,
-        resolve_data_path,
-        resolve_path,
-        split_train_test,
-    )
-    from .utils.cli_config import (  # type: ignore
-        add_config_json_arg,
-        resolve_and_load_config,
-        resolve_data_config,
-        resolve_split_config,
-        resolve_runtime_config,
-        resolve_output_dirs,
-    )
-except Exception:  # pragma: no cover
-    try:
-        import bayesopt as ropt  # type: ignore
-        from utils.cli_common import (  # type: ignore
-            PLOT_MODEL_LABELS,
-            PYTORCH_TRAINERS,
-            build_model_names,
-            dedupe_preserve_order,
-            load_dataset,
-            parse_model_pairs,
-            resolve_data_path,
-            resolve_path,
-            split_train_test,
-        )
-        from utils.cli_config import (  # type: ignore
-            add_config_json_arg,
-            resolve_and_load_config,
-            resolve_data_config,
-            resolve_split_config,
-            resolve_runtime_config,
-            resolve_output_dirs,
-        )
-    except Exception:
-        try:
-            import ins_pricing.modelling.core.bayesopt as ropt  # type: ignore
-            from ins_pricing.cli.utils.cli_common import (  # type: ignore
-                PLOT_MODEL_LABELS,
-                PYTORCH_TRAINERS,
-                build_model_names,
-                dedupe_preserve_order,
-                load_dataset,
-                parse_model_pairs,
-                resolve_data_path,
-                resolve_path,
-                split_train_test,
-            )
-            from ins_pricing.cli.utils.cli_config import (  # type: ignore
-                add_config_json_arg,
-                resolve_and_load_config,
-                resolve_data_config,
-                resolve_split_config,
-                resolve_runtime_config,
-                resolve_output_dirs,
-            )
-        except Exception:
-            import BayesOpt as ropt  # type: ignore
-            from utils.cli_common import (  # type: ignore
-                PLOT_MODEL_LABELS,
-                PYTORCH_TRAINERS,
-                build_model_names,
-                dedupe_preserve_order,
-                load_dataset,
-                parse_model_pairs,
-                resolve_data_path,
-                resolve_path,
-                split_train_test,
-            )
-            from utils.cli_config import (  # type: ignore
-                add_config_json_arg,
-                resolve_and_load_config,
-                resolve_data_config,
-                resolve_split_config,
-                resolve_runtime_config,
-                resolve_output_dirs,
-            )
-
-try:
-    from .utils.run_logging import configure_run_logging  # type: ignore
-except Exception:  # pragma: no cover
-    try:
-        from utils.run_logging import configure_run_logging  # type: ignore
-    except Exception:  # pragma: no cover
-        configure_run_logging = None  # type: ignore
+import pandas as pd
+
+from ins_pricing.cli.utils.import_resolver import resolve_imports, setup_sys_path
+
+setup_sys_path()
+_imports = resolve_imports()
+
+ropt = _imports.bayesopt
+if ropt is None:  # pragma: no cover
+    raise ImportError("Failed to resolve ins_pricing.bayesopt for incremental CLI.")
+
+PLOT_MODEL_LABELS = _imports.PLOT_MODEL_LABELS
+PYTORCH_TRAINERS = _imports.PYTORCH_TRAINERS
+build_model_names = _imports.build_model_names
+dedupe_preserve_order = _imports.dedupe_preserve_order
+load_dataset = _imports.load_dataset
+parse_model_pairs = _imports.parse_model_pairs
+resolve_data_path = _imports.resolve_data_path
+resolve_path = _imports.resolve_path
+split_train_test = _imports.split_train_test
+
+add_config_json_arg = _imports.add_config_json_arg
+resolve_and_load_config = _imports.resolve_and_load_config
+resolve_data_config = _imports.resolve_data_config
+resolve_split_config = _imports.resolve_split_config
+resolve_runtime_config = _imports.resolve_runtime_config
+resolve_output_dirs = _imports.resolve_output_dirs
+
+configure_run_logging = _imports.configure_run_logging
 
 
 def _log(message: str) -> None:

ins_pricing/cli/Explain_Run.py

@@ -1,25 +1,33 @@
-from __future__ import annotations
-
+from __future__ import annotations
+
 from pathlib import Path
 from typing import Optional
-
-try:
-    from .utils.notebook_utils import run_from_config, run_from_config_cli  # type: ignore
-except Exception:  # pragma: no cover
-    from utils.notebook_utils import run_from_config, run_from_config_cli  # type: ignore
-
-
-def run(config_json: str | Path) -> None:
-    """Run explain by config.json (runner.mode=explain)."""
-    run_from_config(config_json)
-
-
-def main(argv: Optional[list[str]] = None) -> None:
-    run_from_config_cli(
-        "Explain_Run: run explain by config.json (runner.mode=explain).",
-        argv,
-    )
-
-
-if __name__ == "__main__":
-    main()
+import importlib.util
+import sys
+
+if __package__ in {None, ""}:
+    if importlib.util.find_spec("ins_pricing") is None:
+        repo_root = Path(__file__).resolve().parents[2]
+        if str(repo_root) not in sys.path:
+            sys.path.insert(0, str(repo_root))
+
+try:
+    from ins_pricing.cli.utils.notebook_utils import run_from_config, run_from_config_cli  # type: ignore
+except Exception:  # pragma: no cover
+    from utils.notebook_utils import run_from_config, run_from_config_cli  # type: ignore
+
+
+def run(config_json: str | Path) -> None:
+    """Run explain by config.json (runner.mode=explain)."""
+    run_from_config(config_json)
+
+
+def main(argv: Optional[list[str]] = None) -> None:
+    run_from_config_cli(
+        "Explain_Run: run explain by config.json (runner.mode=explain).",
+        argv,
+    )
+
+
+if __name__ == "__main__":
+    main()