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

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,7 +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:
@@ -436,6 +436,146 @@ class LogRatioOfUpdateAndPreviousParamNormEnvStepObserver(LHOPTBaseObserver):
             tensor_statistics=[stats for stats in param_statistics.values() if isinstance(stats, TensorStatistics)]
         ).norm_
 
+        if self._previous_param_norm is None:
+            self._previous_param_norm = current_param_norm
+            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
+
+        return [tanh_feature, cdf_feature]
+
+    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.ParameterUpdateStatistics.__name__: dict(include_statistics=self.include_statistics),
+            statistic_trackers.ParameterStatistics.__name__: dict(include_statistics=self.include_statistics),
+        }
+
+    def reset(self) -> None:
+        """
+        Reset the observer by clearing the previous parameter norm and time series.
+        """
+
+        super().reset()
+        self._previous_param_norm = None
+
+
+class LHOPTAverageParameterUpdateMagnitudeObserver(LHOPTBaseObserver):
+
+    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 can_standardize(self) -> bool:
+        """
+        :return: Whether the observation can be standardized.
+        """
+
+        return False
+
+    @property
+    def vector_length(self) -> int:
+        """
+        :return: Length of the vector returned by this observation if it returns a vector.
+        """
+        return 2  # [raw_feature, 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.AverageParameterUpdateMagnitudeStatistics.__name__]
+
+        raw_feature = list(statistics.values())[0]  # type: ignore[list-item]
+
+        cdf_feature = self._compute_cdf_feature(raw_feature)  # type: ignore[arg-type]
+        self._update_time()
+
+        return [raw_feature, 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.AverageParameterUpdateMagnitudeStatistics.__name__: dict(
+                include_statistics=self.include_statistics, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
+            )
+        }
+
+
+class LogRatioOfUpdateAndPreviousParamNormInnerStepObserver(LHOPTBaseObserver):
+    def __init__(self, **kwargs):
+        """
+        This observer is used to compute the log ratio of the update and previous parameter norm for the inner step. The sample frequency of the statistics needs to be set to 4 (according to the OpenAI paper).
+
+        """
+        super().__init__(**kwargs)
+        self._previous_param_norm = None
+
+    @property
+    def vector_length(self) -> int:
+        """
+        :return: Length of the vector returned by this observation if it returns a vector.
+        """
+        return 2  # [tanh_feature, 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 TensorStatistics models.
+        :param action_taken: Action taken by the agent this class instance is assigned to.
+        :return: List containing [raw_log_ratio, cdf_feature].
+        """
+
+        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_
+
+        current_param_norm = observation_utils.average_tensor_statistics(
+            tensor_statistics=[stats for stats in param_statistics.values() if isinstance(stats, TensorStatistics)]
+        ).norm_
+
         if self._previous_param_norm is None:
             self._previous_param_norm = current_param_norm
             self._compute_cdf_feature(0.0)  # default value since we can't compute log ratio yet
@@ -456,8 +596,12 @@ 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.LHOPTParameterUpdateStatistics.__name__: dict(
+                include_statistics=self.include_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"]
+            ),
         }
 
     def reset(self) -> None:
@@ -467,3 +611,73 @@ class LogRatioOfUpdateAndPreviousParamNormEnvStepObserver(LHOPTBaseObserver):
 
         super().reset()
         self._previous_param_norm = None
+
+
+class LHOPTGlobalLAMBTrustRatio(LHOPTBaseObserver):
+
+    def __init__(
+        self,
+        *,
+        use_log_transform: bool = False,
+        **kwargs,
+    ) -> None:
+        """
+        :param use_log_transform: Whether to transform the LAMB trust ratio by taking ln(1 + R).
+        :param kwargs: Other observation keyword arguments.
+        """
+
+        super().__init__(**kwargs)
+
+        self.use_log_transform = use_log_transform
+
+    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.LHOPTLAMBTrustRatioStatistics.__name__]
+
+        raw_value = sum(statistics.values()) / len(statistics)  # type: ignore[arg-type]
+        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.LHOPTLAMBTrustRatioStatistics.__name__: dict(
+                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

@@ -4,11 +4,13 @@
 #
 # ======================================================================================================================
 
+import math
 from typing import Any
 
 from libinephany.observations import observation_utils, statistic_trackers
-from libinephany.observations.observation_utils import StatisticStorageTypes
+from libinephany.observations.observation_utils import StatisticStorageTypes, compute_cdf_feature
 from libinephany.observations.observers.base_observers import LocalObserver
+from libinephany.observations.observers.global_observers.constants import LHOPT_CONSTANTS
 from libinephany.pydantic_models.schemas.observation_models import ObservationInputs
 from libinephany.pydantic_models.schemas.tensor_statistics import TensorStatistics
 from libinephany.pydantic_models.states.hyperparameter_states import HyperparameterStates
@@ -66,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):
@@ -130,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
             )
         }
 
@@ -178,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):
@@ -224,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):
@@ -270,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):
@@ -690,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:
@@ -723,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:
         """
