libinephany 0.15.3__tar.gz → 0.16.0__tar.gz

libinephany-0.16.0/CODE_VERSION.cfg

@@ -0,0 +1 @@
+0.16.0

{libinephany-0.15.3/libinephany.egg-info → libinephany-0.16.0}/PKG-INFO

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

{libinephany-0.15.3 → libinephany-0.16.0}/libinephany/observations/observation_utils.py

@@ -167,6 +167,20 @@ def create_one_hot_depth_encoding(agent_controlled_modules: list[str], parameter
     return create_one_hot_observation(vector_length=3, one_hot_index=one_hot_index)
 
 
+def check_if_tensor_is_xpu(tensor: torch.Tensor | None) -> bool:
+    """
+    :param tensor: Tensor to check whether it is an XPU tensor.
+    :return: Whether the tensor is an XPU tensor.
+    """
+
+    try:
+        xpu_available = torch.xpu.is_available()
+        return xpu_available and tensor.is_xpu
+
+    except AttributeError:
+        return False
+
+
 def tensor_on_local_rank(tensor: torch.Tensor | None) -> bool:
     """
     :param tensor: Tensor to check whether it is owned by the local rank, partially or entirely.
@@ -176,10 +190,10 @@ def tensor_on_local_rank(tensor: torch.Tensor | None) -> bool:
     valid_tensor = tensor is not None and tensor.numel() > 0
     device_index = tensor.device.index if valid_tensor else None
 
-    xpu_available = torch.xpu.is_available()
+    is_xpu = check_if_tensor_is_xpu(tensor)
     cuda_available = torch.cuda.is_available()
 
-    if valid_tensor and xpu_available and tensor.is_xpu:
+    if valid_tensor and is_xpu:
         current_device = torch.xpu.current_device()
         return device_index == current_device
 

{libinephany-0.15.3 → libinephany-0.16.0}/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.3 → libinephany-0.16.0}/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.3 → libinephany-0.16.0}/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.3 → libinephany-0.16.0}/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.3 → libinephany-0.16.0/libinephany.egg-info}/PKG-INFO

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

libinephany-0.15.3/CODE_VERSION.cfg

@@ -1 +0,0 @@
-0.15.3