gradlab 0.2.1__tar.gz → 0.2.2__tar.gz

{gradlab-0.2.1 → gradlab-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gradlab
-Version: 0.2.1
+Version: 0.2.2
 Summary: Generic reinforcement-learning lab for training and evaluating game agents
 License-Expression: MIT
 License-File: LICENSE
@@ -64,7 +64,7 @@ with portable policies and evidence-backed results.
 Try the bundled ROM-free smoke recipe without cloning, credentials, or a ROM:
 
 ```bash
-uvx gradlab@0.2.1 train gradlab__bandit/ppo
+uvx gradlab@0.2.2 train gradlab__bandit/ppo
 ```
 
 The run writes a directly playable policy below `~/.config/gradlab/runs/`.

{gradlab-0.2.1 → gradlab-0.2.2}/README.md

@@ -12,7 +12,7 @@ with portable policies and evidence-backed results.
 Try the bundled ROM-free smoke recipe without cloning, credentials, or a ROM:
 
 ```bash
-uvx gradlab@0.2.1 train gradlab__bandit/ppo
+uvx gradlab@0.2.2 train gradlab__bandit/ppo
 ```
 
 The run writes a directly playable policy below `~/.config/gradlab/runs/`.

{gradlab-0.2.1 → gradlab-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gradlab"
-version = "0.2.1"
+version = "0.2.2"
 description = "Generic reinforcement-learning lab for training and evaluating game agents"
 readme = "README.md"
 requires-python = "==3.14.*"

{gradlab-0.2.1 → gradlab-0.2.2}/src/gradlab/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{gradlab-0.2.1 → gradlab-0.2.2}/src/gradlab/batch_runtime.py

@@ -585,6 +585,7 @@ class BatchRuntime:
                     "live snapshot continuation"
                 )
         self.reset_infos: list[dict[str, Any]] = [{} for _ in range(self.num_envs)]
+        self._reset_info_dtypes: dict[str, np.dtype[Any]] = {}
         self._episode_returns = np.zeros(self.num_envs, dtype=np.float64)
         self._episode_lengths = np.zeros(self.num_envs, dtype=np.int64)
         self._episode_indices = np.zeros(self.num_envs, dtype=np.int64)
@@ -748,6 +749,7 @@ class BatchRuntime:
         observations, infos = self.provider.reset(seed=normalized_seeds, options=options)
         if not isinstance(infos, Mapping):
             raise TypeError("native provider reset infos must be a columnar mapping")
+        self._remember_reset_info_dtypes(infos)
         self.kernel.on_reset(observations, infos, mask)
         encoded = self.kernel.encode_observations(observations)
         if self._reuse_provider_observations:
@@ -942,28 +944,32 @@ class BatchRuntime:
     ) -> tuple[bytes, ...]:
         if any(not info for info in self.reset_infos):
             raise RuntimeError("policy reset cell keys require an initialized runtime")
-        keys = set().union(*(info.keys() for info in self.reset_infos))
-        infos = {
-            key: np.asarray([info.get(key) for info in self.reset_infos])
-            for key in keys
-            if not key.startswith("_")
-        }
         return self.policy_cell_keys(
             cell_config,
-            infos,
+            self._columnar_reset_infos(),
             source="reset",
         )
 
     def state_archive_reset_cell_keys(self) -> tuple[bytes, ...]:
         if any(not info for info in self.reset_infos):
             raise RuntimeError("state archive reset cell keys require an initialized runtime")
+        return self.state_archive_cell_keys(self._columnar_reset_infos(), source="reset")
+
+    def _remember_reset_info_dtypes(self, infos: Mapping[str, Any]) -> None:
+        for key, value in infos.items():
+            if isinstance(key, str) and not key.startswith("_") and isinstance(value, np.ndarray):
+                self._reset_info_dtypes[key] = value.dtype
+
+    def _columnar_reset_infos(self) -> dict[str, np.ndarray]:
         keys = set().union(*(info.keys() for info in self.reset_infos))
