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

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

@@ -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.

ins_pricing/modelling/bayesopt/config_components.py

@@ -178,10 +178,18 @@ class XGBoostConfig:
     Attributes:
         max_depth_max: Maximum tree depth for hyperparameter tuning
         n_estimators_max: Maximum number of estimators for tuning
+        gpu_id: GPU device id for XGBoost (None = default)
+        cleanup_per_fold: Whether to cleanup GPU memory after each fold
+        cleanup_synchronize: Whether to synchronize CUDA during cleanup
+        use_dmatrix: Whether to use xgb.train with DMatrix/QuantileDMatrix
     """
 
     max_depth_max: int = 25
     n_estimators_max: int = 500
+    gpu_id: Optional[int] = None
+    cleanup_per_fold: bool = False
+    cleanup_synchronize: bool = False
+    use_dmatrix: bool = True
 
     @classmethod
     def from_flat_dict(cls, d: Dict[str, Any]) -> "XGBoostConfig":
@@ -189,6 +197,10 @@ class XGBoostConfig:
         return cls(
             max_depth_max=int(d.get("xgb_max_depth_max", 25)),
             n_estimators_max=int(d.get("xgb_n_estimators_max", 500)),
+            gpu_id=d.get("xgb_gpu_id"),
+            cleanup_per_fold=bool(d.get("xgb_cleanup_per_fold", False)),
+            cleanup_synchronize=bool(d.get("xgb_cleanup_synchronize", False)),
+            use_dmatrix=bool(d.get("xgb_use_dmatrix", True)),
         )
 
 

ins_pricing/modelling/bayesopt/config_preprocess.py

@@ -14,6 +14,13 @@ from sklearn.preprocessing import StandardScaler
 from ins_pricing.utils.io import IOUtils
 from ins_pricing.utils.losses import normalize_loss_name
 from ins_pricing.exceptions import ConfigurationError, DataValidationError
+from ins_pricing.utils import get_logger, log_print
+
+_logger = get_logger("ins_pricing.modelling.bayesopt.config_preprocess")
+
+
+def _log(*args, **kwargs) -> None:
+    log_print(_logger, *args, **kwargs)
 
 # NOTE: Some CSV exports may contain invisible BOM characters or leading/trailing
 # spaces in column names. Pandas requires exact matches, so we normalize a few
@@ -86,9 +93,20 @@ class BayesOptConfig:
         prop_test: Proportion of data for validation (0.0-1.0)
         rand_seed: Random seed for reproducibility
         epochs: Number of training epochs
-        use_gpu: Whether to use GPU acceleration
-        xgb_max_depth_max: Maximum tree depth for XGBoost tuning
-        xgb_n_estimators_max: Maximum estimators for XGBoost tuning
+        use_gpu: Whether to use GPU acceleration
+        xgb_max_depth_max: Maximum tree depth for XGBoost tuning
+        xgb_n_estimators_max: Maximum estimators for XGBoost tuning
+        xgb_gpu_id: GPU device id for XGBoost (None = default)
+        xgb_cleanup_per_fold: Whether to cleanup GPU memory after each XGBoost fold
+        xgb_cleanup_synchronize: Whether to synchronize CUDA during XGBoost cleanup
+        xgb_use_dmatrix: Whether to use xgb.train with DMatrix/QuantileDMatrix
+        ft_cleanup_per_fold: Whether to cleanup GPU memory after each FT fold
+        ft_cleanup_synchronize: Whether to synchronize CUDA during FT cleanup
+        resn_cleanup_per_fold: Whether to cleanup GPU memory after each ResNet fold
+        resn_cleanup_synchronize: Whether to synchronize CUDA during ResNet cleanup
+        gnn_cleanup_per_fold: Whether to cleanup GPU memory after each GNN fold
+        gnn_cleanup_synchronize: Whether to synchronize CUDA during GNN cleanup
+        optuna_cleanup_synchronize: Whether to synchronize CUDA during Optuna cleanup
         use_resn_data_parallel: Use DataParallel for ResNet
         use_ft_data_parallel: Use DataParallel for FT-Transformer
         use_resn_ddp: Use DDP for ResNet
@@ -128,9 +146,20 @@ class BayesOptConfig:
     epochs: int = 100
     use_gpu: bool = True
 
-    # XGBoost settings
-    xgb_max_depth_max: int = 25
-    xgb_n_estimators_max: int = 500
+    # XGBoost settings
+    xgb_max_depth_max: int = 25
+    xgb_n_estimators_max: int = 500
+    xgb_gpu_id: Optional[int] = None
+    xgb_cleanup_per_fold: bool = False
+    xgb_cleanup_synchronize: bool = False
+    xgb_use_dmatrix: bool = True
+    ft_cleanup_per_fold: bool = False
+    ft_cleanup_synchronize: bool = False
+    resn_cleanup_per_fold: bool = False
+    resn_cleanup_synchronize: bool = False
+    gnn_cleanup_per_fold: bool = False
+    gnn_cleanup_synchronize: bool = False
+    optuna_cleanup_synchronize: bool = False
 
     # Distributed training settings
     use_resn_data_parallel: bool = False
@@ -244,10 +273,18 @@ class BayesOptConfig:
             errors.append(
                 f"xgb_max_depth_max must be >= 1, got {self.xgb_max_depth_max}"
             )
-        if self.xgb_n_estimators_max < 1:
-            errors.append(
-                f"xgb_n_estimators_max must be >= 1, got {self.xgb_n_estimators_max}"
-            )
+        if self.xgb_n_estimators_max < 1:
+            errors.append(
+                f"xgb_n_estimators_max must be >= 1, got {self.xgb_n_estimators_max}"
+            )
+        if self.xgb_gpu_id is not None:
+            try:
+                gpu_id = int(self.xgb_gpu_id)
+            except (TypeError, ValueError):
+                errors.append(f"xgb_gpu_id must be an integer, got {self.xgb_gpu_id!r}")
+            else:
+                if gpu_id < 0:
+                    errors.append(f"xgb_gpu_id must be >= 0, got {gpu_id}")
 
         # Validate distributed training: can't use both DataParallel and DDP
         if self.use_resn_data_parallel and self.use_resn_ddp:
@@ -363,7 +400,7 @@ class VersionManager:
         IOUtils.ensure_parent_dir(str(path))
         with open(path, "w", encoding="utf-8") as f:
             json.dump(payload, f, ensure_ascii=False, indent=2, default=str)
-        print(f"[Version] Saved snapshot: {path}")
+        _log(f"[Version] Saved snapshot: {path}")
         return str(path)
 
     def load_latest(self, tag: str) -> Optional[Dict[str, Any]]:
@@ -377,7 +414,7 @@ class VersionManager:
         try:
             return json.loads(path.read_text(encoding="utf-8"))
         except Exception as exc:
-            print(f"[Version] Failed to load snapshot {path}: {exc}")
+            _log(f"[Version] Failed to load snapshot {path}: {exc}")
             return None
 
 
@@ -469,7 +506,7 @@ class DatasetPreprocessor:
 
         build_oht = bool(getattr(cfg, "build_oht", True))
         if not build_oht:
-            print("[Preprocess] build_oht=False; skip one-hot features.", flush=True)
+            _log("[Preprocess] build_oht=False; skip one-hot features.", flush=True)
             self.train_oht_data = None
             self.test_oht_data = None
             self.train_oht_scl_data = None

ins_pricing/modelling/bayesopt/core.py

@@ -16,7 +16,7 @@ from ins_pricing.modelling.bayesopt.model_explain_mixin import BayesOptExplainMi
 from ins_pricing.modelling.bayesopt.model_plotting_mixin import BayesOptPlottingMixin
 from ins_pricing.modelling.bayesopt.models import GraphNeuralNetSklearn
 from ins_pricing.modelling.bayesopt.trainers import FTTrainer, GLMTrainer, GNNTrainer, ResNetTrainer, XGBTrainer
-from ins_pricing.utils import EPS, infer_factor_and_cate_list, set_global_seed
+from ins_pricing.utils import EPS, infer_factor_and_cate_list, set_global_seed, get_logger, log_print
 from ins_pricing.utils.io import IOUtils
 from ins_pricing.utils.losses import (
     infer_loss_name_from_model_name,
@@ -25,6 +25,12 @@ from ins_pricing.utils.losses import (
     resolve_xgb_objective,
 )
 
+_logger = get_logger("ins_pricing.modelling.bayesopt.core")
+
+
+def _log(*args, **kwargs) -> None:
+    log_print(_logger, *args, **kwargs)
+
 
 class _CVSplitter:
     """Wrapper to carry optional groups or time order for CV splits."""
@@ -108,11 +114,22 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
                  region_effect_alpha: Optional[float] = None,
                  geo_feature_nmes: Optional[List[str]] = None,
                  geo_token_hidden_dim: Optional[int] = None,
-                 geo_token_layers: Optional[int] = None,
-                 geo_token_dropout: Optional[float] = None,
-                 geo_token_k_neighbors: Optional[int] = None,
-                 geo_token_learning_rate: Optional[float] = None,
-                 geo_token_epochs: Optional[int] = None):
+                 geo_token_layers: Optional[int] = None,
+                 geo_token_dropout: Optional[float] = None,
+                 geo_token_k_neighbors: Optional[int] = None,
+                 geo_token_learning_rate: Optional[float] = None,
+                 geo_token_epochs: Optional[int] = None,
+                 xgb_gpu_id: Optional[int] = None,
+                 xgb_cleanup_per_fold: bool = False,
+                 xgb_cleanup_synchronize: bool = False,
+                 xgb_use_dmatrix: bool = True,
+                 ft_cleanup_per_fold: bool = False,
+                 ft_cleanup_synchronize: bool = False,
+                 resn_cleanup_per_fold: bool = False,
+                 resn_cleanup_synchronize: bool = False,
+                 gnn_cleanup_per_fold: bool = False,
+                 gnn_cleanup_synchronize: bool = False,
+                 optuna_cleanup_synchronize: bool = False):
         """Orchestrate BayesOpt training across multiple trainers.
 
         Args:
