libinephany 0.18.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

libinephany/observations/observation_utils.py

@@ -25,6 +25,7 @@ from libinephany.utils import optim_utils
 # ======================================================================================================================
 
 EXP_AVERAGE = "exp_avg"
+MOMENTUM_BUFFER = "momentum_buffer"
 MIN_DECAY_FACTOR = 1e-10
 
 MIN_TOTAL_WEIGHT = 1e-15  # Minimum total weight threshold for numerical stability
@@ -64,10 +65,8 @@ def get_exponential_weighted_average(values: list[int | float]) -> float:
     :param values: List of values to average via EWA.
     :return: EWA of the given values.
     """
-
     exp_weighted_average = pd.Series(values).ewm(alpha=0.1).mean().iloc[-1]
     assert isinstance(exp_weighted_average, float)
-
     return exp_weighted_average
 
 
@@ -232,6 +231,24 @@ def form_update_tensor(
         raise NotImplementedError(f"Optimizer {type(optimizer).__name__} is not supported!")
 
 
+def form_momentum_tensor(
+    optimizer: optim.Optimizer, parameters: list[torch.Tensor], parameter_group: dict[str, Any]
+) -> None | torch.Tensor:
+    """
+    :param optimizer: Optimizer to form the momentum tensor from.
+    :param parameters: Parameters to create the momentum tensor from.
+    :param parameter_group: Parameter group within the optimizer the given parameters came from.
+    """
+    if type(optimizer) in optim_utils.ADAM_OPTIMISERS:
+        momentum_list = [optimizer.state[p][EXP_AVERAGE].view(-1) for p in parameters if tensor_on_local_rank(p)]
+        return torch.cat(momentum_list) if momentum_list else None
+    elif type(optimizer) in optim_utils.SGD_OPTIMISERS:
+        momentum_list = [optimizer.state[p][MOMENTUM_BUFFER].view(-1) for p in parameters if tensor_on_local_rank(p)]
+        return torch.cat(momentum_list) if momentum_list else None
+    else:
+        raise NotImplementedError(f"Optimizer {type(optimizer).__name__} is not supported!")
+
+
 def null_standardizer(value_to_standardize: float, **kwargs) -> float:
     """
     :param value_to_standardize: Value to mock the standardization of.

libinephany/observations/observers/base_observers.py

@@ -43,15 +43,15 @@ class Observer(ABC):
         standardizer: Standardizer | None,
         observer_config: ObserverConfig,
         should_standardize: bool = True,
-        skip_statistics: list[str] | None = None,
+        include_statistics: list[str] | None = None,
         **kwargs,
     ) -> None:
         """
         :param standardizer: None or the standardizer to apply to the returned observations.
         :param global_config: ObserverConfig that can be used to inform various observation calculations.
         :param should_standardize: Whether standardization should be applied to returned values.
-        :param skip_statistics: If the observation uses the TensorStatistic model to return observations, names of the
-        fields in the model to not include in returned observations.
+        :param include_statistics: If the observation uses the TensorStatistic model to return observations, names of the
+        fields in the model to include in returned observations.
         :param kwargs: Miscellaneous keyword arguments.
         """
 
@@ -63,7 +63,10 @@ class Observer(ABC):
         self.standardize = standardizer if standardizer is not None else observation_utils.null_standardizer
         self.should_standardize = should_standardize and self.can_standardize
 
-        self.skip_statistics = TensorStatistics.filter_skip_statistics(skip_statistics=skip_statistics)
+        self.include_statistics: list[str] | None = None
+
+        if include_statistics is not None:
+            self.include_statistics = TensorStatistics.filter_include_statistics(include_statistics=include_statistics)
 
     @final
     @property
@@ -102,7 +105,10 @@ class Observer(ABC):
         observation_format = self.observation_format
 
         if observation_format is StatisticStorageTypes.TENSOR_STATISTICS:
-            return len([field for field in TensorStatistics.model_fields.keys() if field not in self.skip_statistics])
+            if self.include_statistics is None:
+                raise ValueError(f"{self.__class__.__name__} must be provided with include_statistics.")
+
+            return len([field for field in TensorStatistics.model_fields.keys() if field in self.include_statistics])
 
         elif observation_format is StatisticStorageTypes.FLOAT:
             return 1