-        infos = {
-            key: np.asarray([info.get(key) for info in self.reset_infos])
+        return {
+            key: np.asarray(
+                [info.get(key) for info in self.reset_infos],
+                dtype=self._reset_info_dtypes.get(key),
+            )
             for key in keys
             if not key.startswith("_")
         }
-        return self.state_archive_cell_keys(infos, source="reset")
 
     def _set_curriculum_reset_baselines(
         self,
@@ -1669,6 +1675,7 @@ class BatchRuntime:
             reset_seconds = time.perf_counter() - reset_started_at
             if not isinstance(reset_infos, Mapping):
                 raise TypeError("native provider reset infos must be a columnar mapping")
+            self._remember_reset_info_dtypes(reset_infos)
             if curriculum is not None and archive_selections:
                 curriculum.note_reset(
                     len(archive_selections),

{gradlab-0.2.1 → gradlab-0.2.2}/src/gradlab/checkpoint_acceptance.py

@@ -330,7 +330,7 @@ def build_checkpoint_eval_contract(
     if str(seed_protocol) != SEED_PROTOCOL:
         raise ValueError(f"unsupported checkpoint eval seed protocol: {seed_protocol!r}")
     action_sampling = str(action_sampling).strip()
-    if action_sampling not in {"stochastic", "epsilon_greedy", "program"}:
+    if action_sampling not in {"stochastic", "epsilon_greedy", "program", "route"}:
         raise ValueError(f"unsupported checkpoint eval action selection: {action_sampling!r}")
     rules = normalize_metric_threshold_rules(acceptance, label="goal.eval.acceptance")
     if not rules:
@@ -438,9 +438,7 @@ def acceptance_aggregates(
     if len(rows) == int(contract["episodes"]):
         if rates:
             result[EVAL_FULL_OUTCOME_SUCCESS_STARTS_RATE_MIN] = min(rates.values())
-            result[EVAL_FULL_OUTCOME_SUCCESS_STARTS_RATE_MEAN] = sum(rates.values()) / len(
-                rates
-            )
+            result[EVAL_FULL_OUTCOME_SUCCESS_STARTS_RATE_MEAN] = sum(rates.values()) / len(rates)
         returns = [float(row["return"]) for row in rows if row.get("return") is not None]
         if len(returns) == len(rows) and returns:
             if not all(math.isfinite(value) for value in returns):

{gradlab-0.2.1 → gradlab-0.2.2}/src/gradlab/task_kernels.py

@@ -2053,11 +2053,9 @@ class IdentityTaskDefinition:
             raise ValueError(
                 "identity task termination.bootstrap references unknown events: "
                 + ", ".join(unknown_bootstrap_events)
-        )
+            )
         non_success_bootstrap_events = sorted(
-            name
-            for name in bootstrap_events
-            if event_outcomes.get(name) != Outcome.SUCCESS
+            name for name in bootstrap_events if event_outcomes.get(name) != Outcome.SUCCESS
         )
         if non_success_bootstrap_events:
             raise ValueError(
@@ -2467,7 +2465,7 @@ class IdentityTaskKernel:
         if len(dtypes) != 1:
             raise ValueError(f"archive signal {semantic_name!r} must be scalar")
         dtype = dtypes[0]
-        if not np.issubdtype(dtype, np.number) or np.issubdtype(dtype, np.bool_):
+        if not (np.issubdtype(dtype, np.number) or np.issubdtype(dtype, np.bool_)):
             raise ValueError(f"archive signal {semantic_name!r} must be numeric")
 
     def archive_signal_values(
@@ -2559,8 +2557,7 @@ class EventRewardTaskKernel:
                 "task.reward.event_rewards references unknown events: " + ", ".join(missing)
             )
         self._configured = tuple(
-            (name, event_indices[name], coefficient)
-            for name, coefficient in normalized.items()
+            (name, event_indices[name], coefficient) for name, coefficient in normalized.items()
         )
         self._event_reward_components = {
             name: np.zeros(self.num_envs, dtype=np.float32) for name in normalized
@@ -2684,6 +2681,7 @@ class MarioTaskConfig:
     lives: SignalSource = "lives"
     level: SignalSource = ("levelHi", "levelLo")
     game_mode: SignalSource | None = None
+    declared_signals: tuple[tuple[str, SignalSource], ...] = ()
     action_masks: np.ndarray | None = None
     reward_mode: str = "baseline"
     use_native_reward: bool = False
@@ -2814,6 +2812,14 @@ class MarioTaskConfig:
             value = signals.get(name, default)
             return value if isinstance(value, str) else tuple(value)
 
+        declared_signals = tuple(
+            (
+                str(name),
+                source if isinstance(source, str) else tuple(source),
+            )
+            for name, source in signals.items()
+        )
+
         reward_mode = str(reward_value("reward_mode", "baseline"))
         if reward_mode not in {"native", "bounded", "baseline", "score", "additive"}:
             raise ValueError(f"unsupported Mario reward mode {reward_mode!r}")
@@ -2824,6 +2830,7 @@ class MarioTaskConfig:
             lives=signal_value("lives", cls.lives),
             level=signal_value("level", cls.level),
             game_mode=game_mode_source if game_complete_rule else None,
+            declared_signals=declared_signals,
             action_masks=None,
             reward_mode=reward_mode,
             use_native_reward=reward.get("use_native_reward", False),
@@ -2881,12 +2888,15 @@ class MarioTaskKernel:
         self.num_envs = int(num_envs)
         self._native_observation_space = descriptor.native_observation_space
         self.observation_space = _policy_observation_space(self._native_observation_space)
-        signal_sources: dict[str, SignalSource] = {
-            "x": config.x,
-            "score": config.score,
-            "lives": config.lives,
-            "level": config.level,
-        }
+        signal_sources: dict[str, SignalSource] = dict(config.declared_signals)
+        signal_sources.update(
+            {
+                "x": config.x,
+                "score": config.score,
+                "lives": config.lives,
+                "level": config.level,
+            }
+        )
         if config.game_mode is not None:
             signal_sources["game_mode"] = config.game_mode
         self.bindings = SignalBindings(descriptor, signal_sources, self.num_envs)
@@ -3252,7 +3262,7 @@ class MarioTaskKernel:
         elif len(dtypes) != 1:
             raise ValueError(f"archive signal {semantic_name!r} must be scalar")
         if any(
-            not np.issubdtype(dtype, np.number) or np.issubdtype(dtype, np.bool_)
+            not (np.issubdtype(dtype, np.number) or np.issubdtype(dtype, np.bool_))
             for dtype in dtypes
         ):
             raise ValueError(f"archive signal {semantic_name!r} must be numeric")