@@ -229,8 +246,19 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
                 rand_seed=rand_seed,
                 epochs=epochs,
                 use_gpu=use_gpu,
-                xgb_max_depth_max=int(xgb_max_depth_max),
-                xgb_n_estimators_max=int(xgb_n_estimators_max),
+                xgb_max_depth_max=int(xgb_max_depth_max),
+                xgb_n_estimators_max=int(xgb_n_estimators_max),
+                xgb_gpu_id=int(xgb_gpu_id) if xgb_gpu_id is not None else None,
+                xgb_cleanup_per_fold=bool(xgb_cleanup_per_fold),
+                xgb_cleanup_synchronize=bool(xgb_cleanup_synchronize),
+                xgb_use_dmatrix=bool(xgb_use_dmatrix),
+                ft_cleanup_per_fold=bool(ft_cleanup_per_fold),
+                ft_cleanup_synchronize=bool(ft_cleanup_synchronize),
+                resn_cleanup_per_fold=bool(resn_cleanup_per_fold),
+                resn_cleanup_synchronize=bool(resn_cleanup_synchronize),
+                gnn_cleanup_per_fold=bool(gnn_cleanup_per_fold),
+                gnn_cleanup_synchronize=bool(gnn_cleanup_synchronize),
+                optuna_cleanup_synchronize=bool(optuna_cleanup_synchronize),
                 use_resn_data_parallel=use_resn_data_parallel,
                 use_ft_data_parallel=use_ft_data_parallel,
                 use_resn_ddp=use_resn_ddp,
