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

ins_pricing/governance/__init__.py

@@ -1,20 +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",
-]
+from __future__ import annotations
+
+from ins_pricing.governance.approval import ApprovalAction, ApprovalRequest, ApprovalStore
+from ins_pricing.governance.audit import AuditEvent, AuditLogger
+from ins_pricing.governance.registry import ModelArtifact, ModelRegistry, ModelVersion
+from ins_pricing.governance.release import DeploymentState, ModelRef, ReleaseManager
+
+__all__ = [
+    "ApprovalAction",
+    "ApprovalRequest",
+    "ApprovalStore",
+    "AuditEvent",
+    "AuditLogger",
+    "ModelArtifact",
+    "ModelRegistry",
+    "ModelVersion",
+    "DeploymentState",
+    "ModelRef",
+    "ReleaseManager",
+]

ins_pricing/governance/release.py

@@ -1,159 +1,159 @@
-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
-
-from .audit import AuditLogger
-from .registry import ModelRegistry
-
-
-@dataclass
-class ModelRef:
-    name: str
-    version: str
-    activated_at: str
-    actor: Optional[str] = None
-    note: Optional[str] = None
-
-
-@dataclass
-class DeploymentState:
-    env: str
-    active: Optional[ModelRef] = None
-    history: List[ModelRef] = field(default_factory=list)
-    updated_at: Optional[str] = None
-
-
-class ReleaseManager:
-    """Environment release manager with rollback support."""
-
-    def __init__(
-        self,
-        state_dir: str | Path,
-        *,
-        registry: Optional[ModelRegistry] = None,
-        audit_logger: Optional[AuditLogger] = None,
-    ):
-        self.state_dir = Path(state_dir)
-        self.state_dir.mkdir(parents=True, exist_ok=True)
-        self.registry = registry
-        self.audit_logger = audit_logger
-
-    def _state_path(self, env: str) -> Path:
-        return self.state_dir / f"{env}.json"
-
-    def _load(self, env: str) -> DeploymentState:
-        path = self._state_path(env)
-        if not path.exists():
-            return DeploymentState(env=env)
-        with path.open("r", encoding="utf-8") as fh:
-            payload = json.load(fh)
-        active = payload.get("active")
-        history = payload.get("history", [])
-        return DeploymentState(
-            env=payload.get("env", env),
-            active=ModelRef(**active) if active else None,
-            history=[ModelRef(**item) for item in history],
-            updated_at=payload.get("updated_at"),
-        )
-
-    def _save(self, state: DeploymentState) -> None:
-        payload = {
-            "env": state.env,
-            "active": asdict(state.active) if state.active else None,
-            "history": [asdict(item) for item in state.history],
-            "updated_at": state.updated_at,
-        }
-        path = self._state_path(state.env)
-        with path.open("w", encoding="utf-8") as fh:
-            json.dump(payload, fh, indent=2, ensure_ascii=True)
-
-    def get_active(self, env: str) -> Optional[ModelRef]:
-        state = self._load(env)
-        return state.active
-
-    def list_history(self, env: str) -> List[ModelRef]:
-        return self._load(env).history
-
-    def deploy(
-        self,
-        env: str,
-        name: str,
-        version: str,
-        *,
-        actor: Optional[str] = None,
-        note: Optional[str] = None,
-        update_registry_status: bool = True,
-        registry_status: str = "production",
-    ) -> DeploymentState:
-        state = self._load(env)
-        if state.active and state.active.name == name and state.active.version == version:
-            return state
-
-        if state.active is not None:
-            state.history.append(state.active)
-
-        now = datetime.utcnow().isoformat()
-        state.active = ModelRef(
-            name=name,
-            version=version,
-            activated_at=now,
-            actor=actor,
-            note=note,
-        )
-        state.updated_at = now
-        self._save(state)
-
-        if self.registry and update_registry_status:
-            self.registry.promote(name, version, new_status=registry_status)
-
-        if self.audit_logger:
-            self.audit_logger.log(
-                "deploy",
-                actor or "unknown",
-                metadata={"env": env, "name": name, "version": version},
-                note=note,
-            )
-
-        return state
-
-    def rollback(
-        self,
-        env: str,
-        *,
-        actor: Optional[str] = None,
-        note: Optional[str] = None,
-        update_registry_status: bool = False,
-        registry_status: str = "production",
-    ) -> DeploymentState:
-        state = self._load(env)
-        if not state.history:
-            raise ValueError("No history available to rollback.")
-
-        previous = state.history.pop()
-        now = datetime.utcnow().isoformat()
-        state.active = ModelRef(
-            name=previous.name,
-            version=previous.version,
-            activated_at=now,
-            actor=actor or previous.actor,
-            note=note or previous.note,
-        )
-        state.updated_at = now
-        self._save(state)
-
-        if self.registry and update_registry_status:
-            self.registry.promote(previous.name, previous.version, new_status=registry_status)
-
-        if self.audit_logger:
-            self.audit_logger.log(
-                "rollback",
-                actor or "unknown",
-                metadata={"env": env, "name": previous.name, "version": previous.version},
-                note=note,
-            )
-
-        return state
+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
+
+from ins_pricing.governance.audit import AuditLogger
+from ins_pricing.governance.registry import ModelRegistry
+
+
+@dataclass
+class ModelRef:
+    name: str
+    version: str
+    activated_at: str
+    actor: Optional[str] = None
+    note: Optional[str] = None
+
+
+@dataclass
+class DeploymentState:
+    env: str
+    active: Optional[ModelRef] = None
+    history: List[ModelRef] = field(default_factory=list)
+    updated_at: Optional[str] = None
+
+
+class ReleaseManager:
+    """Environment release manager with rollback support."""
+
+    def __init__(
+        self,
+        state_dir: str | Path,
+        *,
+        registry: Optional[ModelRegistry] = None,
+        audit_logger: Optional[AuditLogger] = None,
+    ):
+        self.state_dir = Path(state_dir)
+        self.state_dir.mkdir(parents=True, exist_ok=True)
+        self.registry = registry
+        self.audit_logger = audit_logger
+
+    def _state_path(self, env: str) -> Path:
+        return self.state_dir / f"{env}.json"
+
+    def _load(self, env: str) -> DeploymentState:
+        path = self._state_path(env)
+        if not path.exists():
+            return DeploymentState(env=env)
+        with path.open("r", encoding="utf-8") as fh:
+            payload = json.load(fh)
+        active = payload.get("active")
+        history = payload.get("history", [])
+        return DeploymentState(
+            env=payload.get("env", env),
+            active=ModelRef(**active) if active else None,
+            history=[ModelRef(**item) for item in history],
+            updated_at=payload.get("updated_at"),
+        )
+
+    def _save(self, state: DeploymentState) -> None:
+        payload = {
+            "env": state.env,
+            "active": asdict(state.active) if state.active else None,
+            "history": [asdict(item) for item in state.history],
+            "updated_at": state.updated_at,
+        }
+        path = self._state_path(state.env)
+        with path.open("w", encoding="utf-8") as fh:
+            json.dump(payload, fh, indent=2, ensure_ascii=True)
+
+    def get_active(self, env: str) -> Optional[ModelRef]:
+        state = self._load(env)
+        return state.active
+
+    def list_history(self, env: str) -> List[ModelRef]:
+        return self._load(env).history
+
+    def deploy(
+        self,
+        env: str,
+        name: str,
+        version: str,
+        *,
+        actor: Optional[str] = None,
+        note: Optional[str] = None,
+        update_registry_status: bool = True,
+        registry_status: str = "production",
+    ) -> DeploymentState:
+        state = self._load(env)
+        if state.active and state.active.name == name and state.active.version == version:
+            return state
+
+        if state.active is not None:
+            state.history.append(state.active)
+
+        now = datetime.utcnow().isoformat()
+        state.active = ModelRef(
+            name=name,
+            version=version,
+            activated_at=now,
+            actor=actor,
+            note=note,
+        )
+        state.updated_at = now
+        self._save(state)
+
+        if self.registry and update_registry_status:
+            self.registry.promote(name, version, new_status=registry_status)
+
+        if self.audit_logger:
+            self.audit_logger.log(
+                "deploy",
+                actor or "unknown",
+                metadata={"env": env, "name": name, "version": version},
+                note=note,
+            )
+
+        return state
+
+    def rollback(
+        self,
+        env: str,
+        *,
+        actor: Optional[str] = None,
+        note: Optional[str] = None,
+        update_registry_status: bool = False,
+        registry_status: str = "production",
+    ) -> DeploymentState:
+        state = self._load(env)
+        if not state.history:
+            raise ValueError("No history available to rollback.")
+
+        previous = state.history.pop()
+        now = datetime.utcnow().isoformat()
+        state.active = ModelRef(
+            name=previous.name,
+            version=previous.version,
+            activated_at=now,
+            actor=actor or previous.actor,
+            note=note or previous.note,
+        )
+        state.updated_at = now
+        self._save(state)
+
+        if self.registry and update_registry_status:
+            self.registry.promote(previous.name, previous.version, new_status=registry_status)
+
+        if self.audit_logger:
+            self.audit_logger.log(
+                "rollback",
+                actor or "unknown",
+                metadata={"env": env, "name": previous.name, "version": previous.version},
+                note=note,
+            )
+
+        return state