@@ -756,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
@@ -774,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:
@@ -807,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:
         """
@@ -838,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
@@ -860,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:
@@ -893,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:
@@ -924,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(
@@ -1069,3 +1078,127 @@ class PercentageDepth(LocalObserver):
         """
 
         return {}
+
+
+class LogOfNoiseScaleObserver(LocalObserver):
+
+    def __init__(
+        self,
+        *,
+        decay_factor: float = LHOPT_CONSTANTS["DEFAULT_DECAY_FACTOR"],
+        time_window: int = LHOPT_CONSTANTS["DEFAULT_TIME_WINDOW"],
+        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 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.include_statistics = include_statistics
+        self.decay_factor = max(0.0, decay_factor)
+        self.time_window = max(1, time_window)
+
+        # Store time series data for CDF calculation
+        self._time_series: list[tuple[float, float]] = []  # (time, value) pairs
+        self._current_time: float = 0.0
+
+    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 can_standardize(self) -> bool:
+        """
+        :return: Whether the observation can be standardized.
+        """
+
+        return False
+
+    @property
+    def can_inform(self) -> bool:
+        """
+        :return: Whether observations from the observer can be used in the agent info dictionary.
+        """
+
+        return False
+
+    def _update_time(self) -> None:
+        """Update the current time counter."""
+        self._current_time += 1.0
+
+    def _compute_cdf_feature(self, value: float) -> float:
+        """
+        Compute CDF feature for the given value.
+        training loss will be added to the time series after this call.
+        :param value: The value to compute CDF feature for
+        :return: CDF feature value
+        """
+        return compute_cdf_feature(value, self._time_series, self.decay_factor, self._current_time, self.time_window)
+
+    @property
+    def vector_length(self) -> int:
+        """
+        :return: Length of the vector returned by this observation if it returns a vector.
+        """
+        return 2  # [log_noise_scale, 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.LogOfNoiseScaleStatistics.__name__]
+
+        raw_value = list(statistics.values())[0]  # type: ignore[list-item]
+        assert isinstance(raw_value, float), f"Expected float, got {type(raw_value)}"  # to avoid type errors with mypy
+        batch_size = hyperparameter_states.global_hparams.batch_size.external_value
+        learning_rate = hyperparameter_states.parameter_group_hparams[
+            self.parameter_group_name
+        ].learning_rate.external_value
+
+        log_b_over_epsilon = math.log(batch_size / learning_rate)
+
+        log_noise_scale = raw_value + log_b_over_epsilon
+
+        cdf_feature = self._compute_cdf_feature(log_noise_scale)  # type: ignore[arg-type]
+        self._update_time()
+
+        return [log_noise_scale, 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.LogOfNoiseScaleStatistics.__name__: dict(
+                include_statistics=self.include_statistics, sample_frequency=LHOPT_CONSTANTS["DEFAULT_SAMPLE_FREQUENCY"]
+            )
+        }
+
+    def reset(self) -> None:
+        """Reset the observer by clearing the time series."""
+        self._time_series = []
+        self._current_time = 0.0