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

ins_pricing/cli/utils/notebook_utils.py

@@ -142,8 +142,8 @@ def build_explain_cmd(
     return _stringify_cmd(cmd)
 
 
-def wrap_with_watchdog(
-    cmd: Sequence[str],
+def wrap_with_watchdog(
+    cmd: Sequence[str],
     *,
     idle_seconds: int = 7200,
     max_restarts: int = 50,
@@ -179,28 +179,122 @@ def wrap_with_watchdog(
     if stop_on_nonzero_exit:
         wd_cmd.append("--stop-on-nonzero-exit")
     wd_cmd.append("--")
-    wd_cmd.extend(list(cmd))
-    return _stringify_cmd(wd_cmd)
-
-
-def run(cmd: Sequence[str], *, check: bool = True) -> subprocess.CompletedProcess:
-    """Run an external command from a notebook (blocking)."""
-    return subprocess.run(list(cmd), check=check)
-
-
-def _build_config_parser(description: str) -> argparse.ArgumentParser:
+    wd_cmd.extend(list(cmd))
+    return _stringify_cmd(wd_cmd)
+
+
+def run(cmd: Sequence[str], *, check: bool = True) -> subprocess.CompletedProcess:
+    """Run an external command from a notebook (blocking)."""
+    return subprocess.run(list(cmd), check=check)
+
+
+def _build_config_parser(description: str) -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description=description)
     add_config_json_arg(
         parser,
         help_text="Path to config.json (relative paths are resolved from ins_pricing/ when possible).",
-    )
-    return parser
-
-
-def run_from_config_cli(
-    description: str,
-    argv: Optional[Sequence[str]] = None,
-) -> subprocess.CompletedProcess:
+    )
+    return parser
+
+
+def build_cmd_from_config(config_json: str | Path) -> tuple[List[str], str]:
+    """Build a command list from config.json runner settings.
+
+    Returns:
+        (cmd, mode) where mode is one of: entry, incremental, explain.
+    """
+    pkg_dir = _find_ins_pricing_dir()
+    config_path = Path(config_json)
+    if not config_path.is_absolute():
+        config_path = (pkg_dir / config_path).resolve() if (pkg_dir / config_path).exists() else config_path.resolve()
+    raw = json.loads(config_path.read_text(encoding="utf-8", errors="replace"))
+    set_env(raw.get("env", {}))
+    runner = cast(dict, raw.get("runner") or {})
+
+    mode = str(runner.get("mode") or "entry").strip().lower()
+    use_watchdog = bool(runner.get("use_watchdog", False))
+    if mode == "watchdog":
+        use_watchdog = True
+        mode = "entry"
+
+    idle_seconds = int(runner.get("idle_seconds", 7200))
+    max_restarts = int(runner.get("max_restarts", 50))
+    restart_delay_seconds = int(runner.get("restart_delay_seconds", 10))
+
+    if mode == "incremental":
+        inc_args = runner.get("incremental_args") or []
+        if not isinstance(inc_args, list):
+            raise ValueError("config.runner.incremental_args must be a list of strings.")
+        cmd = build_incremental_cmd(config_path, extra_args=[str(x) for x in inc_args])
+        if use_watchdog:
+            cmd = wrap_with_watchdog(
+                cmd,
+                idle_seconds=idle_seconds,
+                max_restarts=max_restarts,
+                restart_delay_seconds=restart_delay_seconds,
+            )
+        return cmd, "incremental"
+
+    if mode == "explain":
+        exp_args = runner.get("explain_args") or []
+        if not isinstance(exp_args, list):
+            raise ValueError("config.runner.explain_args must be a list of strings.")
+        cmd = build_explain_cmd(config_path, extra_args=[str(x) for x in exp_args])
+        if use_watchdog:
+            cmd = wrap_with_watchdog(
+                cmd,
+                idle_seconds=idle_seconds,
+                max_restarts=max_restarts,
+                restart_delay_seconds=restart_delay_seconds,
+            )
+        return cmd, "explain"
+
+    if mode != "entry":
+        raise ValueError(
+            f"Unsupported runner.mode={mode!r}, expected 'entry', 'incremental', or 'explain'."
+        )
+
+    model_keys = runner.get("model_keys")
+    if not model_keys:
+        model_keys = raw.get("model_keys")
+    if not model_keys:
+        model_keys = ["ft"]
+    if not isinstance(model_keys, list):
+        raise ValueError("runner.model_keys must be a list of strings.")
+
+    nproc_per_node = int(runner.get("nproc_per_node", 1))
+    max_evals = int(runner.get("max_evals", raw.get("max_evals", 50)))
+    plot_curves = bool(runner.get("plot_curves", raw.get("plot_curves", True)))
+    ft_role = runner.get("ft_role", None)
+    if ft_role is None:
+        ft_role = raw.get("ft_role")
+
+    cmd = build_bayesopt_entry_cmd(
+        config_path,
+        model_keys=[str(x) for x in model_keys],
+        nproc_per_node=nproc_per_node,
+        extra_args=[
+            "--max-evals",
+            str(max_evals),
+            *(["--plot-curves"] if plot_curves else []),
+            *(["--ft-role", str(ft_role)] if ft_role else []),
+        ],
+    )
+
+    if use_watchdog:
+        cmd = wrap_with_watchdog(
+            cmd,
+            idle_seconds=idle_seconds,
+            max_restarts=max_restarts,
+            restart_delay_seconds=restart_delay_seconds,
+        )
+    return cmd, "entry"
+
+
+def run_from_config_cli(
+    description: str,
+    argv: Optional[Sequence[str]] = None,
+) -> subprocess.CompletedProcess:
     parser = _build_config_parser(description)
     args = parser.parse_args(argv)
     return run_from_config(args.config_json)
@@ -245,8 +339,8 @@ def run_bayesopt_entry(
     return run(cmd, check=True)
 
 
-def run_from_config(config_json: str | Path) -> subprocess.CompletedProcess:
-    """Notebook entry point: switch execution modes by editing config.json.
+def run_from_config(config_json: str | Path) -> subprocess.CompletedProcess:
+    """Notebook entry point: switch execution modes by editing config.json.
 
     Convention: config.json may include a `runner` section for notebook control:
     - runner.mode: "entry" (default), "incremental", or "explain"
@@ -254,87 +348,7 @@ def run_from_config(config_json: str | Path) -> subprocess.CompletedProcess:
     - runner.model_keys: list of models to run (entry only)
     - runner.max_evals / runner.plot_curves / runner.ft_role (entry only; override config fields)
     - runner.use_watchdog / runner.idle_seconds / runner.max_restarts / runner.restart_delay_seconds
-    - runner.incremental_args: List[str] (incremental only; extra args for cli/BayesOpt_incremental.py)
-    """
-    pkg_dir = _find_ins_pricing_dir()
-    config_path = Path(config_json)
-    if not config_path.is_absolute():
-        config_path = (pkg_dir / config_path).resolve() if (pkg_dir / config_path).exists() else config_path.resolve()
-    raw = json.loads(config_path.read_text(encoding="utf-8", errors="replace"))
-    set_env(raw.get("env", {}))
-    runner = cast(dict, raw.get("runner") or {})
-
-    mode = str(runner.get("mode") or "entry").strip().lower()
-    use_watchdog = bool(runner.get("use_watchdog", False))
-    idle_seconds = int(runner.get("idle_seconds", 7200))
-    max_restarts = int(runner.get("max_restarts", 50))
-    restart_delay_seconds = int(runner.get("restart_delay_seconds", 10))
-
-    if mode == "incremental":
-        inc_args = runner.get("incremental_args") or []
-        if not isinstance(inc_args, list):
-            raise ValueError("config.runner.incremental_args must be a list of strings.")
-        cmd = build_incremental_cmd(config_path, extra_args=[str(x) for x in inc_args])
-        if use_watchdog:
-            cmd = wrap_with_watchdog(
-                cmd,
-                idle_seconds=idle_seconds,
-                max_restarts=max_restarts,
-                restart_delay_seconds=restart_delay_seconds,
-            )
-        return run(cmd, check=True)
-
-    if mode == "explain":
-        exp_args = runner.get("explain_args") or []
-        if not isinstance(exp_args, list):
-            raise ValueError("config.runner.explain_args must be a list of strings.")
-        cmd = build_explain_cmd(config_path, extra_args=[str(x) for x in exp_args])
-        if use_watchdog:
-            cmd = wrap_with_watchdog(
-                cmd,
-                idle_seconds=idle_seconds,
-                max_restarts=max_restarts,
-                restart_delay_seconds=restart_delay_seconds,
-            )
-        return run(cmd, check=True)
-
-    if mode != "entry":
-        raise ValueError(
-            f"Unsupported runner.mode={mode!r}, expected 'entry', 'incremental', or 'explain'."
-        )
-
-    model_keys = runner.get("model_keys")
-    if not model_keys:
-        model_keys = raw.get("model_keys")
-    if not model_keys:
-        model_keys = ["ft"]
-    if not isinstance(model_keys, list):
-        raise ValueError("runner.model_keys must be a list of strings.")
-
-    nproc_per_node = int(runner.get("nproc_per_node", 1))
-    max_evals = int(runner.get("max_evals", raw.get("max_evals", 50)))
-    plot_curves = bool(runner.get("plot_curves", raw.get("plot_curves", True)))
-    ft_role = runner.get("ft_role", None)
-    if ft_role is None:
-        ft_role = raw.get("ft_role")
-
-    cmd = build_bayesopt_entry_cmd(
-        config_path,
-        model_keys=[str(x) for x in model_keys],
-        nproc_per_node=nproc_per_node,
-        extra_args=[
-            "--max-evals",
-            str(max_evals),
-            *(["--plot-curves"] if plot_curves else []),
-            *(["--ft-role", str(ft_role)] if ft_role else []),
-        ],
-    )
-
-    if use_watchdog:
-        cmd = wrap_with_watchdog(
-            cmd,
-            idle_seconds=idle_seconds,
-            max_restarts=max_restarts,
-            restart_delay_seconds=restart_delay_seconds,
-        )
-    return run(cmd, check=True)
+    - runner.incremental_args: List[str] (incremental only; extra args for cli/BayesOpt_incremental.py)
+    """
+    cmd, _mode = build_cmd_from_config(config_json)
+    return run(cmd, check=True)

ins_pricing/cli/watchdog_run.py

@@ -10,11 +10,21 @@ import threading
 import time
 from typing import List, Optional
 
-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))
+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()
 
 try:
     from ins_pricing.cli.utils.run_logging import configure_run_logging  # type: ignore

ins_pricing/frontend/app.py

@@ -17,16 +17,31 @@ from ins_pricing.frontend.ft_workflow import FTWorkflowHelper
 from ins_pricing.frontend.runner import TaskRunner
 from ins_pricing.frontend.config_builder import ConfigBuilder
 import json
+import tempfile
 import sys
 import inspect
+import importlib.util
 from pathlib import Path
-from typing import Optional, Dict, Any, Callable, Iterable, Tuple
+from typing import Optional, Dict, Any, Callable, Iterable, Tuple, Generator
 import threading
 import queue
 import time
 
-# Add parent directory to path to import ins_pricing modules
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+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] / "cli" / "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()
 
 os.environ.setdefault("GRADIO_ANALYTICS_ENABLED", "False")
 os.environ.setdefault("GRADIO_TELEMETRY_ENABLED", "False")
