libinephany 0.15.4__tar.gz → 0.16.1__tar.gz

libinephany-0.16.1/CODE_VERSION.cfg

@@ -0,0 +1 @@
+0.16.1

{libinephany-0.15.4/libinephany.egg-info → libinephany-0.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libinephany
-Version: 0.15.4
+Version: 0.16.1
 Summary: Inephany library containing code commonly used by multiple subpackages.
 Author-email: Inephany <info@inephany.com>
 License: Apache 2.0

{libinephany-0.15.4 → libinephany-0.16.1}/libinephany/observations/observation_utils.py

@@ -4,6 +4,7 @@
 #
 # ======================================================================================================================
 
+import math
 from enum import Enum
 from itertools import chain
 from typing import Any, Callable
@@ -54,15 +55,25 @@ class StatisticStorageTypes(Enum):
 # ======================================================================================================================
 
 
-def get_exponential_weighted_average(values: list[float]) -> float:
+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)
+    # Check for NaN and infinite values in input
+    valid_values = [float(val) for val in values if not math.isnan(float(val)) and not math.isinf(float(val))]
+
+    if not valid_values:
+        raise ValueError("Cannot compute exponential weighted average on empty list")
 
+    if len(valid_values) == 1:
+        return valid_values[0]
+
+    exp_weighted_average = pd.Series(valid_values).ewm(alpha=0.1).mean().iloc[-1]
+    assert isinstance(exp_weighted_average, float)
+    assert not math.isnan(exp_weighted_average)
+    assert not math.isinf(exp_weighted_average)
     return exp_weighted_average
 
 

{libinephany-0.15.4 → libinephany-0.16.1}/libinephany/observations/observer_pipeline.py

@@ -4,6 +4,7 @@
 #
 # ======================================================================================================================
 
+import copy
 from typing import Any
 
 import gymnasium as gym
@@ -216,33 +217,42 @@ class ObserverPipeline:
         hyperparameter_states: HyperparameterStates,
         tracked_statistics: dict[str, dict[str, float | TensorStatistics]],
         actions_taken: dict[str, float | int | None],
-    ) -> tuple[dict[str, list[float | int]], bool]:
+        return_dict: bool = False,
+    ) -> tuple[dict[str, list[float | int]], bool, dict[str, dict[str, list[float | int]]] | None]:
         """
         :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 actions_taken: Dictionary mapping agent IDs to actions taken by that agent.
-        :return: Tuple of a dictionary mapping agent ID to that agent's completed observation vector and a boolean
-        indicating whether an observation clip occurred.
+        :param return_dict: Whether to return a dictionary of observations as well as the normal vector.
+        :return: Tuple of a dictionary mapping agent ID to that agent's completed observation vector, a boolean
+        indicating whether an observation clip occurred and a dictionary of observations.
         """
 
