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

ins_pricing/utils/device.py

@@ -1,76 +1,91 @@
-"""Device management utilities for PyTorch models.
-
+"""Device management utilities for PyTorch models.
+
 This module consolidates GPU/CPU device management logic from:
-- modelling/core/bayesopt/utils.py
-- modelling/core/bayesopt/trainers/trainer_base.py
-- production/predict.py
-
-Example:
-    >>> from ins_pricing.utils import DeviceManager, GPUMemoryManager
-    >>> device = DeviceManager.get_best_device()
-    >>> DeviceManager.move_to_device(model, device)
-    >>> with GPUMemoryManager.cleanup_context():
-    ...     model.train()
-"""
-
-from __future__ import annotations
-
-import gc
-import os
-from contextlib import contextmanager
-from typing import Any, Dict, Optional
-
-try:
-    import torch
-    import torch.nn as nn
-    from torch.nn.parallel import DistributedDataParallel as DDP
-
-    TORCH_AVAILABLE = True
-except ImportError:
-    TORCH_AVAILABLE = False
-    torch = None
-    nn = None
-    DDP = None
-
-from .logging import get_logger
-
-
-# =============================================================================
-# GPU Memory Manager
-# =============================================================================
-
-
-class GPUMemoryManager:
-    """Context manager for GPU memory management and cleanup.
-
-    This class consolidates GPU memory cleanup logic that was previously
-    scattered across multiple trainer files.
-
-    Example:
-        >>> with GPUMemoryManager.cleanup_context():
-        ...     model.train()
-        ...     # Memory cleaned up after exiting context
-
-        >>> # Or use directly:
-        >>> GPUMemoryManager.clean()
-    """
-
-    _logger = get_logger("ins_pricing.gpu")
-
-    @classmethod
-    def clean(cls, verbose: bool = False) -> None:
+- modelling/bayesopt/utils.py
+- modelling/bayesopt/trainers/trainer_base.py
+- production/inference.py
+
+Example:
+    >>> from ins_pricing.utils import DeviceManager, GPUMemoryManager
+    >>> device = DeviceManager.get_best_device()
+    >>> DeviceManager.move_to_device(model, device)
+    >>> with GPUMemoryManager.cleanup_context():
+    ...     model.train()
+"""
+
+from __future__ import annotations
+
+import gc
+import os
+from contextlib import contextmanager
+from typing import Any, Dict, Optional
+
+try:
+    import torch
+    import torch.nn as nn
+    from torch.nn.parallel import DistributedDataParallel as DDP
+
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+    torch = None
+    nn = None
+    DDP = None
+
+from ins_pricing.utils.logging import get_logger
+
+
+# =============================================================================
+# GPU Memory Manager
+# =============================================================================
+
+
+class GPUMemoryManager:
+    """Context manager for GPU memory management and cleanup.
+
+    This class consolidates GPU memory cleanup logic that was previously
+    scattered across multiple trainer files.
+
+    Example:
+        >>> with GPUMemoryManager.cleanup_context():
+        ...     model.train()
+        ...     # Memory cleaned up after exiting context
+
+        >>> # Or use directly:
+        >>> GPUMemoryManager.clean()
+    """
+
+    _logger = get_logger("ins_pricing.gpu")
+
+    @classmethod
+    def clean(
+        cls,
+        verbose: bool = False,
+        *,
+        synchronize: bool = True,
+        empty_cache: bool = True,
+    ) -> None:
         """Clean up GPU memory.
 
         Args:
             verbose: If True, log cleanup details
+            synchronize: If True, synchronize CUDA device after cleanup
+            empty_cache: If True, clear CUDA cache
         """
         gc.collect()
 
         if TORCH_AVAILABLE and torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            torch.cuda.synchronize()
+            if empty_cache:
+                torch.cuda.empty_cache()
+            if synchronize:
+                torch.cuda.synchronize()
             if verbose:
-                cls._logger.debug("CUDA cache cleared and synchronized")
+                if empty_cache and synchronize:
+                    cls._logger.debug("CUDA cache cleared and synchronized")
+                elif empty_cache:
+                    cls._logger.debug("CUDA cache cleared")
+                elif synchronize:
+                    cls._logger.debug("CUDA synchronized")
 
             # Optional: Force IPC collect for multi-process scenarios
             if os.environ.get("BAYESOPT_CUDA_IPC_COLLECT", "0") == "1":
@@ -80,177 +95,183 @@ class GPUMemoryManager:
                         cls._logger.debug("CUDA IPC collect performed")
                 except Exception:
                     pass
