libinephany 0.19.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

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/gradient_observers.py

@@ -53,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):
@@ -110,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
             )
         }
 
@@ -252,7 +252,7 @@ class LHOPTMomentumGradientRatio(LHOPTBaseObserver):
 
         return {
             statistic_trackers.MomentumGradientRatioStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics,
+                include_statistics=self.include_statistics,
                 sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"],
             ),
         }
@@ -269,18 +269,17 @@ class CosineSimilarityObserverOfGradientAndMomentum(LHOPTBaseObserver):
     def __init__(
         self,
         *,
-        skip_statistics: list[str] | None = None,
+        include_statistics: list[str] | None = None,
         **kwargs,
     ) -> None:
         """
-        :param compute_hessian_diagonal: Whether to compute the Hessian diagonal to determine second order gradients
-        or use the squared first order gradients as approximations in the same way Adam does.
+        :param include_statistics: List of statistics to include.
         :param kwargs: Miscellaneous keyword arguments.
         """
 
         super().__init__(**kwargs)
 
-        self.skip_statistics = skip_statistics
+        self.include_statistics = include_statistics
 
     def _get_observation_format(self) -> StatisticStorageTypes:
         """
@@ -338,7 +337,7 @@ class CosineSimilarityObserverOfGradientAndMomentum(LHOPTBaseObserver):
 
         return {
             statistic_trackers.CosineSimilarityObserverOfGradientAndMomentumStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics,
+                include_statistics=self.include_statistics,
                 sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"],
             )
         }
@@ -355,17 +354,17 @@ class CosineSimilarityObserverOfGradientAndUpdate(LHOPTBaseObserver):
     def __init__(
         self,
         *,
-        skip_statistics: list[str] | None = None,
+        include_statistics: list[str] | None = None,
         **kwargs,
     ) -> None:
         """
-        :param skip_statistics: List of statistics to skip.
+        :param include_statistics: List of statistics to include.
         :param kwargs: Miscellaneous keyword arguments.
         """
 
         super().__init__(**kwargs)
 
-        self.skip_statistics = skip_statistics
+        self.include_statistics = include_statistics
 
     def _get_observation_format(self) -> StatisticStorageTypes:
         """
@@ -423,7 +422,7 @@ class CosineSimilarityObserverOfGradientAndUpdate(LHOPTBaseObserver):
 
         return {
             statistic_trackers.CosineSimilarityObserverOfGradientAndUpdateStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics,
+                include_statistics=self.include_statistics,
                 sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"],
             )
         }
@@ -440,16 +439,16 @@ class CosineSimilarityOfGradientAndParameter(LHOPTBaseObserver):
     def __init__(
         self,
         *,
-        skip_statistics: list[str] | None = None,
+        include_statistics: list[str] | None = None,
         **kwargs,
     ) -> None:
         """
-        :param skip_statistics: List of statistics to skip.
+        :param include_statistics: List of statistics to include.
         :param kwargs: Miscellaneous keyword arguments.
         """
         super().__init__(**kwargs)
 
-        self.skip_statistics = skip_statistics
+        self.include_statistics = include_statistics
 
     def _get_observation_format(self) -> StatisticStorageTypes:
         """
@@ -505,7 +504,7 @@ class CosineSimilarityOfGradientAndParameter(LHOPTBaseObserver):
 
         return {
             statistic_trackers.CosineSimilarityOfGradientAndParameterStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics,
+                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 = []

libinephany/observations/observers/global_observers/model_observers.py

@@ -59,7 +59,7 @@ class GlobalActivations(GlobalObserver):
         needed.
         """
 
-        return {statistic_trackers.ActivationStatistics.__name__: dict(skip_statistics=self.skip_statistics)}
+        return {statistic_trackers.ActivationStatistics.__name__: dict(include_statistics=self.include_statistics)}
 
 
 class GlobalParameterUpdates(GlobalObserver):
@@ -98,7 +98,7 @@ class GlobalParameterUpdates(GlobalObserver):
         needed.
         """
 
-        return {statistic_trackers.ParameterUpdateStatistics.__name__: dict(skip_statistics=self.skip_statistics)}
+        return {statistic_trackers.ParameterUpdateStatistics.__name__: dict(include_statistics=self.include_statistics)}
 
 
 class GlobalParameters(GlobalObserver):
@@ -137,7 +137,7 @@ class GlobalParameters(GlobalObserver):
         needed.
         """
 
-        return {statistic_trackers.ParameterStatistics.__name__: dict(skip_statistics=self.skip_statistics)}
+        return {statistic_trackers.ParameterStatistics.__name__: dict(include_statistics=self.include_statistics)}
 
 
 class GlobalLAMBTrustRatio(GlobalObserver):
@@ -385,9 +385,7 @@ class LogRatioOfPreviousAndCurrentParamNormEnvStepObserver(LHOPTBaseObserver):
         """
 
         return {
-            statistic_trackers.ParameterStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics,
-            ),
+            statistic_trackers.ParameterStatistics.__name__: dict(include_statistics=self.include_statistics),
         }
 
     def reset(self) -> None:
@@ -443,9 +441,11 @@ class LogRatioOfUpdateAndPreviousParamNormEnvStepObserver(LHOPTBaseObserver):
             self._compute_cdf_feature(0.0)  # default value since we can't compute log ratio yet
             self._update_time()
             return [0.0, 0.0]
+
         log_ratio = self._compute_log_ratio(update_norm, self._previous_param_norm)
         tanh_feature = math.tanh(max(-LHOPT_CONSTANTS["TANH_BOUND"], min(LHOPT_CONSTANTS["TANH_BOUND"], log_ratio)))
         cdf_feature = self._compute_cdf_feature(log_ratio)
+
         self._update_time()
         self._previous_param_norm = current_param_norm
 
@@ -458,12 +458,8 @@ class LogRatioOfUpdateAndPreviousParamNormEnvStepObserver(LHOPTBaseObserver):
         """
 
         return {
-            statistic_trackers.ParameterUpdateStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics,
-            ),
-            statistic_trackers.ParameterStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics,
-            ),
+            statistic_trackers.ParameterUpdateStatistics.__name__: dict(include_statistics=self.include_statistics),
+            statistic_trackers.ParameterStatistics.__name__: dict(include_statistics=self.include_statistics),
         }
 
     def reset(self) -> None:
@@ -533,7 +529,7 @@ class LHOPTAverageParameterUpdateMagnitudeObserver(LHOPTBaseObserver):
 
         return {
             statistic_trackers.AverageParameterUpdateMagnitudeStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
+                include_statistics=self.include_statistics, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
             )
         }
 
@@ -570,8 +566,8 @@ class LogRatioOfUpdateAndPreviousParamNormInnerStepObserver(LHOPTBaseObserver):
         :return: List containing [raw_log_ratio, cdf_feature].
         """
 
-        update_statistics = tracked_statistics[statistic_trackers.InnerStepParameterUpdateStatistics.__name__]
-        param_statistics = tracked_statistics[statistic_trackers.InnerStepParameterStatistics.__name__]
+        update_statistics = tracked_statistics[statistic_trackers.LHOPTParameterUpdateStatistics.__name__]
+        param_statistics = tracked_statistics[statistic_trackers.LHOPTParameterStatistics.__name__]
         update_norm = observation_utils.average_tensor_statistics(
             tensor_statistics=[stats for stats in update_statistics.values() if isinstance(stats, TensorStatistics)]
         ).norm_
@@ -600,11 +596,11 @@ class LogRatioOfUpdateAndPreviousParamNormInnerStepObserver(LHOPTBaseObserver):
         """
 
         return {
-            statistic_trackers.InnerStepParameterUpdateStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
+            statistic_trackers.LHOPTParameterUpdateStatistics.__name__: dict(
+                include_statistics=self.include_statistics, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
             ),
-            statistic_trackers.InnerStepParameterStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
+            statistic_trackers.LHOPTParameterStatistics.__name__: dict(
+                include_statistics=self.include_statistics, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
             ),
         }
 
@@ -680,6 +676,8 @@ class LHOPTGlobalLAMBTrustRatio(LHOPTBaseObserver):
 
         return {
             statistic_trackers.LHOPTLAMBTrustRatioStatistics.__name__: dict(
-                use_log_transform=self.use_log_transform, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
+                include_statistics=self.include_statistics,
+                use_log_transform=self.use_log_transform,
+                sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"],
             )
         }

libinephany/observations/observers/global_observers/progress_observers.py

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #
-# imports
+# IMPORTS
 #
 # ======================================================================================================================
 
@@ -13,6 +13,12 @@ from libinephany.pydantic_models.schemas.observation_models import ObservationIn
 from libinephany.pydantic_models.schemas.tensor_statistics import TensorStatistics
 from libinephany.pydantic_models.states.hyperparameter_states import HyperparameterStates
 
+# ======================================================================================================================
+#
+# CLASSES
+#
+# ======================================================================================================================
+
 
 class TrainingProgress(GlobalObserver):
 

libinephany/observations/observers/local_observers.py

@@ -68,7 +68,7 @@ class FirstOrderGradients(LocalObserver):
         needed.
         """
 
-        return {statistic_trackers.FirstOrderGradients.__name__: dict(skip_statistics=self.skip_statistics)}
+        return {statistic_trackers.FirstOrderGradients.__name__: dict(include_statistics=self.include_statistics)}
 
 
 class SecondOrderGradients(LocalObserver):
@@ -132,7 +132,7 @@ class SecondOrderGradients(LocalObserver):
 
         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
             )
         }
 
@@ -180,7 +180,7 @@ class Activations(LocalObserver):
         needed.
         """
 
-        return {statistic_trackers.ActivationStatistics.__name__: dict(skip_statistics=self.skip_statistics)}
+        return {statistic_trackers.ActivationStatistics.__name__: dict(include_statistics=self.include_statistics)}
 
 
 class ParameterUpdates(LocalObserver):
@@ -226,7 +226,7 @@ class ParameterUpdates(LocalObserver):
         needed.
         """
 
-        return {statistic_trackers.ParameterUpdateStatistics.__name__: dict(skip_statistics=self.skip_statistics)}
+        return {statistic_trackers.ParameterUpdateStatistics.__name__: dict(include_statistics=self.include_statistics)}
 
 
 class Parameters(LocalObserver):
@@ -272,7 +272,7 @@ class Parameters(LocalObserver):
         needed.
         """
 
-        return {statistic_trackers.ParameterStatistics.__name__: dict(skip_statistics=self.skip_statistics)}
+        return {statistic_trackers.ParameterStatistics.__name__: dict(include_statistics=self.include_statistics)}
 
 
 class LAMBTrustRatio(LocalObserver):
@@ -692,16 +692,16 @@ class ModuleTypeOneHot(LocalObserver):
 
 class CurrentHyperparameters(LocalObserver):
 
-    def __init__(self, skip_hparams: list[str] | None = None, **kwargs) -> None:
+    def __init__(self, include_hparams: list[str] | None = None, **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)
 
-        self.skip_hparams = skip_hparams if skip_hparams is not None else []
+        self.include_hparams = include_hparams
 
     @property
     def can_standardize(self) -> bool:
@@ -725,11 +725,12 @@ class CurrentHyperparameters(LocalObserver):
         :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_layerwise_hyperparameters()
 
-        return len(
-            [hparam for hparam in available_hparams if not any(skipped in hparam for skipped in self.skip_hparams)]
-        )
+        return len([hparam for hparam in available_hparams if hparam in self.include_hparams])
 
     def _get_observation_format(self) -> StatisticStorageTypes:
         """
@@ -758,7 +759,7 @@ class CurrentHyperparameters(LocalObserver):
         assert self.parameter_group_name is not None
 
         current_internal_values = hyperparameter_states[self.parameter_group_name].get_current_internal_values(
-            skip_hparams=self.skip_hparams
+            include_hparams=self.include_hparams
         )
 
         self._cached_observation = current_internal_values
@@ -776,16 +777,16 @@ class CurrentHyperparameters(LocalObserver):
 
 class CurrentHyperparameterDeltas(LocalObserver):
 
-    def __init__(self, skip_hparams: list[str] | None = None, **kwargs) -> None:
+    def __init__(self, include_hparams: list[str] | None = None, **kwargs) -> None:
         """
-        :param skip_hparams: Names of the hyperparameters to not include in the initial deltas vector returned by
+        :param include_hparams: Names of the hyperparameters to include in the initial deltas vector returned by
         this observation.
         :param kwargs: Miscellaneous keyword arguments.
         """
 
         super().__init__(**kwargs)
 
-        self.skip_hparams = skip_hparams if skip_hparams is not None else []
+        self.include_hparams = include_hparams
 
     @property
     def can_standardize(self) -> bool:
@@ -809,11 +810,12 @@ class CurrentHyperparameterDeltas(LocalObserver):
         :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_layerwise_hyperparameters()
 
-        return len(
-            [hparam for hparam in available_hparams if not any(skipped in hparam for skipped in self.skip_hparams)]
-        )
+        return len([hparam for hparam in available_hparams if hparam in self.include_hparams])
 
     def _get_observation_format(self) -> StatisticStorageTypes:
         """
@@ -840,9 +842,10 @@ class CurrentHyperparameterDeltas(LocalObserver):
         """
 
         assert self.parameter_group_name is not None
+        assert self.include_hparams is not None
 
         current_deltas = hyperparameter_states[self.parameter_group_name].get_current_deltas(
-            skip_hparams=self.skip_hparams
+            include_hparams=self.include_hparams
         )
 
         self._cached_observation = current_deltas
@@ -862,16 +865,16 @@ class HyperparameterTransformTypes(LocalObserver):
 
     TRANSFORM_TYPE_TO_IDX = dict(((s, i) for i, s in enumerate(HyperparameterTransformType)))
 
-    def __init__(self, skip_hparams: list[str] | None = None, **kwargs) -> None:
+    def __init__(self, include_hparams: list[str] | None = None, **kwargs) -> None:
         """
-        :param skip_hparams: Names of the hyperparameters to not include in the transforms vector returned by
+        :param include_hparams: Names of the hyperparameters to include in the transforms vector returned by
         this observation.
         :param kwargs: Miscellaneous keyword arguments.
         """
 
         super().__init__(**kwargs)
 
-        self.skip_hparams = skip_hparams if skip_hparams is not None else []
+        self.include_hparams = include_hparams
 
     @property
     def can_standardize(self) -> bool:
@@ -895,10 +898,13 @@ class HyperparameterTransformTypes(LocalObserver):
         :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_layerwise_hyperparameters()
 
         return len(HyperparameterTransformType) * len(
-            [hparam for hparam in available_hparams if not any(skipped in hparam for skipped in self.skip_hparams)]
+            [hparam for hparam in available_hparams if hparam in self.include_hparams]
         )
 
     def _get_observation_format(self) -> StatisticStorageTypes:
@@ -926,10 +932,11 @@ class HyperparameterTransformTypes(LocalObserver):
         """
 
         assert self.parameter_group_name is not None
+        assert self.include_hparams is not None
 
         parameter_group_hparams = hyperparameter_states[self.parameter_group_name]
         hyperparameter_transform_types = parameter_group_hparams.get_hyperparameter_transform_types(
-            skip_hparams=self.skip_hparams
+            include_hparams=self.include_hparams
         )
         hyperparameter_transform_types_onehot_list = [
             observation_utils.create_one_hot_observation(
@@ -1080,20 +1087,20 @@ class LogOfNoiseScaleObserver(LocalObserver):
         *,
         decay_factor: float = LHOPT_CONSTANTS["DEFAULT_DECAY_FACTOR"],
         time_window: int = LHOPT_CONSTANTS["DEFAULT_TIME_WINDOW"],
-        skip_statistics: list[str] | None = None,
+        include_statistics: list[str] | None = None,
         **kwargs,
     ) -> None:
         """
         :param decay_factor: Decay factor for CDF calculation in [1, 2.5, 5, 10, 20]
         :param time_window: Number of time steps to consider for CDF calculation
-        :param skip_statistics: Whether to skip the statistics
+        :param include_statistics: List of statistics to include.
         or use the squared first order gradients as approximations in the same way Adam does.
         :param kwargs: Miscellaneous keyword arguments.
         """
 
         super().__init__(**kwargs)
 
-        self.skip_statistics = skip_statistics
+        self.include_statistics = include_statistics
         self.decay_factor = max(0.0, decay_factor)
         self.time_window = max(1, time_window)
 
@@ -1187,7 +1194,7 @@ class LogOfNoiseScaleObserver(LocalObserver):
 
         return {
             statistic_trackers.LogOfNoiseScaleStatistics.__name__: dict(
-                skip_statistics=self.skip_statistics, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
+                include_statistics=self.include_statistics, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
             )
         }