update arcade

.github/workflows/python-publish.yml

@@ -0,0 +1,70 @@
+# This workflow will upload a Python Package to PyPI when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Build release distributions
+        run: |
+          # NOTE: put your own distribution build steps here.
+          python -m pip install build
+          python -m build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+
+    # Dedicated environments with protections for publishing are strongly recommended.
+    # For more information, see: https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-protection-rules
+    environment:
+      name: pypi
+      # OPTIONAL: uncomment and update to include your PyPI project URL in the deployment status:
+      url: https://pypi.org/p/popgym-arcade
+      #
+      # ALTERNATIVE: if your GitHub Release name is the PyPI project version string
+      # ALTERNATIVE: exactly, uncomment the following line instead:
+      # url: https://pypi.org/project/YOURPROJECT/${{ github.event.release.name }}
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

.github/workflows/python_app.yaml

@@ -0,0 +1,33 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Tests
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python 3.13
+      uses: actions/setup-python@v3
+      with:
+        python-version: "3.13"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pytest pytest-cov
+        pip install -e .
+    - name: Test with pytest
+      run: |
+        pytest tests/test* --doctest-modules --junitxml=junit/test-results.xml --cov=. --cov-report=xml --cov-report=html

.gitignore

@@ -0,0 +1,14 @@
+*.swp
+*.swo
+*.pyc
+*__pycache__
+*.egg-info
+*.DS_Store
+*.idea
+*.pkl
+*.pdf
+*.csv
+build/
+.vscode/
+plotting/fpsdata/
+plotting/gradientdata/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Zekang Wang and Zhe He
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,212 @@
+# POPGym Arcade - GPU-Accelerated POMDPs 
+
+[![Tests](https://github.com/bolt-research/popgym-arcade/actions/workflows/python_app.yaml/badge.svg)](https://github.com/bolt-research/popgym-arcade/actions/workflows/python_app.yaml)
+
+<div style="display: flex; flex-direction: column; align-items: center; gap: 20px;">
+    <div style="display: flex; flex-wrap: wrap; gap: 10px; justify-content: space-between;
+                border: 2px solid #3498db; border-radius: 10px; 
+                padding: 10px;  
+                box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1); 
+                background: linear-gradient(135deg, #ffffff, #ffe4e1);">
+        <img src="imgs/minesweeper_f.gif" alt="GIF 1" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/countrecall_f.gif" alt="GIF 2" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/battleship_f.gif" alt="GIF 3" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/cartpole_f.gif" alt="GIF 4" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/ncartpole_f.gif" alt="GIF 5" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/autoencode_f.gif" alt="GIF 6" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/navigator_f.gif" alt="GIF 7" style="width: 100px; height: 100px; border-radius: 5px;">
+    </div>
+    <div style="display: flex; flex-wrap: wrap; gap: 10px; justify-content: space-between;
+                border: 2px solid #e74c3c; border-radius: 10px; 
+                padding: 10px; 
+                box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1); 
+                background: linear-gradient(135deg, #ffffff, #ffe4e1);">
+        <img src="imgs/minesweeper_p.gif" alt="GIF 1" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/countrecall_p.gif" alt="GIF 2" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/battleship_p.gif" alt="GIF 3" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/cartpole_p.gif" alt="GIF 4" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/ncartpole_p.gif" alt="GIF 5" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/autoencode_p.gif" alt="GIF 6" style="width: 100px; height: 100px; border-radius: 5px;">
+        <img src="imgs/navigator_p.gif" alt="GIF 7" style="width: 100px; height: 100px; border-radius: 5px;">
+    </div>
+</div>
+
+
+[//]: # (<p float="left">)
+
+[//]: # (    <img src="imgs/minesweeper_f.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/countrecall_f.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/battleship_f.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/cartpole_f.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/ncartpole_f.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/autoencode_f.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/navigator_f.gif" width="96" height="96" /> )
+
+[//]: # (</p>)
+
+[//]: # ()
+[//]: # (<p float="left">)
+
+[//]: # (    <img src="imgs/minesweeper_p.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/countrecall_p.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/battleship_p.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/cartpole_p.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/ncartpole_p.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/autoencode_p.gif" width="96" height="96" /> )
+
+[//]: # (    <img src="imgs/navigator_p.gif" width="96" height="96" /> )
+
+[//]: # (</p>)
+
+POPGym Arcade contains 7 pixel-based POMDPs in the style of the [Arcade Learning Environment](https://github.com/Farama-Foundation/Arcade-Learning-Environment). Each environment provides:
+- 3 Difficulty settings
+- Common observation and action space shared across all envs
+- Fully observable and partially observable configurations
+- Fast and easy GPU vectorization using `jax.vmap` and `jax.jit`
+
+## Gradient Visualization
+We also provide tools to visualize how policies use memory. 
+<img src="imgs/grads_example.jpg" height="192" />
+
+See [below](#Memory-Introspection-Tools) for further instructions.
+
+## Throughput
+You can expect millions of frames per second on a consumer-grade GPU. With `obs_size=128`, most policies converge within 30-60 minutes of training. 
+
+<img src="imgs/fps.png" height="192" />  
+<img src="imgs/wandb.png" height="192" /> 
+
+## Getting Started
+
+
+### Installation 
+
+To install the environments, run
+
+```bash
+pip install popgym-arcade
+```
+If you plan to use our training scripts, install the baselines as well
+
+```bash
+pip install 'popgym-arcade[baselines]'
+```
+
+### Human Play
+To best understand the environments, you should try and play them yourself. The [play script](popgym_arcade/play.py) lets you play the games yourself using the arrow keys and spacebar.
+
+```bash
+popgym-arcade-play NoisyCartPoleEasy        # play MDP 256 pixel version
+popgym-arcade-play BattleShipEasy -p -o 128 # play POMDP 128 pixel version
+```
+
+### Creating and Stepping Environments
+Our envs are `gymnax` envs, so you can use your wrappers and code designed to work with `gymnax`. The following example demonstrates how to integrate POPGym Arcade into your code. 
+
+```python
+import popgym_arcade
+import jax
+
+# Create both POMDP and MDP env variants
+pomdp, pomdp_params = popgym_arcade.make("BattleShipEasy", partial_obs=True)
+mdp, mdp_params = popgym_arcade.make("BattleShipEasy", partial_obs=False)
+
+# Let's vectorize and compile the envs
+# Note when you are training a policy, it is better to compile your policy_update rather than the env_step
+pomdp_reset = jax.jit(jax.vmap(pomdp.reset, in_axes=(0, None)))
+pomdp_step = jax.jit(jax.vmap(pomdp.step, in_axes=(0, 0, 0, None)))
+mdp_reset = jax.jit(jax.vmap(mdp.reset, in_axes=(0, None)))
+mdp_step = jax.jit(jax.vmap(mdp.step, in_axes=(0, 0, 0, None)))
+    
+# Initialize four vectorized environments
+n_envs = 4
+# Initialize PRNG keys
+key = jax.random.key(0)
+reset_keys = jax.random.split(key, n_envs)
+    
+# Reset environments
+observation, env_state = pomdp_reset(reset_keys, pomdp_params)
+
+# Step the POMDPs
+for t in range(10):
+    # Propagate some randomness
+    action_key, step_key = jax.random.split(jax.random.key(t))
+    action_keys = jax.random.split(action_key, n_envs)
+    step_keys = jax.random.split(step_key, n_envs)
+    # Pick actions at random
+    actions = jax.vmap(pomdp.action_space(pomdp_params).sample)(action_keys)
+    # Step the env to the next state
+    # No need to reset, gymnax automatically resets when done
+    observation, env_state, reward, done, info = pomdp_step(step_keys, env_state, actions, pomdp_params)
+
+# POMDP and MDP variants share states
+# We can plug the POMDP states into the MDP and continue playing 
+action_keys = jax.random.split(jax.random.key(t + 1), n_envs)
+step_keys = jax.random.split(jax.random.key(t + 2), n_envs)
+markov_state, env_state, reward, done, info = mdp_step(step_keys, env_state, actions, mdp_params)
+```
+
+## Memory Introspection Tools 
+We implement visualization tools to probe which pixels persist in agent memory, and their
+impact on Q value predictions. Try code below or [vis example](plotting/plot_grads.ipynb) to visualize the memory your agent uses
+
+```python
+from popgym_arcade.baselines.model.builder import QNetworkRNN
+from popgym_arcade.baselines.utils import get_saliency_maps, vis_fn
+import equinox as eqx
+import jax
+
+config = {
+    # Env string
+    "ENV_NAME": "NavigatorEasy",
+    # Whether to use full or partial observability
+    "PARTIAL": True,
+    # Memory model type (see models directory)
+    "MEMORY_TYPE": "lru",
+    # Evaluation episode seed
+    "SEED": 0,
+    # Observation size in pixels (128 or 256)
+    "OBS_SIZE": 128,
+}
+
+# Initialize the random key
+rng = jax.random.PRNGKey(config["SEED"])
+
+# Initialize the model
+network = QNetworkRNN(rng, rnn_type=config["MEMORY_TYPE"], obs_size=config["OBS_SIZE"])
+# Load the model
+model = eqx.tree_deserialise_leaves("PATH_TO_YOUR_MODEL_WEIGHTS.pkl", network)
+# Compute the saliency maps
+grads, obs_seq, grad_accumulator = get_saliency_maps(rng, model, config)
+# Visualize the saliency maps
+# If you have latex installed, set use_latex=True
+vis_fn(grads, obs_seq, config, use_latex=False)
+```
+
+## Other Useful Libraries
+- [`gymnax`](https://github.com/RobertTLange/gymnax) - The (deprecated) `jax`-capable `gymnasium` API
+- [`stable-gymnax`](https://github.com/smorad/stable-gymnax) - A maintained and patched version of `gymnax`
+- [`popgym`](https://github.com/proroklab/popgym) - The original collection of POMDPs, implemented in `numpy`
+- [`popjaxrl`](https://github.com/luchris429/popjaxrl) - A `jax` version of `popgym`
+- [`popjym`](https://github.com/EdanToledo/popjym) - A more readable version of `popjaxrl` environments that served as a basis for our work
+
+## Citation
+```
+@article{wang2025popgym,
+  title={POPGym Arcade: Parallel Pixelated POMDPs},
+  author={Wang, Zekang and He, Zhe and Zhang, Borong and Toledo, Edan and Morad, Steven},
+  journal={arXiv preprint arXiv:2503.01450},
+  year={2025}
+}
+```

analysis.py

@@ -0,0 +1,113 @@
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+
+import popgym_arcade
+from popgym_arcade.baselines.model.builder import QNetworkRNN
+from popgym_arcade.baselines.utils import get_saliency_maps, vis_fn
+from popgym_arcade.wrappers import LogWrapper
+
+##
+## Simpler approach:
+## Compute gradients using random initial state
+##
+config = {
+    "ENV_NAME": "MineSweeperEasy",
+    "PARTIAL": False,
+    "MEMORY_TYPE": "lru",
+    "SEED": 0,
+    "OBS_SIZE": 128,
+}
+# Path to your model weights
+config["MODEL_PATH"] = (
+    f"nips_analysis_128/PQN_RNN_{config['MEMORY_TYPE']}_{config['ENV_NAME']}_model_Partial={config['PARTIAL']}_SEED=0.pkl"
+)
+
+# Initialize the random key
+rng = jax.random.PRNGKey(config["SEED"])
+
+# Initialize the model
+network = QNetworkRNN(rng, rnn_type=config["MEMORY_TYPE"], obs_size=config["OBS_SIZE"])
+# Load the model
+model = eqx.tree_deserialise_leaves(config["MODEL_PATH"], network)
+# Compute the saliency maps
+grads, obs_seq, grad_accumulator = get_saliency_maps(rng, model, config, max_steps=30)
+# Visualize the saliency maps
+vis_fn(grads, obs_seq, config, use_latex=True)
+
+
+##
+## More complex approach
+## Generate custom initial state and then compute gradients
+##
+config = {
+    "ENV_NAME": "NavigatorEasy",
+    "PARTIAL": True,
+    "MEMORY_TYPE": "lru",
+    "SEED": 0,
+    "OBS_SIZE": 128,
+}
+config["MODEL_PATH"] = (
+    f"nips_analysis_128/PQN_RNN_{config['MEMORY_TYPE']}_{config['ENV_NAME']}_model_Partial={config['PARTIAL']}_SEED=0.pkl"
+)
+
+
+rng = jax.random.PRNGKey(config["SEED"])
+# Initialize the model
+network = QNetworkRNN(rng, rnn_type=config["MEMORY_TYPE"], obs_size=config["OBS_SIZE"])
+# Load the model
+model = eqx.tree_deserialise_leaves(config["MODEL_PATH"], network)
+
+# Setup initial state
+seed, _rng = jax.random.split(jax.random.key(config["SEED"]))
+env, env_params = popgym_arcade.make(
+    config["ENV_NAME"], partial_obs=config["PARTIAL"], obs_size=config["OBS_SIZE"]
+)
+env = LogWrapper(env)
+n_envs = 1
+vmap_reset = lambda n_envs: lambda rng: jax.vmap(env.reset, in_axes=(0, None))(
+    jax.random.split(rng, n_envs), env_params
+)
+vmap_step = lambda n_envs: lambda rng, env_state, action: jax.vmap(
+    env.step, in_axes=(0, 0, 0, None)
+)(jax.random.split(rng, n_envs), env_state, action, env_params)
+init_obs, init_state = vmap_reset(n_envs)(_rng)
+
+# Replace initial state with custom initial state
+new_init_state = eqx.tree_at(
+    lambda x: x.env_state.action_x, init_state, replace=jnp.array([6])
+)
+new_init_state = eqx.tree_at(
+    lambda x: x.env_state.action_y, new_init_state, replace=jnp.array([6])
+)
+board = (
+    new_init_state.env_state.board.at[jnp.where(new_init_state.env_state.board == 2)]
+    .set(0)
+    .at[:, 1, 1]
+    .set(2)
+)
+# Can also set the entire board manually if needed
+# board = (
+#     jnp.zeros_like(new_init_state.env_state.board)
+#     # tnt
+#     .at[0, 3, 2].set(1)
+#     .at[0, 4, 2].set(1)
+#     .at[0, 5, 3].set(1)
+#     .at[0, 6, 3].set(1)
+#     # goal
+#     .at[0, 6, 6].set(2)
+# )
+new_init_state = eqx.tree_at(lambda x: x.env_state.board, new_init_state, replace=board)
+new_init_obs = jax.vmap(env.get_obs)(new_init_state.env_state)
+
+
+# Compute the saliency maps
+grads, obs_seq, grad_accumulator = get_saliency_maps(
+    rng,
+    model,
+    config,
+    max_steps=10,
+    initial_state_and_obs=(new_init_state, new_init_obs),
+)
+# Visualize the saliency maps
+vis_fn(grads, obs_seq, config, use_latex=True)

plotting/Atari_FPS_test.py

@@ -0,0 +1,58 @@
+import csv
+import os
+import sys
+import time
+
+import ale_py
+import gymnasium as gym
+import jax
+import jax.numpy as jnp
+
+import sys
+
+sys.path.extend(["/home/ubuntu-user/popjym-main"])
+
+# import matplotlib.pyplot as plt
+
+gym.register_envs(ale_py)
+n_envs = int(os.getenv("NUM_ENVS", 512))
+n_steps = int(os.getenv("NUM_STEPS", 32))
+seed = int(os.getenv("SEED"))
+
+env_name = os.getenv("ENV_NAME", "Pong-v4")
+env = gym.make_vec(env_name, num_envs=n_envs, vectorization_mode="sync")
+env_params = None
+
+
+def test_multi_env_fps(
+    env=env, env_params=env_params, seed=seed, n_envs=n_envs, n_steps=n_steps
+):
+    """Test FPS for multiple environments."""
+
+    obs, infos = env.reset(seed=seed)
+
+    for _ in range(n_steps):
+        _ = env.action_space.seed(seed)
+        actions = env.action_space.sample()
+        obs, rewards, terminates, truncates, infos = env.step(actions)
+        # plt.imshow(obs[0])
+        # plt.show()
+
+    return obs
+
+
+start = time.time()
+test_multi_env_fps(env, env_params, seed, n_envs, n_steps)
+end = time.time()
+
+runtime = end - start
+fps = n_envs * n_steps / runtime
+print(f"time: {end - start}s")
+print(f"{env_name} - Multi Env - Envs: {n_envs}, Steps: {n_steps}, FPS: {fps}")
+csv_file = "atari_fps_results.csv"
+write_header = not os.path.exists(csv_file)
+with open(csv_file, mode="a", newline="") as file:
+    writer = csv.writer(file)
+    if write_header:
+        writer.writerow(["Environment", "Num Envs", "Num Steps", "FPS", "Seed"])
+    writer.writerow([env_name, n_envs, n_steps, f"{fps:.0f}", seed])

plotting/MinAtar_popgym_FPS_test.py

@@ -0,0 +1,51 @@
+import multiprocessing
+import time
+
+# Test FPS for MinAtar environment
+# Source: https://github.com/kenjyoung/MinAtar/tree/master
+import gymnasium as gym
+import popgym
+from popgym.envs.battleship import Battleship
+
+TestEnv = gym.make("MinAtar/Asterix-v1")
+
+NUM_STEPS = 512
+
+# Test FPS for popgym environment
+# Source: https://github.com/proroklab/popgym
+# TestEnv = Battleship()
+
+
+def run_sample(e, num_steps):
+    env = e
+    env.reset()
+    start = time.time()
+    for i in range(num_steps):
+        obs, _, terminated, truncated, _ = env.step(env.action_space.sample())
+        print(obs.shape)
+        if terminated or truncated:
+            env.reset()
+    end = time.time()
+    elapsed = end - start
+    fps = num_steps / elapsed
+    return fps
+
+
+def main():
+    print(f"Testing environment: {TestEnv}")
+    for n in range(1, 10):
+        num_workers = 2**n
+
+        # Single environment test (for baseline reference)
+        fps_single = run_sample(TestEnv, NUM_STEPS)
+        print(f"{TestEnv} (1x) FPS: {fps_single:.0f}")
+
+        with multiprocessing.Pool(processes=num_workers) as p:
+            envs = num_workers * [TestEnv]
+            steps = num_workers * [int(NUM_STEPS // num_workers)]
+            fps_multi = sum(p.starmap(run_sample, zip(envs, steps)))
+            print(f"{TestEnv} ({num_workers}x) FPS: {fps_multi:.0f}")
+
+
+if __name__ == "__main__":
+    main()

plotting/PArcade_gymnax_FPS_test.py

@@ -0,0 +1,78 @@
+"""
+Compute the average steps per second of the environment.
+
+"""
+
+import sys
+
+sys.path.extend(["/home/ubuntu-user/popjym-main"])
+
+import csv
+import os
+import sys
+import time
+
+import gymnax
+import jax
+import jax.numpy as jnp
+from jaxlib.xla_extension import XlaRuntimeError
+
+import popgym_arcade
+
+env_name = os.getenv("ENV_NAME", "MineSweeperEasy")
+partial_obs = os.getenv("PARTIAL_OBS", "False") == "True"
+
+n_envs = int(os.getenv("NUM_ENVS", 512))
+n_steps = int(os.getenv("NUM_STEPS", 512))
+seed = jax.random.PRNGKey(0)
+
+# Test FPS for popgym arcade environments
+# env, env_params = popgym_arcade.make(env_name, partial_obs=partial_obs)
+
+# Test FPS for gymnax environments
+# Source: https://github.com/RobertTLange/gymnax
+env, env_params = gymnax.make(env_name)
+
+# jax.config.update("jax_enable_x64", True)
+
+
+def test_multi_env_fps(
+    env=env, env_params=env_params, seed=seed, num_envs=n_envs, num_steps=n_steps
+):
+    """Test FPS for multiple environments."""
+    vmap_reset = jax.vmap(env.reset, in_axes=(0, None))
+    vmap_step = jax.vmap(env.step, in_axes=(0, 0, 0, None))
+    vmap_sample = jax.vmap(env.action_space(env_params).sample)
+    seeds = jax.random.split(seed, num_envs)
+    obs, states = vmap_reset(seeds, env_params)
+
+    for _ in range(num_steps):
+        action = vmap_sample(seeds)
+        obs, states, rewards, dones, _ = vmap_step(seeds, states, action, env_params)
+
+    return obs
+
+
+fps = jax.jit(test_multi_env_fps)
+carry = fps(seed=jax.random.PRNGKey(1))
+carry.block_until_ready()
+
+start = time.time()
+carry = fps(seed=jax.random.PRNGKey(2))
+carry.block_until_ready()
+end = time.time()
+
+runtime = end - start
+fps = n_envs * n_steps / runtime
+print(f"env: {env_name}, partial_obs: {partial_obs}")
+print(f"time: {end - start}s")
+print(f"{env_name} - Multi Env - Envs: {n_envs}, Steps: {n_steps}, FPS: {fps}")
+csv_file = "gymnaxfpsdata.csv"
+write_header = not os.path.exists(csv_file)
+with open(csv_file, mode="a", newline="") as file:
+    writer = csv.writer(file)
+    if write_header:
+        writer.writerow(["Environment", "Partial Obs", "Num Envs", "Num Steps", "FPS"])
+    writer.writerow([env_name, partial_obs, n_envs, n_steps, f"{fps:.0f}"])
+
+print("Testing complete. Results appended to fps_results.csv")

plotting/churn.py

@@ -0,0 +1,202 @@
+"""
+Plotting churn ratio difference between partial and full observability
+"""
+
+import jax.numpy as jnp
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from jax import lax
+from scipy.interpolate import interp1d
+
+import wandb
+
+
+def f(name):
+    WINDOW_SIZE = 100
+    SIGMA = 100
+    INTERP_POINTS = 1000
+    NORMALIZING_FACTOR = 200
+
+    ENV_MAX_STEPS = {
+        "CountRecallEasy": 2e7,
+        "CountRecallMedium": 2e7,
+        "CountRecallHard": 2e7,
+        "BattleShipEasy": 2e7,
+        "BattleShipMedium": 2e7,
+        "BattleShipHard": 2e7,
+        # other environments with default max steps 1e7
+    }
+    AXIS_FONT = {"fontsize": 9, "labelpad": 8}
+    TICK_FONT = {"labelsize": 8}
+
+    api = wandb.Api()
+    runs = api.runs("bolt-um/Arcade-RLC-Churn")
+    filtered_runs = [run for run in runs if run.state == "finished"]
+    print(f"Total runs: {len(runs)}, Completed runs: {len(filtered_runs)}")
+
+    METRIC_MAPPING = {
+        "PQN": {"churn_ratio": "churn_ratio", "time_col": "env_step"},
+        "PQN_RNN": {"churn_ratio": "churn_ratio", "time_col": "env_step"},
+        "default": {"churn_ratio": "churn_ratio", "time_col": "TOTAL_TIMESTEPS"},
+    }
+
+    def process_run(run):
+        """Process individual W&B run with dynamic max steps per environment"""
+        try:
+            config = {k: v for k, v in run.config.items() if not k.startswith("_")}
+            env_name = config.get("ENV_NAME", "UnknownEnv")
+            partial_status = str(config.get("PARTIAL", False))
+
+            if env_name in ENV_MAX_STEPS:
+                env_max_step = ENV_MAX_STEPS[env_name]
+            else:
+                env_max_step = 1e7
+
+            alg_name = config.get("ALG_NAME", "").upper()
+            memory_type = "MLP"
+            if alg_name == "PQN_RNN":
+                memory_type = config.get("MEMORY_TYPE", "Unknown").capitalize()
+
+            metric_map = METRIC_MAPPING.get(alg_name, METRIC_MAPPING["default"])
+            history = list(
+                run.scan_history(
+                    keys=[metric_map["churn_ratio"], metric_map["time_col"]]
+                )
+            )
+            history = pd.DataFrame(
+                history, columns=[metric_map["churn_ratio"], metric_map["time_col"]]
+            )
+
+            history["true_steps"] = history[metric_map["time_col"]].clip(
+                upper=env_max_step
+            )
+            history = history.sort_values(metric_map["time_col"]).drop_duplicates(
+                subset=["true_steps"]
+            )
+
+            if len(history) < 2:
+                print(f"Skipping {run.name} due to insufficient data points")
+                return None
+
+            # Get first and last values for extrapolation
+            first_return = history[metric_map["churn_ratio"]].iloc[0]
+            last_return = history[metric_map["churn_ratio"]].iloc[-1]
+
+            # Create unified interpolation grid for this environment
+            unified_steps = np.linspace(0, env_max_step, INTERP_POINTS)
+            unified_steps = np.round(unified_steps, decimals=5)
+            scale_factor = NORMALIZING_FACTOR / env_max_step
+
+            # Interpolate returns to uniform grid
+            interp_func = interp1d(
+                history["true_steps"],
+                history[metric_map["churn_ratio"]],
+                kind="linear",
+                bounds_error=False,
+                fill_value=(first_return, last_return),
+            )
+            interpolated_churn_ratio = interp_func(unified_steps)
+
+            return pd.DataFrame(
+                {
+                    "Algorithm": f"{alg_name} ({memory_type})",
+                    "churn_ratio": interpolated_churn_ratio,
+                    # "Smoothed Return": smoothed_returns,
+                    # "Cummax Return": np.array(cummax_returns),  # Convert back to NumPy
+                    "True Steps": unified_steps,
+                    "EnvName": env_name,
+                    "Partial": partial_status,
+                    "Seed": str(config.get("SEED", 0)),
+                    "run_id": run.id,
+                    "StepsNormalized": unified_steps / env_max_step,
+                    "EnvMaxStep": env_max_step,
+                    "ScaleFactor": scale_factor,
+                }
+            )
+
+        except Exception as e:
+            print(f"Error processing {run.name}: {str(e)}")
+        return None
+
+    # Process all runs and combine data
+    # all_data = [df for run in filtered_runs if (df := process_run(run)) is not None]
+
+    # if not all_data:
+    #     print("No valid data to process")
+    #     exit()
+    # runs_df = pd.concat(all_data, ignore_index=True)
+    # runs_df.to_pickle("churnratiodata.pkl")
+
+    runs_df = pd.read_pickle("churnratiodata.pkl")
+    # print(f"Total runs processed: {runs_df}")
+
+    diff_df = pd.DataFrame()
+
+    for env_name in runs_df["EnvName"].unique():
+        env_data = runs_df[runs_df["EnvName"] == env_name]
+
+        partial_true = env_data[env_data["Partial"] == "True"]
+        partial_false = env_data[env_data["Partial"] == "False"]
+
+        merged = pd.merge(
+            partial_true[["StepsNormalized", "churn_ratio"]],
+            partial_false[["StepsNormalized", "churn_ratio"]],
+            on="StepsNormalized",
+            suffixes=("_true", "_false"),
+            how="inner",
+        )
+
+        merged["churn_diff"] = np.abs(
+            merged["churn_ratio_true"] - merged["churn_ratio_false"]
+        )
+        merged["EnvName"] = env_name.replace("Easy", "")
+
+        # diff_df = pd.concat([diff_df, merged[['EnvName', 'StepsNormalized', 'churn_diff']]], ignore_index=True)
+        merged["churn_diff_cummax"] = merged.groupby("EnvName")["churn_diff"].cummax()
+        # merged['churn_diff_avg'] = merged.groupby('EnvName')['churn_diff'].transform('mean')
+        merged["churn_diff_avg"] = merged.groupby("EnvName")["churn_diff"].transform(
+            lambda x: x.rolling(window=20, min_periods=1).mean()
+        )
+
+        diff_df = pd.concat(
+            [
+                diff_df,
+                merged[
+                    [
+                        "EnvName",
+                        "StepsNormalized",
+                        "churn_diff",
+                        "churn_diff_cummax",
+                        "churn_diff_avg",
+                    ]
+                ],
+            ],
+            ignore_index=True,
+        )
+
+    plt.figure(figsize=(12, 7))
+    sns.set()
+    sns.lineplot(
+        data=diff_df,
+        x="StepsNormalized",
+        y="churn_diff_avg",
+        hue="EnvName",
+        palette="Spectral",
+        linewidth=2.5,
+    )
+
+    plt.title("Relative Policy Churn", fontsize=35)
+    plt.xlabel("Training Progress", fontsize=35)
+    plt.ylabel("POMDP/MDP Difference", fontsize=35)
+    plt.tick_params(axis="both", which="major", labelsize=35)
+    plt.legend(title="", loc="upper left", fontsize=20, ncol=2)
+    plt.grid(True, alpha=0.5)
+    plt.tight_layout()
+    plt.savefig("{}.pdf".format(name), dpi=300, bbox_inches="tight", facecolor="white")
+
+
+for i in range(1):
+    f(f"churn{i}")
+    print(f"churn{i} done")

plotting/fps.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+# filepath: ./run_all_experiments.sh
+
+# POPGYM Arcade environment names
+# ENV_NAMES=("MineSweeperEasy" "NavigatorEasy" "CartPoleEasy" "AutoEncodeEasy" "BattleShipEasy" "NoisyCartPoleEasy" "CountRecallEasy")
+
+
+# # Atari environment names
+# ENV_NAMES=("Pong-v4")
+
+# gymnax environment names
+# JIT error: "Asterix-MinAtar" "Freeway-MinAtar"
+ENV_NAMES=("Acrobot-v1" "Pendulum-v1" "SpaceInvaders-MinAtar" "Breakout-MinAtar" "CartPole-v1" "MountainCar-v0")
+
+# PARTIAL_OBS=("True")
+SEEDS=($(seq 0 9))
+NUM_ENVS_POWERS=($(seq 1 9))
+NUM_STEPS=32
+
+# Loop over each setting combination
+for env_name in "${ENV_NAMES[@]}"; do
+    for seed in "${SEEDS[@]}"; do
+        for power in "${NUM_ENVS_POWERS[@]}"; do
+            # Calculate number of environments using 2^power
+            n_envs=$(echo "2^$power" | bc)
+            
+            # Export environment variables
+            export ENV_NAME="$env_name"
+            export SEED="$seed"
+            export NUM_ENVS="$n_envs"
+            export NUM_STEPS="$NUM_STEPS"
+            
+            echo "Running experiment with ENV_NAME=$ENV_NAME, SEED=$SEED, NUM_ENVS=$NUM_ENVS, NUM_STEPS=$NUM_STEPS"
+            python PArcade_gymnax_FPS_test.py
+
+            echo "Cleaning up leftover GPU processes..."
+            pids=$(nvidia-smi | awk '/python/ {print $5}')
+            for pid in $pids; do
+                echo "Killing process with PID $pid"
+                kill -9 $pid 2>/dev/null
+            done
+        done
+    done
+done
+
+echo "All experiments complete."

plotting/generate_analysis_data.py

@@ -0,0 +1,419 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+
+# Import the function from run_multi_seed_analysis.py
+from plotting.run_multi_seed_analysis import run_multiple_seeds_and_save_csv
+
+
+def analyze_model_saliency(
+    config, seeds=[0, 1, 2, 3, 4], max_steps=200, visualize=True
+):
+    """
+    Analyze the saliency maps of a model with the given configuration.
+
+    Args:
+        config (dict): Dictionary containing model configuration with keys:
+            - ENV_NAME: Environment name
+            - PARTIAL: Whether to use partial observations
+            - MEMORY_TYPE: Type of memory to use
+            - OBS_SIZE: Size of observations
+            - MODEL_SEED: Seed used for the model (to locate model file)
+        seeds (list): List of seeds to run the analysis with
+        max_steps (int): Maximum number of steps per episode
+        visualize (bool): Whether to create visualization plots
+
+    Returns:
+        dict: A dictionary containing:
+            - csv_path: Path to the CSV file with results
+            - avg_plot_path: Path to the average saliency plot
+            - individual_plot_path: Path to the individual seeds saliency plot
+    """
+    output_csv = f'saliency_results_{config["MEMORY_TYPE"]}_{config["ENV_NAME"]}_Partial={config["PARTIAL"]}.csv'
+
+    # Run the analysis for all seeds
+    output_csv = run_multiple_seeds_and_save_csv(
+        config, seeds, max_steps=max_steps, output_csv=output_csv
+    )
+
+    result_paths = {"csv_path": output_csv}
+
+    if visualize:
+        # Load the results for visualization
+        results_df = pd.read_csv(output_csv)
+
+        # Create a visualization of the distributions for each seed
+        plt.figure(figsize=(12, 8))
+        sns.set_style("whitegrid")
+
+        # Filter columns that represent positions
+        pos_columns = [col for col in results_df.columns if col.startswith("pos_")]
+
+        # Plot each seed's distribution
+        for idx, row in results_df.iterrows():
+            seed = row["seed"]
+            positions = [float(col.split("_")[1]) for col in pos_columns]
+            values = [row[col] for col in pos_columns]
+            plt.plot(positions, values, marker="o", markersize=3, label=f"Seed {seed}")
+
+        plt.xlabel("Normalized Episode Position")
+        plt.ylabel("Saliency Magnitude")
+        plt.title(
+            f"Terminal Saliency Distribution by Seed\n{config['MEMORY_TYPE']} on {config['ENV_NAME']}"
+        )
+        plt.legend()
+        plt.tight_layout()
+
+        individual_plot_path = f"saliency_plot_{config['MEMORY_TYPE']}_{config['ENV_NAME']}_Partial={config['PARTIAL']}.png"
+        plt.savefig(individual_plot_path, dpi=300)
+        plt.close()
+
+        # Calculate average distribution across seeds
+        avg_values = [results_df[col].mean() for col in pos_columns]
+        std_values = [results_df[col].std() for col in pos_columns]
+        positions = [float(col.split("_")[1]) for col in pos_columns]
+
+        plt.figure(figsize=(12, 8))
+        plt.plot(positions, avg_values, "b-", linewidth=2, label="Mean Distribution")
+        plt.fill_between(
+            positions,
+            [avg - std for avg, std in zip(avg_values, std_values)],
+            [avg + std for avg, std in zip(avg_values, std_values)],
+            color="b",
+            alpha=0.2,
+            label="Standard Deviation",
+        )
+
+        plt.xlabel("Normalized Episode Position")
+        plt.ylabel("Average Saliency Magnitude")
+        plt.title(
+            f"Average Terminal Saliency Distribution Across Seeds\n{config['MEMORY_TYPE']} on {config['ENV_NAME']}"
+        )
+        plt.legend()
+        plt.tight_layout()
+
+        avg_plot_path = f"avg_saliency_plot_{config['MEMORY_TYPE']}_{config['ENV_NAME']}_Partial={config['PARTIAL']}.png"
+        plt.savefig(avg_plot_path, dpi=300)
+        plt.close()
+
+        result_paths["individual_plot_path"] = individual_plot_path
+        result_paths["avg_plot_path"] = avg_plot_path
+
+    print(f"Analysis complete. Results saved to: {output_csv}")
+    return result_paths
+
+
+# Example usage
+if __name__ == "__main__":
+    configs = [
+        # fart models
+        {
+            "ENV_NAME": "AutoEncodeEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 3,
+        },
+        {
+            "ENV_NAME": "AutoEncodeEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 4,
+        },
+        {
+            "ENV_NAME": "BattleShipEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "BattleShipEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "CartPoleEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "CartPoleEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 1,
+        },
+        {
+            "ENV_NAME": "CountRecallEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "CountRecallEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "MineSweeperEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 4,
+        },
+        {
+            "ENV_NAME": "MineSweeperEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 3,
+        },
+        {
+            "ENV_NAME": "NavigatorEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 2,
+        },
+        {
+            "ENV_NAME": "NavigatorEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 1,
+        },
+        {
+            "ENV_NAME": "NoisyCartPoleEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 4,
+        },
+        {
+            "ENV_NAME": "NoisyCartPoleEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "fart",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        # lru models
+        {
+            "ENV_NAME": "AutoEncodeEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "AutoEncodeEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "BattleShipEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 1,
+        },
+        {
+            "ENV_NAME": "BattleShipEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 2,
+        },
+        {
+            "ENV_NAME": "CartPoleEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 3,
+        },
+        {
+            "ENV_NAME": "CartPoleEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 3,
+        },
+        {
+            "ENV_NAME": "CountRecallEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "CountRecallEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 1,
+        },
+        {
+            "ENV_NAME": "MineSweeperEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 4,
+        },
+        {
+            "ENV_NAME": "MineSweeperEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 1,
+        },
+        {
+            "ENV_NAME": "NavigatorEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 2,
+        },
+        {
+            "ENV_NAME": "NavigatorEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 4,
+        },
+        {
+            "ENV_NAME": "NoisyCartPoleEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 2,
+        },
+        {
+            "ENV_NAME": "NoisyCartPoleEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "lru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 2,
+        },
+        # mingru models
+        {
+            "ENV_NAME": "AutoEncodeEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 1,
+        },
+        {
+            "ENV_NAME": "AutoEncodeEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 1,
+        },
+        {
+            "ENV_NAME": "BattleShipEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 2,
+        },
+        {
+            "ENV_NAME": "BattleShipEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 2,
+        },
+        {
+            "ENV_NAME": "CartPoleEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 4,
+        },
+        {
+            "ENV_NAME": "CartPoleEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 4,
+        },
+        {
+            "ENV_NAME": "CountRecallEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 2,
+        },
+        {
+            "ENV_NAME": "CountRecallEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 2,
+        },
+        {
+            "ENV_NAME": "MineSweeperEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "MineSweeperEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 2,
+        },
+        {
+            "ENV_NAME": "NavigatorEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "NavigatorEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 0,
+        },
+        {
+            "ENV_NAME": "NoisyCartPoleEasy",
+            "PARTIAL": False,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 3,
+        },
+        {
+            "ENV_NAME": "NoisyCartPoleEasy",
+            "PARTIAL": True,
+            "MEMORY_TYPE": "mingru",
+            "OBS_SIZE": 128,
+            "MODEL_SEED": 4,
+        },
+    ]
+
+    # Example usage
+    seeds = [0, 1, 2, 3, 4]
+
+    for config in configs:
+        print(
+            f"Analyzing {config['MEMORY_TYPE']} on {config['ENV_NAME']} (Partial={config['PARTIAL']}, Seed={config['MODEL_SEED']})"
+        )
+
+        results = analyze_model_saliency(
+            config=config, seeds=seeds, max_steps=200, visualize=True
+        )
+        print(f"Successfully analyzed: {results}")

plotting/noiseva.py

@@ -0,0 +1,449 @@
+# Require pip install moviepy==1.0.3
+import os
+from typing import NamedTuple
+
+import chex
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+import matplotlib.pyplot as plt
+import numpy as np
+import optax
+import seaborn as sns
+from jax import lax
+
+import popgym_arcade
+import wandb
+from popgym_arcade.baselines.model import QNetworkRNN, add_batch_dim
+from popgym_arcade.baselines.pqn_rnn import debug_shape
+from popgym_arcade.wrappers import LogWrapper
+
+plt.rcParams["text.usetex"] = True
+plt.rcParams["font.family"] = "sans-serif"
+plt.rcParams["font.sans-serif"] = ["Arial"]
+
+# This is the number of steps or frames to evaluate
+STEPS = 101
+
+
+def evaluate(model, config):
+    seed = jax.random.PRNGKey(11)
+    seed, _rng = jax.random.split(seed)
+    env, env_params = popgym_arcade.make(
+        config["ENV_NAME"], partial_obs=config["PARTIAL"], obs_size=config["OBS_SIZE"]
+    )
+    vmap_reset = lambda n_envs: lambda rng: jax.vmap(env.reset, in_axes=(0, None))(
+        jax.random.split(rng, n_envs), env_params
+    )
+    vmap_step = lambda n_envs: lambda rng, env_state, action: jax.vmap(
+        env.step, in_axes=(0, 0, 0, None)
+    )(jax.random.split(rng, n_envs), env_state, action, env_params)
+
+    def run_evaluation(rng):
+        # Reset environment
+        obs, state = vmap_reset(2)(rng)
+        init_done = jnp.zeros(2, dtype=bool)
+        init_action = jnp.zeros(2, dtype=int)
+        init_hs = model.initialize_carry(key=rng)
+        hs = add_batch_dim(init_hs, 2)
+
+        frame_shape = obs[0].shape
+        frames = jnp.zeros((STEPS, *frame_shape), dtype=jnp.float32)
+        # Store initial observation
+        frame = jnp.asarray(obs[0])
+        frame = (frame * 255).astype(jnp.float32)
+        frames = frames.at[0].set(frame)
+        normal_qvals = jnp.zeros((STEPS, 2, 5))
+        carry = (hs, obs, init_done, init_action, state, frames, rng)
+
+        def evaluate_step(carry, i):
+            hs, obs, done, action, state, frames, _rng = carry
+            _rng, rng_step = jax.random.split(_rng, 2)
+
+            obs_batch = obs[jnp.newaxis, :]
+            done_batch = done[jnp.newaxis, :]
+            action_batch = action[jnp.newaxis, :]
+            # jax.debug.print("hs shape: {}", debug_shape(hs)) # tuple (2, 512) (2,)
+            # jax.debug.print("obs_batch shape: {}", obs_batch.shape) # Shape (1, 2, 128, 128, 3)
+            # jax.debug.print("done_batch shape: {}", done_batch.shape) # Shape (1, 2)
+            # jax.debug.print("action_batch shape: {}", action_batch.shape) # Shape (1, 2)
+            hs, q_val = model(hs, obs_batch, done_batch, action_batch)
+            q_val = lax.stop_gradient(q_val)
+            q_val = q_val.squeeze(axis=0)
+            # jax.debug.print("q_val shape: {}", q_val.shape) # Shape (2, n_actions)
+
+            action = jnp.argmax(q_val, axis=-1)
+
+            obs, new_state, reward, done, info = vmap_step(2)(rng_step, state, action)
+            state = new_state
+
+            frame = jnp.asarray(obs[0])
+            frame = (frame * 255).astype(jnp.float32)
+            frames = frames.at[i + 1].set(frame)
+
+            carry = (hs, obs, done, action, state, frames, _rng)
+            return carry, q_val
+
+        def body_fun(i, val):
+            carry, normal_qvals = val
+            carry, q_val = evaluate_step(carry, i)
+            normal_qvals = normal_qvals.at[i].set(q_val)
+
+            return (carry, normal_qvals)
+
+        carry, normal_qvals = lax.fori_loop(0, STEPS, body_fun, (carry, normal_qvals))
+        _, _, _, _, _, frames, _rng = carry
+        return frames, _rng, normal_qvals
+
+    # imageio.mimsave('{}_{}_{}_Partial={}_SEED={}.gif'.format(config["TRAIN_TYPE"], config["MEMORY_TYPE"], config["ENV_NAME"], config["PARTIAL"], config["SEED"]), frames)
+    # wandb.log({"{}_{}_{}_model_Partial={}_SEED={}".format(config["TRAIN_TYPE"], config["MEMORY_TYPE"], config["ENV_NAME"], config["PARTIAL"], config["SEED"]): wandb.Video(frames, fps=4)})
+    wandb.init(
+        project=f'{config["PROJECT"]}',
+        name=f'{config["TRAIN_TYPE"]}_{config["MEMORY_TYPE"]}_{config["ENV_NAME"]}_Partial={config["PARTIAL"]}_SEED={config["SEED"]}',
+    )
+
+    # Rollout
+    noiseless_frames, _rng, normal_qvals = run_evaluation(
+        _rng
+    )  # Shape (STEPS, 128, 128, 3), normal_qvals shape (STEPS, 2, n_actions)
+
+    def add_noise(o, _rng):
+        noise = jax.random.normal(_rng, o.shape) * 1.0
+        return noise + o
+
+    def qvals_for_frames(frames, rng, init_hs):
+        hs = add_batch_dim(init_hs, 2)
+        init_done = jnp.zeros(2, dtype=bool)
+        init_action = jnp.zeros(2, dtype=int)
+        q_vals = jnp.zeros((STEPS, 2, 5))
+
+        def process_step(carry, frame):
+            hs, done, action = carry
+            obs = jnp.asarray(frame)
+            # jax.debug.print("frame shape: {}", obs.shape)  # Shape (128, 128, 3)
+            obs = jnp.stack([obs, obs], axis=0)  # Simulate 2 environments
+
+            obs_batch = obs[jnp.newaxis, :]  # Shape (1, 2, 128, 128, 3)
+            done_batch = done[jnp.newaxis, :]  # Shape (1, 2)
+            action_batch = action[jnp.newaxis, :]  # Shape (1, 2)
+
+            hs, q_val = model(hs, obs_batch, done_batch, action_batch)
+            q_val = lax.stop_gradient(q_val)
+            q_val = q_val.squeeze(axis=0)  # Shape (2, n_actions)
+            # jax.debug.print("=q_val shape: {}", q_val.shape)  # Shape (2, n_actions)
+            carry = (hs, done, action)
+            return carry, q_val
+
+        def body_fun(i, val):
+            carry, q_vals = val
+            carry, q_val = process_step(carry, frames[i])
+            q_vals = q_vals.at[i].set(q_val)
+            return (carry, q_vals)
+
+        carry = (hs, init_done, init_action)
+        _, q_vals = lax.fori_loop(0, STEPS, body_fun, (carry, q_vals))
+        return q_vals  # Shape (STEPS, 2, n_actions)
+
+    last_qs = []
+    noisy_frames = []
+    num_noise = STEPS - 1
+
+    for noise_idx in range(
+        1, num_noise + 1
+    ):  # This is how many trajectories we want to generate
+        init_hs = model.initialize_carry(key=_rng)
+        rng, sub_rng = jax.random.split(_rng)
+
+        frames = noiseless_frames.copy()
+
+        noisy_frame = add_noise(frames[noise_idx], sub_rng)
+        noisy_frame = (noisy_frame * 255).astype(jnp.float32)  # Shape (128, 128, 3)
+        frames = frames.at[noise_idx].set(noisy_frame)  # Shape (STEPS, 128, 128, 3)
+        noisy_frames.append(np.array(noisy_frame, dtype=np.uint8))
+
+        frames_np = np.array(frames, dtype=np.uint8)  # Shape (STEPS, 128, 128, 3)
+        frames_np = frames_np.transpose((0, 3, 1, 2))
+
+        log_key = "{}_{}_{}_model_Partial={}_SEED={}_NoiseIdx={}".format(
+            config["TRAIN_TYPE"],
+            config["MEMORY_TYPE"],
+            config["ENV_NAME"],
+            config["PARTIAL"],
+            config["SEED"],
+            noise_idx,
+        )
+        wandb.log({log_key: wandb.Video(frames_np, fps=4)})
+
+        q_vals = qvals_for_frames(frames, sub_rng, init_hs)
+        q_vals = jnp.array(q_vals)
+        # print(f"{noise_idx}{q_vals}")  # Shape (STEPS, 2, n_actions)
+        q_vals_np = np.array(q_vals)  # shape (STEPS, 2, 5)
+        q_vals_plot = q_vals_np[:, 0, :]  # shape (STEPS, 5)
+        last_qs.append(q_vals_plot[-1])
+
+        frames = np.arange(q_vals_plot.shape[0])
+        n_actions = q_vals_plot.shape[1]
+
+        _rng = rng
+
+    plt.rcParams["text.usetex"] = True
+    plt.rcParams["text.latex.preamble"] = (
+        r"\usepackage{amsmath} \usepackage{amssymb} \usepackage{amsfonts}"
+    )
+
+    def plot(noisy_frames, noiseless_frames, normal_qvals, last_qs):
+        sns.set()
+        fig, axes = plt.subplots(num_noise + 1, 4, figsize=(10, 3 * (num_noise + 1)))
+
+        normal_last_qvals = normal_qvals[:, 0, :][-1]
+        last_qs = np.array(last_qs)  # shape (10, 5)
+        all_qvals = [normal_last_qvals] + [last_qs[idx] for idx in range(num_noise)]
+        ymin = min(q.min() for q in all_qvals)
+        ymax = max(q.max() for q in all_qvals) + 0.1
+        action_symbols = ["↑", "↓", "←", "→", "4"]
+
+        axes[0, 0].imshow(np.array(noiseless_frames[0], dtype=np.uint8))
+        axes[0, 0].set_title(r"$O_0$", fontsize=20)
+        axes[0, 1].imshow(np.array(noiseless_frames[1], dtype=np.uint8))
+        axes[0, 1].set_title(r"$O_1$", fontsize=20)
+        axes[0, 2].imshow(np.array(noiseless_frames[-1], dtype=np.uint8))
+        axes[0, 2].set_title(rf"$O_{{{num_noise}}}$", fontsize=20)
+        max_idx = np.argmax(normal_last_qvals)
+        colors = ["#BBBBBB"] * len(normal_last_qvals)
+        colors[max_idx] = "lightblue"
+
+        axes[0, 3].bar(
+            np.arange(normal_last_qvals.shape[0]),
+            normal_last_qvals,
+            color=colors,
+            edgecolor="black",
+        )
+        axes[0, 3].set_title(rf"$Q(s_{{{num_noise}}}, a_{{{num_noise}}})$", fontsize=20)
+        axes[0, 3].set_xticks(np.arange(len(normal_last_qvals)))
+
+        axes[0, 3].set_xticklabels(action_symbols, fontsize=10)
+        # axes[0, 3].set_ylim(ymin, ymax)
+        # axes[0, 3].set_yticks(np.arange(0.0, ymax + 0.05, 0.1))
+        # axes[0, 3].tick_params(axis='y', labelsize=20)
+        axes[0, 3].set_yticks([])
+        axes[0, 3].yaxis.set_visible(False)
+
+        for idx in range(num_noise):
+
+            qvals = last_qs[idx]
+            max_idx = np.argmax(qvals)
+            colors = ["#BBBBBB"] * len(qvals)
+            colors[max_idx] = "#FFB6C1"
+            axes[idx + 1, 0].imshow(np.array(noiseless_frames[0], dtype=np.uint8))
+            axes[idx + 1, 0].set_title(r"$O_0$", fontsize=20)
+            axes[idx + 1, 1].imshow(np.array(noisy_frames[idx], dtype=np.uint8))
+            axes[idx + 1, 1].set_title(rf"$O_{{{idx+1}}} + \epsilon$", fontsize=20)
+            axes[idx + 1, 2].imshow(np.array(noiseless_frames[-1], dtype=np.uint8))
+            axes[idx + 1, 2].set_title(rf"$O_{{{num_noise}}}$", fontsize=20)
+            axes[idx + 1, 3].bar(
+                np.arange(last_qs[idx].shape[0]),
+                last_qs[idx],
+                color=colors,
+                edgecolor="black",
+            )
+            axes[idx + 1, 3].set_title(
+                rf"$Q(s_{{{num_noise}}}, a_{{{num_noise}}})$", fontsize=20
+            )
+            # axes[idx , 3].set_ylim(ymin, ymax)
+            # axes[idx + 1, 3].set_yticks(np.arange(0.0, ymax + 0.05, 0.1))
+
+            # axes[idx + 1, 3].tick_params(axis='y', labelsize=20)
+            axes[idx + 1, 3].set_yticks([])
+            axes[idx + 1, 3].yaxis.set_visible(False)
+            axes[idx + 1, 3].set_xticks(np.arange(len(last_qs[idx])))
+
+            axes[idx + 1, 3].set_xticklabels(action_symbols, fontsize=10)
+
+        for row in axes:
+            for ax in row[:3]:
+                ax.axis("off")
+
+        plt.tight_layout()
+        plt.subplots_adjust(wspace=0.1)
+
+        for row in axes:
+            ax2 = row[2]
+            ax3 = row[3]
+
+            pos2 = ax2.get_position()
+            pos3 = ax3.get_position()
+
+            new_spacing = 0.04  # Adjust this value to increase/decrease the space between ax2 and ax3
+            new_ax3_x0 = pos2.x1 + new_spacing
+
+            ax3.set_position([new_ax3_x0, pos3.y0, pos3.width, pos3.height])
+
+        plt.savefig("summary.png", dpi=300, bbox_inches="tight")
+        plt.close()
+
+    def batch_plot(noisy_frames, noiseless_frames, normal_qvals, last_qs):
+        sns.set()
+        plt.rcParams["text.usetex"] = True
+        plt.rcParams["text.latex.preamble"] = (
+            r"\usepackage{amsmath} \usepackage{amssymb} \usepackage{amsfonts}"
+        )
+
+        BATCH_SIZE = 20  # Number of rows per batch
+        total_rows = num_noise + 1
+        num_batches = (total_rows + BATCH_SIZE - 1) // BATCH_SIZE
+
+        normal_last_qvals = normal_qvals[:, 0, :][-1]
+        last_qs = np.array(last_qs)  # shape (num_noise, 5)
+        all_qvals = [normal_last_qvals] + [last_qs[idx] for idx in range(num_noise)]
+        ymin = min(q.min() for q in all_qvals)
+        ymax = max(q.max() for q in all_qvals) + 0.1
+        action_symbols = ["↑", "↓", "←", "→", "4"]
+
+        for batch_idx in range(num_batches):
+            start = batch_idx * BATCH_SIZE
+            end = min((batch_idx + 1) * BATCH_SIZE, total_rows)
+            batch_rows = end - start
+
+            fig, axes = plt.subplots(batch_rows, 4, figsize=(10, 3 * batch_rows))
+            if batch_rows == 1:
+                axes = axes[None, :]  # Ensure axes is 2D
+
+            for row_idx in range(batch_rows):
+                idx = start + row_idx
+                if idx == 0:
+                    # first row
+                    axes[row_idx, 0].imshow(
+                        np.array(noiseless_frames[0], dtype=np.uint8)
+                    )
+                    axes[row_idx, 0].set_title(r"$O_0$", fontsize=20)
+                    axes[row_idx, 1].imshow(
+                        np.array(noiseless_frames[1], dtype=np.uint8)
+                    )
+                    axes[row_idx, 1].set_title(r"$O_1$", fontsize=20)
+                    axes[row_idx, 2].imshow(
+                        np.array(noiseless_frames[-1], dtype=np.uint8)
+                    )
+                    axes[row_idx, 2].set_title(rf"$O_{{{num_noise}}}$", fontsize=20)
+                    max_idx = np.argmax(normal_last_qvals)
+                    colors = ["#BBBBBB"] * len(normal_last_qvals)
+                    colors[max_idx] = "lightblue"
+                    axes[row_idx, 3].bar(
+                        np.arange(normal_last_qvals.shape[0]),
+                        normal_last_qvals,
+                        color=colors,
+                        edgecolor="black",
+                    )
+                    axes[row_idx, 3].set_title(
+                        rf"$Q(s_{{{num_noise}}}, a_{{{num_noise}}})$", fontsize=20
+                    )
+                    axes[row_idx, 3].set_xticks(np.arange(len(normal_last_qvals)))
+                    axes[row_idx, 3].set_xticklabels(action_symbols, fontsize=10)
+                    axes[row_idx, 3].set_yticks([])
+                    axes[row_idx, 3].yaxis.set_visible(False)
+                else:
+                    qvals = last_qs[idx - 1]
+                    max_idx = np.argmax(qvals)
+                    colors = ["#BBBBBB"] * len(qvals)
+                    colors[max_idx] = "#FFB6C1"
+                    axes[row_idx, 0].imshow(
+                        np.array(noiseless_frames[0], dtype=np.uint8)
+                    )
+                    axes[row_idx, 0].set_title(r"$O_0$", fontsize=20)
+                    axes[row_idx, 1].imshow(
+                        np.array(noisy_frames[idx - 1], dtype=np.uint8)
+                    )
+                    axes[row_idx, 1].set_title(
+                        rf"$O_{{{idx}}} + \epsilon$", fontsize=20
+                    )
+                    axes[row_idx, 2].imshow(
+                        np.array(noiseless_frames[-1], dtype=np.uint8)
+                    )
+                    axes[row_idx, 2].set_title(rf"$O_{{{num_noise}}}$", fontsize=20)
+                    axes[row_idx, 3].bar(
+                        np.arange(qvals.shape[0]),
+                        qvals,
+                        color=colors,
+                        edgecolor="black",
+                    )
+                    axes[row_idx, 3].set_title(
+                        rf"$Q(s_{{{num_noise}}}, a_{{{num_noise}}})$", fontsize=20
+                    )
+                    axes[row_idx, 3].set_yticks([])
+                    axes[row_idx, 3].yaxis.set_visible(False)
+                    axes[row_idx, 3].set_xticks(np.arange(len(qvals)))
+                    axes[row_idx, 3].set_xticklabels(action_symbols, fontsize=10)
+
+                for ax in axes[row_idx, :3]:
+                    ax.axis("off")
+
+            plt.tight_layout()
+            plt.subplots_adjust(wspace=0.1)
+
+            for row in axes:
+                ax2 = row[2]
+                ax3 = row[3]
+                pos2 = ax2.get_position()
+                pos3 = ax3.get_position()
+                new_spacing = 0.04
+                new_ax3_x0 = pos2.x1 + new_spacing
+                ax3.set_position([new_ax3_x0, pos3.y0, pos3.width, pos3.height])
+
+            plt.savefig(f"summary_batch_{batch_idx}.png", dpi=300, bbox_inches="tight")
+            plt.close()
+
+    # plot(noisy_frames, noiseless_frames, normal_qvals, last_qs)
+    batch_plot(noisy_frames, noiseless_frames, normal_qvals, last_qs)
+
+
+os.environ["WANDB_MODE"] = "disabled"
+MEMORY_TYPES = {"lru"}
+# , "mingru", "fart"
+ENV_NAMES = {
+    # "AutoEncodeEasy",
+    # "BattleShipEasy",
+    "CartPoleEasy",
+    # "NoisyCartPoleEasy",
+    # "CountRecallEasy",
+    # "MineSweeperEasy",
+    # "NavigatorEasy",
+}
+PATH = "./pkls_gradients/"
+for filename in os.listdir(PATH):
+    if filename.startswith("PQN_RNN_"):
+        parts = filename.split("_")
+        train_type = "_".join(parts[:2])  # "PQN_RNN"
+        memory_type = parts[2].lower()
+        env_name = parts[3]
+        partial_part = parts[5]
+        seed_part = parts[6]
+    else:
+        continue
+
+    # Extract Partial and SEED values
+    partial = partial_part.split("=")[1]
+    seed = seed_part.split("=")[1].replace(".pkl", "")
+    # Check if this file matches our criteria
+    if (
+        train_type == "PQN_RNN"
+        and partial.lower() == "false"
+        and memory_type in MEMORY_TYPES
+        and env_name in ENV_NAMES
+    ):
+
+        # Create config
+        config = {
+            "ENV_NAME": env_name,
+            "OBS_SIZE": 128,
+            "MEMORY_TYPE": memory_type,
+            "PARTIAL": False,
+            "TRAIN_TYPE": train_type,
+            "SEED": int(seed),
+            "PROJECT": "noiseva",
+        }
+        print(f"Evaluating {filename} with config: {config}")
+
+        rng = jax.random.PRNGKey(config["SEED"])
+        rng, _rng = jax.random.split(rng)
+        network = QNetworkRNN(_rng, config["OBS_SIZE"], config["MEMORY_TYPE"])
+        model = eqx.tree_deserialise_leaves(PATH + filename, network)
+        evaluate(model, config)

plotting/plot_fps.py

@@ -0,0 +1,74 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+
+# import sys; sys.path.extend(['/home/ubuntu-user/popjym-main/'])
+
+alldata = pd.read_csv(
+    "F:/Desktop/ML/Popjym/popjym/popjym/popjym/plotting/fps_data/all.csv"
+)
+popgymarcadedata = pd.read_csv(
+    "F:/Desktop/ML/Popjym/popjym/popjym/popjym/plotting/fps_data/True_popgymarcadefpsdata.csv"
+)
+
+sns.set()
+# sns.color_palette("Paired")
+
+# plt.figure(figsize=(12, 8))
+fig, axes = plt.subplots(1, 2, figsize=(24, 8), sharex=True, sharey=True)
+
+sns.lineplot(
+    data=popgymarcadedata,
+    x="Num Envs",
+    y="FPS",
+    hue="Environment",
+    marker="o",
+    markersize=25,
+    ax=axes[0],
+    # errorbar=('ci', 95)
+)
+axes[0].set_xscale("log", base=2)
+axes[0].set_yscale("log", base=10)
+axes[0].tick_params(axis="both", which="major", labelsize=35)
+axes[0].legend(title="", title_fontsize="20", fontsize="22", ncol=3)
+axes[0].set_xlabel("")
+axes[0].set_ylabel("")
+sns.lineplot(
+    data=alldata,
+    x="Num Envs",
+    y="FPS",
+    hue="Environment",
+    marker="o",
+    markersize=25,
+    # errorbar=('ci', 95)
+    ax=axes[1],
+)
+
+axes[1].set_xscale("log", base=2)
+axes[1].set_yscale("log", base=2)
+axes[1].tick_params(axis="both", which="major", labelsize=35)
+axes[1].legend(title="", title_fontsize="20", fontsize="22", ncol=3)
+axes[1].set_xlabel("")
+axes[1].set_ylabel("")
+fig.text(0.55, 0.04, "Number of Parallel Environments", ha="center", fontsize=35)
+fig.text(0.04, 0.6, "Frames per second", va="center", rotation="vertical", fontsize=35)
+
+# fig.subplots_adjust(wspace=0.3)
+
+# fig.subplots_adjust(left=0.05, wspace=0.3)
+plt.tight_layout(rect=[0.07, 0.07, 1, 1])
+plt.show()
+
+# plt.xlabel('Number of Parallel Environments', fontsize=50)
+# plt.ylabel('Frames per second (FPS)', fontsize=50)
+# # Optionally, adjust tick label sizes
+# plt.tick_params(axis='both', which='major', labelsize=50)
+
+# plt.xscale('log', base=2)
+# plt.yscale('log', base=10)
+
+# # Show the plot
+# plt.legend(title='', title_fontsize='20', fontsize='20')
+# plt.tight_layout()
+# # plt.savefig('POMDP.png')
+# plt.show()

plotting/plot_separate_returns_curve.py

@@ -0,0 +1,336 @@
+"""
+This file is to plot the MDP and POMDP results separately.
+"""
+
+import jax.numpy as jnp  # Import JAX
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from jax import lax  # Import lax for cummax
+from scipy.interpolate import interp1d
+
+import wandb
+
+
+def f(name):
+    WINDOW_SIZE = 100
+    SIGMA = 100
+    INTERP_POINTS = 1000
+    NORMALIZING_FACTOR = 200
+
+    ENV_MAX_STEPS = {
+        "CountRecallEasy": 2e7,
+        "CountRecallMedium": 2e7,
+        "CountRecallHard": 2e7,
+        "BattleShipEasy": 2e7,
+        "BattleShipMedium": 2e7,
+        "BattleShipHard": 2e7,
+        # other environments with default max steps 1e7
+    }
+    AXIS_FONT = {"fontsize": 9, "labelpad": 8}
+    TICK_FONT = {"labelsize": 8}
+
+    api = wandb.Api()
+    runs = api.runs("bolt-um/Arcade-RLC")
+    filtered_runs = [run for run in runs if run.state == "finished"]
+    print(f"Total runs: {len(runs)}, Completed runs: {len(filtered_runs)}")
+
+    METRIC_MAPPING = {
+        "PQN": {"return_col": "returned_episode_returns", "time_col": "env_step"},
+        "PQN_RNN": {"return_col": "returned_episode_returns", "time_col": "env_step"},
+        "default": {"return_col": "episodic return", "time_col": "TOTAL_TIMESTEPS"},
+    }
+
+    def process_run(run):
+        """Process individual W&B run with dynamic max steps per environment"""
+        try:
+            config = {k: v for k, v in run.config.items() if not k.startswith("_")}
+            env_name = config.get("ENV_NAME", "UnknownEnv")
+            partial_status = str(config.get("PARTIAL", False))
+
+            if env_name in ENV_MAX_STEPS:
+                env_max_step = ENV_MAX_STEPS[env_name]
+            else:
+                env_max_step = 1e7
+
+            alg_name = config.get("ALG_NAME", "").upper()
+            memory_type = "MLP"
+            if alg_name == "PQN_RNN":
+                memory_type = config.get("MEMORY_TYPE", "Unknown").capitalize()
+
+            metric_map = METRIC_MAPPING.get(alg_name, METRIC_MAPPING["default"])
+            # history = run.scan_history(keys=[metric_map["return_col"], metric_map["time_col"]])
+            history = list(
+                run.scan_history(
+                    keys=[metric_map["return_col"], metric_map["time_col"]]
+                )
+            )
+            history = pd.DataFrame(
+                history, columns=[metric_map["return_col"], metric_map["time_col"]]
+            )
+
+            history["true_steps"] = history[metric_map["time_col"]].clip(
+                upper=env_max_step
+            )
+            history = history.sort_values(metric_map["time_col"]).drop_duplicates(
+                subset=["true_steps"]
+            )
+
+            if len(history) < 2:
+                print(f"Skipping {run.name} due to insufficient data points")
+                return None
+
+            # Get first and last values for extrapolation
+            first_return = history[metric_map["return_col"]].iloc[0]
+            last_return = history[metric_map["return_col"]].iloc[-1]
+
+            # Create unified interpolation grid for this environment
+            unified_steps = np.linspace(0, env_max_step, INTERP_POINTS)
+            unified_steps = np.round(unified_steps, decimals=5)
+            scale_factor = NORMALIZING_FACTOR / env_max_step
+
+            # Interpolate returns to uniform grid
+            interp_func = interp1d(
+                history["true_steps"],
+                history[metric_map["return_col"]],
+                kind="linear",
+                bounds_error=False,
+                fill_value=(first_return, last_return),
+            )
+            interpolated_returns = interp_func(unified_steps)
+
+            smoothed_returns = (
+                pd.Series(interpolated_returns)
+                .ewm(span=100, adjust=False, min_periods=1)
+                .mean()
+                .values
+            )
+            # smoothed_returns = pd.Series(interpolated_returns).rolling(window=WINDOW_SIZE, min_periods=1).mean().values
+
+            # Compute cumulative maximum using JAX
+            cummax_returns = lax.cummax(jnp.array(smoothed_returns))
+
+            return pd.DataFrame(
+                {
+                    "Algorithm": f"{alg_name} ({memory_type})",
+                    "Return": interpolated_returns,
+                    "Smoothed Return": smoothed_returns,
+                    "Cummax Return": np.array(cummax_returns),  # Convert back to NumPy
+                    "True Steps": unified_steps,
+                    "EnvName": env_name,
+                    "Partial": partial_status,
+                    "Seed": str(config.get("SEED", 0)),
+                    "run_id": run.id,
+                    "StepsNormalized": unified_steps * scale_factor,
+                    "EnvMaxStep": env_max_step,
+                    "ScaleFactor": scale_factor,
+                }
+            )
+
+        except Exception as e:
+            print(f"Error processing {run.name}: {str(e)}")
+        return None
+
+    # Process all runs and combine data
+    all_data = [df for run in filtered_runs if (df := process_run(run)) is not None]
+    if not all_data:
+        print("No valid data to process")
+        exit()
+    runs_df = pd.concat(all_data, ignore_index=True)
+
+    # Generate interpolation grid for each environment
+    interpolated_data = []
+    for (alg, env, partial), group in runs_df.groupby(
+        ["Algorithm", "EnvName", "Partial"]
+    ):
+        all_steps = group["True Steps"].unique()
+        if len(all_steps) != INTERP_POINTS:
+            print(
+                f"Alignment error in {alg}-{env}-{partial}: {len(all_steps)} vs {INTERP_POINTS}"
+            )
+            continue
+
+        pivot_df = group.pivot_table(
+            index="True Steps",
+            columns="run_id",
+            values="Smoothed Return",
+            aggfunc="first",
+        )
+
+        # Calculate cumulative maximum for each run
+        cummax_df = group.pivot_table(
+            index="True Steps",
+            columns="run_id",
+            values="Cummax Return",
+            aggfunc="first",
+        )
+
+        stats_df = pd.DataFrame(
+            {
+                "Steps": pivot_df.index,
+                "Mean": pivot_df.mean(axis=1),
+                "Cummax Mean": cummax_df.mean(axis=1),  # Mean of cumulative max
+                "Std": pivot_df.std(axis=1),
+                "Count": pivot_df.count(axis=1),
+            }
+        )
+        stats_df["Lower"] = stats_df["Mean"] - stats_df["Std"]
+        stats_df["Upper"] = stats_df["Mean"] + stats_df["Std"]
+
+        stats_df["Lower"] = np.array(lax.cummax(jnp.array(stats_df["Lower"])))
+        stats_df["Upper"] = np.array(lax.cummax(jnp.array(stats_df["Upper"])))
+
+        stats_df["StepsNormalized"] = stats_df["Steps"] * (
+            NORMALIZING_FACTOR / group["EnvMaxStep"].iloc[0]
+        )
+
+        interpolated_data.append(
+            pd.DataFrame(
+                {
+                    "Algorithm": alg,
+                    "EnvName": env,
+                    "Partial": partial,
+                    "Steps": stats_df["Steps"],
+                    "Smoothed": stats_df["Mean"],
+                    "Cummax": stats_df["Cummax Mean"],  # Add cumulative max
+                    "Lower": stats_df["Lower"],
+                    "Upper": stats_df["Upper"],
+                    "StepsNormalized": stats_df["StepsNormalized"],
+                    "EnvMaxStep": group["EnvMaxStep"].iloc[0],
+                }
+            )
+        )
+
+    final_df = pd.concat(interpolated_data, ignore_index=True)
+
+    def plot_comparative_curves(df, name):
+        """Plot comparative curves for all environments"""
+        algorithms = df["Algorithm"].unique().tolist()
+        palette = sns.husl_palette(n_colors=len(algorithms), s=0.7)
+
+        # plt.style.use('seaborn-v0_8')
+        sns.set()
+        envs = df[["EnvName", "Partial", "EnvMaxStep"]].drop_duplicates()
+        envs["BaseName"] = envs["EnvName"].apply(
+            lambda x: x.replace("Easy", "").replace("Medium", "").replace("Hard", "")
+        )
+        envs["Difficulty"] = envs["EnvName"].apply(
+            lambda x: (
+                0 if "Easy" in x else 1 if "Medium" in x else 2 if "Hard" in x else 3
+            )
+        )
+        envs = envs.sort_values(by=["BaseName", "Difficulty"])
+
+        n_plots = len(envs)
+        n_cols = min(3, n_plots)
+        n_rows = int(np.ceil(n_plots / n_cols))
+
+        fig = plt.figure(figsize=(12, n_rows * 4.5))
+        gs = fig.add_gridspec(
+            n_rows, n_cols, hspace=0.35, wspace=0.25, bottom=0.12, top=0.92
+        )
+
+        for idx, (_, row) in enumerate(envs.iterrows()):
+            ax = fig.add_subplot(gs[idx // n_cols, idx % n_cols])
+            env, partial, max_step = row[["EnvName", "Partial", "EnvMaxStep"]]
+            env_data = df[(df.EnvName == env) & (df.Partial == partial)]
+
+            ax.set_xlim(0, 200)
+
+            env_data_filtered = env_data[np.isfinite(env_data["Smoothed"])]
+
+            y_min = env_data_filtered["Smoothed"].min()
+            y_max = env_data_filtered["Smoothed"].max()
+
+            ax.set_ylim(y_min - 0.05 * (y_max - y_min), y_max + 0.05 * (y_max - y_min))
+
+            ax.text(
+                1.0,
+                -0.1,
+                f"{max_step:.0e}".replace("+", "").replace("0", ""),
+                transform=ax.transAxes,
+                ha="right",
+                va="top",
+                fontsize=8,
+                color="#666666",
+                bbox=dict(facecolor="white", alpha=0.8, edgecolor="none", pad=2),
+            )
+
+            for alg, color in zip(algorithms, palette):
+                alg_data = env_data[env_data.Algorithm == alg]
+                if not alg_data.empty:
+                    # Plot smoothed returns
+                    # ax.plot(
+                    #     alg_data['StepsNormalized'],
+                    #     alg_data['Smoothed'],
+                    #     color=color,
+                    #     linewidth=2.5,
+                    #     alpha=0.9,
+                    #     label=alg,
+                    #     solid_capstyle='round',
+                    #     zorder=5
+                    # )
+
+                    # Plot cumulative maximum
+                    ax.plot(
+                        alg_data["StepsNormalized"],
+                        alg_data["Cummax"],
+                        color=color,
+                        linewidth=2.5,
+                        alpha=0.9,
+                        label=alg,
+                        solid_capstyle="round",
+                        zorder=5,
+                    )
+
+                    ax.fill_between(
+                        alg_data["StepsNormalized"],
+                        alg_data["Lower"],
+                        alg_data["Upper"],
+                        color=color,
+                        alpha=0.2,
+                        linewidth=0,
+                        edgecolor=None,
+                        zorder=2,
+                    )
+
+            ax.xaxis.set_major_locator(plt.MultipleLocator(50))
+            ax.yaxis.set_major_locator(plt.AutoLocator())
+            ax.set_ylabel("Episodic Return", **AXIS_FONT)
+            ax.tick_params(**TICK_FONT)
+
+            ax.set_title(
+                f"{env} ({'Partial' if partial=='True' else 'Full'})",
+                fontsize=10,
+                pad=12,
+                fontweight="semibold",
+            )
+
+            ax.grid(True, alpha=0.8, linestyle="-", linewidth=0.8)
+
+        handles, labels = ax.get_legend_handles_labels()
+        fig.legend(
+            handles,
+            labels,
+            loc="upper center",
+            ncol=min(4, len(algorithms)),
+            bbox_to_anchor=(0.5, 1.02),
+            frameon=True,
+            framealpha=0.95,
+            edgecolor="#DDDDDD",
+            title="Algorithm Types",
+            title_fontsize=9,
+            fontsize=8,
+        )
+
+        plt.savefig(
+            "{}.pdf".format(name), dpi=300, bbox_inches="tight", facecolor="white"
+        )
+        plt.close()
+
+    plot_comparative_curves(final_df, name)
+
+
+for i in range(1):
+    f(f"plot_{i}")

plotting/plot_twins_returns_curve.py

@@ -0,0 +1,482 @@
+"""
+This file to plot the partial and full curves for all algorithms in the same plot for all environments.
+"""
+
+import jax.numpy as jnp
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from jax import lax
+from scipy.interpolate import interp1d
+
+import wandb
+
+
+def f(name):
+    WINDOW_SIZE = 100
+    SIGMA = 100
+    INTERP_POINTS = 1000
+    NORMALIZING_FACTOR = 200
+
+    ENV_MAX_STEPS = {
+        "CountRecallEasy": 2e7,
+        "CountRecallMedium": 2e7,
+        "CountRecallHard": 2e7,
+        "BattleShipEasy": 2e7,
+        "BattleShipMedium": 2e7,
+        "BattleShipHard": 2e7,
+        # other environments with default max steps 1e7
+    }
+    AXIS_FONT = {"fontsize": 9, "labelpad": 8}
+    TICK_FONT = {"labelsize": 8}
+
+    api = wandb.Api()
+    runs = api.runs("bolt-um/Arcade-RLC")
+    filtered_runs = [run for run in runs if run.state == "finished"]
+    print(f"Total runs: {len(runs)}, Completed runs: {len(filtered_runs)}")
+
+    METRIC_MAPPING = {
+        "PQN": {"return_col": "returned_episode_returns", "time_col": "env_step"},
+        "PQN_RNN": {"return_col": "returned_episode_returns", "time_col": "env_step"},
+        "default": {"return_col": "episodic return", "time_col": "TOTAL_TIMESTEPS"},
+    }
+
+    def process_run(run):
+        """Process individual W&B run with dynamic max steps per environment"""
+        try:
+            config = {k: v for k, v in run.config.items() if not k.startswith("_")}
+            env_name = config.get("ENV_NAME", "UnknownEnv")
+            partial_status = str(config.get("PARTIAL", False))
+
+            if env_name in ENV_MAX_STEPS:
+                env_max_step = ENV_MAX_STEPS[env_name]
+            else:
+                env_max_step = 1e7
+
+            alg_name = config.get("ALG_NAME", "").upper()
+            memory_type = "MLP"
+            if alg_name == "PQN_RNN":
+                memory_type = config.get("MEMORY_TYPE", "Unknown").capitalize()
+
+            metric_map = METRIC_MAPPING.get(alg_name, METRIC_MAPPING["default"])
+            # history = run.history(keys=[metric_map["return_col"], metric_map["time_col"]])
+            history = list(
+                run.scan_history(
+                    keys=[metric_map["return_col"], metric_map["time_col"]]
+                )
+            )
+            history = pd.DataFrame(
+                history, columns=[metric_map["return_col"], metric_map["time_col"]]
+            )
+
+            history["true_steps"] = history[metric_map["time_col"]].clip(
+                upper=env_max_step
+            )
+            history = history.sort_values(metric_map["time_col"]).drop_duplicates(
+                subset=["true_steps"]
+            )
+
+            if len(history) < 2:
+                print(f"Skipping {run.name} due to insufficient data points")
+                return None
+
+            # Get first and last values for extrapolation
+            first_return = history[metric_map["return_col"]].iloc[0]
+            last_return = history[metric_map["return_col"]].iloc[-1]
+
+            # Create unified interpolation grid for this environment
+            unified_steps = np.linspace(0, env_max_step, INTERP_POINTS)
+            unified_steps = np.round(unified_steps, decimals=5)
+            scale_factor = NORMALIZING_FACTOR / env_max_step
+
+            # Interpolate returns to uniform grid
+            interp_func = interp1d(
+                history["true_steps"],
+                history[metric_map["return_col"]],
+                kind="linear",
+                bounds_error=False,
+                fill_value=(first_return, last_return),
+            )
+            interpolated_returns = interp_func(unified_steps)
+
+            smoothed_returns = (
+                pd.Series(interpolated_returns)
+                .ewm(span=100, adjust=False, min_periods=1)
+                .mean()
+                .values
+            )
+
+            # Compute cumulative maximum using JAX
+            cummax_returns = lax.cummax(jnp.array(smoothed_returns))
+
+            return pd.DataFrame(
+                {
+                    "Algorithm": f"{alg_name} ({memory_type})",
+                    "Return": interpolated_returns,
+                    "Smoothed Return": smoothed_returns,
+                    "Cummax Return": np.array(cummax_returns),  # Convert back to NumPy
+                    "True Steps": unified_steps,
+                    "EnvName": env_name,
+                    "Partial": partial_status,
+                    "Seed": str(config.get("SEED", 0)),
+                    "run_id": run.id,
+                    "StepsNormalized": unified_steps * scale_factor,
+                    "EnvMaxStep": env_max_step,
+                    "ScaleFactor": scale_factor,
+                }
+            )
+
+        except Exception as e:
+            print(f"Error processing {run.name}: {str(e)}")
+        return None
+
+    # Process all runs and combine data
+    # all_data = [df for run in filtered_runs if (df := process_run(run)) is not None]
+
+    # if not all_data:
+    #     print("No valid data to process")
+    #     exit()
+    # runs_df = pd.concat(all_data, ignore_index=True)
+    # runs_df.to_pickle("newdata.pkl")
+
+    runs_df = pd.read_pickle("newdata.pkl")
+
+    # Generate interpolation grid for each environment
+    interpolated_data = []
+    for (alg, env, partial), group in runs_df.groupby(
+        ["Algorithm", "EnvName", "Partial"]
+    ):
+        all_steps = group["True Steps"].unique()
+        if len(all_steps) != INTERP_POINTS:
+            print(
+                f"Alignment error in {alg}-{env}: {len(all_steps)} vs {INTERP_POINTS}"
+            )
+            continue
+
+        pivot_df = group.pivot_table(
+            index="True Steps",
+            columns=["run_id", "Partial"],
+            values="Smoothed Return",
+            aggfunc="first",
+        )
+
+        # Calculate cumulative maximum for each run
+        cummax_df = group.pivot_table(
+            index="True Steps",
+            columns=["run_id", "Partial"],
+            values="Cummax Return",
+            aggfunc="first",
+        )
+
+        # Compute mean and std for smoothed returns
+        stats_df = pd.DataFrame(
+            {
+                "Steps": pivot_df.index,
+                "Mean": pivot_df.mean(axis=1),
+                "Cummax Mean": cummax_df.mean(axis=1),  # Mean of cumulative max
+                "Std": pivot_df.std(axis=1),
+                "Count": pivot_df.count(axis=1),
+            }
+        )
+
+        # Compute lower and upper bounds for confidence interval
+        stats_df["Lower"] = stats_df["Mean"] - stats_df["Std"]
+        stats_df["Upper"] = stats_df["Mean"] + stats_df["Std"]
+
+        # Apply cummax to lower and upper bounds
+        stats_df["Lower"] = np.array(lax.cummax(jnp.array(stats_df["Lower"])))
+        stats_df["Upper"] = np.array(lax.cummax(jnp.array(stats_df["Upper"])))
+
+        # stats_df['StepsNormalized'] = stats_df['Steps'] * (NORMALIZING_FACTOR / group['EnvMaxStep'].iloc[0])
+        stats_df["StepsNormalized"] = stats_df["Steps"] / group["EnvMaxStep"].iloc[0]
+
+        interpolated_data.append(
+            pd.DataFrame(
+                {
+                    "Algorithm": alg,
+                    "EnvName": env,
+                    "Partial": partial,  # Include 'Partial' column
+                    "Steps": stats_df["Steps"],
+                    "Smoothed": stats_df["Mean"],
+                    "Cummax": stats_df["Cummax Mean"],  # Add cumulative max
+                    "Lower": stats_df["Lower"],  # Cumulative max applied to lower bound
+                    "Upper": stats_df["Upper"],  # Cumulative max applied to upper bound
+                    "StepsNormalized": stats_df["StepsNormalized"],
+                    "EnvMaxStep": group["EnvMaxStep"].iloc[0],
+                }
+            )
+        )
+
+    final_df = pd.concat(interpolated_data, ignore_index=True)
+    df_battleship = final_df[final_df["EnvName"].str.contains("BattleShip")].copy()
+
+    def plot_comparative_curves(df, name):
+        """Plot comparative curves for all environments"""
+        algorithms = df["Algorithm"].unique().tolist()
+        palette = sns.color_palette(
+            "husl", n_colors=len(algorithms)
+        )  # Use a standard palette for algorithms
+
+        # plt.style.use('seaborn-v0_8')
+
+        envs = df[["EnvName", "EnvMaxStep"]].drop_duplicates()
+        envs["BaseName"] = envs["EnvName"].apply(
+            lambda x: x.replace("Easy", "").replace("Medium", "").replace("Hard", "")
+        )
+        envs["Difficulty"] = envs["EnvName"].apply(
+            lambda x: (
+                0 if "Easy" in x else 1 if "Medium" in x else 2 if "Hard" in x else 3
+            )
+        )
+        envs = envs.sort_values(by=["BaseName", "Difficulty"]).head(2)
+        sns.set()
+        n_plots = len(envs)
+        n_cols = min(3, n_plots)
+        n_rows = int(np.ceil(n_plots / n_cols))
+        fig, axes = plt.subplots(
+            n_rows, n_cols, figsize=(16, n_rows * 4.5), sharey=True
+        )
+        # fig = plt.figure(figsize=(12, n_rows*4.5))
+        # gs = fig.add_gridspec(n_rows, n_cols, hspace=0.35, wspace=0.25,
+        # bottom=0.12, top=0.92)
+        if n_rows * n_cols == 1:
+            axes = [axes]
+        else:
+            axes = axes.flatten()
+        # axes[0].set_xticks([0.5, 1.0])
+        # axes[1].set_xticks([0.0, 0.5, 1.0])
+        for idx, (_, row) in enumerate(envs.iterrows()):
+            # ax = fig.add_subplot(gs[idx//n_cols, idx%n_cols])
+            ax = axes[idx]
+            env, max_step = row[["EnvName", "EnvMaxStep"]]
+            env_data = df[df.EnvName == env]
+            # ax.set_xlim(0, 200)
+            ax.set_xlim(0.0, 1.0)
+            env_data_filtered = env_data[np.isfinite(env_data["Smoothed"])]
+
+            y_min = env_data_filtered["Smoothed"].min()
+            y_max = env_data_filtered["Smoothed"].max()
+
+            # ax.set_ylim(y_min - 0.05*(y_max-y_min),
+            #         y_max + 0.05*(y_max-y_min))
+            ax.set_ylim(0.0, 1.0)
+            ax.set_xticks([0.0, 0.5, 1.0])
+            ax.set_yticks([0.0, 0.5, 1.0])
+            ax.tick_params(axis="x", pad=5)
+            ax.tick_params(axis="y", pad=15)
+            ax.text(
+                1.07,
+                -0.15,
+                f"{max_step:.0e}".replace("+", "").replace("0", ""),
+                transform=ax.transAxes,
+                ha="right",
+                va="top",
+                fontsize=35,
+                color="#666666",
+                bbox=dict(facecolor="white", alpha=0.8, edgecolor="none", pad=2),
+            )
+
+            for alg_idx, alg in enumerate(algorithms):
+                for partial_status in [
+                    "True",
+                    "False",
+                ]:  # Plot both Partial and Full statuses
+                    alg_data = env_data[
+                        (env_data.Algorithm == alg)
+                        & (env_data.Partial == partial_status)
+                    ]
+                    if not alg_data.empty:
+                        # Use distinct colors for partial and full
+                        if partial_status == "True":
+                            color = palette[alg_idx]
+                        else:
+                            color = sns.desaturate(palette[alg_idx], 0.5)
+
+                        line_style = (
+                            "--" if partial_status == "True" else "-"
+                        )  # Use dashed lines for Partial
+                        ax.plot(
+                            alg_data["StepsNormalized"],
+                            alg_data["Cummax"],
+                            color=color,
+                            linewidth=2.5,
+                            alpha=0.9,
+                            label=f"{alg} ({'Partial' if partial_status == 'True' else 'Full'})",
+                            linestyle=line_style,
+                            solid_capstyle="round",
+                            zorder=5,
+                        )
+
+                        ax.fill_between(
+                            alg_data["StepsNormalized"],
+                            alg_data["Lower"],
+                            alg_data["Upper"],
+                            color=color,
+                            alpha=0.2,
+                            linewidth=0,
+                            edgecolor=None,
+                            zorder=2,
+                        )
+
+            ax.set_xlabel("Env Steps", fontsize=35, labelpad=8)
+            # ax.set_ylabel("Episodic Return", fontsize=20)
+            ax.tick_params(labelsize=30)
+            ax.set_title(f"{env}", fontsize=35, pad=12, fontweight="semibold")
+
+            ax.grid(True, alpha=0.8, linestyle="-", linewidth=0.8)
+        fig.text(
+            0.04, 0.5, "Episodic Return", va="center", rotation="vertical", fontsize=35
+        )
+        # handles, labels = ax.get_legend_handles_labels()
+        # fig.legend(handles, labels,
+        #         loc='upper center',
+        #         ncol=min(4, len(algorithms)),
+        #         bbox_to_anchor=(0.5, 1.02),
+        #         frameon=True,
+        #         framealpha=0.95,
+        #         edgecolor='#DDDDDD',
+        #         title="Algorithm Types",
+        #         title_fontsize=9,
+        #         fontsize=8)
+
+        plt.savefig(
+            "{}.pdf".format(name), dpi=300, bbox_inches="tight", facecolor="white"
+        )
+        # plt.show()
+        plt.close()
+
+    # plot_comparative_curves(final_df, name)
+    def plot_env_curves(df, name):
+        """Plot separate curves per environment and save a separate legend PDF."""
+        algorithms = df["Algorithm"].unique().tolist()
+        palette = sns.color_palette("husl", n_colors=len(algorithms))
+        sns.set()
+        # Group environments (sorting by base name and difficulty)
+        envs = df[["EnvName", "EnvMaxStep"]].drop_duplicates()
+        envs["BaseName"] = envs["EnvName"].apply(
+            lambda x: x.replace("Easy", "").replace("Medium", "").replace("Hard", "")
+        )
+        envs["Difficulty"] = envs["EnvName"].apply(
+            lambda x: (
+                0 if "Easy" in x else 1 if "Medium" in x else 2 if "Hard" in x else 3
+            )
+        )
+        envs = envs.sort_values(by=["BaseName", "Difficulty"])
+
+        # Prepare storage for legend handles
+        legend_handles = []
+        legend_labels = []
+
+        # Loop over each environment and create a separate figure/pdf
+        for idx, row in envs.iterrows():
+            env = row["EnvName"]
+            max_step = row["EnvMaxStep"]
+            fig, ax = plt.subplots(figsize=(6, 4))
+            # ax.set_xlim(0, 200)
+            ax.set_xlim(0, 1)
+
+            env_data = df[df.EnvName == env]
+            env_data_filtered = env_data[np.isfinite(env_data["Smoothed"])]
+            y_min = env_data_filtered["Smoothed"].min()
+            y_max = env_data_filtered["Smoothed"].max()
+            ax.set_ylim(y_min - 0.1 * (y_max - y_min), y_max + 0.1 * (y_max - y_min))
+            # ax.set_ylim(0.0, 1.0)
+            ax.text(
+                1.05,
+                -0.15,
+                f"{max_step:.0e}".replace("+", "").replace("0", ""),
+                transform=ax.transAxes,
+                ha="right",
+                va="top",
+                fontsize=20,
+                color="#666666",
+                bbox=dict(facecolor="white", alpha=0.8, edgecolor="none", pad=2),
+            )
+
+            # Plot curves per algorithm and partial status
+            for alg_idx, alg in enumerate(algorithms):
+                for partial_status in ["True", "False"]:
+                    alg_data = env_data[
+                        (env_data.Algorithm == alg)
+                        & (env_data.Partial == partial_status)
+                    ]
+                    if not alg_data.empty:
+                        # Choose line color and style based on partial status
+                        color = (
+                            palette[alg_idx]
+                            if partial_status == "True"
+                            else sns.desaturate(palette[alg_idx], 0.5)
+                        )
+                        line_style = "--" if partial_status == "True" else "-"
+
+                        (line,) = ax.plot(
+                            alg_data["StepsNormalized"],
+                            alg_data["Cummax"],
+                            color=color,
+                            linewidth=2.5,
+                            alpha=0.9,
+                            linestyle=line_style,
+                            solid_capstyle="round",
+                            zorder=5,
+                        )
+
+                        label = (
+                            f"{alg} ({'Partial' if partial_status=='True' else 'Full'})"
+                        )
+                        # Add handle & label once (global legend)
+                        if label not in legend_labels:
+                            legend_handles.append(line)
+                            legend_labels.append(label)
+
+                        ax.fill_between(
+                            alg_data["StepsNormalized"],
+                            alg_data["Lower"],
+                            alg_data["Upper"],
+                            color=color,
+                            alpha=0.2,
+                            linewidth=0,
+                            edgecolor=None,
+                            zorder=2,
+                        )
+
+            ax.set_xlabel("Env Steps", fontsize=20, labelpad=8)
+            ax.set_ylabel("Episodic Return", fontsize=20, labelpad=8)
+            ax.set_title(env, fontsize=20, pad=12, fontweight="semibold")
+            ax.tick_params(labelsize=20)
+            ax.grid(True, alpha=0.8, linestyle="-", linewidth=0.8)
+
+            # Save individual environment figure as its own pdf
+            fig.savefig(
+                f"{env}_{name}_curve.pdf",
+                dpi=300,
+                bbox_inches="tight",
+                facecolor="white",
+            )
+            plt.close(fig)
+
+        # Create separate figure just for the legend and save it
+        # fig_legend = plt.figure(figsize=(8, 1))
+        # legend = fig_legend.legend(
+        #     legend_handles, legend_labels,
+        #     loc='center',
+        #     ncol=min(4, len(legend_handles)),
+        #     frameon=True,
+        #     framealpha=0.95,
+        #     edgecolor='#ffffff',
+        #     title="",
+        #     title_fontsize=9,
+        #     fontsize=20
+        # )
+        # # Remove axes for legend figure
+        # fig_legend.canvas.draw()
+        # fig_legend.savefig(f"legend.pdf", dpi=300, bbox_inches='tight', facecolor='white')
+        # plt.close(fig_legend)
+
+    # plot_env_curves(final_df, name)
+    plot_comparative_curves(df_battleship, name)
+
+
+for i in range(1):
+    f(f"plot_PartialCompare{i}")
+    print(f"plot_PartialCompare{i} done")

plotting/plottable.py

@@ -0,0 +1,207 @@
+"""
+This file is to plot the MDP and POMDP results separately.
+"""
+
+import jax.numpy as jnp  # Import JAX
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from jax import lax  # Import lax for cummax
+from scipy.interpolate import interp1d
+
+import wandb
+
+
+def f(name):
+    WINDOW_SIZE = 100
+    SIGMA = 100
+    INTERP_POINTS = 1000
+    NORMALIZING_FACTOR = 200
+
+    ENV_MAX_STEPS = {
+        "CountRecallEasy": 2e7,
+        "CountRecallMedium": 2e7,
+        "CountRecallHard": 2e7,
+        "BattleShipEasy": 2e7,
+        "BattleShipMedium": 2e7,
+        "BattleShipHard": 2e7,
+        # other environments with default max steps 1e7
+    }
+    AXIS_FONT = {"fontsize": 9, "labelpad": 8}
+    TICK_FONT = {"labelsize": 8}
+
+    api = wandb.Api()
+    runs = api.runs("bolt-um/Arcade-RLC")
+    filtered_runs = [run for run in runs if run.state == "finished"]
+    print(f"Total runs: {len(runs)}, Completed runs: {len(filtered_runs)}")
+
+    METRIC_MAPPING = {
+        "PQN": {"return_col": "returned_episode_returns", "time_col": "env_step"},
+        "PQN_RNN": {"return_col": "returned_episode_returns", "time_col": "env_step"},
+        "default": {"return_col": "episodic return", "time_col": "TOTAL_TIMESTEPS"},
+    }
+
+    def process_run(run):
+        """Process individual W&B run with dynamic max steps per environment"""
+        try:
+            config = {k: v for k, v in run.config.items() if not k.startswith("_")}
+            env_name = config.get("ENV_NAME", "UnknownEnv")
+            partial_status = str(config.get("PARTIAL", False))
+
+            if env_name in ENV_MAX_STEPS:
+                env_max_step = ENV_MAX_STEPS[env_name]
+            else:
+                env_max_step = 1e7
+
+            alg_name = config.get("ALG_NAME", "").upper()
+            memory_type = "MLP"
+            if alg_name == "PQN_RNN":
+                memory_type = config.get("MEMORY_TYPE", "Unknown").capitalize()
+
+            metric_map = METRIC_MAPPING.get(alg_name, METRIC_MAPPING["default"])
+            # history = run.scan_history(keys=[metric_map["return_col"], metric_map["time_col"]])
+            history = list(
+                run.scan_history(
+                    keys=[metric_map["return_col"], metric_map["time_col"]]
+                )
+            )
+            history = pd.DataFrame(
+                history, columns=[metric_map["return_col"], metric_map["time_col"]]
+            )
+
+            history["true_steps"] = history[metric_map["time_col"]].clip(
+                upper=env_max_step
+            )
+            history = history.sort_values(metric_map["time_col"]).drop_duplicates(
+                subset=["true_steps"]
+            )
+
+            if len(history) < 2:
+                print(f"Skipping {run.name} due to insufficient data points")
+                return None
+
+            # Get first and last values for extrapolation
+            first_return = history[metric_map["return_col"]].iloc[0]
+            last_return = history[metric_map["return_col"]].iloc[-1]
+
+            # Create unified interpolation grid for this environment
+            unified_steps = np.linspace(0, env_max_step, INTERP_POINTS)
+            unified_steps = np.round(unified_steps, decimals=5)
+            scale_factor = NORMALIZING_FACTOR / env_max_step
+
+            # Interpolate returns to uniform grid
+            interp_func = interp1d(
+                history["true_steps"],
+                history[metric_map["return_col"]],
+                kind="linear",
+                bounds_error=False,
+                fill_value=(first_return, last_return),
+            )
+            interpolated_returns = interp_func(unified_steps)
+
+            smoothed_returns = (
+                pd.Series(interpolated_returns)
+                .ewm(span=100, adjust=False, min_periods=1)
+                .mean()
+                .values
+            )
+            # smoothed_returns = pd.Series(interpolated_returns).rolling(window=WINDOW_SIZE, min_periods=1).mean().values
+
+            # Compute cumulative maximum using JAX
+            cummax_returns = lax.cummax(jnp.array(smoothed_returns))
+
+            return pd.DataFrame(
+                {
+                    "Algorithm": f"{alg_name} ({memory_type})",
+                    "Return": interpolated_returns,
+                    "Smoothed Return": smoothed_returns,
+                    "Cummax Return": np.array(cummax_returns),  # Convert back to NumPy
+                    "True Steps": unified_steps,
+                    "EnvName": env_name,
+                    "Partial": partial_status,
+                    "Seed": str(config.get("SEED", 0)),
+                    "run_id": run.id,
+                    "StepsNormalized": unified_steps * scale_factor,
+                    "EnvMaxStep": env_max_step,
+                    "ScaleFactor": scale_factor,
+                }
+            )
+
+        except Exception as e:
+            print(f"Error processing {run.name}: {str(e)}")
+        return None
+
+    # # Process all runs and combine data
+    # all_data = [df for run in filtered_runs if (df := process_run(run)) is not None]
+    # if not all_data:
+    #     print("No valid data to process")
+    #     exit()
+    # runs_df = pd.concat(all_data, ignore_index=True)
+    # # save the data
+    # runs_df.to_csv("data.csv")
+
+    # load the data
+    runs_df = pd.read_csv("F:/desktop/env_group.csv")
+
+    # runs_df['FinalReturn'] = runs_df['Cummax Return'].astype(float)
+
+    # # First aggregate across seeds within each environment for each model and Partial status:
+    # # For each (Algorithm, Partial, EnvName) group, take the maximum final return across seeds.
+    # seedgroup = runs_df.groupby(['Algorithm', 'Partial', 'EnvName', 'run_id', 'Seed'])['FinalReturn'].max().reset_index()
+
+    # seedgroup.to_csv("seedgroup.csv")
+    # env_group = seedgroup.groupby(['Algorithm', 'Partial', 'EnvName'])['FinalReturn'].agg(['mean', 'std']).reset_index()
+    # # max for each seed then aggregate
+
+    # # env_group.to_csv("env_group.csv")
+
+    # # Now aggregate across the environments and difficults: compute mean and std for each (Algorithm, Partial)
+    # model_group = env_group.groupby(['Algorithm', 'Partial']).agg(
+    #     mean=('mean', 'mean'),
+    #     std=('std', 'mean')
+    # ).reset_index()
+    # # model_group.to_csv("model_group.csv")
+
+    # Pivot the table so that rows = Model and columns for Partial outcomes.
+    # This will produce MultiIndex columns; then we rename them.
+    pivot = {}
+    for algo, group in runs_df.groupby("Algorithm"):
+        table = group.pivot(index="EnvName", columns="Partial", values=["mean", "std"])
+        pivot[algo] = table
+        # Rename columns so that "False" becomes "MDP" and "True" becomes "POMDP".
+        table.columns = table.columns.map(
+            lambda x: (
+                "MDP"
+                if (x[0] == "mean" and str(x[1]) == "False")
+                else (
+                    "POMDP"
+                    if (x[0] == "mean" and str(x[1]) == "True")
+                    else (
+                        "MDP_std"
+                        if (x[0] == "std" and str(x[1]) == "False")
+                        else (
+                            "POMDP_std"
+                            if (x[0] == "std" and str(x[1]) == "True")
+                            else f"{x[0]}_{x[1]}"
+                        )
+                    )
+                )
+            )
+        )
+
+        # Compute the overall performance (MDP+POMDP) for the mean as the average of the two
+        table["MDP+POMDP"] = table[["MDP", "POMDP"]].mean(axis=1)
+
+        # Optionally, compute a combined variance (average the variances, here approximated via std)
+        table["MDP+POMDP_std"] = table[["MDP_std", "POMDP_std"]].mean(axis=1)
+    for algo, table in pivot.items():
+        print(f"\n{algo}")
+        print(table)
+        # Print or save the table
+        # print(table)
+        table.to_csv(f"{algo}.csv", index=True)
+
+
+for i in range(1):
+    f(f"plot_{i}")

plotting/rlcgrad.py

@@ -0,0 +1,222 @@
+"""
+This file to plot the partial and full curves for all algorithms in the same plot for all environments.
+"""
+
+import jax.numpy as jnp
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from jax import lax
+from scipy.interpolate import interp1d
+
+import wandb
+
+
+def f(name):
+    WINDOW_SIZE = 100
+    SIGMA = 100
+    INTERP_POINTS = 1000
+    NORMALIZING_FACTOR = 200
+
+    ENV_MAX_STEPS = {
+        "CountRecallEasy": 1e8,
+        "CountRecallMedium": 1e8,
+        "CountRecallHard": 1e8,
+        "BattleShipEasy": 1e8,
+        "BattleShipMedium": 1e8,
+        "BattleShipHard": 1e8,
+        # other environments with default max steps 1e7
+    }
+    AXIS_FONT = {"fontsize": 9, "labelpad": 8}
+    TICK_FONT = {"labelsize": 8}
+
+    api = wandb.Api()
+    runs = api.runs("bolt-um/Arcade-RLC-Grad")
+    filtered_runs = [run for run in runs if run.state == "finished"]
+    print(f"Total runs: {len(runs)}, Completed runs: {len(filtered_runs)}")
+
+    METRIC_MAPPING = {
+        "PQN": {"return_col": "returned_episode_returns", "time_col": "env_step"},
+        "PQN_RNN": {"return_col": "returned_episode_returns", "time_col": "env_step"},
+        "default": {"return_col": "episodic return", "time_col": "TOTAL_TIMESTEPS"},
+    }
+
+    def process_run(run):
+        """Process individual W&B run with dynamic max steps per environment"""
+        try:
+            config = {k: v for k, v in run.config.items() if not k.startswith("_")}
+            env_name = config.get("ENV_NAME", "UnknownEnv")
+            partial_status = str(config.get("PARTIAL", False))
+
+            if env_name in ENV_MAX_STEPS:
+                env_max_step = ENV_MAX_STEPS[env_name]
+            else:
+                env_max_step = 1e8
+
+            alg_name = config.get("ALG_NAME", "").upper()
+            memory_type = "MLP"
+            if alg_name == "PQN_RNN":
+                memory_type = config.get("MEMORY_TYPE", "Unknown").capitalize()
+
+            metric_map = METRIC_MAPPING.get(alg_name, METRIC_MAPPING["default"])
+            # history = run.history(keys=[metric_map["return_col"], metric_map["time_col"]])
+            history = list(
+                run.scan_history(
+                    keys=[metric_map["return_col"], metric_map["time_col"]]
+                )
+            )
+            history = pd.DataFrame(
+                history, columns=[metric_map["return_col"], metric_map["time_col"]]
+            )
+
+            history["true_steps"] = history[metric_map["time_col"]].clip(
+                upper=env_max_step
+            )
+            history = history.sort_values(metric_map["time_col"]).drop_duplicates(
+                subset=["true_steps"]
+            )
+
+            if len(history) < 2:
+                print(f"Skipping {run.name} due to insufficient data points")
+                return None
+
+            # Get first and last values for extrapolation
+            first_return = history[metric_map["return_col"]].iloc[0]
+            last_return = history[metric_map["return_col"]].iloc[-1]
+
+            # Create unified interpolation grid for this environment
+            unified_steps = np.linspace(0, env_max_step, INTERP_POINTS)
+            unified_steps = np.round(unified_steps, decimals=5)
+            scale_factor = NORMALIZING_FACTOR / env_max_step
+
+            # Interpolate returns to uniform grid
+            interp_func = interp1d(
+                history["true_steps"],
+                history[metric_map["return_col"]],
+                kind="linear",
+                bounds_error=False,
+                fill_value=(first_return, last_return),
+            )
+            interpolated_returns = interp_func(unified_steps)
+
+            smoothed_returns = (
+                pd.Series(interpolated_returns)
+                .ewm(span=100, adjust=False, min_periods=1)
+                .mean()
+                .values
+            )
+
+            # Compute cumulative maximum using JAX
+            cummax_returns = lax.cummax(jnp.array(smoothed_returns))
+
+            return pd.DataFrame(
+                {
+                    "Algorithm": f"{alg_name} ({memory_type})",
+                    "Return": interpolated_returns,
+                    "Smoothed Return": smoothed_returns,
+                    "Cummax Return": np.array(cummax_returns),  # Convert back to NumPy
+                    "True Steps": unified_steps,
+                    "EnvName": env_name,
+                    "Partial": partial_status,
+                    "Seed": str(config.get("SEED", 0)),
+                    "run_id": run.id,
+                    "StepsNormalized": unified_steps / env_max_step,
+                    "EnvMaxStep": env_max_step,
+                    "ScaleFactor": scale_factor,
+                }
+            )
+
+        except Exception as e:
+            print(f"Error processing {run.name}: {str(e)}")
+        return None
+
+    # Process all runs and combine data
+    # all_data = [df for run in filtered_runs if (df := process_run(run)) is not None]
+
+    # if not all_data:
+    #     print("No valid data to process")
+    #     exit()
+    # runs_df = pd.concat(all_data, ignore_index=True)
+    # runs_df.to_pickle("rlcgrad.pkl")
+
+    runs_df = pd.read_pickle("rlcgrad.pkl")
+
+    def plot_comparative_curves(runs_df, name):
+        """Plot comparative curves for all environments in a single plot"""
+        runs_df["EnvBaseName"] = runs_df["EnvName"].apply(
+            lambda x: x.replace("Easy", "").replace("Medium", "").replace("Hard", "")
+        )
+
+        envs = runs_df["EnvBaseName"].unique()
+
+        palette = sns.color_palette("husl", len(envs))
+        env_color_map = dict(zip(envs, palette))
+
+        partial_map = {"True": "POMDP", "False": "MDP"}
+        max_step = 1e8
+        plt.figure(figsize=(12, 7))
+        sns.set()
+        plt.text(
+            1,
+            -0.15,
+            f"{max_step:.0e}".replace("+", "").replace("0", ""),
+            transform=plt.gca().transAxes,
+            ha="right",
+            va="top",
+            fontsize=35,
+            color="#666666",
+            bbox=dict(facecolor="white", alpha=0.8, edgecolor="none", pad=2),
+        )
+
+        pomdp_handles = []
+        pomdp_labels = []
+        mdp_handles = []
+        mdp_labels = []
+        for env_base in envs:
+            for partial_status in ["False", "True"]:
+                data = runs_df[
+                    (runs_df["EnvBaseName"] == env_base)
+                    & (runs_df["Partial"] == partial_status)
+                ]
+                if not data.empty:
+                    color = env_color_map[env_base]
+                    line_style = "--" if partial_status == "True" else "-"
+                    label = f"{env_base} - {partial_map[partial_status]}"
+
+                    line = plt.plot(
+                        data["StepsNormalized"],
+                        data["Cummax Return"],
+                        color=color,
+                        linewidth=2.5,
+                        linestyle=line_style,
+                        label=label,
+                    )[0]
+                    if partial_status == "True":
+                        pomdp_handles.append(line)
+                        pomdp_labels.append(label)
+                    else:
+                        mdp_handles.append(line)
+                        mdp_labels.append(label)
+
+        plt.xlabel("Env Steps", fontsize=35)
+        plt.ylabel("Episodic Return", fontsize=35)
+        plt.tick_params(axis="both", which="major", labelsize=35)
+        plt.grid(True, alpha=0.5)
+
+        handles = mdp_handles + pomdp_handles
+        labels = mdp_labels + pomdp_labels
+        plt.legend(handles, labels, loc="best", fontsize=22, ncol=2)
+
+        plt.title("LRU", fontsize=35, pad=12, fontweight="semibold")
+        plt.tight_layout()
+        plt.savefig(
+            "{}.pdf".format(name), dpi=300, bbox_inches="tight", facecolor="white"
+        )
+        plt.close()
+
+    plot_comparative_curves(runs_df, name)
+
+
+for i in range(1):
+    f(f"rlcgrad{i}")

plotting/run_multi_seed_analysis.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import argparse
+import os
+
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+import numpy as np
+import pandas as pd
+
+from popgym_arcade.baselines.model.builder import QNetworkRNN
+from popgym_arcade.baselines.utils import get_terminal_saliency_maps
+
+
+def run_multiple_seeds_and_save_csv(config, seeds, max_steps=200, output_csv=None):
+    """
+    Run saliency analysis on multiple seeds and save the results in a CSV file.
+
+    Args:
+        config: Configuration dictionary
+        seeds: List of seeds to run
+        max_steps: Maximum number of steps for each episode
+        output_csv: Path to save the CSV file (default: auto-generated based on config)
+
+    Returns:
+        Path to the saved CSV file
+    """
+    # Create a default output path if none provided
+    if output_csv is None:
+        output_csv = f'saliency_results_{config["MEMORY_TYPE"]}_{config["ENV_NAME"]}_Partial={config["PARTIAL"]}.csv'
+
+    # List to store results
+    all_results = []
+
+    # Store saliency distributions for each seed
+    for seed_value in seeds:
+        print(f"Processing seed {seed_value}...")
+
+        # Update config with current seed
+        config["SEED"] = seed_value
+
+        # Create the model path for this seed
+        model_path = f"pkls_gradients/PQN_RNN_{config['MEMORY_TYPE']}_{config['ENV_NAME']}_model_Partial={config['PARTIAL']}_SEED={config['MODEL_SEED']}.pkl"
+
+        # Initialize random key for this seed
+        rng = jax.random.PRNGKey(seed_value)
+
+        # Initialize and load the model
+        network = QNetworkRNN(
+            rng, rnn_type=config["MEMORY_TYPE"], obs_size=config["OBS_SIZE"]
+        )
+        # try:
+        model = eqx.tree_deserialise_leaves(model_path, network)
+
+        # Define path for saving the distribution for this seed
+        dist_save_path = f'dist_{config["MEMORY_TYPE"]}_{config["ENV_NAME"]}_Partial={config["PARTIAL"]}_SEED={seed_value}.npy'
+
+        # Run terminal saliency analysis
+        grads_obs = get_terminal_saliency_maps(
+            rng,
+            model,
+            config,
+        )
+
+        # print(grads_obs.shape)
+        # grads_obs = grads_obs.squeeze(1)
+
+        grads_obs = jnp.abs(grads_obs).sum(axis=(1, 2, 3))
+        dist = grads_obs / grads_obs.sum()
+        print(dist.sum())
+        # Convert JAX array to numpy for DataFrame
+        dist_np = np.array(dist)
+
+        # Create result dictionary
+        result = {
+            "seed": seed_value,
+            "distribution": dist_np,
+            "length": len(dist_np),
+            "dist_path": dist_save_path,
+        }
+
+        all_results.append(result)
+        print(f"Seed {seed_value} completed. Distribution length: {len(dist_np)}")
+
+        # except Exception as e:
+        #     raise e
+        #     # print(f"Error processing seed {seed_value}: {e}")
+
+    # Process results for CSV format
+    csv_data = []
+    max_length = max([r["length"] for r in all_results]) if all_results else 0
+
+    for result in all_results:
+        # Pad distribution to max length if needed
+        padded_dist = np.zeros(max_length)
+        padded_dist[: result["length"]] = result["distribution"]
+
+        # Create row data
+        row = {
+            "seed": result["seed"],
+            "length": result["length"],
+            "dist_path": result["dist_path"],
+        }
+
+        # Add each position value as a separate column
+        for i in range(max_length):
+            norm_pos = i / max_length if max_length > 0 else 0
+            row[f"pos_{norm_pos:.3f}"] = padded_dist[i]
+
+        csv_data.append(row)
+
+    # Create DataFrame and save to CSV
+    df = pd.DataFrame(csv_data)
+    df.to_csv(output_csv, index=False)
+    print(f"Results saved to {output_csv}")
+
+    return output_csv

popgym_arcade/__init__.py

@@ -0,0 +1 @@
+from popgym_arcade.registration import make

popgym_arcade/baselines/model/__init__.py

@@ -0,0 +1,10 @@
+from popgym_arcade.baselines.model.builder import (
+    ActorCritic,
+    ActorCriticRNN,
+    QNetwork,
+    QNetworkRNN,
+)
+from popgym_arcade.baselines.model.memorax import (
+    add_batch_dim,
+    get_residual_memory_model,
+)

popgym_arcade/baselines/model/builder.py

@@ -0,0 +1,706 @@
+from typing import Tuple
+
+import equinox as eqx
+import equinox.nn as nn
+import jax
+import jax.numpy as jnp
+from distreqx import distributions
+from jaxtyping import Array, PRNGKeyArray
+
+from popgym_arcade.baselines.model.memorax import get_residual_memory_model
+
+
+class ActorCritic(eqx.Module):
+    action_dim: int = 5
+    actor_cnn: nn.Sequential
+    actor_trunk: nn.Sequential
+    critic_cnn: nn.Sequential
+    critic_trunk: nn.Sequential
+
+    def __init__(self, key: PRNGKeyArray, obs_size: int):
+        key_array = jax.random.split(key, 14)
+        if obs_size == 256:
+            self.actor_cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=7,
+                        stride=2,
+                        key=key_array[0],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[1],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[2],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[3],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+            self.critic_cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=7,
+                        stride=2,
+                        key=key_array[7],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[8],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[9],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[10],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+        else:
+            self.actor_cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=5,
+                        stride=2,
+                        key=key_array[0],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[1],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[2],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=3, stride=1),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=1,
+                        stride=1,
+                        key=key_array[3],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+            self.critic_cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=5,
+                        stride=2,
+                        key=key_array[0],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[1],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[2],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=3, stride=1),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=1,
+                        stride=1,
+                        key=key_array[3],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+        self.actor_trunk = nn.Sequential(
+            [
+                nn.Linear(in_features=512, out_features=256, key=key_array[4]),
+                nn.LayerNorm(shape=256),
+                nn.Lambda(jax.nn.leaky_relu),
+                nn.Linear(in_features=256, out_features=256, key=key_array[5]),
+                nn.LayerNorm(shape=256),
+                nn.Lambda(jax.nn.leaky_relu),
+                nn.Linear(
+                    in_features=256, out_features=self.action_dim, key=key_array[6]
+                ),
+            ]
+        )
+
+        self.critic_trunk = nn.Sequential(
+            [
+                nn.Linear(in_features=512, out_features=256, key=key_array[11]),
+                nn.LayerNorm(shape=256),
+                nn.Lambda(jax.nn.leaky_relu),
+                nn.Linear(in_features=256, out_features=256, key=key_array[12]),
+                nn.LayerNorm(shape=256),
+                nn.Lambda(jax.nn.leaky_relu),
+                nn.Linear(in_features=256, out_features=1, key=key_array[13]),
+            ]
+        )
+
+    def __call__(self, x: Array) -> Tuple:
+        """Expects image in [0, 255]"""
+        x = x.transpose((0, 3, 1, 2)) / 255.0
+        actor_embedding = eqx.filter_vmap(self.actor_cnn)(x)
+        critic_embedding = eqx.filter_vmap(self.critic_cnn)(x)
+
+        actor_embedding = actor_embedding.reshape(actor_embedding.shape[0], -1)
+        critic_embedding = critic_embedding.reshape(critic_embedding.shape[0], -1)
+
+        actor_mean = eqx.filter_vmap(self.actor_trunk)(actor_embedding)
+        critic = eqx.filter_vmap(self.critic_trunk)(critic_embedding)
+        pi = distributions.Categorical(logits=actor_mean)
+        return pi, jnp.squeeze(critic, axis=-1)
+
+
+class ActorCriticRNN(eqx.Module):
+    action_dim: int = 5
+    actor_cnn: nn.Sequential
+    actor_rnn: eqx.Module
+    actor_trunk: nn.Sequential
+    critic_cnn: nn.Sequential
+    critic_rnn: eqx.Module
+    critic_trunk: nn.Sequential
+
+    def __init__(self, key: PRNGKeyArray, obs_size: int, rnn_type: str = "lru"):
+        key_array = jax.random.split(key, 14)
+        if obs_size == 256:
+            self.actor_cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=7,
+                        stride=2,
+                        key=key_array[0],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[1],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[2],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[3],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+            self.critic_cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=7,
+                        stride=2,
+                        key=key_array[6],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[7],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[8],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[9],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+        else:
+            self.actor_cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=5,
+                        stride=2,
+                        key=key_array[0],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[1],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[2],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=3, stride=1),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=1,
+                        stride=1,
+                        key=key_array[3],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+            self.critic_cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=5,
+                        stride=2,
+                        key=key_array[0],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[1],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=key_array[2],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=3, stride=1),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=1,
+                        stride=1,
+                        key=key_array[3],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+        self.actor_rnn = get_residual_memory_model(
+            input=512,
+            hidden=512,
+            output=256,
+            num_layers=2,
+            rnn_type=rnn_type,
+            key=key_array[4],
+        )
+        self.actor_trunk = nn.Sequential(
+            [
+                nn.Linear(in_features=256, out_features=256, key=key_array[5]),
+                nn.LayerNorm(shape=256),
+                nn.Lambda(jax.nn.leaky_relu),
+                nn.Linear(
+                    in_features=256, out_features=self.action_dim, key=key_array[12]
+                ),
+            ]
+        )
+
+        self.critic_rnn = get_residual_memory_model(
+            input=512,
+            hidden=512,
+            output=256,
+            num_layers=1,
+            rnn_type=rnn_type,
+            key=key_array[10],
+        )
+        self.critic_trunk = nn.Sequential(
+            [
+                nn.Linear(in_features=256, out_features=256, key=key_array[5]),
+                nn.LayerNorm(shape=256),
+                nn.Lambda(jax.nn.leaky_relu),
+                nn.Linear(in_features=256, out_features=1, key=key_array[13]),
+            ]
+        )
+
+    def __call__(self, actor_state, critic_state, x):
+        """Expects image in [0, 255]"""
+        inputs, dones = x
+        inputs = inputs.transpose((0, 1, 4, 2, 3)) / 255.0
+        actor_embedding = eqx.filter_vmap(eqx.filter_vmap(self.actor_cnn))(inputs)
+        critic_embedding = eqx.filter_vmap(eqx.filter_vmap(self.critic_cnn))(inputs)
+
+        actor_embedding = actor_embedding.reshape(
+            (actor_embedding.shape[0], actor_embedding.shape[1], -1)
+        )
+        critic_embedding = critic_embedding.reshape(
+            (critic_embedding.shape[0], critic_embedding.shape[1], -1)
+        )
+        actor_rnn_in = (actor_embedding, dones)
+        critic_rnn_in = (critic_embedding, dones)
+        actor_state, actor_embedding = eqx.filter_vmap(
+            self.actor_rnn, in_axes=(0, 1), out_axes=(0, 1)
+        )(actor_state, actor_rnn_in)
+        actor_state = eqx.filter_vmap(self.actor_rnn.latest_recurrent_state, in_axes=0)(
+            actor_state
+        )
+        critic_state, critic_embedding = eqx.filter_vmap(
+            self.critic_rnn, in_axes=(0, 1), out_axes=(0, 1)
+        )(critic_state, critic_rnn_in)
+        critic_state = eqx.filter_vmap(
+            self.critic_rnn.latest_recurrent_state, in_axes=0
+        )(critic_state)
+        actor_mean = eqx.filter_vmap(eqx.filter_vmap(self.actor_trunk))(actor_embedding)
+        pi = distributions.Categorical(logits=actor_mean)
+        # pi = distrax.Categorical(logits=actor_mean)
+        critic = eqx.filter_vmap(eqx.filter_vmap(self.critic_trunk))(critic_embedding)
+        return actor_state, critic_state, pi, jnp.squeeze(critic, axis=-1)
+
+    def initialize_carry(self, key: PRNGKeyArray):
+        key_init = jax.random.split(key, 2)
+        actor_state = eqx.filter_jit(self.actor_rnn.initialize_carry)(key=key_init[0])
+        critic_state = eqx.filter_jit(self.critic_rnn.initialize_carry)(key=key_init[1])
+        return actor_state, critic_state
+
+
+class QNetwork(eqx.Module):
+    """CNN + MLP"""
+
+    action_dim: int = 5
+    cnn: nn.Sequential
+    trunk: nn.Sequential
+
+    def __init__(self, key: PRNGKeyArray, obs_size: int):
+        keys = jax.random.split(key, 9)
+        if obs_size == 256:
+            self.cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=7,
+                        stride=2,
+                        key=keys[0],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=keys[1],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=keys[2],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=3,
+                        stride=2,
+                        key=keys[3],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+        else:
+            self.cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=5,
+                        stride=2,
+                        key=keys[0],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=keys[1],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=keys[2],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=3, stride=1),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=1,
+                        stride=1,
+                        key=keys[3],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+
+        self.trunk = nn.Sequential(
+            [
+                nn.Linear(in_features=512, out_features=256, key=keys[4]),
+                nn.LayerNorm(shape=256),
+                nn.Lambda(jax.nn.leaky_relu),
+                nn.Linear(in_features=256, out_features=256, key=keys[5]),
+                nn.LayerNorm(shape=256),
+                nn.Lambda(jax.nn.leaky_relu),
+                nn.Linear(in_features=256, out_features=self.action_dim, key=keys[6]),
+            ]
+        )
+
+    def __call__(self, x: jax.Array):
+        """Expects image in [0, 255]"""
+        print(jnp.max(x), jnp.min(x))
+        x = x.transpose((0, 3, 1, 2)) / 255.0
+        print(jnp.max(x), jnp.min(x))
+        x = eqx.filter_vmap(self.cnn)(x)
+        x = x.reshape(x.shape[0], -1)
+        x = eqx.filter_vmap(self.trunk)(x)
+        return x
+
+
+class QNetworkRNN(eqx.Module):
+    """CNN + MLP"""
+
+    action_dim: int = 5
+    cnn: nn.Sequential
+    rnn: eqx.Module
+    trunk: nn.Sequential
+
+    def __init__(self, key: PRNGKeyArray, obs_size: int, rnn_type: str = "lru"):
+        keys = jax.random.split(key, 8)
+        if obs_size == 256:
+            self.cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=7,
+                        stride=2,
+                        key=keys[0],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=keys[1],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=keys[2],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=3,
+                        stride=2,
+                        key=keys[3],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+        else:
+            self.cnn = nn.Sequential(
+                [
+                    nn.Conv2d(
+                        in_channels=3,
+                        out_channels=64,
+                        kernel_size=5,
+                        stride=2,
+                        key=keys[0],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=64,
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=2,
+                        key=keys[1],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=2, stride=2),
+                    nn.Conv2d(
+                        in_channels=128,
+                        out_channels=256,
+                        kernel_size=3,
+                        stride=2,
+                        key=keys[2],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                    nn.MaxPool2d(kernel_size=3, stride=1),
+                    nn.Conv2d(
+                        in_channels=256,
+                        out_channels=512,
+                        kernel_size=1,
+                        stride=1,
+                        key=keys[3],
+                    ),
+                    nn.Lambda(jax.nn.leaky_relu),
+                ]
+            )
+        self.rnn = get_residual_memory_model(
+            input=517,
+            hidden=512,
+            output=256,
+            num_layers=2,
+            rnn_type=rnn_type,
+            key=keys[4],
+        )
+        self.trunk = nn.Sequential(
+            [nn.Linear(in_features=256, out_features=self.action_dim, key=keys[7])]
+        )
+
+    def __call__(self, hidden_state, x, done, last_action):
+        """Expects image in [0, 255]"""
+        x = x.transpose((0, 1, 4, 2, 3)) / 255.0
+        x = eqx.filter_vmap(eqx.filter_vmap(self.cnn))(x)
+
+        x = x.reshape((x.shape[0], x.shape[1], -1))
+
+        last_action = jax.nn.one_hot(last_action, self.action_dim)
+        x = jnp.concatenate([x, last_action], axis=-1)
+        rnn_in = (x, done)
+
+        hidden_state, x = eqx.filter_vmap(self.rnn, in_axes=(0, 1), out_axes=(0, 1))(
+            hidden_state, rnn_in
+        )
+        hidden_state = eqx.filter_vmap(self.rnn.latest_recurrent_state, in_axes=0)(
+            hidden_state
+        )
+
+        q_vals = eqx.filter_vmap(eqx.filter_vmap(self.trunk))(x)
+
+        return hidden_state, q_vals
+
+    def initialize_carry(self, key: PRNGKeyArray):
+        key_init = jax.random.split(key, 1)
+        hidden_state = eqx.filter_jit(self.rnn.initialize_carry)(key=key_init[0])
+        return hidden_state

popgym_arcade/baselines/model/memorax/__init__.py

@@ -0,0 +1,4 @@
+from popgym_arcade.baselines.model.memorax.train_utils import (
+    add_batch_dim,
+    get_residual_memory_model,
+)

popgym_arcade/baselines/model/memorax/gras.py

@@ -0,0 +1,106 @@
+from functools import partial
+from typing import Callable, Optional, Tuple
+
+import equinox as eqx
+import jax
+from jaxtyping import PRNGKeyArray, Shaped
+
+from popgym_arcade.baselines.model.memorax.groups import BinaryAlgebra, Module
+from popgym_arcade.baselines.model.memorax.mtypes import (
+    Input,
+    OutputEmbedding,
+    RecurrentState,
+    SingleRecurrentState,
+)
+from popgym_arcade.baselines.model.memorax.scans import semigroup_scan, set_action_scan
+
+
+class GRAS(Module):
+    r"""A Generalized Recurrent Algebraic Structure (GRAS)
+
+    Given a recurrent state and inputs, returns the corresponding recurrent states and outputs
+
+    A GRAS contains a set action or semigroup :math:`(H, \bullet)` and two maps/functions :math:`f,g`
+
+    For a semigroup, we express a GRAS via
+
+    .. math::
+
+        f: X^n \times \{0, 1\}^n \mapsto H^n
+
+        \bullet: H \times H \mapsto H
+
+        g: H^n \times X^n \{0, \1}^n \mapsto Y^n
+
+    where :math:`\bullet` may be an associative/parallel scan or sequential scan.
+
+    For a set action, the GRAS recurrent update is slightly altered
+
+    .. math::
+        f: X^n \times \{0, 1\}^n \mapsto Z^n
+
+        \bullet: H \times Z \mapsto H
+
+        g: H^n \times X^n \{0, \1}^n \mapsto Y^n
+
+    where :math:`\bullet` must be a sequential scan.
+
+    """
+
+    algebra: BinaryAlgebra
+    scan: Callable[
+        [
+            Callable[[RecurrentState, RecurrentState], RecurrentState],
+            RecurrentState,
+            RecurrentState,
+        ],
+        RecurrentState,
+    ]
+
+    def forward_map(
+        self, x: Input, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> RecurrentState:
+        """Maps inputs to the monoid space"""
+        raise NotImplementedError
+
+    def backward_map(
+        self,
+        h: RecurrentState,
+        x: Input,
+        key: Optional[Shaped[PRNGKeyArray, ""]] = None,
+    ) -> OutputEmbedding:
+        """Maps the monoid space to outputs"""
+        raise NotImplementedError
+
+    def __call__(
+        self,
+        h: SingleRecurrentState,
+        x: Input,
+        key: Optional[Shaped[PRNGKeyArray, ""]] = None,
+    ) -> Tuple[RecurrentState, OutputEmbedding]:
+        """Calls the mapping and scan functions.
+
+        You probably do not need to override this."""
+        emb, start = x
+        T = start.shape[0]
+        if key is None:
+            in_key, scan_key, out_key = (None, None, None)
+        else:
+            in_key, scan_key, out_key = jax.random.split(key, 3)
+            in_key = jax.random.split(in_key, T)
+            # scan_key = jax.random.split(scan_key, T + 1)
+            out_key = jax.random.split(out_key, T)
+        scan_input = eqx.filter_vmap(self.forward_map)(x, in_key)
+        next_h = self.scan(self.algebra, h, scan_input)
+        y = eqx.filter_vmap(self.backward_map)(next_h, x, out_key)
+        return next_h, y
+
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> SingleRecurrentState:
+        """Initialize the recurrent state for a new sequence."""
+        return self.algebra.initialize_carry(key=key)
+
+    def latest_recurrent_state(self, h: RecurrentState) -> RecurrentState:
+        """Get the latest state from a sequence of recurrent states."""
+        return jax.tree.map(lambda x: x[-1], h)

popgym_arcade/baselines/model/memorax/groups.py

@@ -0,0 +1,158 @@
+from functools import partial
+from typing import Optional, Tuple
+
+import equinox as eqx
+import jax
+import jax.numpy as jnp
+from jaxtyping import PRNGKeyArray, Shaped
+
+from popgym_arcade.baselines.model.memorax.mtypes import (
+    Input,
+    RecurrentState,
+    ResetRecurrentState,
+    StartFlag,
+)
+from popgym_arcade.baselines.model.memorax.utils import debug_shape
+
+
+class Module(eqx.Module):
+    r"""
+    The base module for memory/sequence models.
+
+    A module :math:`f` maps a recurrent state and inputs to an output recurrent state and outputs.
+    We always include a binary start flag in the inputs.
+
+    .. math::
+
+        f: H \times X^n \times \{0, 1\}^n \mapsto H^n \times Y^n
+
+
+    The start flag signifies the beginning of a new sequence. For example,
+    .. code::
+
+        [1, 2, 3, 4, 5]
+        [0, 0, 1, 0, 1]
+
+    Denotes that the input at 3 and 5 begin new sequences.
+
+    """
+
+    def __call__(self, s: RecurrentState, x: Input) -> RecurrentState:
+        raise NotImplementedError
+
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> RecurrentState:
+        raise NotImplementedError
+
+
+class BinaryAlgebra(Module):
+    r"""An binary algebraic structure (e.g., monoid, magma, group, etc) that maps two inputs to an output.
+
+    The inputs and output must belong to the same set
+
+    .. math::
+
+            f: H \times H \mapsto H
+    """
+
+    def __call__(self, carry: RecurrentState, input: RecurrentState) -> RecurrentState:
+        pass
+
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> RecurrentState:
+        raise NotImplementedError
+
+
+class SetAction(BinaryAlgebra):
+    r"""A magma, as defined in https://en.wikipedia.org/wiki/Magma_(algebra)
+
+    A Magma is a set :math:`H` and an operator :math:`\bullet` that maps two inputs to an output
+
+    .. math::
+
+        \bullet: H \times H \mapsto H
+    """
+
+    def __call__(self, carry: RecurrentState, input: RecurrentState) -> RecurrentState:
+        pass
+
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> RecurrentState:
+        raise NotImplementedError
+
+
+class Semigroup(BinaryAlgebra):
+    r"""A monoid, as defined in https://en.wikipedia.org/wiki/Monoid
+
+    A monoid is a set :math:`H`, an operator :math:`\bullet`, and an identity element :math:`e_I`. Unlike
+    the Magma, the monoid operator must be associative.
+
+    .. math::
+
+        \bullet: H \times H \mapsto H
+
+        e_I \in H
+
+        (a \bullet b) \bullet c = a \bullet (b \bullet c)
+
+        a \bullet e_I = e_I \bullet a = a
+    """
+
+    def __call__(self, carry: RecurrentState, input: RecurrentState) -> RecurrentState:
+        raise NotImplementedError
+
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> RecurrentState:
+        raise NotImplementedError
+
+
+class Resettable(BinaryAlgebra):
+    """A wrapper that resets the recurrent state upon beginning a new sequence.
+
+    You can apply this to monoids or magmas to reset the recurrent state upon a start flag.
+    """
+
+    algebra: BinaryAlgebra
+
+    def __init__(self, algebra: BinaryAlgebra):
+        self.algebra = algebra
+
+    def __call__(self, carry: ResetRecurrentState, input: ResetRecurrentState):
+        assert jax.tree.structure(carry) == jax.tree.structure(
+            input
+        ), f"Mismatched structures passed to algebra, {jax.tree.structure(carry)} and {jax.tree.structure(input)}"
+        states, prev_carry_reset_flag = carry
+        xs, start = input
+
+        def reset_state(
+            start: StartFlag,
+            current_state: RecurrentState,
+            initial_state: RecurrentState,
+        ):
+            assert initial_state.ndim == current_state.ndim
+            out = current_state * jnp.logical_not(start) + initial_state * start
+            return out
+
+        # TODO: Plumb key thru
+        initial_states = self.algebra.initialize_carry(None)
+        states = jax.tree.map(partial(reset_state, start), states, initial_states)
+        out = self.algebra(states, xs)
+        carry_reset_flag = jnp.logical_or(start, prev_carry_reset_flag)
+        to_return = out, carry_reset_flag
+        assert jax.tree.structure(carry) == jax.tree.structure(
+            to_return
+        ), f"Mismatched structures passed from algebra,\n{jax.tree.structure(carry)} and\n{jax.tree.structure(out)}"
+        assert all(
+            jax.tree.leaves(jax.tree.map(lambda x, y: x.shape == y.shape, states, out))
+        ), f"Shapes do not match\n{debug_shape(states)} and\n{debug_shape(out)}"
+
+        return to_return
+
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> RecurrentState:
+        return self.algebra.initialize_carry(key), jnp.zeros((), dtype=bool)

popgym_arcade/baselines/model/memorax/magmas/__init__.py

@@ -0,0 +1,5 @@
+from popgym_arcade.baselines.model.memorax.magmas.elman import Elman
+from popgym_arcade.baselines.model.memorax.magmas.gru import GRU
+from popgym_arcade.baselines.model.memorax.magmas.lstm import LSTM
+from popgym_arcade.baselines.model.memorax.magmas.mgu import MGU
+from popgym_arcade.baselines.model.memorax.magmas.spherical import Spherical

popgym_arcade/baselines/model/memorax/magmas/elman.py

@@ -0,0 +1,138 @@
+from typing import Callable, Optional, Tuple
+
+import jax
+import jax.numpy as jnp
+from beartype import beartype as typechecker
+from equinox import nn
+from jaxtyping import Array, Float, PRNGKeyArray, Shaped, jaxtyped
+
+from popgym_arcade.baselines.model.memorax.gras import GRAS
+from popgym_arcade.baselines.model.memorax.groups import (
+    BinaryAlgebra,
+    Resettable,
+    SetAction,
+)
+from popgym_arcade.baselines.model.memorax.mtypes import Input, StartFlag
+from popgym_arcade.baselines.model.memorax.scans import set_action_scan
+
+ElmanRecurrentState = Float[Array, "Recurrent"]
+ElmanRecurrentStateWithReset = Tuple[ElmanRecurrentState, StartFlag]
+
+
+class ElmanMagma(SetAction):
+    """
+    The Elman Magma
+
+    Paper: https://onlinelibrary.wiley.com/doi/abs/10.1207/s15516709cog1402_1.
+    """
+
+    recurrent_size: int
+    U_h: nn.Linear
+
+    def __init__(self, recurrent_size: int, key):
+        self.recurrent_size = recurrent_size
+        self.U_h = nn.Linear(recurrent_size, recurrent_size, key=key)
+
+    @jaxtyped(typechecker=typechecker)
+    def __call__(
+        self, carry: ElmanRecurrentState, input: ElmanRecurrentState
+    ) -> ElmanRecurrentState:
+        return jax.nn.tanh(self.U_h(carry) + input)
+
+    @jaxtyped(typechecker=typechecker)
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> ElmanRecurrentState:
+        return jnp.zeros((self.recurrent_size,))
+
+
+class LNElmanMagma(SetAction):
+    """
+    The Elman Recurrent Network
+
+    Paper: https://onlinelibrary.wiley.com/doi/abs/10.1207/s15516709cog1402_1.
+
+    The tanh is replaced with layernorm.
+    """
+
+    recurrent_size: int
+    U_h: nn.Linear
+    ln: nn.LayerNorm
+
+    def __init__(self, recurrent_size: int, key):
+        self.recurrent_size = recurrent_size
+        self.U_h = nn.Linear(recurrent_size, recurrent_size, key=key)
+        self.ln = nn.LayerNorm((recurrent_size,), use_bias=False, use_weight=False)
+
+    @jaxtyped(typechecker=typechecker)
+    def __call__(
+        self, carry: ElmanRecurrentState, input: Float[Array, "Recurrent"]
+    ) -> ElmanRecurrentState:
+        return self.ln(self.U_h(carry) + input)
+
+    @jaxtyped(typechecker=typechecker)
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> ElmanRecurrentState:
+        return jnp.zeros((self.recurrent_size,))
+
+
+class Elman(GRAS):
+    """
+    The Elman Recurrent Network
+
+    Paper: https://onlinelibrary.wiley.com/doi/abs/10.1207/s15516709cog1402_1.
+    """
+
+    algebra: BinaryAlgebra
+    scan: Callable[
+        [
+            Callable[
+                [ElmanRecurrentStateWithReset, ElmanRecurrentStateWithReset],
+                ElmanRecurrentStateWithReset,
+            ],
+            ElmanRecurrentStateWithReset,
+            ElmanRecurrentStateWithReset,
+        ],
+        ElmanRecurrentStateWithReset,
+    ]
+    recurrent_size: int
+    hidden_size: int
+    W_h: nn.Linear
+    W_y: nn.Linear
+
+    def __init__(self, recurrent_size, hidden_size, ln_variant=False, *, key):
+        self.recurrent_size = recurrent_size
+        self.hidden_size = hidden_size
+        keys = jax.random.split(key, 3)
+        if ln_variant:
+            self.algebra = Resettable(LNElmanMagma(recurrent_size, key=keys[0]))
+        else:
+            self.algebra = Resettable(ElmanMagma(recurrent_size, key=keys[0]))
+        self.scan = set_action_scan
+        self.W_h = nn.Linear(hidden_size, recurrent_size, use_bias=False, key=keys[1])
+        self.W_y = nn.Linear(recurrent_size, hidden_size, key=keys[2])
+
+    @jaxtyped(typechecker=typechecker)
+    def forward_map(
+        self, x: Input, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> ElmanRecurrentStateWithReset:
+        emb, start = x
+        return self.W_h(emb), start
+
+    @jaxtyped(typechecker=typechecker)
+    def backward_map(
+        self,
+        h: ElmanRecurrentStateWithReset,
+        x: Input,
+        key: Optional[Shaped[PRNGKeyArray, ""]] = None,
+    ) -> Float[Array, "{self.hidden_size}"]:
+        z, reset_flag = h
+        emb, start = x
+        return self.W_y(z)
+
+    @jaxtyped(typechecker=typechecker)
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> ElmanRecurrentStateWithReset:
+        return self.algebra.initialize_carry(key)

popgym_arcade/baselines/model/memorax/magmas/gru.py

@@ -0,0 +1,120 @@
+from typing import Callable, Optional, Tuple
+
+import jax
+import jax.numpy as jnp
+from beartype import beartype as typechecker
+from equinox import nn
+from jaxtyping import Array, Float, PRNGKeyArray, Shaped, jaxtyped
+
+from popgym_arcade.baselines.model.memorax.gras import GRAS
+from popgym_arcade.baselines.model.memorax.groups import (
+    BinaryAlgebra,
+    Resettable,
+    SetAction,
+)
+from popgym_arcade.baselines.model.memorax.mtypes import Input, StartFlag
+from popgym_arcade.baselines.model.memorax.scans import set_action_scan
+
+GRURecurrentState = Float[Array, "Recurrent"]
+GRURecurrentStateWithReset = Tuple[GRURecurrentState, StartFlag]
+
+
+class GRUMagma(SetAction):
+    """
+    The Gated Recurrent Unit Magma
+
+    Paper: https://arxiv.org/abs/1406.1078
+    """
+
+    recurrent_size: int
+    U_z: nn.Linear
+    U_r: nn.Linear
+    U_h: nn.Linear
+    W_z: nn.Linear
+    W_r: nn.Linear
+    W_h: nn.Linear
+
+    def __init__(self, recurrent_size: int, key):
+        self.recurrent_size = recurrent_size
+        keys = jax.random.split(key, 6)
+        self.U_z = nn.Linear(
+            recurrent_size, recurrent_size, use_bias=False, key=keys[0]
+        )
+        self.U_r = nn.Linear(
+            recurrent_size, recurrent_size, use_bias=False, key=keys[1]
+        )
+        self.U_h = nn.Linear(
+            recurrent_size, recurrent_size, use_bias=False, key=keys[2]
+        )
+
+        self.W_z = nn.Linear(recurrent_size, recurrent_size, key=keys[3])
+        self.W_r = nn.Linear(recurrent_size, recurrent_size, key=keys[4])
+        self.W_h = nn.Linear(recurrent_size, recurrent_size, key=keys[5])
+
+    @jaxtyped(typechecker=typechecker)
+    def __call__(
+        self, carry: GRURecurrentState, input: Float[Array, "Recurrent"]
+    ) -> GRURecurrentState:
+        z = jax.nn.sigmoid(self.W_z(input) + self.U_z(carry))
+        r = jax.nn.sigmoid(self.W_r(input) + self.U_r(carry))
+        h_hat = jax.nn.tanh(self.W_h(input) + self.U_h(r * carry))
+        out = (1 - z) * carry + z * h_hat
+        return out
+
+    @jaxtyped(typechecker=typechecker)
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> GRURecurrentState:
+        return jnp.zeros((self.recurrent_size,))
+
+
+class GRU(GRAS):
+    """
+    The Gated Recurrent Unit
+
+    Paper: https://arxiv.org/abs/1406.1078
+    """
+
+    algebra: BinaryAlgebra
+    scan: Callable[
+        [
+            Callable[
+                [GRURecurrentStateWithReset, GRURecurrentStateWithReset],
+                GRURecurrentStateWithReset,
+            ],
+            GRURecurrentStateWithReset,
+            GRURecurrentStateWithReset,
+        ],
+        GRURecurrentStateWithReset,
+    ]
+    recurrent_size: int
+
+    def __init__(self, recurrent_size, key):
+        keys = jax.random.split(key, 3)
+        self.recurrent_size = recurrent_size
+        self.algebra = Resettable(GRUMagma(recurrent_size, key=keys[0]))
+        self.scan = set_action_scan
+
+    @jaxtyped(typechecker=typechecker)
+    def forward_map(
+        self, x: Input, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> GRURecurrentStateWithReset:
+        emb, start = x
+        return emb, start
+
+    @jaxtyped(typechecker=typechecker)
+    def backward_map(
+        self,
+        h: GRURecurrentStateWithReset,
+        x: Input,
+        key: Optional[Shaped[PRNGKeyArray, ""]] = None,
+    ) -> Float[Array, "{self.recurrent_size}"]:
+        z, reset_flag = h
+        emb, start = x
+        return z
+
+    @jaxtyped(typechecker=typechecker)
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> GRURecurrentStateWithReset:
+        return self.algebra.initialize_carry(key)

popgym_arcade/baselines/model/memorax/magmas/lstm.py

@@ -0,0 +1,134 @@
+from typing import Callable, Optional, Tuple
+
+import jax
+import jax.numpy as jnp
+from beartype import beartype as typechecker
+from equinox import nn
+from jaxtyping import Array, Float, PRNGKeyArray, Shaped, jaxtyped
+
+from popgym_arcade.baselines.model.memorax.gras import GRAS
+from popgym_arcade.baselines.model.memorax.groups import (
+    BinaryAlgebra,
+    Resettable,
+    SetAction,
+)
+from popgym_arcade.baselines.model.memorax.mtypes import (
+    Input,
+    InputEmbedding,
+    StartFlag,
+)
+from popgym_arcade.baselines.model.memorax.scans import set_action_scan
+
+LSTMRecurrentState = Tuple[Float[Array, "Recurrent"], Float[Array, "Recurrent"]]
+LSTMRecurrentStateWithReset = Tuple[LSTMRecurrentState, StartFlag]
+
+
+class LSTMMagma(SetAction):
+    """
+    The Long Short-Term Memory Magma
+
+    Paper: https://www.bioinf.jku.at/publications/older/2604.pdf
+    """
+
+    recurrent_size: int
+    U_z: nn.Linear
+    U_r: nn.Linear
+    U_h: nn.Linear
+    W_z: nn.Linear
+    W_r: nn.Linear
+    W_h: nn.Linear
+
+    def __init__(self, recurrent_size: int, key):
+        self.recurrent_size = recurrent_size
+        keys = jax.random.split(key, 8)
+        self.U_f = nn.Linear(
+            recurrent_size, recurrent_size, use_bias=False, key=keys[0]
+        )
+        self.U_i = nn.Linear(
+            recurrent_size, recurrent_size, use_bias=False, key=keys[1]
+        )
+        self.U_o = nn.Linear(
+            recurrent_size, recurrent_size, use_bias=False, key=keys[2]
+        )
+        self.U_c = nn.Linear(
+            recurrent_size, recurrent_size, use_bias=False, key=keys[3]
+        )
+
+        self.W_f = nn.Linear(recurrent_size, recurrent_size, key=keys[4])
+        self.W_i = nn.Linear(recurrent_size, recurrent_size, key=keys[5])
+        self.W_o = nn.Linear(recurrent_size, recurrent_size, key=keys[6])
+        self.W_c = nn.Linear(recurrent_size, recurrent_size, key=keys[7])
+
+    @jaxtyped(typechecker=typechecker)
+    def __call__(
+        self, carry: LSTMRecurrentState, input: Float[Array, "Recurrent"]
+    ) -> LSTMRecurrentState:
+        c, h = carry
+        f_f = jax.nn.sigmoid(self.W_f(input) + self.U_f(h))
+        f_i = jax.nn.sigmoid(self.W_i(input) + self.U_i(h))
+        f_o = jax.nn.sigmoid(self.W_o(input) + self.U_o(h))
+        f_c = jax.nn.sigmoid(self.W_c(input) + self.U_c(h))
+
+        c = f_f * c + f_i * f_c
+        h = f_o * c
+
+        return (c, h)
+
+    @jaxtyped(typechecker=typechecker)
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> LSTMRecurrentState:
+        return (
+            jnp.zeros((self.recurrent_size,)),
+            jnp.zeros((self.recurrent_size,)),
+        )
+
+
+class LSTM(GRAS):
+    """
+    The Long Short-Term Memory
+
+    Paper: https://www.bioinf.jku.at/publications/older/2604.pdf
+    """
+
+    algebra: BinaryAlgebra
+    scan: Callable[
+        [
+            Callable[
+                [LSTMRecurrentStateWithReset, LSTMRecurrentStateWithReset],
+                LSTMRecurrentStateWithReset,
+            ],
+            LSTMRecurrentStateWithReset,
+            LSTMRecurrentStateWithReset,
+        ],
+        LSTMRecurrentStateWithReset,
+    ]
+
+    def __init__(self, recurrent_size, key):
+        keys = jax.random.split(key, 3)
+        self.algebra = Resettable(LSTMMagma(recurrent_size, key=keys[0]))
+        self.scan = set_action_scan
+
+    @jaxtyped(typechecker=typechecker)
+    def forward_map(
+        self, x: Input, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> LSTMRecurrentStateWithReset:
+        emb, start = x
+        return emb, start
+
+    @jaxtyped(typechecker=typechecker)
+    def backward_map(
+        self,
+        h: LSTMRecurrentStateWithReset,
+        x: Input,
+        key: Optional[Shaped[PRNGKeyArray, ""]] = None,
+    ) -> Float[Array, "{self.hidden_size}"]:
+        z, reset_flag = h
+        emb, start = x
+        return z
+
+    @jaxtyped(typechecker=typechecker)
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> LSTMRecurrentState:
+        return self.algebra.initialize_carry(key)

popgym_arcade/baselines/model/memorax/magmas/mgu.py

@@ -0,0 +1,111 @@
+from typing import Callable, Optional, Tuple
+
+import jax
+import jax.numpy as jnp
+from beartype import beartype as typechecker
+from equinox import nn
+from jaxtyping import Array, Float, PRNGKeyArray, Shaped, jaxtyped
+
+from popgym_arcade.baselines.model.memorax.gras import GRAS
+from popgym_arcade.baselines.model.memorax.groups import (
+    BinaryAlgebra,
+    Resettable,
+    SetAction,
+)
+from popgym_arcade.baselines.model.memorax.mtypes import Input, StartFlag
+from popgym_arcade.baselines.model.memorax.scans import set_action_scan
+
+MGURecurrentState = Float[Array, "Recurrent"]
+MGURecurrentStateWithReset = Tuple[MGURecurrentState, StartFlag]
+
+
+class MGUMagma(SetAction):
+    """
+    The Minimal Gated Unit Magma
+
+    Paper: https://arxiv.org/abs/1701.03452
+    """
+
+    recurrent_size: int
+    U_h: nn.Linear
+    U_f: nn.Linear
+    W_h: nn.Linear
+    W_f: nn.Linear
+
+    def __init__(self, recurrent_size: int, key):
+        self.recurrent_size = recurrent_size
+        keys = jax.random.split(key, 4)
+        self.U_h = nn.Linear(
+            recurrent_size, recurrent_size, use_bias=False, key=keys[0]
+        )
+        self.U_f = nn.Linear(
+            recurrent_size, recurrent_size, use_bias=False, key=keys[1]
+        )
+        self.W_h = nn.Linear(recurrent_size, recurrent_size, key=keys[2])
+        self.W_f = nn.Linear(recurrent_size, recurrent_size, key=keys[3])
+
+    @jaxtyped(typechecker=typechecker)
+    def __call__(
+        self, carry: MGURecurrentState, input: Float[Array, "Recurrent"]
+    ) -> MGURecurrentState:
+        f = jax.nn.sigmoid(self.W_f(input) + self.U_f(carry))
+        h_hat = jax.nn.tanh(self.W_h(input) + self.U_h(f * carry))
+        h = (1 - f) * carry + f * h_hat
+        return h
+
+    @jaxtyped(typechecker=typechecker)
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> MGURecurrentState:
+        return jnp.zeros((self.recurrent_size,))
+
+
+class MGU(GRAS):
+    """The minimal gated unit
+
+    Paper: https://arxiv.org/abs/1701.03452
+    """
+
+    algebra: BinaryAlgebra
+    scan: Callable[
+        [
+            Callable[
+                [MGURecurrentStateWithReset, MGURecurrentStateWithReset],
+                MGURecurrentStateWithReset,
+            ],
+            MGURecurrentStateWithReset,
+            MGURecurrentStateWithReset,
+        ],
+        MGURecurrentStateWithReset,
+    ]
+    recurrent_size: int
+
+    def __init__(self, recurrent_size, key):
+        self.recurrent_size = recurrent_size
+        keys = jax.random.split(key, 3)
+        self.algebra = Resettable(MGUMagma(recurrent_size, key=keys[0]))
+        self.scan = set_action_scan
+
+    @jaxtyped(typechecker=typechecker)
+    def forward_map(
+        self, x: Input, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> MGURecurrentStateWithReset:
+        emb, start = x
+        return emb, start
+
+    @jaxtyped(typechecker=typechecker)
+    def backward_map(
+        self,
+        h: MGURecurrentStateWithReset,
+        x: Input,
+        key: Optional[Shaped[PRNGKeyArray, ""]] = None,
+    ) -> Float[Array, "{self.recurrent_size}"]:
+        z, reset_flag = h
+        emb, start = x
+        return z
+
+    @jaxtyped(typechecker=typechecker)
+    def initialize_carry(
+        self, key: Optional[Shaped[PRNGKeyArray, ""]] = None
+    ) -> MGURecurrentStateWithReset:
+        return self.algebra.initialize_carry(key)