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

ins_pricing/modelling/bayesopt/utils/__init__.py

@@ -0,0 +1,67 @@
+"""Backward compatibility re-exports for bayesopt utilities.
+
+This module keeps legacy imports working while routing general helpers
+through ins_pricing.utils and leaving bayesopt-specific utilities in place.
+"""
+
+from __future__ import annotations
+
+# Constants and simple utilities
+from ins_pricing.modelling.bayesopt.utils.constants import (
+    EPS,
+    set_global_seed,
+    ensure_parent_dir,
+    compute_batch_size,
+    tweedie_loss,
+    infer_factor_and_cate_list,
+)
+
+# I/O utilities
+from ins_pricing.modelling.bayesopt.utils.io_utils import (
+    IOUtils,
+    csv_to_dict,
+)
+
+# Distributed training
+from ins_pricing.modelling.bayesopt.utils.distributed_utils import (
+    DistributedUtils,
+    TrainingUtils,
+    free_cuda,
+)
+
+# PyTorch training mixin
+from ins_pricing.modelling.bayesopt.utils.torch_trainer_mixin import (
+    TorchTrainerMixin,
+)
+
+# Metrics and device helpers (shared utilities)
+from ins_pricing.modelling.bayesopt.utils.metrics_and_devices import (
+    get_logger,
+    MetricFactory,
+    GPUMemoryManager,
+    DeviceManager,
+)
+
+__all__ = [
+    # Constants
+    'EPS',
+    'set_global_seed',
+    'ensure_parent_dir',
+    'compute_batch_size',
+    'tweedie_loss',
+    'infer_factor_and_cate_list',
+    # I/O
+    'IOUtils',
+    'csv_to_dict',
+    # Distributed
+    'DistributedUtils',
+    'TrainingUtils',
+    'free_cuda',
+    # PyTorch
+    'TorchTrainerMixin',
+    # Utilities
+    'get_logger',
+    'MetricFactory',
+    'GPUMemoryManager',
+    'DeviceManager',
+]

ins_pricing/modelling/bayesopt/utils/constants.py

@@ -0,0 +1,21 @@
+"""Backward-compatible re-exports for numerical utilities."""
+
+from __future__ import annotations
+
+from ins_pricing.utils.features import infer_factor_and_cate_list
+from ins_pricing.utils.io import ensure_parent_dir
+from ins_pricing.utils.numerics import (
+    EPS,
+    compute_batch_size,
+    set_global_seed,
+    tweedie_loss,
+)
+
+__all__ = [
+    "EPS",
+    "set_global_seed",
+    "ensure_parent_dir",
+    "compute_batch_size",
+    "tweedie_loss",
+    "infer_factor_and_cate_list",
+]

ins_pricing/modelling/{core/bayesopt → bayesopt}/utils/distributed_utils.py

