libinephany 0.16.2__tar.gz → 0.16.3__tar.gz

libinephany-0.16.3/CODE_VERSION.cfg

@@ -0,0 +1 @@
+0.16.3

{libinephany-0.16.2/libinephany.egg-info → libinephany-0.16.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libinephany
-Version: 0.16.2
+Version: 0.16.3
 Summary: Inephany library containing code commonly used by multiple subpackages.
 Author-email: Inephany <info@inephany.com>
 License: Apache 2.0
@@ -18,6 +18,7 @@ Requires-Dist: pydantic<3.0.0,>=2.5.0
 Requires-Dist: loguru<0.8.0,>=0.7.0
 Requires-Dist: requests<3.0.0,>=2.28.0
 Requires-Dist: numpy<2.0.0,>=1.24.0
+Requires-Dist: scipy<2.0.0,>=1.10.0
 Requires-Dist: slack-sdk<4.0.0,>=3.20.0
 Requires-Dist: boto3<2.0.0,>=1.26.0
 Requires-Dist: fastapi<0.116.0,>=0.100.0

{libinephany-0.16.2 → libinephany-0.16.3}/libinephany/observations/observation_utils.py

@@ -13,6 +13,7 @@ import numpy as np
 import pandas as pd
 import torch
 import torch.optim as optim
+from scipy.stats import norm
 
 from libinephany.pydantic_models.schemas.tensor_statistics import TensorStatistics
 from libinephany.utils import optim_utils
@@ -24,6 +25,9 @@ from libinephany.utils import optim_utils
 # ======================================================================================================================
 
 EXP_AVERAGE = "exp_avg"
+MIN_DECAY_FACTOR = 1e-10
+
+MIN_TOTAL_WEIGHT = 1e-15  # Minimum total weight threshold for numerical stability
 
 # ======================================================================================================================
 #
@@ -280,3 +284,165 @@ def concatenate_lists(lists: list[list[Any]]) -> list[Any]:
     """
 
     return list(chain(*lists))
+
+
+def compute_cdf_weighted_mean_and_std(
+    time_series: list[tuple[float, float]], decay_factor: float
+) -> tuple[float, float]:
+    """
+    Compute the CDF-weighted standard deviation using the same exponential decay weights
+    as the mean calculation, with numerical integration.
+
+    :param time_series: List of (time, value) pairs
+    :param decay_factor: Decay factor b in the exponential weight formula b in [1.25, 2.5, 5, 10, 20]
+    :return: Tuple of (weighted mean, weighted standard deviation)
+    """
+
+    if len(time_series) == 0:
+        return 0.0, 0.0
+
+    if len(time_series) == 1:
+        return time_series[0][1], 0.0
+
+    sorted_series = sorted(time_series, key=lambda x: x[0])
+
+    # Handle the special case when decay_factor = 1.0
+    if abs(decay_factor - 1.0) < MIN_DECAY_FACTOR:
+        # When decay_factor = 1.0, w(t) = 1 for all t
+        # So the result is just the arithmetic mean
+        values = [v for _, v in sorted_series]
+        mean = float(np.mean(values))
+        std = float(np.std(values))
+        return mean, std
+
+    log_decay_factor = math.log(decay_factor)
+
+    total_weight = 0.0  # ∫ w(t) dt - total weight across all time intervals
+    total_weighted_value = 0.0  # ∫ w(t) y(t) dt - total weighted value
+    total_weighted_squared = 0.0  # ∫ w(t) y(t)² dt - total weighted squared value
+
+    for time_series_index in range(len(sorted_series) - 1):
+        start_time_point = sorted_series[time_series_index][0]
+        end_time_point = sorted_series[time_series_index + 1][0]
+        start_value = sorted_series[time_series_index][1]
+        end_value = sorted_series[time_series_index + 1][1]
+
+        time_interval = end_time_point - start_time_point
+        assert time_interval > 0, "Time interval must be positive"
+
+        interval_value = _weighted_interval_expectation(
+            start_time_point=start_time_point,
+            start_value=start_value,
+            end_time_point=end_time_point,
+            end_value=end_value,
+            log_decay_factor=log_decay_factor,
+        )
+        interval_squared_value = _weighted_interval_expectation(
+            start_time_point=start_time_point,
+            start_value=start_value**2,
+            end_time_point=end_time_point,
+            end_value=end_value**2,
+            log_decay_factor=log_decay_factor,
+        )
+
+        total_weighted_value += interval_value
+        total_weighted_squared += interval_squared_value
+
+    total_weight = (1 / log_decay_factor) * (
+        math.exp(log_decay_factor * sorted_series[-1][0]) - math.exp(log_decay_factor * sorted_series[0][0])
+    )
+    # Check if total weight is too small (numerical stability)
+    if total_weight < MIN_TOTAL_WEIGHT:
+        values = [v for _, v in sorted_series]
+        mean = float(np.mean(values))
+        std = float(np.std(values))
+        return mean, std
+
+    # Calculate weighted mean: μ = ∫ w(t) y(t) dt / ∫ w(t) dt
+    # This gives us the expected value under the weight distribution
+    weighted_mean = float(total_weighted_value / total_weight)
+
+    # Calculate weighted variance: Var = ∫ w(t) y(t)² dt / ∫ w(t) dt - μ²
+    # This follows from the definition: Var(X) = E[X²] - (E[X])²
+    # where E[X] = ∫ w(t) y(t) dt / ∫ w(t) dt and E[X²] = ∫ w(t) y(t)² dt / ∫ w(t) dt
+    weighted_variance = float(total_weighted_squared / total_weight - weighted_mean**2)
+
+    # Calculate weighted standard deviation: σ = √Var
+    # This is the square root of the variance, representing the spread of values
+    weighted_std = float(math.sqrt(max(0, weighted_variance)))
+
+    return weighted_mean, weighted_std
+
+
+def _weighted_interval_expectation(
+    start_time_point: float,
+    start_value: float,
+    end_time_point: float,
+    end_value: float,
+    log_decay_factor: float,
+) -> float:
+    """
+    Computes the weighted interval expectation from Appendix E of the LHOPT paper.
+
+    :param start_time_point: the start time value of the interval.
+    :param start_value: the value at start_time_point.
+    :param end_time_point: the end time value of the interval.
+    :param end_value: the value at end_time_point.
+    :param log_decay_factor: the logarithm of the decay factor used to weight the expectation.
+    :return: the exponentially-weighted expectation of the linear interpolation between the start and end points.
+    """
+
+    interval_gradient = (end_value - start_value) / (end_time_point - start_time_point)
+    start_exp_time = math.exp(log_decay_factor * start_time_point)
+    end_exp_time = math.exp(log_decay_factor * end_time_point)
+    return (1 / log_decay_factor) * (end_value * end_exp_time - start_value * start_exp_time) + (
+        1 / log_decay_factor**2
+    ) * interval_gradient * (end_exp_time - start_exp_time)
+
+
+def compute_cdf_feature(
+    current_value: float,
+    time_series: list[tuple[float, float]],
+    decay_factor: float,
+    current_time: float,
+    time_window: int,
+) -> float:
+    """
+
+    This function computes a CDF feature that represents the cumulative probability
+    of the current value given the historical distribution, weighted by time decay.
+    Uses scipy.stats.norm.cdf with loc (mean) and scale (std) computed from CDF utilities.
+
+    The mean and std formula from the OpenAI paper:
+    https://arxiv.org/pdf/2305.18290.pdf
+
+
+    :param current_value: Current value to compute CDF feature for
+    :param time_series: List of (time, value) pairs for CDF calculation. time_series will be updated in-place each time this function is called.
+    :param decay_factor: Decay factor for CDF calculation (0 < factor < 1)
+    :param current_time: Current time step
+    :param time_window: Maximum number of time steps to keep in time series
+    :return: CDF feature value (cumulative probability from normal distribution)
+    """
+    # Add current observation to time series
+    time_series.append((current_time, current_value))
+
+    # Keep only the last time_window observations
+    if len(time_series) > time_window:
+        time_series[:] = time_series[-time_window:]
+
+    # If we don't have enough data, return 0.0
+    if len(time_series) < 2:
+        return 0.0
+
+    # Compute CDF-weighted mean (loc) and standard deviation (scale)
+    cdf_mean, cdf_std = compute_cdf_weighted_mean_and_std(time_series, decay_factor)
+
+    # Compute CDF feature using scipy.stats.norm.cdf
+    if cdf_std > 0:
+        # Use norm.cdf with loc=cdf_mean and scale=cdf_std
+        cdf_feature = norm.cdf(current_value, loc=cdf_mean, scale=cdf_std)
+        return cdf_feature
+    else:
+        # If the standard deviation is 0, return 0.0
+        return 0.0

{libinephany-0.16.2 → libinephany-0.16.3}/libinephany/utils/constants.py

@@ -80,3 +80,4 @@ PREFIXES_TO_HPARAMS = {
     AGENT_PREFIX_SGD_MOMENTUM: SGD_MOMENTUM,
     AGENT_GRADIENT_ACCUMULATION: GRADIENT_ACCUMULATION,
 }
+HPARAMS_TO_PREFIXES = {hparam: prefix for prefix, hparam in PREFIXES_TO_HPARAMS.items()}

{libinephany-0.16.2 → libinephany-0.16.3}/libinephany/utils/enums.py

@@ -78,6 +78,24 @@ class AgentTypes(EnumWithIndices):
     Tokens = TOKENS
     Samples = SAMPLES
 
+    @classmethod
+    def get_possible_active_agents(cls) -> list["AgentTypes"]:
+        """
+        :return: List of active agents.
+        """
+
+        return [
+            cls.LearningRateAgent,
+            cls.WeightDecayAgent,
+            cls.DropoutAgent,
+            cls.GradientClippingAgent,
+            cls.AdamBetaOneAgent,
+            cls.AdamBetaTwoAgent,
+            cls.AdamEpsAgent,
+            cls.SGDMomentumAgent,
+            cls.GradientAccumulationAgent,
+        ]
+
 
 class ModelFamilies(EnumWithIndices):
 

{libinephany-0.16.2 → libinephany-0.16.3}/libinephany/utils/samplers.py

@@ -68,6 +68,13 @@ class Sampler:
 
         raise NotImplementedError
 
+    @classmethod
+    def get_subclasses(cls):
+        """Recursively gets subclasses of the Sampler class."""
+        for subclass in cls.__subclasses__():
+            yield from subclass.get_subclasses()
+            yield subclass
+
 
 class LogUniformSampler(Sampler):
 
@@ -228,6 +235,34 @@ class DiscreteValueSampler(Sampler):
         ).astype(self.sample_dtype)
 
 
+class DiscreteValueListSampler(DiscreteValueSampler):
+
+    def __init__(
+        self,
+        length: int,
+        discrete_values: list[float | int | str],
+        sample_dtype: type[np.generic | float | int | str] = np.float64,
+        **kwargs,
+    ) -> None:
+        """
+        :param length: Length of list to sample.
+        :param discrete_values: List of discrete values to sample from.
+        :param kwargs: Miscellaneous keyword arguments.
+        """
+
+        super().__init__(discrete_values=discrete_values, sample_dtype=sample_dtype)
+        self.list_length = length
+
+    def sample(self, number_of_samples: int = 1, **kwargs) -> list[np.ndarray | list[Any]]:
+        """
+        :param number_of_samples: Number of samples to make.
+        :param kwargs: Miscellaneous keyword arguments.
+        :return: Array of sampled values.
+        """
+
+        return [super().sample(number_of_samples=self.list_length) for _ in range(number_of_samples)]
+
+
 class RoundRobinDiscreteValueSampler(Sampler):
 
     def __init__(
@@ -287,7 +322,7 @@ def build_sampler(sampler_name: str, lower_bound: float | int, upper_bound: floa
     :return: Constructed sampler.
     """
 
-    possible_samplers = {sampler_type.__name__: sampler_type for sampler_type in Sampler.__subclasses__()}
+    possible_samplers = {sampler_type.__name__: sampler_type for sampler_type in Sampler.get_subclasses()}
 
     try:
         return possible_samplers[sampler_name](lower_bound=lower_bound, upper_bound=upper_bound, **kwargs)  # type: ignore

{libinephany-0.16.2 → libinephany-0.16.3/libinephany.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libinephany
-Version: 0.16.2
+Version: 0.16.3
 Summary: Inephany library containing code commonly used by multiple subpackages.
 Author-email: Inephany <info@inephany.com>
 License: Apache 2.0
@@ -18,6 +18,7 @@ Requires-Dist: pydantic<3.0.0,>=2.5.0
 Requires-Dist: loguru<0.8.0,>=0.7.0
 Requires-Dist: requests<3.0.0,>=2.28.0
 Requires-Dist: numpy<2.0.0,>=1.24.0
+Requires-Dist: scipy<2.0.0,>=1.10.0
 Requires-Dist: slack-sdk<4.0.0,>=3.20.0
 Requires-Dist: boto3<2.0.0,>=1.26.0
 Requires-Dist: fastapi<0.116.0,>=0.100.0

{libinephany-0.16.2 → libinephany-0.16.3}/libinephany.egg-info/requires.txt

@@ -2,6 +2,7 @@ pydantic<3.0.0,>=2.5.0
 loguru<0.8.0,>=0.7.0
 requests<3.0.0,>=2.28.0
 numpy<2.0.0,>=1.24.0
+scipy<2.0.0,>=1.10.0
 slack-sdk<4.0.0,>=3.20.0
 boto3<2.0.0,>=1.26.0
 fastapi<0.116.0,>=0.100.0

{libinephany-0.16.2 → libinephany-0.16.3}/pyproject.toml

@@ -26,6 +26,7 @@ dependencies = [
     "loguru>=0.7.0,<0.8.0",
     "requests>=2.28.0,<3.0.0",
     "numpy>=1.24.0,<2.0.0",
+    "scipy>=1.10.0,<2.0.0",
     "slack-sdk>=3.20.0,<4.0.0",
     "boto3>=1.26.0,<2.0.0",
     "fastapi>=0.100.0,<0.116.0",

libinephany-0.16.2/CODE_VERSION.cfg

@@ -1 +0,0 @@
-0.16.2