ins_pricing/modelling/README.md

@@ -4,7 +4,7 @@ This directory contains reusable training tooling and frameworks centered on Bay
 
 ## Key locations
 
-- `core/bayesopt/` - core training/tuning package
+- `bayesopt/` - core training/tuning package
 - `explain/` - explainability helpers
 - `plotting/` - plotting utilities
 - `ins_pricing/cli/` - CLI entry points

ins_pricing/modelling/__init__.py

@@ -1,95 +1,150 @@
-from __future__ import annotations
-
-from importlib import import_module
-from pathlib import Path
-import sys
-import types
-
-# Keep imports lazy to avoid hard dependencies when only using lightweight modules.
-
-__all__ = [
-    "BayesOptConfig",
-    "BayesOptModel",
-    "IOUtils",
-    "TrainingUtils",
-    "free_cuda",
-    "bayesopt",
-    "plotting",
-    "explain",
-]
-
-_LAZY_ATTRS = {
-    "bayesopt": "ins_pricing.modelling.core.bayesopt",
-    "plotting": "ins_pricing.modelling.plotting",
-    "explain": "ins_pricing.modelling.explain",
-    "BayesOptConfig": "ins_pricing.modelling.core.bayesopt.core",
-    "BayesOptModel": "ins_pricing.modelling.core.bayesopt.core",
-    "IOUtils": "ins_pricing.modelling.core.bayesopt.utils",
-    "TrainingUtils": "ins_pricing.modelling.core.bayesopt.utils",
-    "free_cuda": "ins_pricing.modelling.core.bayesopt.utils",
-}
-
+from __future__ import annotations
+
+from importlib import import_module
+from pathlib import Path
+import sys
+import types
+
+# Keep imports lazy to avoid hard dependencies when only using lightweight modules.
+
+__all__ = sorted(
+    {
+        "BayesOptConfig",
+        "BayesOptModel",
+        "bayesopt",
+        "plotting",
+        "explain",
+        "evaluation",
+        "cli",
+    }
+)
+
+_LAZY_ATTRS = {
+    "bayesopt": "ins_pricing.modelling.bayesopt",
+    "plotting": "ins_pricing.modelling.plotting",
+    "explain": "ins_pricing.modelling.explain",
+    "BayesOptConfig": "ins_pricing.modelling.bayesopt.core",
+    "BayesOptModel": "ins_pricing.modelling.bayesopt.core",
+}
+
+_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",
+}
+
+__all__ = sorted(set(__all__) | set(_BAYESOPT_EXPORTS) | set(_LEGACY_EXPORTS))
+
 _LAZY_SUBMODULES = {
-    "bayesopt": "ins_pricing.modelling.core.bayesopt",
-    "BayesOpt": "ins_pricing.modelling.core.BayesOpt",
-    "evaluation": "ins_pricing.modelling.core.evaluation",
+    "bayesopt": "ins_pricing.modelling.bayesopt",
+    "evaluation": "ins_pricing.modelling.evaluation",
     "cli": "ins_pricing.cli",
 }
