ins-pricing 0.4.5__tar.gz → 0.5.1__tar.gz

{ins_pricing-0.4.5 → ins_pricing-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ins_pricing
-Version: 0.4.5
+Version: 0.5.1
 Summary: Reusable modelling, pricing, governance, and reporting utilities.
 Author: meishi125478
 License: Proprietary

{ins_pricing-0.4.5 → ins_pricing-0.5.1}/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-0.4.5 → ins_pricing-0.5.1}/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-0.4.5 → ins_pricing-0.5.1}/ins_pricing/cli/BayesOpt_entry.py

@@ -1,56 +1,68 @@
-"""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:
+def _ensure_repo_root() -> None:
+    if __package__ not in {None, ""}:
         return
-    idx = argv.index("--config-json")
-    if idx + 1 >= len(argv):
+    if importlib.util.find_spec("ins_pricing") is not None:
         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:
+    bootstrap_path = Path(__file__).resolve().parents[1] / "utils" / "bootstrap.py"
+    spec = importlib.util.spec_from_file_location("ins_pricing.cli.utils.bootstrap", bootstrap_path)
+    if spec is None or spec.loader is None:
         return
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    module.ensure_repo_root()
 
-_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()
+_ensure_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-0.4.5 → ins_pricing-0.5.1}/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,26 @@ 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
+
+
+def _ensure_repo_root() -> None:
+    if __package__ not in {None, ""}:
+        return
+    if importlib.util.find_spec("ins_pricing") is not None:
+        return
+    bootstrap_path = Path(__file__).resolve().parents[1] / "utils" / "bootstrap.py"
+    spec = importlib.util.spec_from_file_location("ins_pricing.cli.utils.bootstrap", bootstrap_path)
+    if spec is None or spec.loader is None:
+        return
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    module.ensure_repo_root()
+
+
+_ensure_repo_root()
 
 import argparse
 import json
@@ -31,102 +43,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:
@@ -488,9 +433,20 @@ class IncrementalUpdateRunner:
         self.prediction_cache_dir = runtime_cfg["prediction_cache_dir"]
         self.prediction_cache_format = runtime_cfg["prediction_cache_format"]
         self.plot_path_style = runtime_cfg["plot_path_style"]
-        self.xgb_max_depth_max = runtime_cfg["xgb_max_depth_max"]
-        self.xgb_n_estimators_max = runtime_cfg["xgb_n_estimators_max"]
-        self.optuna_storage = runtime_cfg["optuna_storage"]
+        self.xgb_max_depth_max = runtime_cfg["xgb_max_depth_max"]
+        self.xgb_n_estimators_max = runtime_cfg["xgb_n_estimators_max"]
+        self.xgb_gpu_id = runtime_cfg["xgb_gpu_id"]
+        self.xgb_cleanup_per_fold = runtime_cfg["xgb_cleanup_per_fold"]
+        self.xgb_cleanup_synchronize = runtime_cfg["xgb_cleanup_synchronize"]
+        self.xgb_use_dmatrix = runtime_cfg["xgb_use_dmatrix"]
+        self.ft_cleanup_per_fold = runtime_cfg["ft_cleanup_per_fold"]
+        self.ft_cleanup_synchronize = runtime_cfg["ft_cleanup_synchronize"]
+        self.resn_cleanup_per_fold = runtime_cfg["resn_cleanup_per_fold"]
+        self.resn_cleanup_synchronize = runtime_cfg["resn_cleanup_synchronize"]
+        self.gnn_cleanup_per_fold = runtime_cfg["gnn_cleanup_per_fold"]
+        self.gnn_cleanup_synchronize = runtime_cfg["gnn_cleanup_synchronize"]
+        self.optuna_cleanup_synchronize = runtime_cfg["optuna_cleanup_synchronize"]
+        self.optuna_storage = runtime_cfg["optuna_storage"]
         self.optuna_study_prefix = runtime_cfg["optuna_study_prefix"]
         self.best_params_files = runtime_cfg["best_params_files"]
         self.reuse_best_params = runtime_cfg["reuse_best_params"]
@@ -659,8 +615,19 @@ class IncrementalUpdateRunner:
             use_ft_ddp=self.cfg.get("use_ft_ddp", False),
             use_gnn_ddp=self.cfg.get("use_gnn_ddp", False),
             output_dir=str(self.output_root) if self.output_root else None,
-            xgb_max_depth_max=self.xgb_max_depth_max,
-            xgb_n_estimators_max=self.xgb_n_estimators_max,
+            xgb_max_depth_max=self.xgb_max_depth_max,
+            xgb_n_estimators_max=self.xgb_n_estimators_max,
+            xgb_gpu_id=self.xgb_gpu_id,
+            xgb_cleanup_per_fold=self.xgb_cleanup_per_fold,
+            xgb_cleanup_synchronize=self.xgb_cleanup_synchronize,
+            xgb_use_dmatrix=self.xgb_use_dmatrix,
+            ft_cleanup_per_fold=self.ft_cleanup_per_fold,
+            ft_cleanup_synchronize=self.ft_cleanup_synchronize,
+            resn_cleanup_per_fold=self.resn_cleanup_per_fold,
+            resn_cleanup_synchronize=self.resn_cleanup_synchronize,
+            gnn_cleanup_per_fold=self.gnn_cleanup_per_fold,
+            gnn_cleanup_synchronize=self.gnn_cleanup_synchronize,
+            optuna_cleanup_synchronize=self.optuna_cleanup_synchronize,
             resn_weight_decay=self.cfg.get("resn_weight_decay"),
             final_ensemble=bool(self.cfg.get("final_ensemble", False)),
             final_ensemble_k=int(self.cfg.get("final_ensemble_k", 3)),