@@ -112,10 +127,21 @@ class PricingApp:
         output_dir: str,
         use_gpu: bool,
         model_keys: str,
-        max_evals: int,
-        xgb_max_depth_max: int,
-        xgb_n_estimators_max: int,
-    ) -> tuple[str, str]:
+        max_evals: int,
+        xgb_max_depth_max: int,
+        xgb_n_estimators_max: int,
+        xgb_gpu_id: int,
+        xgb_cleanup_per_fold: bool,
+        xgb_cleanup_synchronize: bool,
+        xgb_use_dmatrix: bool,
+        ft_cleanup_per_fold: bool,
+        ft_cleanup_synchronize: bool,
+        resn_cleanup_per_fold: bool,
+        resn_cleanup_synchronize: bool,
+        gnn_cleanup_per_fold: bool,
+        gnn_cleanup_synchronize: bool,
+        optuna_cleanup_synchronize: bool,
+    ) -> tuple[str, str]:
         """Build configuration from UI parameters."""
         try:
             # Parse comma-separated lists
@@ -148,10 +174,21 @@ class PricingApp:
                 output_dir=output_dir,
                 use_gpu=use_gpu,
                 model_keys=model_keys,
-                max_evals=max_evals,
-                xgb_max_depth_max=xgb_max_depth_max,
-                xgb_n_estimators_max=xgb_n_estimators_max,
-            )
+                max_evals=max_evals,
+                xgb_max_depth_max=xgb_max_depth_max,
+                xgb_n_estimators_max=xgb_n_estimators_max,
+                xgb_gpu_id=xgb_gpu_id,
+                xgb_cleanup_per_fold=xgb_cleanup_per_fold,
+                xgb_cleanup_synchronize=xgb_cleanup_synchronize,
+                xgb_use_dmatrix=xgb_use_dmatrix,
+                ft_cleanup_per_fold=ft_cleanup_per_fold,
+                ft_cleanup_synchronize=ft_cleanup_synchronize,
+                resn_cleanup_per_fold=resn_cleanup_per_fold,
+                resn_cleanup_synchronize=resn_cleanup_synchronize,
+                gnn_cleanup_per_fold=gnn_cleanup_per_fold,
+                gnn_cleanup_synchronize=gnn_cleanup_synchronize,
+                optuna_cleanup_synchronize=optuna_cleanup_synchronize,
+            )
 
             is_valid, msg = self.config_builder.validate_config(config)
             if not is_valid:
@@ -180,54 +217,60 @@ class PricingApp:
         except Exception as e:
             return f"Error saving config: {str(e)}"
 
-    def run_training(self, config_json: str) -> tuple[str, str]:
+    def run_training(self, config_json: str) -> Generator[tuple[str, str], None, None]:
         """
         Run task (training, explain, plotting, etc.) with the current configuration.
 
         The task type is automatically detected from config.runner.mode.
         Supported modes: entry (training), explain, incremental, watchdog, etc.
         """
-        try:
-            temp_config_path = None
-            if config_json:
-                config = json.loads(config_json)
-                task_mode = config.get('runner', {}).get('mode', 'entry')
-                base_dir = self.current_config_dir or Path.cwd()
-                temp_config_path = (base_dir / "temp_config.json").resolve()
-                with open(temp_config_path, 'w', encoding='utf-8') as f:
-                    json.dump(config, f, indent=2)
-                config_path = temp_config_path
-            elif self.current_config_path and self.current_config_path.exists():
-                config_path = self.current_config_path
-                config = json.loads(config_path.read_text(encoding="utf-8"))
-                task_mode = config.get('runner', {}).get('mode', 'entry')
-            elif self.current_config:
-                config = self.current_config
-                task_mode = config.get('runner', {}).get('mode', 'entry')
-                temp_config_path = (Path.cwd() / "temp_config.json").resolve()
-                with open(temp_config_path, 'w', encoding='utf-8') as f:
-                    json.dump(config, f, indent=2)
-                config_path = temp_config_path
-            else:
-                return "No configuration provided", ""
-
-            log_generator = self.runner.run_task(str(config_path))
-
-            # Collect logs
-            full_log = ""
-            for log_line in log_generator:
-                full_log += log_line + "\n"
-                yield f"Task [{task_mode}] in progress...", full_log
-
-            # Clean up
-            if temp_config_path and temp_config_path.exists():
-                temp_config_path.unlink()
-
-            yield f"Task [{task_mode}] completed!", full_log
-
-        except Exception as e:
-            error_msg = f"Error during task execution: {str(e)}"
-            yield error_msg, error_msg
+        temp_config_path: Optional[Path] = None
+        try:
+            if config_json:
+                config = json.loads(config_json)
+                task_mode = config.get('runner', {}).get('mode', 'entry')
+                base_dir = self.current_config_dir or Path.cwd()
+                fd, temp_path = tempfile.mkstemp(prefix="temp_config_", suffix=".json", dir=base_dir)
+                temp_config_path = Path(temp_path)
+                with os.fdopen(fd, 'w', encoding='utf-8') as f:
+                    json.dump(config, f, indent=2)
+                config_path = temp_config_path
+            elif self.current_config_path and self.current_config_path.exists():
+                config_path = self.current_config_path
+                config = json.loads(config_path.read_text(encoding="utf-8"))
+                task_mode = config.get('runner', {}).get('mode', 'entry')
+            elif self.current_config:
+                config = self.current_config
+                task_mode = config.get('runner', {}).get('mode', 'entry')
+                base_dir = Path.cwd()
+                fd, temp_path = tempfile.mkstemp(prefix="temp_config_", suffix=".json", dir=base_dir)
+                temp_config_path = Path(temp_path)
+                with os.fdopen(fd, 'w', encoding='utf-8') as f:
+                    json.dump(config, f, indent=2)
+                config_path = temp_config_path
+            else:
+                yield "No configuration provided", ""
+                return
+
+            log_generator = self.runner.run_task(str(config_path))
+
+            # Collect logs
+            full_log = ""
+            for log_line in log_generator:
+                full_log += log_line + "\n"
+                yield f"Task [{task_mode}] in progress...", full_log
+
+            yield f"Task [{task_mode}] completed!", full_log
+
+        except Exception as e:
+            error_msg = f"Error during task execution: {str(e)}"
+            yield error_msg, error_msg
+        finally:
+            if temp_config_path is not None:
+                try:
+                    temp_config_path.unlink(missing_ok=True)
+                except Exception:
+                    pass
 
     def prepare_ft_step1(self, config_json: str, use_ddp: bool, nproc: int) -> tuple[str, str]:
         """Prepare FT Step 1 configuration."""