-
-_PACKAGE_PATHS = {
-    "bayesopt": Path(__file__).resolve().parent / "core" / "bayesopt",
-    "cli": Path(__file__).resolve().parents[1] / "cli",
-}
-
-
-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):
-    target = _LAZY_ATTRS.get(name)
-    if not target:
-        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-    module = import_module(target)
-    if name in {"bayesopt", "plotting", "explain"}:
-        value = module
-    else:
-        value = getattr(module, name)
-    globals()[name] = value
-    return value
-
-
-def __dir__() -> list[str]:
-    return sorted(set(__all__) | set(globals().keys()))
+
+_PACKAGE_PATHS = {
+    "bayesopt": Path(__file__).resolve().parent / "bayesopt",
+    "cli": Path(__file__).resolve().parents[1] / "cli",
+}
+
+
+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):
+    target = _LAZY_ATTRS.get(name)
+    if target:
+        module = import_module(target)
+        if name in {"bayesopt", "plotting", "explain"}:
+            value = module
+        else:
+            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(_BAYESOPT_EXPORTS) | set(_LEGACY_EXPORTS) | set(globals().keys()))

ins_pricing/modelling/{core/bayesopt → bayesopt}/README.md

@@ -6,7 +6,7 @@ It supports JSON-driven CLI runs and a Python API for notebooks/scripts.
 ## Recommended API (config-based)
 
 ```python
-from ins_pricing.modelling.core.bayesopt import BayesOptConfig
+from ins_pricing.modelling.bayesopt import BayesOptConfig
 from ins_pricing.modelling import BayesOptModel
 
 config = BayesOptConfig(
@@ -27,7 +27,7 @@ model.optimize_model("xgb", max_evals=50)
 ## Load config from file
 
 ```python