-
-    @classmethod
-    @contextmanager
-    def cleanup_context(cls, verbose: bool = False):
-        """Context manager that cleans GPU memory on exit.
-
-        Args:
-            verbose: If True, log cleanup details
-
-        Yields:
-            None
-        """
-        try:
-            yield
-        finally:
-            cls.clean(verbose=verbose)
-
-    @classmethod
-    def move_model_to_cpu(cls, model: Any) -> Any:
-        """Move a model to CPU and clean GPU memory.
-
-        Args:
-            model: PyTorch model to move
-
-        Returns:
-            Model on CPU
-        """
-        if model is not None and hasattr(model, "to"):
-            model.to("cpu")
-        cls.clean()
-        return model
-
-    @classmethod
-    def get_memory_info(cls) -> Dict[str, Any]:
-        """Get current GPU memory usage information.
-
-        Returns:
-            Dictionary with memory info (allocated, reserved, free)
-        """
-        if not TORCH_AVAILABLE or not torch.cuda.is_available():
-            return {"available": False}
-
-        try:
-            allocated = torch.cuda.memory_allocated()
-            reserved = torch.cuda.memory_reserved()
-            free, total = torch.cuda.mem_get_info()
-            return {
-                "available": True,
-                "allocated_mb": allocated // (1024 * 1024),
-                "reserved_mb": reserved // (1024 * 1024),
-                "free_mb": free // (1024 * 1024),
-                "total_mb": total // (1024 * 1024),
-            }
-        except Exception:
-            return {"available": False}
-
-
-# =============================================================================
-# Device Manager
-# =============================================================================
-
-
-class DeviceManager:
-    """Unified device management for model and tensor placement.
-
-    This class consolidates device detection and model movement logic
-    that was previously duplicated across trainer_base.py and predict.py.
-
-    Example:
-        >>> device = DeviceManager.get_best_device()
-        >>> model = DeviceManager.move_to_device(model)
-    """
-
-    _logger = get_logger("ins_pricing.device")
-    _cached_device: Optional[Any] = None  # torch.device when available
-
-    @classmethod
-    def get_best_device(cls, prefer_cuda: bool = True) -> Any:
-        """Get the best available device.
-
-        Args:
-            prefer_cuda: If True, prefer CUDA over MPS
-
-        Returns:
-            Best available torch.device
-        """
-        if not TORCH_AVAILABLE:
-            return None
-
-        if cls._cached_device is not None:
-            return cls._cached_device
-
-        if prefer_cuda and torch.cuda.is_available():
-            cls._cached_device = torch.device("cuda")
-        elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
-            cls._cached_device = torch.device("mps")
-        else:
-            cls._cached_device = torch.device("cpu")
-
-        cls._logger.debug(f"Selected device: {cls._cached_device}")
-        return cls._cached_device
-
-    @classmethod
-    def move_to_device(cls, model_obj: Any, device: Optional[Any] = None) -> None:
-        """Move a model object to the specified device.
-
-        Handles sklearn-style wrappers that have .ft, .resnet, or .gnn attributes.
-
-        Args:
-            model_obj: Model object to move (may be sklearn wrapper)
-            device: Target device (defaults to best available)
-        """
-        if model_obj is None:
-            return
-
-        device = device or cls.get_best_device()
-        if device is None:
-            return
-
-        # Update device attribute if present
-        if hasattr(model_obj, "device"):
-            model_obj.device = device
-
-        # Move the main model
-        if hasattr(model_obj, "to"):
-            model_obj.to(device)
-
-        # Move nested submodules (sklearn wrappers)
-        for attr_name in ("ft", "resnet", "gnn"):
-            submodule = getattr(model_obj, attr_name, None)
-            if submodule is not None and hasattr(submodule, "to"):
-                submodule.to(device)
-
-    @classmethod
-    def unwrap_module(cls, module: Any) -> Any:
-        """Unwrap DDP or DataParallel wrapper to get the base module.
-
-        Args:
-            module: Potentially wrapped PyTorch module
-
-        Returns:
-            Unwrapped base module
-        """
-        if not TORCH_AVAILABLE:
-            return module
-
-        if isinstance(module, (DDP, nn.DataParallel)):
-            return module.module
-        return module
-
-    @classmethod
-    def reset_cache(cls) -> None:
-        """Reset cached device selection."""
-        cls._cached_device = None
-
-    @classmethod
-    def is_cuda_available(cls) -> bool:
-        """Check if CUDA is available.
-
-        Returns:
-            True if CUDA is available
-        """
-        return TORCH_AVAILABLE and torch.cuda.is_available()
-
-    @classmethod
-    def is_mps_available(cls) -> bool:
-        """Check if MPS (Apple Silicon) is available.
-
-        Returns:
-            True if MPS is available
-        """
-        if not TORCH_AVAILABLE:
-            return False
-        return hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+
+    @classmethod
+    @contextmanager
+    def cleanup_context(
+        cls,
+        verbose: bool = False,
+        *,
+        synchronize: bool = True,
+        empty_cache: bool = True,
+    ):
+        """Context manager that cleans GPU memory on exit.
+
+        Args:
+            verbose: If True, log cleanup details
+
+        Yields:
+            None
+        """
+        try:
+            yield
+        finally:
+            cls.clean(verbose=verbose, synchronize=synchronize, empty_cache=empty_cache)
+
+    @classmethod
+    def move_model_to_cpu(cls, model: Any) -> Any:
+        """Move a model to CPU and clean GPU memory.
+
+        Args:
+            model: PyTorch model to move
+
+        Returns:
+            Model on CPU
+        """
+        if model is not None and hasattr(model, "to"):
+            model.to("cpu")
+        cls.clean()
+        return model
+
+    @classmethod
+    def get_memory_info(cls) -> Dict[str, Any]:
+        """Get current GPU memory usage information.
+
+        Returns:
+            Dictionary with memory info (allocated, reserved, free)
+        """
+        if not TORCH_AVAILABLE or not torch.cuda.is_available():
+            return {"available": False}
+
+        try:
+            allocated = torch.cuda.memory_allocated()
+            reserved = torch.cuda.memory_reserved()
+            free, total = torch.cuda.mem_get_info()
+            return {
+                "available": True,
+                "allocated_mb": allocated // (1024 * 1024),
+                "reserved_mb": reserved // (1024 * 1024),
+                "free_mb": free // (1024 * 1024),
+                "total_mb": total // (1024 * 1024),
+            }
+        except Exception:
+            return {"available": False}
+
+
+# =============================================================================
+# Device Manager
+# =============================================================================
+
+
+class DeviceManager:
+    """Unified device management for model and tensor placement.
+
+    This class consolidates device detection and model movement logic
+    that was previously duplicated across trainer_base.py and predict.py.
+
+    Example:
+        >>> device = DeviceManager.get_best_device()
+        >>> model = DeviceManager.move_to_device(model)
+    """
+
+    _logger = get_logger("ins_pricing.device")
+    _cached_device: Optional[Any] = None  # torch.device when available
+
+    @classmethod
+    def get_best_device(cls, prefer_cuda: bool = True) -> Any:
+        """Get the best available device.
+
+        Args:
+            prefer_cuda: If True, prefer CUDA over MPS
+
+        Returns:
+            Best available torch.device
+        """
+        if not TORCH_AVAILABLE:
+            return None
+
+        if cls._cached_device is not None:
+            return cls._cached_device
+
+        if prefer_cuda and torch.cuda.is_available():
+            cls._cached_device = torch.device("cuda")
+        elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+            cls._cached_device = torch.device("mps")
+        else:
+            cls._cached_device = torch.device("cpu")
+
+        cls._logger.debug(f"Selected device: {cls._cached_device}")
+        return cls._cached_device
+
+    @classmethod
+    def move_to_device(cls, model_obj: Any, device: Optional[Any] = None) -> None:
+        """Move a model object to the specified device.
+
+        Handles sklearn-style wrappers that have .ft, .resnet, or .gnn attributes.
+
+        Args:
+            model_obj: Model object to move (may be sklearn wrapper)
+            device: Target device (defaults to best available)
+        """
+        if model_obj is None:
+            return
+
+        device = device or cls.get_best_device()
+        if device is None:
+            return
+
+        # Update device attribute if present
+        if hasattr(model_obj, "device"):
+            model_obj.device = device
+
+        # Move the main model
+        if hasattr(model_obj, "to"):
+            model_obj.to(device)
+
+        # Move nested submodules (sklearn wrappers)
+        for attr_name in ("ft", "resnet", "gnn"):
+            submodule = getattr(model_obj, attr_name, None)
+            if submodule is not None and hasattr(submodule, "to"):
+                submodule.to(device)
+
+    @classmethod
+    def unwrap_module(cls, module: Any) -> Any:
+        """Unwrap DDP or DataParallel wrapper to get the base module.
+
+        Args:
+            module: Potentially wrapped PyTorch module
+
+        Returns:
+            Unwrapped base module
+        """
+        if not TORCH_AVAILABLE:
+            return module
+
+        if isinstance(module, (DDP, nn.DataParallel)):
+            return module.module
+        return module
+
+    @classmethod
+    def reset_cache(cls) -> None:
+        """Reset cached device selection."""
+        cls._cached_device = None
+
+    @classmethod
+    def is_cuda_available(cls) -> bool:
+        """Check if CUDA is available.
+
+        Returns:
+            True if CUDA is available
+        """
+        return TORCH_AVAILABLE and torch.cuda.is_available()
+
+    @classmethod
+    def is_mps_available(cls) -> bool:
+        """Check if MPS (Apple Silicon) is available.
+
+        Returns:
+            True if MPS is available
+        """
+        if not TORCH_AVAILABLE:
+            return False
+        return hasattr(torch.backends, "mps") and torch.backends.mps.is_available()