@@ -551,11 +594,34 @@ def create_ui():
                         label="Max Evaluations", value=50, precision=0)
 
                 with gr.Column():
-                    gr.Markdown("#### XGBoost Settings")
-                    xgb_max_depth_max = gr.Number(
-                        label="XGB Max Depth", value=25, precision=0)
-                    xgb_n_estimators_max = gr.Number(
-                        label="XGB Max Estimators", value=500, precision=0)
+                    gr.Markdown("#### XGBoost Settings")
+                    xgb_max_depth_max = gr.Number(
+                        label="XGB Max Depth", value=25, precision=0)
+                    xgb_n_estimators_max = gr.Number(
+                        label="XGB Max Estimators", value=500, precision=0)
+                    xgb_gpu_id = gr.Number(
+                        label="XGB GPU ID", value=0, precision=0)
+                    xgb_cleanup_per_fold = gr.Checkbox(
+                        label="XGB Cleanup Per Fold", value=False)
+                    xgb_cleanup_synchronize = gr.Checkbox(
+                        label="XGB Cleanup Synchronize", value=False)
+                    xgb_use_dmatrix = gr.Checkbox(
+                        label="XGB Use DMatrix", value=True)
+                    gr.Markdown("#### Fold Cleanup")
+                    ft_cleanup_per_fold = gr.Checkbox(
+                        label="FT Cleanup Per Fold", value=False)
+                    ft_cleanup_synchronize = gr.Checkbox(
+                        label="FT Cleanup Synchronize", value=False)
+                    resn_cleanup_per_fold = gr.Checkbox(
+                        label="ResNet Cleanup Per Fold", value=False)
+                    resn_cleanup_synchronize = gr.Checkbox(
+                        label="ResNet Cleanup Synchronize", value=False)
+                    gnn_cleanup_per_fold = gr.Checkbox(
+                        label="GNN Cleanup Per Fold", value=False)
+                    gnn_cleanup_synchronize = gr.Checkbox(
+                        label="GNN Cleanup Synchronize", value=False)
+                    optuna_cleanup_synchronize = gr.Checkbox(
+                        label="Optuna Cleanup Synchronize", value=False)
 
             with gr.Row():
                 build_btn = gr.Button(
@@ -836,9 +902,14 @@ def create_ui():
                 data_dir, model_list, model_categories, target, weight,
                 feature_list, categorical_features, task_type, prop_test,
                 holdout_ratio, val_ratio, split_strategy, rand_seed, epochs,
-                output_dir, use_gpu, model_keys, max_evals,
-                xgb_max_depth_max, xgb_n_estimators_max
-            ],
+                output_dir, use_gpu, model_keys, max_evals,
+                xgb_max_depth_max, xgb_n_estimators_max,
+                xgb_gpu_id, xgb_cleanup_per_fold, xgb_cleanup_synchronize,
+                xgb_use_dmatrix, ft_cleanup_per_fold, ft_cleanup_synchronize,
+                resn_cleanup_per_fold, resn_cleanup_synchronize,
+                gnn_cleanup_per_fold, gnn_cleanup_synchronize,
+                optuna_cleanup_synchronize
+            ],
             outputs=[build_status, config_json]
         )
 