-from ins_pricing.modelling.core.bayesopt import BayesOptConfig
+from ins_pricing.modelling.bayesopt import BayesOptConfig
 from ins_pricing.modelling import BayesOptModel
 
 config = BayesOptConfig.from_file("config.json")
@@ -46,14 +46,32 @@ python ins_pricing/cli/BayesOpt_entry.py --config-json config_template.json
 - `embedding`: FT trains with labels but exports embeddings (`pred_<prefix>_*`).
 - `unsupervised_embedding`: FT trains without labels and exports embeddings.
 
-## Output layout
-
-`output_dir/` contains:
-- `plot/` plots and diagnostics
-- `Results/` metrics, params, and snapshots
-- `model/` saved models
-
-## Notes
-
-- Relative paths in config are resolved from the config file directory.
-- For multi-GPU, use `torchrun` and set `runner.nproc_per_node` in config.
+## Output layout
+
+`output_dir/` contains:
+- `plot/` plots and diagnostics
+- `Results/` metrics, params, and snapshots
+- `model/` saved models
+
+## XGBoost GPU tips
+
+- Use `xgb_gpu_id` to select a specific GPU on multi-GPU Linux systems.
+- Per-fold GPU cleanup is disabled by default to avoid long idle gaps caused by CUDA sync.
+  - If you need to reclaim memory between folds, set `xgb_cleanup_per_fold=true`.
+  - If you still need a full device sync, set `xgb_cleanup_synchronize=true` (slower).
+- `xgb_use_dmatrix=true` switches XGBoost to `xgb.train` + DMatrix/QuantileDMatrix for better throughput.
+- External-memory DMatrix (file-backed) is disabled; pass in-memory arrays/dataframes.
+
+## Torch model cleanup
+
+To reduce CPU↔GPU thrash, fold-level cleanup for FT/ResNet/GNN is off by default.
+Enable if you see memory pressure:
+- `ft_cleanup_per_fold`, `ft_cleanup_synchronize`
+- `resn_cleanup_per_fold`, `resn_cleanup_synchronize`
+- `gnn_cleanup_per_fold`, `gnn_cleanup_synchronize`
+- `optuna_cleanup_synchronize` controls whether trial-level cleanup syncs CUDA (default false)
+
+## Notes
+
+- Relative paths in config are resolved from the config file directory.
+- For multi-GPU, use `torchrun` and set `runner.nproc_per_node` in config.