ins_pricing/utils/features.py

@@ -0,0 +1,53 @@
+"""Feature inference helpers shared across training and production."""
+
+from __future__ import annotations
+
+from typing import List, Optional, Tuple
+
+import pandas as pd
+
+
+def infer_factor_and_cate_list(
+    train_df: pd.DataFrame,
+    test_df: pd.DataFrame,
+    resp_nme: str,
+    weight_nme: str,
+    *,
+    binary_resp_nme: Optional[str] = None,
+    factor_nmes: Optional[List[str]] = None,
+    cate_list: Optional[List[str]] = None,
+    infer_categorical_max_unique: int = 50,
+    infer_categorical_max_ratio: float = 0.05,
+) -> Tuple[List[str], List[str]]:
+    """Infer factor_nmes/cate_list when feature names are not provided."""
+    excluded = {resp_nme, weight_nme}
+    if binary_resp_nme:
+        excluded.add(binary_resp_nme)
+
+    common_cols = [c for c in train_df.columns if c in test_df.columns]
+    if factor_nmes is None:
+        factors = [c for c in common_cols if c not in excluded]
+    else:
+        factors = [c for c in factor_nmes if c in common_cols and c not in excluded]
+
+    if cate_list is not None:
+        cats = [c for c in cate_list if c in factors]
+        return factors, cats
+
+    n_rows = max(1, len(train_df))
+    cats: List[str] = []
+    for col in factors:
+        s = train_df[col]
+        if (
+            pd.api.types.is_bool_dtype(s)
+            or pd.api.types.is_object_dtype(s)
+            or isinstance(s.dtype, pd.CategoricalDtype)
+        ):
+            cats.append(col)
+            continue
+        if pd.api.types.is_integer_dtype(s):
+            nunique = int(s.nunique(dropna=True))
+            if nunique <= infer_categorical_max_unique or (nunique / n_rows) <= infer_categorical_max_ratio:
+                cats.append(col)
+
+    return factors, cats