@@ -231,10 +237,13 @@ class Observer(ABC):
             self._cached_observation = deepcopy(observations)
 
         if self.observation_format is StatisticStorageTypes.TENSOR_STATISTICS:
+            if self.include_statistics is None:
+                raise ValueError(f"{self.__class__.__name__} must be provided with include_statistics.")
+
             if return_dict:
                 observations_dict = observations.as_observation_dict()  # type: ignore
 
-            observations = observations.to_list(skip_statistics=self.skip_statistics)  # type: ignore
+            observations = observations.to_list(include_statistics=self.include_statistics)  # type: ignore
 
         observations = [observations] if not isinstance(observations, list) else observations  # type: ignore
 
@@ -256,7 +265,7 @@ class Observer(ABC):
     def inform(self) -> float | int | dict[str, float] | None:
         """
         :return: The cached observation. If the observation format is TensorStatistics then it is converted to a
-        dictionary with the statistics specified in skip_statistics excluded.
+        dictionary with the statistics specified in include_statistics included.
         """
 
         if not self.can_inform:
@@ -269,7 +278,10 @@ class Observer(ABC):
             )
 
         if self.observation_format is StatisticStorageTypes.TENSOR_STATISTICS:
-            observation = self._cached_observation.model_dump(exclude=set(self.skip_statistics))  # type: ignore
+            if self.include_statistics is None:
+                raise ValueError(f"{self.__class__.__name__} must be provided with include_statistics.")
+
+            observation = self._cached_observation.model_dump(include=set(self.include_statistics))  # type: ignore
 
         else:
             observation = self._cached_observation

libinephany/observations/observers/global_observers/__init__.py

@@ -8,7 +8,15 @@
 # ======================================================================================================================
 
 
-from .gradient_observers import GlobalFirstOrderGradients, GlobalSecondOrderGradients, LHOPTGradientVarianceFraction
+from .gradient_observers import (
+    CosineSimilarityObserverOfGradientAndMomentum,
+    CosineSimilarityObserverOfGradientAndUpdate,
+    CosineSimilarityOfGradientAndParameter,
+    GlobalFirstOrderGradients,
+    GlobalSecondOrderGradients,
+    LHOPTGradientVarianceFraction,
+    LHOPTMomentumGradientRatio,
+)
 from .hyperparameter_observers import (
     InitialHyperparameters,
     LHOPTHyperparameterRatio,
@@ -31,8 +39,11 @@ from .model_observers import (
     GlobalLAMBTrustRatio,
     GlobalParameters,
     GlobalParameterUpdates,
+    LHOPTAverageParameterUpdateMagnitudeObserver,
+    LHOPTGlobalLAMBTrustRatio,
     LogRatioOfPreviousAndCurrentParamNormEnvStepObserver,
     LogRatioOfUpdateAndPreviousParamNormEnvStepObserver,
+    LogRatioOfUpdateAndPreviousParamNormInnerStepObserver,
     NumberOfLayers,
     NumberOfParameters,
 )
@@ -51,14 +62,17 @@ __all__ = [
     GlobalFirstOrderGradients.__name__,
     GlobalSecondOrderGradients.__name__,
     LHOPTGradientVarianceFraction.__name__,
+    LHOPTMomentumGradientRatio.__name__,
     GlobalActivations.__name__,
     GlobalParameterUpdates.__name__,
     GlobalParameters.__name__,
     GlobalLAMBTrustRatio.__name__,
     NumberOfParameters.__name__,
     NumberOfLayers.__name__,
+    LHOPTAverageParameterUpdateMagnitudeObserver.__name__,
     LogRatioOfPreviousAndCurrentParamNormEnvStepObserver.__name__,
     LogRatioOfUpdateAndPreviousParamNormEnvStepObserver.__name__,
+    LogRatioOfUpdateAndPreviousParamNormInnerStepObserver.__name__,
     TrainingProgress.__name__,
     EpochsCompleted.__name__,
     ProgressAtEachCheckpoint.__name__,
@@ -66,4 +80,8 @@ __all__ = [
     LHOPTValidationLoss.__name__,
     LHOPTLossRatio.__name__,
     PercentileOfLossAtEachCheckpoint.__name__,
+    LHOPTGlobalLAMBTrustRatio.__name__,
+    CosineSimilarityObserverOfGradientAndMomentum.__name__,
+    CosineSimilarityObserverOfGradientAndUpdate.__name__,
+    CosineSimilarityOfGradientAndParameter.__name__,
 ]

libinephany/observations/observers/global_observers/constants.py

@@ -20,6 +20,7 @@ class LHOPTConstants(TypedDict):
     ZERO_DIVISION_TOLERANCE: float
     DEFAULT_SAMPLE_FREQUENCY: int
     DEFAULT_VARIANCE_THRESHOLD: float
+    DEFAULT_ENV_STEP_SAMPLE_FREQUENCY: int
 
 
 # Create the constants instance
@@ -36,4 +37,5 @@ LHOPT_CONSTANTS: LHOPTConstants = LHOPTConstants(
     ZERO_DIVISION_TOLERANCE=1e-8,
     DEFAULT_SAMPLE_FREQUENCY=4,
     DEFAULT_VARIANCE_THRESHOLD=1e-6,
+    DEFAULT_ENV_STEP_SAMPLE_FREQUENCY=10,
 )

libinephany/observations/observers/global_observers/gradient_observers.py

@@ -4,6 +4,7 @@
 #
 # ======================================================================================================================
 
+import math
 from typing import Any
 
 from libinephany.observations import observation_utils, statistic_trackers
@@ -52,7 +53,7 @@ class GlobalFirstOrderGradients(GlobalObserver):
         needed.
         """
 
-        return {statistic_trackers.FirstOrderGradients.__name__: dict(skip_statistics=self.skip_statistics)}
+        return {statistic_trackers.FirstOrderGradients.__name__: dict(include_statistics=self.include_statistics)}
 
 
 class GlobalSecondOrderGradients(GlobalObserver):
@@ -109,7 +110,7 @@ class GlobalSecondOrderGradients(GlobalObserver):
 
         return {
             statistic_trackers.SecondOrderGradients.__name__: dict(
-                skip_statistics=self.skip_statistics, compute_hessian_diagonal=self.compute_hessian_diagonal
+                include_statistics=self.include_statistics, compute_hessian_diagonal=self.compute_hessian_diagonal
             )
         }
 
@@ -189,5 +190,321 @@ class LHOPTGradientVarianceFraction(LHOPTBaseObserver):
         """
 
         return {
-            statistic_trackers.GradientVarianceFraction.__name__: dict(variance_threshold=self.variance_threshold),
+            statistic_trackers.GradientVarianceFraction.__name__: dict(
+                variance_threshold=self.variance_threshold, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
+            ),
+        }
+
+
+class LHOPTMomentumGradientRatio(LHOPTBaseObserver):
+    """
+    This is a global observer from the OpenAI paper "Learning to Optimize with Reinforcement Learning"
+    https://arxiv.org/abs/2305.18291.
+
+    It returns two-dimensional observations: [raw_value, cdf_feature] for momentum gradient ratio values.
+    """
+
+    def _get_observation_format(self) -> StatisticStorageTypes:
+        """
+        :return: Format the observation returns data in. Must be one of the enum attributes in the StatisticStorageTypes
+        enumeration class.
+        """
+
+        return StatisticStorageTypes.VECTOR
+
+    @property
+    def vector_length(self) -> int:
+        """
+        :return: Length of the vector returned by this observation if it returns a vector.
+        """
+        return 2  # [raw_value, cdf_feature]
+
+    def _observe(
+        self,
+        observation_inputs: ObservationInputs,
+        hyperparameter_states: HyperparameterStates,
+        tracked_statistics: dict[str, dict[str, float | TensorStatistics]],
+        action_taken: float | int | None,
+    ) -> float | int | list[int | float] | TensorStatistics:
+        """
+        :param observation_inputs: Observation input metrics not calculated with statistic trackers.
+        :param hyperparameter_states: HyperparameterStates that manages the hyperparameters.
+        :param tracked_statistics: Dictionary mapping statistic tracker class names to dictionaries mapping module
+        names to floats or TensorStatistic models.
+        :param action_taken: Action taken by the agent this class instance is assigned to.
+        :return: Single float/int, list of floats/ints or TensorStatistics model to add to the observation vector.
+        """
+
+        statistics = tracked_statistics[statistic_trackers.MomentumGradientRatioStatistics.__name__]
+
+        raw_value = list(statistics.values())[0]  # type: ignore[list-item]
+
+        cdf_feature = self._compute_cdf_feature(raw_value)  # type: ignore[arg-type]
+        self._update_time()
+
+        return [raw_value, cdf_feature]  # type: ignore[list-item]
+
+    def get_required_trackers(self) -> dict[str, dict[str, Any] | None]:
+        """
+        :return: Dictionary mapping statistic tracker class names to kwargs for the class or None if no kwargs are
+        needed.
+        """
+
+        return {
+            statistic_trackers.MomentumGradientRatioStatistics.__name__: dict(
+                include_statistics=self.include_statistics,
+                sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"],
+            ),
+        }
+
+
+class CosineSimilarityObserverOfGradientAndMomentum(LHOPTBaseObserver):
+    """
+    This is a global observer from the OpenAI paper "Learning to Optimize with Reinforcement Learning"
+    https://arxiv.org/abs/2305.18291.
+
+    It returns two-dimensional observations: [raw_value, cdf_feature] for cosine similarity of gradient and momentum values.
+    """
+
+    def __init__(
+        self,
+        *,
+        include_statistics: list[str] | None = None,
+        **kwargs,
+    ) -> None:
+        """
+        :param include_statistics: List of statistics to include.
+        :param kwargs: Miscellaneous keyword arguments.
+        """
+
+        super().__init__(**kwargs)
+
+        self.include_statistics = include_statistics
+
+    def _get_observation_format(self) -> StatisticStorageTypes:
+        """
+        :return: Format the observation returns data in. Must be one of the enum attributes in the StatisticStorageTypes
+        enumeration class.
+        """
+
+        return StatisticStorageTypes.VECTOR
+
+    @property
+    def vector_length(self) -> int:
+        """
+        :return: Length of the vector returned by this observation if it returns a vector.
+        """
+        return 3  # [raw_value, cdf_feature, logit_of_cdf_feature]
+
+    def _observe(
+        self,
+        observation_inputs: ObservationInputs,
+        hyperparameter_states: HyperparameterStates,
+        tracked_statistics: dict[str, dict[str, float | TensorStatistics]],
+        action_taken: float | int | None,
+    ) -> float | int | list[int | float] | TensorStatistics:
+        """
+        :param observation_inputs: Observation input metrics not calculated with statistic trackers.
+        :param hyperparameter_states: HyperparameterStates that manages the hyperparameters.
+        :param tracked_statistics: Dictionary mapping statistic tracker class names to dictionaries mapping module
+        names to floats or TensorStatistic models.
+        :param action_taken: Action taken by the agent this class instance is assigned to.
+        :return: Single float/int, list of floats/ints or TensorStatistics model to add to the observation vector.
+        """
+
+        statistics = tracked_statistics[
+            statistic_trackers.CosineSimilarityObserverOfGradientAndMomentumStatistics.__name__
+        ]
+
+        raw_value = list(statistics.values())[0]  # type: ignore[list-item]
+
+        cdf_feature = self._compute_cdf_feature(raw_value)  # type: ignore[arg-type]
+        self._update_time()
+
+        # Handle edge cases for logit calculation
+        if cdf_feature <= 0.0 or cdf_feature >= 1.0:
+            logit_of_cdf_feature = 0.0
+        else:
+            logit_of_cdf_feature = math.log(cdf_feature / (1 - cdf_feature))
+
+        return [raw_value, cdf_feature, logit_of_cdf_feature]  # type: ignore[list-item]
+
+    def get_required_trackers(self) -> dict[str, dict[str, Any] | None]:
+        """
+        :return: Dictionary mapping statistic tracker class names to kwargs for the class or None if no kwargs are
+        needed.
+        """
+
+        return {
+            statistic_trackers.CosineSimilarityObserverOfGradientAndMomentumStatistics.__name__: dict(
+                include_statistics=self.include_statistics,
+                sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"],
+            )
+        }
+
+
+class CosineSimilarityObserverOfGradientAndUpdate(LHOPTBaseObserver):
+    """
+    This is a global observer from the OpenAI paper "Learning to Optimize with Reinforcement Learning"
+    https://arxiv.org/abs/2305.18291.
+
+    It returns two-dimensional observations: [raw_value, cdf_feature] for cosine similarity of gradient and update values.
+    """
+
+    def __init__(
+        self,
+        *,
+        include_statistics: list[str] | None = None,
+        **kwargs,
+    ) -> None:
+        """
+        :param include_statistics: List of statistics to include.
+        :param kwargs: Miscellaneous keyword arguments.
+        """
+
+        super().__init__(**kwargs)
+
+        self.include_statistics = include_statistics
+
+    def _get_observation_format(self) -> StatisticStorageTypes:
+        """
+        :return: Format the observation returns data in. Must be one of the enum attributes in the StatisticStorageTypes
+        enumeration class.
+        """
+
+        return StatisticStorageTypes.VECTOR
+
+    @property
+    def vector_length(self) -> int:
+        """
+        :return: Length of the vector returned by this observation if it returns a vector.
+        """
+        return 3  # [raw_value, cdf_feature, logit_of_cdf_feature]
+
+    def _observe(
+        self,
+        observation_inputs: ObservationInputs,
+        hyperparameter_states: HyperparameterStates,
+        tracked_statistics: dict[str, dict[str, float | TensorStatistics]],
+        action_taken: float | int | None,
+    ) -> float | int | list[int | float] | TensorStatistics:
+        """
+        :param observation_inputs: Observation input metrics not calculated with statistic trackers.
+        :param hyperparameter_states: HyperparameterStates that manages the hyperparameters.
+        :param tracked_statistics: Dictionary mapping statistic tracker class names to dictionaries mapping module
+        names to floats or TensorStatistic models.
+        :param action_taken: Action taken by the agent this class instance is assigned to.
+        :return: Single float/int, list of floats/ints or TensorStatistics model to add to the observation vector.
+        """
+
+        statistics = tracked_statistics[
+            statistic_trackers.CosineSimilarityObserverOfGradientAndUpdateStatistics.__name__
+        ]
+
+        raw_value = list(statistics.values())[0]  # type: ignore[list-item]
+
+        cdf_feature = self._compute_cdf_feature(raw_value)  # type: ignore[arg-type]
+        self._update_time()
+
+        # Handle edge cases for logit calculation
+        if cdf_feature <= 0.0 or cdf_feature >= 1.0:
+            logit_of_cdf_feature = 0.0
+        else:
+            logit_of_cdf_feature = math.log(cdf_feature / (1 - cdf_feature))
+
+        return [raw_value, cdf_feature, logit_of_cdf_feature]  # type: ignore[list-item]
+
+    def get_required_trackers(self) -> dict[str, dict[str, Any] | None]:
+        """
+        :return: Dictionary mapping statistic tracker class names to kwargs for the class or None if no kwargs are
+        needed.
+        """
+
+        return {
+            statistic_trackers.CosineSimilarityObserverOfGradientAndUpdateStatistics.__name__: dict(
+                include_statistics=self.include_statistics,
+                sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"],
+            )
+        }
+
+
+class CosineSimilarityOfGradientAndParameter(LHOPTBaseObserver):
+    """
+    This is a global observer from the OpenAI paper "Learning to Optimize with Reinforcement Learning"
+    https://arxiv.org/abs/2305.18291.
+
+    It returns two-dimensional observations: [raw_value, cdf_feature] for cosine similarity of gradient and parameter values.
+    """
+
+    def __init__(
+        self,
+        *,
+        include_statistics: list[str] | None = None,
+        **kwargs,
+    ) -> None:
+        """
+        :param include_statistics: List of statistics to include.
+        :param kwargs: Miscellaneous keyword arguments.
+        """
+        super().__init__(**kwargs)
+
+        self.include_statistics = include_statistics
+
+    def _get_observation_format(self) -> StatisticStorageTypes:
+        """
+        :return: Format the observation returns data in. Must be one of the enum attributes in the StatisticStorageTypes
+        enumeration class.
+        """
+
+        return StatisticStorageTypes.VECTOR
+
+    @property
+    def vector_length(self) -> int:
+        """
+        :return: Length of the vector returned by this observation if it returns a vector.
+        """
+        return 3  # [raw_value, cdf_feature, logit_of_cdf_feature]
+
+    def _observe(
+        self,
+        observation_inputs: ObservationInputs,
+        hyperparameter_states: HyperparameterStates,
+        tracked_statistics: dict[str, dict[str, float | TensorStatistics]],
+        action_taken: float | int | None,
+    ) -> float | int | list[int | float] | TensorStatistics:
+        """
+        :param observation_inputs: Observation input metrics not calculated with statistic trackers.
+        :param hyperparameter_states: HyperparameterStates that manages the hyperparameters.
+        :param tracked_statistics: Dictionary mapping statistic tracker class names to dictionaries mapping module
+        names to floats or TensorStatistic models.
+        :param action_taken: Action taken by the agent this class instance is assigned to.
+        :return: Single float/int, list of floats/ints or TensorStatistics model to add to the observation vector.
+        """
+
+        statistics = tracked_statistics[statistic_trackers.CosineSimilarityOfGradientAndParameterStatistics.__name__]
+
+        raw_value = list(statistics.values())[0]  # type: ignore[list-item]
+
+        cdf_feature = self._compute_cdf_feature(raw_value)  # type: ignore[arg-type]
+        self._update_time()
+
+        # Handle edge cases for logit calculation
+        if cdf_feature <= 0.0 or cdf_feature >= 1.0:
+            logit_of_cdf_feature = 0.0
+        else:
+            logit_of_cdf_feature = math.log(cdf_feature / (1 - cdf_feature))
+
+        return [raw_value, cdf_feature, logit_of_cdf_feature]  # type: ignore[list-item]
+
+    def get_required_trackers(self) -> dict[str, dict[str, Any] | None]:
+        """
+        :return: Dictionary mapping statistic tracker class names to kwargs for the class or None if no kwargs are
+        needed.
+        """
+
+        return {
+            statistic_trackers.CosineSimilarityOfGradientAndParameterStatistics.__name__: dict(
+                include_statistics=self.include_statistics,
+                sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"],
+            )
         }

libinephany/observations/observers/global_observers/hyperparameter_observers.py

@@ -21,18 +21,16 @@ from libinephany.utils.enums import ModelFamilies
 
 class InitialHyperparameters(GlobalObserver):
 
-    def __init__(self, skip_hparams: list[str] | None = None, pad_with: float = 0.0, **kwargs) -> None:
+    def __init__(self, include_hparams: list[str] | None = None, pad_with: float = 0.0, **kwargs) -> None:
         """
-        :param skip_hparams: Names of the hyperparameters to not include in the initial values vector returned by
+        :param include_hparams: Names of the hyperparameters to include in the initial values vector returned by
         this observation.
         :param kwargs: Miscellaneous keyword arguments.
         """
 
         super().__init__(**kwargs)
 
-        force_skip = ["samples", "gradient_accumulation"]
-        skip_hparams = force_skip if skip_hparams is None else skip_hparams + force_skip
-        self.skip_hparams = [] if skip_hparams is None else skip_hparams
+        self.include_hparams = include_hparams
         self.pad_with = pad_with
 
     @property
@@ -41,9 +39,12 @@ class InitialHyperparameters(GlobalObserver):
         :return: Length of the vector returned by this observation if it returns a vector.
         """
 
+        if self.include_hparams is None:
+            raise ValueError(f"{self.__class__.__name__} must be provided with include_hparams.")
+
         available_hparams = HyperparameterStates.get_all_hyperparameters()
 
-        return len([hparam for hparam in available_hparams if hparam not in self.skip_hparams])
+        return len([hparam for hparam in available_hparams if hparam in self.include_hparams])
 
     @property
     def can_standardize(self) -> bool:
@@ -85,12 +86,14 @@ class InitialHyperparameters(GlobalObserver):
         :return: Single float/int, list of floats/ints or TensorStatistics model to add to the observation vector.
         """
 
-        initial_internal_values = hyperparameter_states.get_initial_internal_values(self.skip_hparams)
+        assert self.include_hparams is not None
+
+        initial_internal_values = hyperparameter_states.get_initial_internal_values(self.include_hparams)
         self._cached_observation = initial_internal_values
         initial_internal_values_list = [
             self.pad_with if initial_internal_value is None else initial_internal_value
             for hparam_name, initial_internal_value in initial_internal_values.items()
-            if hparam_name not in self.skip_hparams
+            if hparam_name in self.include_hparams
         ]
         return initial_internal_values_list
 
@@ -179,7 +182,8 @@ class ModelFamilyOneHot(GlobalObserver):
         **kwargs,
     ) -> None:
         """
-        :param skip_observations: List of episode boundary observations to ignore.
+        :param zero_vector_chance: Chance of the output vector being masked with zeros.
+        :param zero_vector_frequency_unit: Unit of time to sample the zero vector.
         :param kwargs: Miscellaneous keyword arguments.
         """
         super().__init__(**kwargs)
@@ -294,17 +298,16 @@ class LHOPTHyperparameterRatio(GlobalObserver):
     providing insights into how much hyperparameters have changed from their starting values.
     """
 
-    def __init__(self, skip_hparams: list[str] | None = None, pad_with: float = 0.0, **kwargs) -> None:
+    def __init__(self, include_hparams: list[str] | None = None, pad_with: float = 0.0, **kwargs) -> None:
         """
-        :param skip_hparams: Names of the hyperparameters to not include in the initial values vector returned by
+        :param include_hparams: Names of the hyperparameters to include in the initial values vector returned by
         this observation.
         :param kwargs: Miscellaneous keyword arguments.
         """
 
         super().__init__(**kwargs)
 
-        force_skip = ["samples", "gradient_accumulation"]
-        self.skip_hparams = force_skip if skip_hparams is None else skip_hparams + force_skip
+        self.include_hparams = include_hparams
         self.pad_with = pad_with
 
     @property
@@ -313,9 +316,12 @@ class LHOPTHyperparameterRatio(GlobalObserver):
         :return: Length of the vector returned by this observation if it returns a vector.
         """
 
+        if self.include_hparams is None:
+            raise ValueError(f"{self.__class__.__name__} must be provided with include_hparams.")
+
         available_hparams = HyperparameterStates.get_all_hyperparameters()
 
-        return len([hparam for hparam in available_hparams if hparam not in self.skip_hparams])
+        return len([hparam for hparam in available_hparams if hparam in self.include_hparams])
 
     @property
     def can_standardize(self) -> bool:
@@ -357,18 +363,20 @@ class LHOPTHyperparameterRatio(GlobalObserver):
         :return: Single float/int, list of floats/ints or TensorStatistics model to add to the observation vector.
         """
 
+        assert self.include_hparams is not None
+
         # Get initial and current hyperparameter values
-        initial_values = hyperparameter_states.get_initial_internal_values(self.skip_hparams)
+        initial_values = hyperparameter_states.get_initial_internal_values(self.include_hparams)
         initial_values = {
             hparam_name: self.pad_with if initial_value is None else initial_value
             for hparam_name, initial_value in initial_values.items()
-            if hparam_name not in self.skip_hparams
+            if hparam_name in self.include_hparams
         }
-        current_values = hyperparameter_states.get_current_internal_values(self.skip_hparams)
+        current_values = hyperparameter_states.get_current_internal_values(self.include_hparams)
         current_values = {
             hparam_name: self.pad_with if current_value is None else current_value
             for hparam_name, current_value in current_values.items()
-            if hparam_name not in self.skip_hparams
+            if hparam_name in self.include_hparams
         }
 
         ratios = []