-        global_obs = self.global_observers.observe(
+        global_obs, global_obs_dict = self.global_observers.observe(
             observation_inputs=observation_inputs,
             hyperparameter_states=hyperparameter_states,
             tracked_statistics=tracked_statistics,
             action_taken=None,
+            return_dict=return_dict,
         )
 
-        local_obs = {
-            agent_id: agent_observers.observe(
+        local_obs: dict[str, list[float | int]] = {}
+        obs_as_dict: dict[str, dict[str, list[float | int]]] = {}
+
+        for agent_id, agent_observers in self.local_observers.items():
+            local_obs[agent_id], local_obs_dict = agent_observers.observe(
                 observation_inputs=observation_inputs,
                 hyperparameter_states=hyperparameter_states,
                 tracked_statistics=tracked_statistics,
                 action_taken=actions_taken[agent_id] if agent_id in actions_taken else None,
+                return_dict=return_dict,
             )
-            for agent_id, agent_observers in self.local_observers.items()
-        }
+
+            if return_dict:
+                obs_as_dict[agent_id] = copy.deepcopy(global_obs_dict)
+                obs_as_dict[agent_id].update(local_obs_dict)
 
         for post_processor in self.post_processors:
             global_obs, local_obs = post_processor.postprocess(
@@ -252,8 +262,9 @@ class ObserverPipeline:
         global_obs, local_obs, obs_clipped = self.clip_observations(
             globals_to_clip=global_obs, locals_to_clip=local_obs
         )
+        merged_obs = self.merge_globals_to_locals(global_obs=global_obs, local_obs=local_obs)
 
-        return self.merge_globals_to_locals(global_obs=global_obs, local_obs=local_obs), obs_clipped
+        return merged_obs, obs_clipped, obs_as_dict if return_dict else None
 
     def inform(self) -> tuple[ObservationInformation, dict[str, ObservationInformation]]:
         """

{libinephany-0.15.4 → libinephany-0.16.1}/libinephany/observations/observers/observer_containers.py

@@ -132,27 +132,36 @@ class ObserverContainer(ABC):
         hyperparameter_states: HyperparameterStates,
         tracked_statistics: dict[str, dict[str, float | TensorStatistics]],
         action_taken: float | int | None,
-    ) -> list[float | int]:
+        return_dict: bool = False,
+    ) -> tuple[list[float | int], dict[str, list[float | int]] | None]:
         """
         :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: List of floats or integers to add to the agent's observation vector.
+        :param return_dict: Whether to return a dictionary of observations as well as the normal vector.
+        :return: Tuple of a list of floats or integers to add to the agent's observation vector and a dictionary of
+        observations as well as the normal vector.
         """
 
         observations = []
+        observations_dict = {}
 
         for observer in self._observers:
-            observations += observer.observe(
+            observer_obs = observer.observe(
                 observation_inputs=observation_inputs,
                 hyperparameter_states=hyperparameter_states,
                 tracked_statistics=tracked_statistics,
                 action_taken=action_taken,
             )
 
-        return observations
+            if return_dict:
+                observations_dict[observer.__class__.__name__] = observer_obs
+
+            observations += observer_obs
+
+        return observations, observations_dict if return_dict else None
 
     @final
     def inform(self) -> ObservationInformation:

{libinephany-0.15.4 → libinephany-0.16.1}/libinephany/observations/pipeline_coordinator.py

@@ -120,6 +120,7 @@ class ObserverPipelineCoordinator:
         hyperparameter_states: HyperparameterStates,
         tracked_statistics: dict[str, dict[str, float | TensorStatistics]],
         actions_taken: dict[str, float | int | None],
+        return_dict: bool = False,
     ) -> Observations:
         """
         :param observation_inputs: Observation input metrics not calculated with statistic trackers.
@@ -127,18 +128,21 @@ class ObserverPipelineCoordinator:
         :param tracked_statistics: Dictionary mapping statistic tracker class names to dictionaries mapping module
         names to floats or TensorStatistic models.
         :param actions_taken: Dictionary mapping agent IDs to actions taken by that agent.
+        :param return_dict: Whether to return a dictionary of observations as well as the normal vector.
         :return: Observations pydantic model.
         """
 
         clipped_observations = False
         observations = {}
+        observations_as_dict: dict[str, dict[str, list[float | int]]] = {}
 
         for pipeline in self.pipelines:
-            pipeline_observations, pipeline_clipped_observations = pipeline.observe(
+            pipeline_observations, pipeline_clipped_observations, pipeline_observations_dict = pipeline.observe(
                 observation_inputs=observation_inputs,
                 hyperparameter_states=hyperparameter_states,
                 tracked_statistics=tracked_statistics,
                 actions_taken=actions_taken,
+                return_dict=return_dict,
             )
 
             clipped_observations = clipped_observations if clipped_observations else pipeline_clipped_observations
@@ -152,10 +156,14 @@ class ObserverPipelineCoordinator:
 
                 observations[agent_id] = agent_obs
 
+                if return_dict:
+                    observations_as_dict[agent_id] = pipeline_observations_dict[agent_id]
+
         return Observations(
             observation_inputs=observation_inputs,
             agent_observations=observations,
             hit_invalid_value=clipped_observations,
+            observations_as_dict=observations_as_dict if return_dict else None,
         )
 
     def inform(self) -> AgentInfo:

{libinephany-0.15.4 → libinephany-0.16.1}/libinephany/pydantic_models/schemas/observation_models.py

@@ -51,9 +51,13 @@ class Observations(BaseModel):
     hit_invalid_value: bool
 
     agent_observations: dict[str, list[float | int]]
+    observations_as_dict: dict[str, dict[str, list[float | int]]] | None = None
 
     def observations_as_arrays(self, dtype: DTypeLike = np.float32) -> dict[str, np.ndarray]:
-        """"""
+        """
+        :param dtype: Data type to cast the observations to.
+        :return: Dictionary mapping agent IDs to their observation vectors as numpy arrays.
+        """
 
         return {
             agent_id: np.array(observation_vector, dtype=dtype)

{libinephany-0.15.4 → libinephany-0.16.1/libinephany.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libinephany
-Version: 0.15.4
+Version: 0.16.1
 Summary: Inephany library containing code commonly used by multiple subpackages.
 Author-email: Inephany <info@inephany.com>
 License: Apache 2.0

libinephany-0.15.4/CODE_VERSION.cfg

@@ -1 +0,0 @@
-0.15.4