ins_pricing/utils/io.py

@@ -0,0 +1,72 @@
+"""File and path helpers shared across ins_pricing."""
+
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+import pandas as pd
+
+
+def ensure_parent_dir(file_path: str) -> None:
+    """Create parent directories when missing."""
+    directory = Path(file_path).parent
+    if directory and not directory.exists():
+        directory.mkdir(parents=True, exist_ok=True)
+
+
+class IOUtils:
+    """File and path utilities for model parameters and configs."""
+
+    @staticmethod
+    def csv_to_dict(file_path: str) -> List[Dict[str, Any]]:
+        """Load CSV file as list of dictionaries."""
+        with open(file_path, mode="r", encoding="utf-8") as file:
+            reader = csv.DictReader(file)
+            return [dict(filter(lambda item: item[0] != "", row.items())) for row in reader]
+
+    @staticmethod
+    def ensure_parent_dir(file_path: str) -> None:
+        """Create parent directories when missing."""
+        ensure_parent_dir(file_path)
+
+    @staticmethod
+    def _sanitize_params_dict(params: Dict[str, Any]) -> Dict[str, Any]:
+        """Filter index-like columns such as "Unnamed: 0" from pandas I/O."""
+        return {
+            k: v
+            for k, v in (params or {}).items()
+            if k and not str(k).startswith("Unnamed")
+        }
+
+    @staticmethod
+    def load_params_file(path: str) -> Dict[str, Any]:
+        """Load parameter dict from JSON/CSV/TSV files."""
+        file_path = Path(path).expanduser().resolve()
+        if not file_path.exists():
+            raise FileNotFoundError(f"params file not found: {file_path}")
+
+        suffix = file_path.suffix.lower()
+        if suffix == ".json":
+            payload = json.loads(file_path.read_text(encoding="utf-8", errors="replace"))
+            if isinstance(payload, dict) and "best_params" in payload:
+                payload = payload.get("best_params") or {}
+            if not isinstance(payload, dict):
+                raise ValueError(f"Invalid JSON params file (expect dict): {file_path}")
+            return IOUtils._sanitize_params_dict(dict(payload))
+
+        if suffix in (".csv", ".tsv"):
+            df = pd.read_csv(file_path, sep="\t" if suffix == ".tsv" else ",")
+            if df.empty:
+                raise ValueError(f"Empty params file: {file_path}")
+            params = df.iloc[0].to_dict()
+            return IOUtils._sanitize_params_dict(params)
+
+        raise ValueError(f"Unsupported params file type '{suffix}': {file_path}")
+
+
+def csv_to_dict(file_path: str) -> List[Dict[str, Any]]:
+    """Load CSV file as list of dictionaries (legacy function)."""
+    return IOUtils.csv_to_dict(file_path)