@@ -542,7 +570,7 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
                 test_embed, index=self.test_data.index, columns=cols)
             return train_tokens, test_tokens, cols, geo_gnn
         except Exception as exc:
-            print(f"[GeoToken] Generation failed: {exc}")
+            _log(f"[GeoToken] Generation failed: {exc}")
             return None
 
     def _prepare_geo_tokens(self) -> None:
@@ -553,7 +581,7 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
                 gnn_trainer.prepare_geo_tokens(force=False)  # type: ignore[attr-defined]
                 return
             except Exception as exc:
-                print(f"[GeoToken] GNNTrainer generation failed: {exc}")
+                _log(f"[GeoToken] GNNTrainer generation failed: {exc}")
 
         result = self._build_geo_tokens()
         if result is None:
@@ -563,7 +591,7 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
         self.test_geo_tokens = test_tokens
         self.geo_token_cols = cols
         self.geo_gnn_model = geo_gnn
-        print(f"[GeoToken] Generated {len(cols)}-dim geo tokens; injecting into FT.")
+        _log(f"[GeoToken] Generated {len(cols)}-dim geo tokens; injecting into FT.")
 
     def _add_region_effect(self) -> None:
         """Partial pooling over province/city to create a smoothed region_effect feature."""
@@ -573,7 +601,7 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
             return
         for col in [prov_col, city_col]:
             if col not in self.train_data.columns:
-                print(f"[RegionEffect] Missing column {col}; skipped.")
+                _log(f"[RegionEffect] Missing column {col}; skipped.")
                 return
 
         def safe_mean(df: pd.DataFrame) -> float:
@@ -691,7 +719,7 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
         if best_params_file and not trainer.best_params:
             trainer.best_params = IOUtils.load_params_file(best_params_file)
             trainer.best_trial = None
-            print(
+            _log(
                 f"[Optuna][{trainer.label}] Loaded best_params from {best_params_file}; skip tuning."
             )
 
@@ -705,7 +733,7 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
                 trainer.best_trial = None
                 trainer.study_name = payload.get(
                     "study_name") if isinstance(payload, dict) else None
-                print(
+                _log(
                     f"[Optuna][{trainer.label}] Reusing best_params from versions snapshot.")
                 return
 
@@ -716,7 +744,7 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
                 try:
                     trainer.best_params = IOUtils.load_params_file(params_path)
                     trainer.best_trial = None
-                    print(
+                    _log(
                         f"[Optuna][{trainer.label}] Reusing best_params from {params_path}.")
                 except ValueError:
                     # Legacy compatibility: ignore empty files and continue tuning.
@@ -725,7 +753,7 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
     # Generic optimization entry point.
     def optimize_model(self, model_key: str, max_evals: int = 100):
         if model_key not in self.trainers:
-            print(f"Warning: Unknown model key: {model_key}")
+            _log(f"Warning: Unknown model key: {model_key}")
             return
 
         trainer = self._require_trainer(model_key)
@@ -774,7 +802,7 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
                 elif hasattr(trainer, "ensemble_predict"):
                     trainer.ensemble_predict(k)
                 else:
-                    print(
+                    _log(
                         f"[Ensemble] Trainer '{model_key}' does not support ensemble prediction.",
                         flush=True,
                     )
@@ -945,7 +973,7 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
                 self.trainers[key].save()
             else:
                 if model_name:  # Only warn when the user specifies a model name.
-                    print(f"[save_model] Warning: Unknown model key {key}")
+                    _log(f"[save_model] Warning: Unknown model key {key}")
 
     def load_model(self, model_name=None):
         keys = [model_name] if model_name else self.trainers.keys()
@@ -962,4 +990,4 @@ class BayesOptModel(BayesOptPlottingMixin, BayesOptExplainMixin):
                         setattr(self, f"{key}_load", trainer.model)
             else:
                 if model_name:
-                    print(f"[load_model] Warning: Unknown model key {key}")
+                    _log(f"[load_model] Warning: Unknown model key {key}")

ins_pricing/modelling/bayesopt/model_plotting_mixin.py

@@ -16,7 +16,13 @@ except Exception as exc:  # pragma: no cover - optional dependency
 import numpy as np
 import pandas as pd
 
-from ins_pricing.utils import EPS
+from ins_pricing.utils import EPS, get_logger, log_print
+
+_logger = get_logger("ins_pricing.modelling.bayesopt.model_plotting_mixin")
+
+
+def _log(*args, **kwargs) -> None:
+    log_print(_logger, *args, **kwargs)
 
 try:
     from ins_pricing.modelling.plotting import curves as plot_curves
@@ -36,9 +42,9 @@ except Exception:  # pragma: no cover - optional for legacy imports
 
 def _plot_skip(label: str) -> None:
     if _MPL_IMPORT_ERROR is not None:
-        print(f"[Plot] Skip {label}: matplotlib unavailable ({_MPL_IMPORT_ERROR}).", flush=True)
+        _log(f"[Plot] Skip {label}: matplotlib unavailable ({_MPL_IMPORT_ERROR}).", flush=True)
     else:
-        print(f"[Plot] Skip {label}: matplotlib unavailable.", flush=True)
+        _log(f"[Plot] Skip {label}: matplotlib unavailable.", flush=True)
 
 
 class BayesOptPlottingMixin:
@@ -54,7 +60,7 @@ class BayesOptPlottingMixin:
             _plot_skip("oneway plot")
             return
         if pred_col is not None and pred_col not in self.train_data.columns:
-            print(
+            _log(
                 f"[Oneway] Missing prediction column '{pred_col}'; skip predicted line.",
                 flush=True,
             )
@@ -146,7 +152,7 @@ class BayesOptPlottingMixin:
             return
 
         if "w_act" not in self.train_data.columns:
-            print("[Oneway] Missing w_act column; skip plotting.", flush=True)
+            _log("[Oneway] Missing w_act column; skip plotting.", flush=True)
             return
 
         for c in self.factor_nmes:
@@ -220,7 +226,7 @@ class BayesOptPlottingMixin:
             ('Lift Chart on Test Data', self.test_data),
         ]:
             if 'w_act' not in data.columns or data['w_act'].isna().all():
-                print(
+                _log(
                     f"[Lift] Missing labels for {title}; skip.",
                     flush=True,
                 )
@@ -228,7 +234,7 @@ class BayesOptPlottingMixin:
             datasets.append((title, data))
 
         if not datasets:
-            print("[Lift] No labeled data available; skip plotting.", flush=True)
+            _log("[Lift] No labeled data available; skip plotting.", flush=True)
             return
 
         if plot_curves is None:
@@ -250,7 +256,7 @@ class BayesOptPlottingMixin:
                     denom = np.maximum(data[self.weight_nme].values, EPS)
                     pred_vals = data[w_pred_col].values / denom
             if pred_vals is None:
-                print(
+                _log(
                     f"[Lift] Missing prediction columns in {title}; skip.",
                     flush=True,
                 )
@@ -313,7 +319,7 @@ class BayesOptPlottingMixin:
         for data_name, data in [('Train Data', self.train_data),
                                 ('Test Data', self.test_data)]:
             if 'w_act' not in data.columns or data['w_act'].isna().all():
-                print(
+                _log(
                     f"[Double Lift] Missing labels for {data_name}; skip.",
                     flush=True,
                 )
@@ -321,7 +327,7 @@ class BayesOptPlottingMixin:
             datasets.append((data_name, data))
 
         if not datasets:
-            print("[Double Lift] No labeled data available; skip plotting.", flush=True)
+            _log("[Double Lift] No labeled data available; skip plotting.", flush=True)
             return
 
         if plot_curves is None:
@@ -358,7 +364,7 @@ class BayesOptPlottingMixin:
                     pred2 = data[w_pred2_col].values / np.maximum(weight_vals, EPS)
 
             if pred1 is None or pred2 is None:
-                print(
+                _log(
                     f"Warning: missing pred_{name1}/pred_{name2} or w_pred columns in {data_name}. Skip plot.")
                 continue
 
@@ -395,7 +401,7 @@ class BayesOptPlottingMixin:
             _plot_skip("conversion lift plot")
             return
         if not self.binary_resp_nme:
-            print("Error: `binary_resp_nme` not provided at BayesOptModel init; cannot plot conversion lift.")
+            _log("Error: `binary_resp_nme` not provided at BayesOptModel init; cannot plot conversion lift.")
             return
 
         if plot_curves is None:
@@ -407,7 +413,7 @@ class BayesOptPlottingMixin:
 
             for ax, (data_name, data) in zip(axes, datasets.items()):
                 if model_pred_col not in data.columns:
-                    print(f"Warning: missing prediction column '{model_pred_col}' in {data_name}. Skip plot.")
+                    _log(f"Warning: missing prediction column '{model_pred_col}' in {data_name}. Skip plot.")
                     continue
 
                 # Sort by model prediction and compute bins.
@@ -463,7 +469,7 @@ class BayesOptPlottingMixin:
 
         for ax, (data_name, data) in zip(axes, datasets.items()):
             if model_pred_col not in data.columns:
-                print(f"Warning: missing prediction column '{model_pred_col}' in {data_name}. Skip plot.")
+                _log(f"Warning: missing prediction column '{model_pred_col}' in {data_name}. Skip plot.")
                 continue
 
             plot_curves.plot_conversion_lift(