@@ -1,186 +1,193 @@
-"""Distributed training utilities for PyTorch DDP.
-
-This module contains:
-- DistributedUtils for DDP setup and process coordination
-- TrainingUtils for CUDA memory management
-- free_cuda() for legacy compatibility
-"""
-
-from __future__ import annotations
-
-import gc
-import os
-from datetime import timedelta
-from typing import Optional
-
-import torch
-import torch.distributed as dist
-
-
-def _select_ddp_backend() -> str:
-    """Select the appropriate DDP backend based on system capabilities.
-
-    Returns:
-        "nccl" if CUDA is available and NCCL is supported (non-Windows),
-        otherwise "gloo"
-    """
-    if not torch.cuda.is_available():
-        return "gloo"
-
-    if os.name == "nt":  # Windows doesn't support NCCL
-        return "gloo"
-
-    try:
-        nccl_available = getattr(dist, "is_nccl_available", lambda: False)()
-        return "nccl" if nccl_available else "gloo"
-    except Exception:
-        return "gloo"
-
-
-def _get_ddp_timeout() -> timedelta:
-    """Get the DDP timeout from environment variable.
-
-    Returns:
-        timedelta for DDP timeout (default: 1800 seconds)
-    """
-    timeout_seconds = int(os.environ.get("BAYESOPT_DDP_TIMEOUT_SECONDS", "1800"))
-    return timedelta(seconds=max(1, timeout_seconds))
-
-
-def _cache_ddp_state(local_rank: int, rank: int, world_size: int) -> tuple:
-    """Cache and return DDP state tuple."""
-    state = (True, local_rank, rank, world_size)
-    DistributedUtils._cached_state = state
-    return state
-
-
-class DistributedUtils:
-    """Utilities for distributed data parallel training.
-
-    This class provides methods for:
-    - Initializing DDP process groups
-    - Checking process rank and world size
-    - Cleanup after distributed training
-    """
-
-    _cached_state: Optional[tuple] = None
-
-    @staticmethod
-    def setup_ddp():
-        """Initialize the DDP process group for distributed training.
-
-        Returns:
-            Tuple of (success, local_rank, rank, world_size)
-        """
-        # Return cached state if already initialized
-        if dist.is_initialized():
-            if DistributedUtils._cached_state is None:
-                DistributedUtils._cached_state = _cache_ddp_state(
-                    int(os.environ.get("LOCAL_RANK", 0)),
-                    dist.get_rank(),
-                    dist.get_world_size(),
-                )
-            return DistributedUtils._cached_state
-
-        # Check for required environment variables
-        if 'RANK' not in os.environ or 'WORLD_SIZE' not in os.environ:
-            print(
-                f">>> DDP Setup Failed: RANK or WORLD_SIZE not found in env. "
-                f"Keys found: {list(os.environ.keys())}"
-            )
-            print(">>> Hint: launch with torchrun --nproc_per_node=<N> <script.py>")
-            return False, 0, 0, 1
-
-        rank = int(os.environ["RANK"])
-        world_size = int(os.environ["WORLD_SIZE"])
-        local_rank = int(os.environ.get("LOCAL_RANK", 0))
-
-        # Windows CUDA DDP is not supported
-        if os.name == "nt" and torch.cuda.is_available() and world_size > 1:
-            print(
-                ">>> DDP Setup Disabled: Windows CUDA DDP is not supported. "
-                "Falling back to single process."
-            )
-            return False, 0, 0, 1
-
-        # Set CUDA device for this process
-        if torch.cuda.is_available():
-            torch.cuda.set_device(local_rank)
-
-        # Initialize process group
-        backend = _select_ddp_backend()
-        timeout = _get_ddp_timeout()
-
-        dist.init_process_group(backend=backend, init_method="env://", timeout=timeout)
-        print(
-            f">>> DDP Initialized ({backend}, timeout={timeout.total_seconds():.0f}s): "
-            f"Rank {rank}/{world_size}, Local Rank {local_rank}"
-        )
-
-        return _cache_ddp_state(local_rank, rank, world_size)
-
-    @staticmethod
-    def cleanup_ddp():
-        """Destroy the DDP process group and clear cached state."""
-        if dist.is_initialized():
-            dist.destroy_process_group()
-        DistributedUtils._cached_state = None
-
-    @staticmethod
-    def is_main_process():
-        """Check if current process is rank 0 (main process).
-
-        Returns:
-            True if main process or DDP not initialized
-        """
-        return not dist.is_initialized() or dist.get_rank() == 0
-
-    @staticmethod
-    def world_size() -> int:
-        """Get the total number of processes in the distributed group.
-
-        Returns:
-            World size (1 if DDP not initialized)
-        """
-        return dist.get_world_size() if dist.is_initialized() else 1
-
-
-class TrainingUtils:
-    """General training utilities including CUDA management."""
-
-    @staticmethod
-    def free_cuda() -> None:
-        """Release CUDA memory and clear cache.
-
-        This performs aggressive cleanup:
-        1. Move all PyTorch models to CPU
-        2. Run garbage collection
-        3. Clear CUDA cache
-        """
-        print(">>> Moving all models to CPU...")
-        for obj in gc.get_objects():
-            try:
-                if hasattr(obj, "to") and callable(obj.to):
-                    obj.to("cpu")
-            except Exception:
-                pass
-
-        print(">>> Releasing tensor/optimizer/DataLoader references...")
-        gc.collect()
-
-        print(">>> Clearing CUDA cache...")
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            torch.cuda.synchronize()
-            print(">>> CUDA memory released.")
-        else:
-            print(">>> CUDA not available; cleanup skipped.")
-
-
-# Backward compatibility function wrapper
-def free_cuda():
-    """Legacy function wrapper for CUDA memory cleanup.
-
-    This function calls TrainingUtils.free_cuda() for backward compatibility.
-    """
-    TrainingUtils.free_cuda()
+"""Distributed training utilities for PyTorch DDP.
+
+This module contains:
+- DistributedUtils for DDP setup and process coordination
+- TrainingUtils for CUDA memory management
+- free_cuda() for legacy compatibility
+"""
+
+from __future__ import annotations
+
+import gc
+import os
+from datetime import timedelta
+from typing import Optional
+
+import torch
+import torch.distributed as dist
+from ins_pricing.utils import get_logger, log_print
+
+_logger = get_logger("ins_pricing.modelling.bayesopt.utils.distributed_utils")
+
+
+def _log(*args, **kwargs) -> None:
+    log_print(_logger, *args, **kwargs)
+
+
+def _select_ddp_backend() -> str:
+    """Select the appropriate DDP backend based on system capabilities.
+
+    Returns:
+        "nccl" if CUDA is available and NCCL is supported (non-Windows),
+        otherwise "gloo"
+    """
+    if not torch.cuda.is_available():
+        return "gloo"
+
+    if os.name == "nt":  # Windows doesn't support NCCL
+        return "gloo"
+
+    try:
+        nccl_available = getattr(dist, "is_nccl_available", lambda: False)()
+        return "nccl" if nccl_available else "gloo"
+    except Exception:
+        return "gloo"
+
+
+def _get_ddp_timeout() -> timedelta:
+    """Get the DDP timeout from environment variable.
+
+    Returns:
+        timedelta for DDP timeout (default: 1800 seconds)
+    """
+    timeout_seconds = int(os.environ.get("BAYESOPT_DDP_TIMEOUT_SECONDS", "1800"))
+    return timedelta(seconds=max(1, timeout_seconds))
+
+
+def _cache_ddp_state(local_rank: int, rank: int, world_size: int) -> tuple:
+    """Cache and return DDP state tuple."""
+    state = (True, local_rank, rank, world_size)
+    DistributedUtils._cached_state = state
+    return state
+
+
+class DistributedUtils:
+    """Utilities for distributed data parallel training.
+
+    This class provides methods for:
+    - Initializing DDP process groups
+    - Checking process rank and world size
+    - Cleanup after distributed training
+    """
+
+    _cached_state: Optional[tuple] = None
+
+    @staticmethod
+    def setup_ddp():
+        """Initialize the DDP process group for distributed training.
+
+        Returns:
+            Tuple of (success, local_rank, rank, world_size)
+        """
+        # Return cached state if already initialized
+        if dist.is_initialized():
+            if DistributedUtils._cached_state is None:
+                DistributedUtils._cached_state = _cache_ddp_state(
+                    int(os.environ.get("LOCAL_RANK", 0)),
+                    dist.get_rank(),
+                    dist.get_world_size(),
+                )
+            return DistributedUtils._cached_state
+
+        # Check for required environment variables
+        if 'RANK' not in os.environ or 'WORLD_SIZE' not in os.environ:
+            _log(
+                f">>> DDP Setup Failed: RANK or WORLD_SIZE not found in env. "
+                f"Keys found: {list(os.environ.keys())}"
+            )
+            _log(">>> Hint: launch with torchrun --nproc_per_node=<N> <script.py>")
+            return False, 0, 0, 1
+
+        rank = int(os.environ["RANK"])
+        world_size = int(os.environ["WORLD_SIZE"])
+        local_rank = int(os.environ.get("LOCAL_RANK", 0))
+
+        # Windows CUDA DDP is not supported
+        if os.name == "nt" and torch.cuda.is_available() and world_size > 1:
+            _log(
+                ">>> DDP Setup Disabled: Windows CUDA DDP is not supported. "
+                "Falling back to single process."
+            )
+            return False, 0, 0, 1
+
+        # Set CUDA device for this process
+        if torch.cuda.is_available():
+            torch.cuda.set_device(local_rank)
+
+        # Initialize process group
+        backend = _select_ddp_backend()
+        timeout = _get_ddp_timeout()
+
+        dist.init_process_group(backend=backend, init_method="env://", timeout=timeout)
+        _log(
+            f">>> DDP Initialized ({backend}, timeout={timeout.total_seconds():.0f}s): "
+            f"Rank {rank}/{world_size}, Local Rank {local_rank}"
+        )
+
+        return _cache_ddp_state(local_rank, rank, world_size)
+
+    @staticmethod
+    def cleanup_ddp():
+        """Destroy the DDP process group and clear cached state."""
+        if dist.is_initialized():
+            dist.destroy_process_group()
+        DistributedUtils._cached_state = None
+
+    @staticmethod
+    def is_main_process():
+        """Check if current process is rank 0 (main process).
+
+        Returns:
+            True if main process or DDP not initialized
+        """
+        return not dist.is_initialized() or dist.get_rank() == 0
+
+    @staticmethod
+    def world_size() -> int:
+        """Get the total number of processes in the distributed group.
+
+        Returns:
+            World size (1 if DDP not initialized)
+        """
+        return dist.get_world_size() if dist.is_initialized() else 1
+
+
+class TrainingUtils:
+    """General training utilities including CUDA management."""
+
+    @staticmethod
+    def free_cuda() -> None:
+        """Release CUDA memory and clear cache.
+
+        This performs aggressive cleanup:
+        1. Move all PyTorch models to CPU
+        2. Run garbage collection
+        3. Clear CUDA cache
+        """
+        _log(">>> Moving all models to CPU...")
+        for obj in gc.get_objects():
+            try:
+                if hasattr(obj, "to") and callable(obj.to):
+                    obj.to("cpu")
+            except Exception:
+                pass
+
+        _log(">>> Releasing tensor/optimizer/DataLoader references...")
+        gc.collect()
+
+        _log(">>> Clearing CUDA cache...")
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.synchronize()
+            _log(">>> CUDA memory released.")
+        else:
+            _log(">>> CUDA not available; cleanup skipped.")
+
+
+# Backward compatibility function wrapper
+def free_cuda():
+    """Legacy function wrapper for CUDA memory cleanup.
+
+    This function calls TrainingUtils.free_cuda() for backward compatibility.
+    """
+    TrainingUtils.free_cuda()

