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

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",

ins_pricing/frontend/example_workflows.py

@@ -19,7 +19,7 @@ from ins_pricing.modelling.plotting import (
     plot_oneway,
 )
 from ins_pricing.modelling.plotting.common import finalize_figure, plt
-from ins_pricing.production.predict import load_predictor_from_config
+from ins_pricing.production.inference import load_predictor_from_config
 
 
 def _parse_csv_list(value: str) -> List[str]: