libinephany 1.1.2__tar.gz → 1.1.4__tar.gz

libinephany-1.1.4/CODE_VERSION.cfg

@@ -0,0 +1 @@
+1.1.4

{libinephany-1.1.2/libinephany.egg-info → libinephany-1.1.4}/PKG-INFO

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

{libinephany-1.1.2 → libinephany-1.1.4}/libinephany/observations/observation_utils.py

@@ -13,6 +13,7 @@ import numpy as np
 import pandas as pd
 import torch
 import torch.optim as optim
+from loguru import logger
 from scipy.stats import norm
 
 from libinephany.pydantic_models.schemas.tensor_statistics import TensorStatistics
@@ -60,18 +61,54 @@ class StatisticStorageTypes(Enum):
 # ======================================================================================================================
 
 
-def get_exponential_weighted_average(values: list[int | float]) -> float:
+def get_exponential_weighted_average(
+    values: list[int | float], invalid_value_threshold: float = 1e10, tracker_name: str = "Unknown"
+) -> float:
     """
     :param values: List of values to average via EWA.
+    :param invalid_value_threshold: Threshold for invalid observations, default is 1e10.
+    :param tracker_name: Name of the tracker for error reporting, default is "Unknown".
     :return: EWA of the given values.
     """
+
+    # Logging statistic tracker name when input is invalid.
+
+    if len(values) == 0:
+        raise ValueError(
+            f"Statistic Tracker: {tracker_name} gathered data with empty list! It likely means a bug is triggered in the"
+            f" code related to {tracker_name} or the inner task. Please check up the code!"
+        )
+
+    if any(not isinstance(value, (float, int)) for value in values):
+        # Should never happen, but just in case
+        raise ValueError(
+            f"Statistic Tracker: {tracker_name} gathered data with invalid values (not int or float)! It likely means a"
+            f" bug is triggered in the code related to {tracker_name} or the inner task. Please check up the code!"
+        )
+
+    if any(abs(value) > invalid_value_threshold for value in values):
+        # check for large values (including negative values)
+        logger.warning(
+            f"Statistic Tracker: {tracker_name} gathered data with values out of range (invalid_value_threshold: "
+            f"{invalid_value_threshold})! May cause episode termination if StopEpisodeFromInvalidObservations is used."
+        )
+
+    if any(np.isnan(value) for value in values):
+        logger.warning(
+            f"Statistic Tracker: {tracker_name} gathered data with NaN values! May cause episode termination if "
+            f"StopEpisodeFromInvalidObservations is used."
+        )
+
     exp_weighted_average = pd.Series(values).ewm(alpha=0.1).mean().iloc[-1]
     assert isinstance(exp_weighted_average, float)
     return exp_weighted_average
 
 
 def apply_averaging_function_to_tensor_statistics(
-    tensor_statistics: list[TensorStatistics], averaging_function: Callable[[list[float]], float]
+    tensor_statistics: list[TensorStatistics],
+    averaging_function: Callable[[list[float], float, str], float],
+    invalid_value_threshold: float = 1e10,
+    tracker_name: str = "Unknown",
 ) -> TensorStatistics:
     """
     :param tensor_statistics: List of statistics models to average over.
@@ -81,40 +118,60 @@ def apply_averaging_function_to_tensor_statistics(
 
     fields = TensorStatistics.model_fields.keys()
     averaged_metrics = {
-        field: averaging_function([getattr(statistics, field) for statistics in tensor_statistics]) for field in fields
+        field: averaging_function(
+            [getattr(statistics, field) for statistics in tensor_statistics],
+            invalid_value_threshold,
+            tracker_name,
+        )
+        for field in fields
     }
 
     return TensorStatistics(**averaged_metrics)
 
 
 def apply_averaging_function_to_dictionary_of_tensor_statistics(
-    data: dict[str, list[TensorStatistics]], averaging_function: Callable[[list[float]], float]
+    data: dict[str, list[TensorStatistics]],
+    averaging_function: Callable[[list[float], float, str], float],
+    invalid_value_threshold: float = 1e10,
+    tracker_name: str = "Unknown",
 ) -> dict[str, TensorStatistics]:
     """
     :param data: Dictionary mapping parameter group names to list of TensorStatistics from that parameter group.
     :param averaging_function: Function to average the values with.
+    :param invalid_value_threshold: Threshold for invalid observations.
+    :param tracker_name: Name of the tracker for error reporting.
     :return: Dictionary mapping parameter group names to TensorStatistics averaged over all statistics in the given
     TensorStatistics models.
     """
 
     return {
         group: apply_averaging_function_to_tensor_statistics(
-            tensor_statistics=metrics, averaging_function=averaging_function
+            tensor_statistics=metrics,
+            averaging_function=averaging_function,
+            invalid_value_threshold=invalid_value_threshold,
+            tracker_name=tracker_name,
         )
         for group, metrics in data.items()
     }
 
 
 def apply_averaging_function_to_dictionary_of_metric_lists(
-    data: dict[str, list[float]], averaging_function: Callable[[list[float]], float]
+    data: dict[str, list[float]],
+    averaging_function: Callable[[list[float], float, str], float],
+    invalid_value_threshold: float = 1e10,
+    tracker_name: str = "Unknown",
 ) -> dict[str, float]:
     """
     :param data: Dictionary mapping parameter group names to list of metrics from that parameter group.
     :param averaging_function: Function to average the values with.
+    :param invalid_value_threshold: Threshold for invalid observations.
+    :param tracker_name: Name of the tracker for error reporting.
     :return: Dictionary mapping parameter group names to averages over all metrics from each parameter group.
     """
 
-    return {group: averaging_function(metrics) for group, metrics in data.items()}
+    return {
+        group: averaging_function(metrics, invalid_value_threshold, tracker_name) for group, metrics in data.items()
+    }
 
 
 def average_tensor_statistics(tensor_statistics: list[TensorStatistics]) -> TensorStatistics:

{libinephany-1.1.2 → libinephany-1.1.4}/libinephany/observations/observers/base_observers.py

@@ -8,6 +8,9 @@ from abc import ABC, abstractmethod
 from copy import deepcopy
 from typing import Any, TypeAlias, final
 
+import numpy as np
+from loguru import logger
+
 from libinephany.observations import observation_utils
 from libinephany.observations.observation_utils import StatisticStorageTypes
 from libinephany.pydantic_models.configs.observer_config import ObserverConfig
@@ -65,6 +68,7 @@ class Observer(ABC):
         self.observer_config = observer_config
         self.standardize = standardizer if standardizer is not None else observation_utils.null_standardizer
         self.should_standardize = should_standardize and self.can_standardize
+        self.invalid_observation_threshold = observer_config.invalid_observation_threshold
 
         self.include_statistics: list[str] | None = None
         self.include_hparams = include_hparams
@@ -220,6 +224,47 @@ class Observer(ABC):
 
         self._validated_observation = True
 
+    @final
+    def _validate_observation_values(self, observations: list[float | int]) -> None:
+        """
+        :param observations: Observation vector to validate.
+        """
+        validate = True
+        if len(observations) == 0:
+            raise ValueError(f"Observer: {self.__class__.__name__} gathered observations with empty list!")
+
+        if any(not isinstance(observation, (float, int)) for observation in observations):
+            # Just in case
+            other_count = sum(1 for observation in observations if not isinstance(observation, (float, int)))
+            other_ratio = other_count / len(observations)
+            raise ValueError(
+                f"Observer: {self.__class__.__name__} gathered observations with invalid values (not float or int)! "
+                f"Ratio: {other_ratio:.2%} ({other_count}/{len(observations)})"
+            )
+
+        # Check for NaN values
+        if any(np.isnan(observation) for observation in observations):
+            nan_count = sum(1 for observation in observations if np.isnan(observation))
+            nan_ratio = nan_count / len(observations)
+            logger.warning(
+                f"Observer: {self.__class__.__name__} gathered observations with NaN values! Ratio: {nan_ratio:.2%} "
+                f" ({nan_count}/{len(observations)})"
+            )
+            validate = False
+
+        # Check for very large values (including negative values)
+        if any(abs(observation) > self.invalid_observation_threshold for observation in observations):
+            inf_count = sum(1 for observation in observations if observation > self.invalid_observation_threshold)
+            inf_ratio = inf_count / len(observations)
+            logger.warning(
+                f"Observer: {self.__class__.__name__} gathered observations with large values (threshold: "
+                f"{self.invalid_observation_threshold})! Ratio: {inf_ratio:.2%} ({inf_count}/{len(observations)})"
+            )
+            validate = False
+        logger.debug(
+            f'Observer: {self.__class__.__name__} observation validation {"passed" if validate else "failed"}!'
+        )
+
     @abstractmethod
     def get_required_trackers(self) -> dict[str, dict[str, Any] | None]:
         """
@@ -285,6 +330,8 @@ class Observer(ABC):
         if not self._validated_observation:
             self._validate_observation(observations=observations)
 
+        self._validate_observation_values(observations=observations)
+
         return observations, observations_dict
 
     @final

{libinephany-1.1.2 → libinephany-1.1.4}/libinephany/observations/statistic_trackers.py

@@ -45,11 +45,12 @@ class Statistic(ABC):
         self,
         *,
         parameter_group_name: str,
-        averaging_function: Callable[[list[float]], float],
+        averaging_function: Callable[[list[float], float, str], float],
         agent_modules: dict[str, str],
         max_statistic_cache_size: int = 3,
         tensor_stats_downsample_percentage: float = 0.01,
         statistic_sample_frequency: int = 10,
+        invalid_observation_threshold: float = 1e10,
         **kwargs,
     ) -> None:
         """
@@ -62,6 +63,7 @@ class Statistic(ABC):
         sample to compute the statistics from.
         :param statistic_sample_frequency: How frequently to cache tensors from the model for later statistic
         computation.
+        :param invalid_observation_threshold: Threshold for invalid observations, default is 1e10.
         :param kwargs: Other observation keyword arguments.
         """
 
@@ -77,6 +79,7 @@ class Statistic(ABC):
         self.downsample_percent = tensor_stats_downsample_percentage
         self.sample_frequency = statistic_sample_frequency
         self.include_statistics: list[str] | None = None
+        self.invalid_observation_threshold = invalid_observation_threshold
 
     @final
     @property
@@ -324,11 +327,18 @@ class Statistic(ABC):
             self._process_tensor_cache()
 
             results = observation_utils.apply_averaging_function_to_tensor_statistics(
-                tensor_statistics=self._data, averaging_function=self._averaging_function  # type: ignore
+                tensor_statistics=self._data,  # type: ignore
+                averaging_function=self._averaging_function,
+                invalid_value_threshold=self.invalid_observation_threshold,
+                tracker_name=self.tracker_name,
             )
 
         elif self.storage_format is StatisticStorageTypes.FLOAT:
-            results = self._averaging_function(self._data)  # type: ignore
+            results = self._averaging_function(
+                self._data,  # type: ignore
+                invalid_value_threshold=self.invalid_observation_threshold,
+                tracker_name=self.tracker_name,
+            )
 
         else:
             raise ValueError(f"Data storage type {self.storage_format} is invalid!")

{libinephany-1.1.2 → libinephany-1.1.4}/libinephany/pydantic_models/schemas/inner_task_profile.py

@@ -7,8 +7,15 @@
 import math
 from typing import Any, Callable
 
-from loguru import logger
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel
+
+# ======================================================================================================================
+#
+# CONSTANTS
+#
+# ======================================================================================================================
+
+VRAM_USAGES_KEY = "vram_usages"
 
 # ======================================================================================================================
 #
@@ -20,26 +27,40 @@ from pydantic import BaseModel, field_validator
 class InnerTaskProfile(BaseModel):
 
     inner_task_name: str
+
     number_of_agents: int
     number_of_layers: int
+    number_of_parameters: int
+
     observation_space_sizes: dict[str, int]
     action_space_sizes: dict[str, int]
-    number_of_parameters: int
-    vram_usage: float
-    idle_vram_usage: float
-    hparam_overrides: dict[str, dict[str, Any]] | None = None
 
