ins-pricing 0.4.4__tar.gz → 0.5.0__tar.gz

{ins_pricing-0.4.4 → ins_pricing-0.5.0}/MANIFEST.in

@@ -1,3 +1,3 @@
-include README.md
-recursive-include ins_pricing *.md
-recursive-exclude ins_pricing/examples *
+include README.md
+recursive-include ins_pricing *.md
+recursive-exclude examples *

{ins_pricing-0.4.4 → ins_pricing-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ins_pricing
-Version: 0.4.4
+Version: 0.5.0
 Summary: Reusable modelling, pricing, governance, and reporting utilities.
 Author: meishi125478
 License: Proprietary
@@ -56,18 +56,19 @@ A reusable toolkit for insurance modeling, pricing, governance, and reporting.
 
 ## Overview
 
-Insurance-Pricing (ins_pricing) is an enterprise-grade Python library designed for machine learning model training, pricing calculations, and model governance workflows in the insurance industry.
+Insurance-Pricing (ins_pricing) is an enterprise-grade Python library designed for machine learning
+model training, pricing calculations, and model governance workflows in the insurance industry.
 
 ### Core Modules
 
 | Module | Description |
 |--------|-------------|
-| **modelling** | ML model training (GLM, XGBoost, ResNet, FT-Transformer, GNN) and model interpretability (SHAP, permutation importance) |
-| **pricing** | Factor table construction, numeric binning, premium calibration, exposure calculation, PSI monitoring |
-| **production** | Model prediction, batch scoring, data drift detection, production metrics monitoring |
-| **governance** | Model registry, version management, approval workflows, audit logging |
-| **reporting** | Report generation (Markdown format), report scheduling |
-| **utils** | Data validation, performance profiling, device management, logging configuration |
+| modelling | ML model training (GLM, XGBoost, ResNet, FT-Transformer, GNN) and model interpretability |
+| pricing | Factor table construction, numeric binning, premium calibration, exposure calculation, PSI monitoring |
+| production | Model prediction, batch scoring, data drift detection, production metrics monitoring |
+| governance | Model registry, version management, approval workflows, audit logging |
+| reporting | Report generation (Markdown format), report scheduling |
+| utils | Data validation, performance profiling, device management, logging configuration |
 
 ### Quick Start
 
@@ -110,17 +111,17 @@ registry.register(model_name, version, metrics=metrics)
 
 ```
 ins_pricing/
-├── cli/                    # Command-line entry points
-├── modelling/
-│   ├── core/bayesopt/     # ML model training core
-│   ├── explain/           # Model interpretability
-│   └── plotting/          # Model visualization
-├── pricing/               # Insurance pricing module
-├── production/            # Production deployment module
-├── governance/            # Model governance
-├── reporting/             # Report generation
-├── utils/                 # Utilities
-└── tests/                 # Test suite
+  cli/                    # Command-line entry points
+  modelling/
+    core/bayesopt/         # ML model training core
+    explain/               # Model interpretability
+    plotting/              # Model visualization
+  pricing/                 # Insurance pricing module
+  production/              # Production deployment module
+  governance/              # Model governance
+  reporting/               # Report generation
+  utils/                   # Utilities
+  tests/                   # Test suite
 ```
 
 ### Installation
@@ -139,24 +140,43 @@ pip install ins_pricing[plotting]    # Visualization
 pip install ins_pricing[gnn]         # Graph neural networks
 ```
 
-#### Multi-platform & GPU installation notes
+#### Multi-platform and GPU notes
 
-- **PyTorch (CPU/GPU/MPS)**: Install the correct PyTorch build for your platform/GPU first (CUDA on
-  Linux/Windows, ROCm on supported AMD platforms, or MPS on Apple Silicon). Then install the
-  optional extras you need (e.g., `bayesopt`, `explain`, or `gnn`). This avoids pip pulling a
-  mismatched wheel.
-- **Torch Geometric (GNN)**: `torch-geometric` often requires platform-specific wheels (e.g.,
-  `torch-scatter`, `torch-sparse`). Follow the official PyG installation instructions for your
-  CUDA/ROCm/CPU environment, then install `ins_pricing[gnn]`.
-- **Multi-GPU**: Training code will use CUDA when available and can enable multi-GPU via
-  `torch.distributed`/`DataParallel` where supported. On Windows, CUDA DDP is not supported and will
-  fall back to single-GPU or DataParallel where possible.
+- 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 torch.distributed/DataParallel where supported; Windows disables CUDA DDP.
 
-### Requirements
+---
+## PyPI Upload (scripts)
 
-- Python >= 3.9
-- Core dependencies: numpy >= 1.20, pandas >= 1.4
+This repo includes upload scripts for Windows and Linux/macOS.
 
-### License
+### Windows
 
-Proprietary
+```cmd
+set TWINE_PASSWORD=your_pypi_token_here
+python -m build
+upload_to_pypi.bat
+```
+
+### Linux / macOS
+
+```bash
+chmod +x upload_to_pypi.sh
+export TWINE_PASSWORD='your_pypi_token_here'
+python -m build
+./upload_to_pypi.sh
+```
+
+### Makefile (if make is available)
+
+```bash
+make build
+make upload
+```
+
+### Tips
+
+- Never commit tokens to version control.
+- Use environment variables or secret managers to store credentials.
+- Test with TestPyPI before publishing when needed.

ins_pricing-0.5.0/README.md

@@ -0,0 +1,130 @@
+# Insurance-Pricing
+
+A reusable toolkit for insurance modeling, pricing, governance, and reporting.
+
+## Overview
+
+Insurance-Pricing (ins_pricing) is an enterprise-grade Python library designed for machine learning
+model training, pricing calculations, and model governance workflows in the insurance industry.
+
+### Core Modules
+
+| Module | Description |
+|--------|-------------|
+| modelling | ML model training (GLM, XGBoost, ResNet, FT-Transformer, GNN) and model interpretability |
+| pricing | Factor table construction, numeric binning, premium calibration, exposure calculation, PSI monitoring |
+| production | Model prediction, batch scoring, data drift detection, production metrics monitoring |
+| governance | Model registry, version management, approval workflows, audit logging |
+| reporting | Report generation (Markdown format), report scheduling |
+| utils | Data validation, performance profiling, device management, logging configuration |
+
+### Quick Start
+
+```python
+# Model training with Bayesian optimization
+from ins_pricing import bayesopt as ropt
+
+model = ropt.BayesOptModel(
+    train_data, test_data,
+    model_name='my_model',
+    resp_nme='target',
+    weight_nme='weight',
+    factor_nmes=feature_list,
+    cate_list=categorical_features,
+)
+model.bayesopt_xgb(max_evals=100)      # Train XGBoost
+model.bayesopt_resnet(max_evals=50)    # Train ResNet
+model.bayesopt_ft(max_evals=50)        # Train FT-Transformer
+
+# Pricing: build factor table
+from ins_pricing.pricing import build_factor_table
+factors = build_factor_table(
+    df,
+    factor_col='age_band',
+    loss_col='claim_amount',
+    exposure_col='exposure',
+)
+
+# Production: batch scoring
+from ins_pricing.production import batch_score
+scores = batch_score(model.trainers['xgb'].predict, df)
+
+# Model governance
+from ins_pricing.governance import ModelRegistry
+registry = ModelRegistry('models.json')
+registry.register(model_name, version, metrics=metrics)
+```
+
+### Project Structure
+
+```
+ins_pricing/
+  cli/                    # Command-line entry points
+  modelling/
+    core/bayesopt/         # ML model training core
+    explain/               # Model interpretability
+    plotting/              # Model visualization
+  pricing/                 # Insurance pricing module
+  production/              # Production deployment module
+  governance/              # Model governance
+  reporting/               # Report generation
+  utils/                   # Utilities
+  tests/                   # Test suite
+```
+
+### Installation
+
+```bash
+# Basic installation
+pip install ins_pricing
+
+# Full installation (all optional dependencies)
+pip install ins_pricing[all]
+
+# Install specific extras
+pip install ins_pricing[bayesopt]    # Model training
+pip install ins_pricing[explain]     # Model explanation
+pip install ins_pricing[plotting]    # Visualization
+pip install ins_pricing[gnn]         # Graph neural networks
+```
+
+#### 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 torch.distributed/DataParallel where supported; Windows disables CUDA DDP.
+
+---
+## PyPI Upload (scripts)
+
+This repo includes upload scripts for Windows and Linux/macOS.
+
+### Windows
+
+```cmd
+set TWINE_PASSWORD=your_pypi_token_here
+python -m build
+upload_to_pypi.bat
+```
+
+### Linux / macOS
+
+```bash
+chmod +x upload_to_pypi.sh
+export TWINE_PASSWORD='your_pypi_token_here'
+python -m build
+./upload_to_pypi.sh
+```
+
+### Makefile (if make is available)
+
+```bash
+make build
+make upload
+```
+
+### Tips
+
+- Never commit tokens to version control.
+- Use environment variables or secret managers to store credentials.
+- Test with TestPyPI before publishing when needed.

ins_pricing-0.5.0/ins_pricing/README.md

@@ -0,0 +1,92 @@
+# ins_pricing
+
+Distribution name: ins_pricing (import package is `ins_pricing`; legacy alias `user_packages` still works).
+
+Reusable modelling and pricing utilities organized as a small toolbox with clear boundaries
+between modelling, production, governance, and reporting.
+
+## Architecture
+
+- `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.
+- `reporting/`: report builder and scheduler.
+
+## Call flow (typical)
+
+1. Model training
+   - Python API: `from ins_pricing.modelling import BayesOptModel`
+   - CLI: `python ins_pricing/cli/BayesOpt_entry.py --config-json ...`
+2. Evaluation and visualization
+   - Curves: `from ins_pricing.plotting import curves`
+   - Importance: `from ins_pricing.plotting import importance`
+   - Geo: `from ins_pricing.plotting import geo`
+3. Explainability
+   - `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`
+   - 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.
+- 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`.
+  - 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
+
+- 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
+
+Legacy import paths continue to work:
+
+- `import user_packages`
+- `import user_packages.bayesopt`
+- `import user_packages.plotting`
+- `import user_packages.explain`
+- `import user_packages.BayesOpt`

{ins_pricing-0.4.4 → ins_pricing-0.5.0}/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()))