ins_pricing/modelling/bayesopt/utils/io_utils.py

@@ -0,0 +1,7 @@
+"""Backward-compatible re-exports for IO utilities."""
+
+from __future__ import annotations
+
+from ins_pricing.utils.io import IOUtils, csv_to_dict, ensure_parent_dir
+
+__all__ = ["IOUtils", "csv_to_dict", "ensure_parent_dir"]

ins_pricing/modelling/bayesopt/utils/losses.py

@@ -0,0 +1,27 @@
+"""Backward-compatible re-exports for loss utilities."""
+
+from __future__ import annotations
+
+from ins_pricing.utils.losses import (
+    CLASSIFICATION_LOSSES,
+    LOSS_ALIASES,
+    REGRESSION_LOSSES,
+    infer_loss_name_from_model_name,
+    loss_requires_positive,
+    normalize_loss_name,
+    regression_loss,
+    resolve_tweedie_power,
+    resolve_xgb_objective,
+)
+
+__all__ = [
+    "LOSS_ALIASES",
+    "REGRESSION_LOSSES",
+    "CLASSIFICATION_LOSSES",
+    "normalize_loss_name",
+    "infer_loss_name_from_model_name",
+    "resolve_tweedie_power",
+    "resolve_xgb_objective",
+    "regression_loss",
+    "loss_requires_positive",
+]

ins_pricing/modelling/bayesopt/utils/metrics_and_devices.py

@@ -0,0 +1,17 @@
+"""Backward-compatible re-exports for metrics and device utilities."""
+
+from __future__ import annotations
+
+from ins_pricing.utils import (
+    DeviceManager,
+    GPUMemoryManager,
+    MetricFactory,
+    get_logger,
+)
+
+__all__ = [
+    "get_logger",
+    "MetricFactory",
+    "GPUMemoryManager",
+    "DeviceManager",
+]