ins_pricing/frontend/config_builder.py

@@ -148,6 +148,17 @@ class ConfigBuilder:
         max_evals: int = 50,
         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,
         nproc_per_node: int = 2,
     ) -> Dict[str, Any]:
         """
@@ -174,6 +185,17 @@ class ConfigBuilder:
             max_evals: Maximum number of evaluations for optimization
             xgb_max_depth_max: Maximum depth for XGBoost
             xgb_n_estimators_max: Maximum estimators for XGBoost
+            xgb_gpu_id: XGBoost GPU device id (None = default)
+            xgb_cleanup_per_fold: Cleanup GPU memory per XGBoost fold
+            xgb_cleanup_synchronize: Synchronize CUDA during XGBoost cleanup
+            xgb_use_dmatrix: Use xgb.train with DMatrix/QuantileDMatrix
+            ft_cleanup_per_fold: Cleanup GPU memory per FT fold
+            ft_cleanup_synchronize: Synchronize CUDA during FT cleanup
+            resn_cleanup_per_fold: Cleanup GPU memory per ResNet fold
+            resn_cleanup_synchronize: Synchronize CUDA during ResNet cleanup
+            gnn_cleanup_per_fold: Cleanup GPU memory per GNN fold
+            gnn_cleanup_synchronize: Synchronize CUDA during GNN cleanup
+            optuna_cleanup_synchronize: Synchronize CUDA during Optuna cleanup
             nproc_per_node: Number of processes per node
 
         Returns:
@@ -204,6 +226,17 @@ class ConfigBuilder:
             "use_gpu": use_gpu,
             "xgb_max_depth_max": xgb_max_depth_max,
             "xgb_n_estimators_max": xgb_n_estimators_max,
+            "xgb_gpu_id": xgb_gpu_id,
+            "xgb_cleanup_per_fold": xgb_cleanup_per_fold,
+            "xgb_cleanup_synchronize": xgb_cleanup_synchronize,
+            "xgb_use_dmatrix": xgb_use_dmatrix,
+            "ft_cleanup_per_fold": ft_cleanup_per_fold,
+            "ft_cleanup_synchronize": ft_cleanup_synchronize,
+            "resn_cleanup_per_fold": resn_cleanup_per_fold,
+            "resn_cleanup_synchronize": resn_cleanup_synchronize,
+            "gnn_cleanup_per_fold": gnn_cleanup_per_fold,
+            "gnn_cleanup_synchronize": gnn_cleanup_synchronize,
+            "optuna_cleanup_synchronize": optuna_cleanup_synchronize,
             "optuna_storage": f"{output_dir}/optuna/bayesopt.sqlite3",
             "stack_model_keys": model_keys,
         })

ins_pricing/frontend/example_config.json

@@ -26,6 +26,17 @@
   "use_gpu": true,
   "xgb_max_depth_max": 25,
   "xgb_n_estimators_max": 500,
+  "xgb_gpu_id": 0,
+  "xgb_cleanup_per_fold": false,
+  "xgb_cleanup_synchronize": false,
+  "xgb_use_dmatrix": true,
+  "ft_cleanup_per_fold": false,
+  "ft_cleanup_synchronize": false,
+  "resn_cleanup_per_fold": false,
+  "resn_cleanup_synchronize": false,
+  "gnn_cleanup_per_fold": false,
+  "gnn_cleanup_synchronize": false,
+  "optuna_cleanup_synchronize": false,
   "optuna_storage": "./Results/optuna/bayesopt.sqlite3",
   "runner": {
     "mode": "entry",