-    @field_validator("vram_usage", "idle_vram_usage", mode="before")
-    def replace_non_with_nan(cls, value: None | float) -> float:
+    vram_usages: dict[int, tuple[float, float]] | None = None
+    expected_vram_usage: float | None = None
+    expected_idle_vram_usage: float | None = None
+    max_batch_size_override: int | None = None
+
+    @property
+    def vram_usage(self) -> float:
+        """
+        :return: VRAM usage at the max batch size.
+        """
+
+        if self.expected_vram_usage is None:
+            return float("nan")
+
+        return self.expected_vram_usage
+
+    @property
+    def idle_vram_usage(self) -> float:
         """
-        :param value: Value to replace with NaN if it is None.
-        :return: Either the given float value or NaN.
+        :return: Idle VRAM usage at the max batch size.
         """
 
-        if value is None:
+        if self.expected_idle_vram_usage is None:
             return float("nan")
 
-        return value
+        return self.expected_idle_vram_usage
 
     @property
     def failed_to_profile(self) -> bool:
@@ -49,19 +70,18 @@ class InnerTaskProfile(BaseModel):
 
         return math.isnan(self.vram_usage)
 
-    def model_dump_json(self, **kwargs) -> str:
+    def model_dump(self, **kwargs) -> dict[str, Any]:
         """
         :param kwargs: Standard Pydantic model dump kwargs.
         :return: Dump result of the superclass' method.
         """
 
-        logger.debug(
-            f"Inner task {self.inner_task_name} consumed {self.vram_usage:.3f} MB of VRAM while training and "
-            f"{self.idle_vram_usage:.3f} MB of VRAM while idle. It has {self.number_of_agents} agents across "
-            f"{self.number_of_layers} inner model layers."
-        )
+        super_dump = super().model_dump(**kwargs)
 
-        return super().model_dump_json(**kwargs)
+        if self.vram_usages is not None:
+            super_dump[VRAM_USAGES_KEY] = {k: list(v) for k, v in self.vram_usages.items()}
+
+        return super_dump
 
 
 class InnerTaskProfiles(BaseModel):
@@ -235,42 +255,6 @@ class InnerTaskProfiles(BaseModel):
 
         return inner_task_name in self.profiles
 
-    def add_profile(
-        self,
-        inner_task_name: str,
-        number_of_agents: int,
-        number_of_layers: int,
-        observation_space_sizes: dict[str, int],
-        action_space_sizes: dict[str, int],
-        number_of_parameters: int,
-        vram_usage: float,
-        idle_vram_usage: float,
-        hparam_overrides: dict[str, dict[str, Any]] | None = None,
-    ) -> None:
-        """
-        :param inner_task_name: Name of the inner task to add a profile for.
-        :param number_of_agents: Number of agents active in the inner task's environment.
-        :param number_of_layers: Number of layers in the inner model.
-        :param observation_space_sizes: Dictionary mapping agent IDs to their observation space sizes.
-        :param action_space_sizes: Dictionary mapping agent IDs to their action space sizes.
-        :param vram_usage: VRAM required to perform the inner task. Can be NaN if an OOM was encountered.
-        :param idle_vram_usage: VRAM required for the inner task to sit loaded but not actively being trained. Can be
-        NaN if an OOM was encountered.
-        :param hparam_overrides: Hyperparameter overrides for the inner task.
-        """
-
-        self.profiles[inner_task_name] = InnerTaskProfile(
-            inner_task_name=inner_task_name,
-            number_of_agents=number_of_agents,
-            number_of_layers=number_of_layers,
-            observation_space_sizes=observation_space_sizes,
-            action_space_sizes=action_space_sizes,
-            number_of_parameters=number_of_parameters,
-            vram_usage=vram_usage,
-            idle_vram_usage=idle_vram_usage,
-            hparam_overrides=hparam_overrides,
-        )
-
     def validate_task_profiles(self, policy_mapping_function: Callable[[str, Any, Any], str]) -> None:
         """
         :param policy_mapping_function: Function which maps agent IDs to policy IDs.

{libinephany-1.1.2 → libinephany-1.1.4/libinephany.egg-info}/PKG-INFO

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

libinephany-1.1.2/CODE_VERSION.cfg

@@ -1 +0,0 @@
-1.1.2