Add files using upload-large-folder tool

cleanrl/cleanrl/ppo_procgen.py

@@ -0,0 +1,346 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_procgenpy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from procgen import ProcgenEnv
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "starpilot"
+    """the id of the environment"""
+    total_timesteps: int = int(25e6)
+    """total timesteps of the experiments"""
+    learning_rate: float = 5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 64
+    """the number of parallel game environments"""
+    num_steps: int = 256
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = False
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.999
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 8
+    """the number of mini-batches"""
+    update_epochs: int = 3
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+# taken from https://github.com/AIcrowd/neurips2020-procgen-starter-kit/blob/142d09586d2272a17f44481a115c4bd817cf6a94/models/impala_cnn_torch.py
+class ResidualBlock(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.conv0 = nn.Conv2d(in_channels=channels, out_channels=channels, kernel_size=3, padding=1)
+        self.conv1 = nn.Conv2d(in_channels=channels, out_channels=channels, kernel_size=3, padding=1)
+
+    def forward(self, x):
+        inputs = x
+        x = nn.functional.relu(x)
+        x = self.conv0(x)
+        x = nn.functional.relu(x)
+        x = self.conv1(x)
+        return x + inputs
+
+
+class ConvSequence(nn.Module):
+    def __init__(self, input_shape, out_channels):
+        super().__init__()
+        self._input_shape = input_shape
+        self._out_channels = out_channels
+        self.conv = nn.Conv2d(in_channels=self._input_shape[0], out_channels=self._out_channels, kernel_size=3, padding=1)
+        self.res_block0 = ResidualBlock(self._out_channels)
+        self.res_block1 = ResidualBlock(self._out_channels)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = nn.functional.max_pool2d(x, kernel_size=3, stride=2, padding=1)
+        x = self.res_block0(x)
+        x = self.res_block1(x)
+        assert x.shape[1:] == self.get_output_shape()
+        return x
+
+    def get_output_shape(self):
+        _c, h, w = self._input_shape
+        return (self._out_channels, (h + 1) // 2, (w + 1) // 2)
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        h, w, c = envs.single_observation_space.shape
+        shape = (c, h, w)
+        conv_seqs = []
+        for out_channels in [16, 32, 32]:
+            conv_seq = ConvSequence(shape, out_channels)
+            shape = conv_seq.get_output_shape()
+            conv_seqs.append(conv_seq)
+        conv_seqs += [
+            nn.Flatten(),
+            nn.ReLU(),
+            nn.Linear(in_features=shape[0] * shape[1] * shape[2], out_features=256),
+            nn.ReLU(),
+        ]
+        self.network = nn.Sequential(*conv_seqs)
+        self.actor = layer_init(nn.Linear(256, envs.single_action_space.n), std=0.01)
+        self.critic = layer_init(nn.Linear(256, 1), std=1)
+
+    def get_value(self, x):
+        return self.critic(self.network(x.permute((0, 3, 1, 2)) / 255.0))  # "bhwc" -> "bchw"
+
+    def get_action_and_value(self, x, action=None):
+        hidden = self.network(x.permute((0, 3, 1, 2)) / 255.0)  # "bhwc" -> "bchw"
+        logits = self.actor(hidden)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(hidden)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = ProcgenEnv(num_envs=args.num_envs, env_name=args.env_id, num_levels=0, start_level=0, distribution_mode="easy")
+    envs = gym.wrappers.TransformObservation(envs, lambda obs: obs["rgb"])
+    envs.single_action_space = envs.action_space
+    envs.single_observation_space = envs.observation_space["rgb"]
+    envs.is_vector_env = True
+    envs = gym.wrappers.RecordEpisodeStatistics(envs)
+    if args.capture_video:
+        envs = gym.wrappers.RecordVideo(envs, f"videos/{run_name}")
+    envs = gym.wrappers.NormalizeReward(envs, gamma=args.gamma)
+    envs = gym.wrappers.TransformReward(envs, lambda reward: np.clip(reward, -10, 10))
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs = torch.Tensor(envs.reset()).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, next_done, info = envs.step(action.cpu().numpy())
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            for item in info:
+                if "episode" in item.keys():
+                    print(f"global_step={global_step}, episodic_return={item['episode']['r']}")
+                    writer.add_scalar("charts/episodic_return", item["episode"]["r"], global_step)
+                    writer.add_scalar("charts/episodic_length", item["episode"]["l"], global_step)
+                    break
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo_rnd_envpool.py

@@ -0,0 +1,539 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo-rnd/#ppo_rnd_envpoolpy
+import os
+import random
+import time
+from collections import deque
+from dataclasses import dataclass
+
+import envpool
+import gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import tyro
+from gym.wrappers.normalize import RunningMeanStd
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "MontezumaRevenge-v5"
+    """the id of the environment"""
+    total_timesteps: int = 2000000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 1e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 128
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.999
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.1
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.001
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # RND arguments
+    update_proportion: float = 0.25
+    """proportion of exp used for predictor update"""
+    int_coef: float = 1.0
+    """coefficient of extrinsic reward"""
+    ext_coef: float = 2.0
+    """coefficient of intrinsic reward"""
+    int_gamma: float = 0.99
+    """Intrinsic reward discount rate"""
+    num_iterations_obs_norm_init: int = 50
+    """number of iterations to initialize the observations normalization parameters"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+class RecordEpisodeStatistics(gym.Wrapper):
+    def __init__(self, env, deque_size=100):
+        super().__init__(env)
+        self.num_envs = getattr(env, "num_envs", 1)
+        self.episode_returns = None
+        self.episode_lengths = None
+
+    def reset(self, **kwargs):
+        observations = super().reset(**kwargs)
+        self.episode_returns = np.zeros(self.num_envs, dtype=np.float32)
+        self.episode_lengths = np.zeros(self.num_envs, dtype=np.int32)
+        self.lives = np.zeros(self.num_envs, dtype=np.int32)
+        self.returned_episode_returns = np.zeros(self.num_envs, dtype=np.float32)
+        self.returned_episode_lengths = np.zeros(self.num_envs, dtype=np.int32)
+        return observations
+
+    def step(self, action):
+        observations, rewards, dones, infos = super().step(action)
+        self.episode_returns += infos["reward"]
+        self.episode_lengths += 1
+        self.returned_episode_returns[:] = self.episode_returns
+        self.returned_episode_lengths[:] = self.episode_lengths
+        self.episode_returns *= 1 - infos["terminated"]
+        self.episode_lengths *= 1 - infos["terminated"]
+        infos["r"] = self.returned_episode_returns
+        infos["l"] = self.returned_episode_lengths
+        return (
+            observations,
+            rewards,
+            dones,
+            infos,
+        )
+
+
+# ALGO LOGIC: initialize agent here:
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        self.network = nn.Sequential(
+            layer_init(nn.Conv2d(4, 32, 8, stride=4)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(32, 64, 4, stride=2)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 64, 3, stride=1)),
+            nn.ReLU(),
+            nn.Flatten(),
+            layer_init(nn.Linear(64 * 7 * 7, 256)),
+            nn.ReLU(),
+            layer_init(nn.Linear(256, 448)),
+            nn.ReLU(),
+        )
+        self.extra_layer = nn.Sequential(layer_init(nn.Linear(448, 448), std=0.1), nn.ReLU())
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(448, 448), std=0.01),
+            nn.ReLU(),
+            layer_init(nn.Linear(448, envs.single_action_space.n), std=0.01),
+        )
+        self.critic_ext = layer_init(nn.Linear(448, 1), std=0.01)
+        self.critic_int = layer_init(nn.Linear(448, 1), std=0.01)
+
+    def get_action_and_value(self, x, action=None):
+        hidden = self.network(x / 255.0)
+        logits = self.actor(hidden)
+        probs = Categorical(logits=logits)
+        features = self.extra_layer(hidden)
+        if action is None:
+            action = probs.sample()
+        return (
+            action,
+            probs.log_prob(action),
+            probs.entropy(),
+            self.critic_ext(features + hidden),
+            self.critic_int(features + hidden),
+        )
+
+    def get_value(self, x):
+        hidden = self.network(x / 255.0)
+        features = self.extra_layer(hidden)
+        return self.critic_ext(features + hidden), self.critic_int(features + hidden)
+
+
+class RNDModel(nn.Module):
+    def __init__(self, input_size, output_size):
+        super().__init__()
+
+        self.input_size = input_size
+        self.output_size = output_size
+
+        feature_output = 7 * 7 * 64
+
+        # Prediction network
+        self.predictor = nn.Sequential(
+            layer_init(nn.Conv2d(in_channels=1, out_channels=32, kernel_size=8, stride=4)),
+            nn.LeakyReLU(),
+            layer_init(nn.Conv2d(in_channels=32, out_channels=64, kernel_size=4, stride=2)),
+            nn.LeakyReLU(),
+            layer_init(nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1)),
+            nn.LeakyReLU(),
+            nn.Flatten(),
+            layer_init(nn.Linear(feature_output, 512)),
+            nn.ReLU(),
+            layer_init(nn.Linear(512, 512)),
+            nn.ReLU(),
+            layer_init(nn.Linear(512, 512)),
+        )
+
+        # Target network
+        self.target = nn.Sequential(
+            layer_init(nn.Conv2d(in_channels=1, out_channels=32, kernel_size=8, stride=4)),
+            nn.LeakyReLU(),
+            layer_init(nn.Conv2d(in_channels=32, out_channels=64, kernel_size=4, stride=2)),
+            nn.LeakyReLU(),
+            layer_init(nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1)),
+            nn.LeakyReLU(),
+            nn.Flatten(),
+            layer_init(nn.Linear(feature_output, 512)),
+        )
+
+        # target network is not trainable
+        for param in self.target.parameters():
+            param.requires_grad = False
+
+    def forward(self, next_obs):
+        target_feature = self.target(next_obs)
+        predict_feature = self.predictor(next_obs)
+
+        return predict_feature, target_feature
+
+
+class RewardForwardFilter:
+    def __init__(self, gamma):
+        self.rewems = None
+        self.gamma = gamma
+
+    def update(self, rews):
+        if self.rewems is None:
+            self.rewems = rews
+        else:
+            self.rewems = self.rewems * self.gamma + rews
+        return self.rewems
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = envpool.make(
+        args.env_id,
+        env_type="gym",
+        num_envs=args.num_envs,
+        episodic_life=True,
+        reward_clip=True,
+        seed=args.seed,
+        repeat_action_probability=0.25,
+    )
+    envs.num_envs = args.num_envs
+    envs.single_action_space = envs.action_space
+    envs.single_observation_space = envs.observation_space
+    envs = RecordEpisodeStatistics(envs)
+    assert isinstance(envs.action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    rnd_model = RNDModel(4, envs.single_action_space.n).to(device)
+    combined_parameters = list(agent.parameters()) + list(rnd_model.predictor.parameters())
+    optimizer = optim.Adam(
+        combined_parameters,
+        lr=args.learning_rate,
+        eps=1e-5,
+    )
+
+    reward_rms = RunningMeanStd()
+    obs_rms = RunningMeanStd(shape=(1, 1, 84, 84))
+    discounted_reward = RewardForwardFilter(args.int_gamma)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    curiosity_rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    ext_values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    int_values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    avg_returns = deque(maxlen=20)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs = torch.Tensor(envs.reset()).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+    num_updates = args.total_timesteps // args.batch_size
+
+    print("Start to initialize observation normalization parameter.....")
+    next_ob = []
+    for step in range(args.num_steps * args.num_iterations_obs_norm_init):
+        acs = np.random.randint(0, envs.single_action_space.n, size=(args.num_envs,))
+        s, r, d, _ = envs.step(acs)
+        next_ob += s[:, 3, :, :].reshape([-1, 1, 84, 84]).tolist()
+
+        if len(next_ob) % (args.num_steps * args.num_envs) == 0:
+            next_ob = np.stack(next_ob)
+            obs_rms.update(next_ob)
+            next_ob = []
+    print("End to initialize...")
+
+    for update in range(1, num_updates + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (update - 1.0) / num_updates
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += 1 * args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                value_ext, value_int = agent.get_value(obs[step])
+                ext_values[step], int_values[step] = (
+                    value_ext.flatten(),
+                    value_int.flatten(),
+                )
+                action, logprob, _, _, _ = agent.get_action_and_value(obs[step])
+
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, done, info = envs.step(action.cpu().numpy())
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(done).to(device)
+            rnd_next_obs = (
+                (
+                    (next_obs[:, 3, :, :].reshape(args.num_envs, 1, 84, 84) - torch.from_numpy(obs_rms.mean).to(device))
+                    / torch.sqrt(torch.from_numpy(obs_rms.var).to(device))
+                ).clip(-5, 5)
+            ).float()
+            target_next_feature = rnd_model.target(rnd_next_obs)
+            predict_next_feature = rnd_model.predictor(rnd_next_obs)
+            curiosity_rewards[step] = ((target_next_feature - predict_next_feature).pow(2).sum(1) / 2).data
+            for idx, d in enumerate(done):
+                if d and info["lives"][idx] == 0:
+                    avg_returns.append(info["r"][idx])
+                    epi_ret = np.average(avg_returns)
+                    print(
+                        f"global_step={global_step}, episodic_return={info['r'][idx]}, curiosity_reward={np.mean(curiosity_rewards[step].cpu().numpy())}"
+                    )
+                    writer.add_scalar("charts/avg_episodic_return", epi_ret, global_step)
+                    writer.add_scalar("charts/episodic_return", info["r"][idx], global_step)
+                    writer.add_scalar(
+                        "charts/episode_curiosity_reward",
+                        curiosity_rewards[step][idx],
+                        global_step,
+                    )
+                    writer.add_scalar("charts/episodic_length", info["l"][idx], global_step)
+
+        curiosity_reward_per_env = np.array(
+            [discounted_reward.update(reward_per_step) for reward_per_step in curiosity_rewards.cpu().data.numpy().T]
+        )
+        mean, std, count = (
+            np.mean(curiosity_reward_per_env),
+            np.std(curiosity_reward_per_env),
+            len(curiosity_reward_per_env),
+        )
+        reward_rms.update_from_moments(mean, std**2, count)
+
+        curiosity_rewards /= np.sqrt(reward_rms.var)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value_ext, next_value_int = agent.get_value(next_obs)
+            next_value_ext, next_value_int = next_value_ext.reshape(1, -1), next_value_int.reshape(1, -1)
+            ext_advantages = torch.zeros_like(rewards, device=device)
+            int_advantages = torch.zeros_like(curiosity_rewards, device=device)
+            ext_lastgaelam = 0
+            int_lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    ext_nextnonterminal = 1.0 - next_done
+                    int_nextnonterminal = 1.0
+                    ext_nextvalues = next_value_ext
+                    int_nextvalues = next_value_int
+                else:
+                    ext_nextnonterminal = 1.0 - dones[t + 1]
+                    int_nextnonterminal = 1.0
+                    ext_nextvalues = ext_values[t + 1]
+                    int_nextvalues = int_values[t + 1]
+                ext_delta = rewards[t] + args.gamma * ext_nextvalues * ext_nextnonterminal - ext_values[t]
+                int_delta = curiosity_rewards[t] + args.int_gamma * int_nextvalues * int_nextnonterminal - int_values[t]
+                ext_advantages[t] = ext_lastgaelam = (
+                    ext_delta + args.gamma * args.gae_lambda * ext_nextnonterminal * ext_lastgaelam
+                )
+                int_advantages[t] = int_lastgaelam = (
+                    int_delta + args.int_gamma * args.gae_lambda * int_nextnonterminal * int_lastgaelam
+                )
+            ext_returns = ext_advantages + ext_values
+            int_returns = int_advantages + int_values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape(-1)
+        b_ext_advantages = ext_advantages.reshape(-1)
+        b_int_advantages = int_advantages.reshape(-1)
+        b_ext_returns = ext_returns.reshape(-1)
+        b_int_returns = int_returns.reshape(-1)
+        b_ext_values = ext_values.reshape(-1)
+
+        b_advantages = b_int_advantages * args.int_coef + b_ext_advantages * args.ext_coef
+
+        obs_rms.update(b_obs[:, 3, :, :].reshape(-1, 1, 84, 84).cpu().numpy())
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+
+        rnd_next_obs = (
+            (
+                (b_obs[:, 3, :, :].reshape(-1, 1, 84, 84) - torch.from_numpy(obs_rms.mean).to(device))
+                / torch.sqrt(torch.from_numpy(obs_rms.var).to(device))
+            ).clip(-5, 5)
+        ).float()
+
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                predict_next_state_feature, target_next_state_feature = rnd_model(rnd_next_obs[mb_inds])
+                forward_loss = F.mse_loss(
+                    predict_next_state_feature, target_next_state_feature.detach(), reduction="none"
+                ).mean(-1)
+
+                mask = torch.rand(len(forward_loss), device=device)
+                mask = (mask < args.update_proportion).type(torch.FloatTensor).to(device)
+                forward_loss = (forward_loss * mask).sum() / torch.max(
+                    mask.sum(), torch.tensor([1], device=device, dtype=torch.float32)
+                )
+                _, newlogprob, entropy, new_ext_values, new_int_values = agent.get_action_and_value(
+                    b_obs[mb_inds], b_actions.long()[mb_inds]
+                )
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                new_ext_values, new_int_values = new_ext_values.view(-1), new_int_values.view(-1)
+                if args.clip_vloss:
+                    ext_v_loss_unclipped = (new_ext_values - b_ext_returns[mb_inds]) ** 2
+                    ext_v_clipped = b_ext_values[mb_inds] + torch.clamp(
+                        new_ext_values - b_ext_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    ext_v_loss_clipped = (ext_v_clipped - b_ext_returns[mb_inds]) ** 2
+                    ext_v_loss_max = torch.max(ext_v_loss_unclipped, ext_v_loss_clipped)
+                    ext_v_loss = 0.5 * ext_v_loss_max.mean()
+                else:
+                    ext_v_loss = 0.5 * ((new_ext_values - b_ext_returns[mb_inds]) ** 2).mean()
+
+                int_v_loss = 0.5 * ((new_int_values - b_int_returns[mb_inds]) ** 2).mean()
+                v_loss = ext_v_loss + int_v_loss
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef + forward_loss
+
+                optimizer.zero_grad()
+                loss.backward()
+                if args.max_grad_norm:
+                    nn.utils.clip_grad_norm_(
+                        combined_parameters,
+                        args.max_grad_norm,
+                    )
+                optimizer.step()
+
+            if args.target_kl is not None:
+                if approx_kl > args.target_kl:
+                    break
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/fwd_loss", forward_loss.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ppo_rubikscube_generalization.py

@@ -0,0 +1,561 @@
+# PPO with small MLP for RAGEN Rubik's Cube 2x2 using the existing env (no env edits)
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple, Dict, Any, List
+import json
+import re
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.rubikscube.env import RubiksCube2x2Env
+from ragen.env.rubikscube.config import RubiksCube2x2Config
+
+
+class RubiksCubeWrapper(gym.Env):
+    """
+    Adapter to use ragen RubiksCube2x2Env with Gymnasium vector API.
+    - Converts text observation to one-hot vector of 24 stickers x 6 colors.
+    - Maps agent actions [0..11] to env actions [1..12].
+    - Exposes proper observation_space and action_space.
+    """
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: RubiksCube2x2Env):
+        super().__init__()
+        self._env = env
+        # 24 stickers, 6 colors -> one-hot size 144
+        self._colors = ['W', 'O', 'G', 'R', 'B', 'Y']
+        self._color_to_idx = {c: i for i, c in enumerate(self._colors)}
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(24 * len(self._colors),), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(12)
+        # precompile regex to extract 4 letters within [X, X]\n [X, X]
+        # Lines look like: "Up (U):    [W, W]\n       [W, W]"
+        self._face_pat = re.compile(r"\[(?:\s*([A-Z])\s*,\s*([A-Z])\s*\])\n\s*\[(?:\s*([A-Z])\s*,\s*([A-Z])\s*\])")
+
+    def _encode_obs(self, text_obs: str) -> np.ndarray:
+        # Extract the six face blocks in the order U, L, F, R, B, D as rendered
+        faces_order = ["Up (U):", "Left (L):", "Front (F):", "Right (R):", "Back (B):", "Down (D):"]
+        onehots: List[int] = []
+        # Build a map from header to its block text
+        lines = text_obs.splitlines()
+        # Collect blocks starting after header line and including the next line for second row
+        i = 0
+        blocks: List[str] = []
+        while i < len(lines):
+            line = lines[i]
+            for header in faces_order:
+                if line.startswith(header):
+                    # Join current line's bracketed pair and the next line (which contains the second pair)
+                    # Remove the "Header:" prefix to keep only the bracket portions
+                    content = line[len(header):].strip()
+                    next_line = lines[i + 1] if i + 1 < len(lines) else ""
+                    block = f"{content}\n{next_line}"
+                    blocks.append(block)
+                    break
+            i += 1
+        # Fallback: if regex fails, return zeros
+        if len(blocks) != 6:
+            return np.zeros(24 * len(self._colors), dtype=np.float32)
+        stickers: List[int] = []
+        for blk in blocks:
+            m = self._face_pat.search(blk)
+            if not m:
+                return np.zeros(24 * len(self._colors), dtype=np.float32)
+            # order: 0,1,2,3 per render() doc
+            c0, c1, c2, c3 = m.group(1), m.group(2), m.group(3), m.group(4)
+            stickers.extend([c0, c1, c2, c3])
+        # stickers now length 24; convert to one-hot
+        grid = np.zeros((24, len(self._colors)), dtype=np.float32)
+        for idx, ch in enumerate(stickers):
+            cidx = self._color_to_idx.get(ch, None)
+            if cidx is not None:
+                grid[idx, cidx] = 1.0
+        return grid.reshape(-1)
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        obs = self._encode_obs(text_obs)
+        return obs, {}
+
+    def step(self, action: int):
+        mapped = int(action) + 1  # 0..11 -> 1..12
+        text_obs, reward, done, info = self._env.step(mapped)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, info or {}
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "RubiksCube2x2"
+    total_timesteps: int = 1000_000
+    learning_rate: float = 2.5e-4
+    num_envs: int = 8
+    num_steps: int = 128
+    anneal_lr: bool = True
+    gamma: float = 0.99
+    gae_lambda: float = 0.95
+    num_minibatches: int = 4
+    update_epochs: int = 4
+    norm_adv: bool = True
+    clip_coef: float = 0.2
+    clip_vloss: bool = True
+    ent_coef: float = 0.01
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    target_kl: float | None = None
+
+    # Rubik specific（scramble_depth 即打乱步数 / 难度，可与 rotation 一一对应）
+    scramble_depth: int = 3
+    max_steps_env: int = 6
+    # 逗号分隔，如 "2,3,4,5"。在训练难度为 scramble_depth 下训练，仅在这些深度上做评估。
+    # 不设或留空则只在训练难度 scramble_depth 上评估（与旧行为一致）。
+    eval_scramble_depths: str | None = None
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+    eval_splits: int = 20
+    eval_episodes: int = 10000
+
+
+def make_env(idx, run_name, seed, scramble_depth, max_steps_env, capture_video=False):
+    def thunk():
+        config = RubiksCube2x2Config(scramble_depth=scramble_depth, max_steps=max_steps_env, render_mode='text')
+        env = RubiksCube2x2Env(config)
+        env = RubiksCubeWrapper(env)
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps_env)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        obs_shape = int(np.array(envs.single_observation_space.shape).prod())
+        hidden = 128
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    # seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # envs
+    envs = gym.vector.SyncVectorEnv([
+        make_env(i, run_name, args.seed, args.scramble_depth, args.max_steps_env, args.capture_video)
+        for i in range(args.num_envs)
+    ])
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete)
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # storage
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # start
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    # eval helper similar to FrozenLake: collect greedy eval trajectories and write metrics.json
+    def collect_eval_trajectories(
+        agent_model,
+        make_env_fn,
+        n_episodes,
+        step_tag,
+        trajectory_subtag: str | None = None,
+        scramble_depth_eval: int | None = None,
+    ):
+        sub = f"step_{step_tag}" if not trajectory_subtag else f"step_{step_tag}_{trajectory_subtag}"
+        out_dir = Path(f"runs/{run_name}/trajectories/{sub}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, _ = env.reset(seed=args.seed + 100000 + collected)
+                traj_states = [state.tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env, '_max_episode_steps', None) or int(args.max_steps_env)
+                while not done:
+                    with torch.no_grad():
+                        logits = agent_model.actor(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0))
+                        action = int(torch.argmax(logits, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env.step(action)
+                    traj_actions.append(int(action))
+                    traj_rewards.append(float(reward))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_state
+                    traj_states.append(state.tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            if scramble_depth_eval is not None:
+                metrics["scramble_depth_eval"] = int(scramble_depth_eval)
+                metrics["scramble_depth_train"] = int(args.scramble_depth)
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    def parse_eval_scramble_depths(s: str | None, train_depth: int) -> List[int]:
+        if s is None or not str(s).strip():
+            return [train_depth]
+        return [int(x.strip()) for x in str(s).split(",") if x.strip()]
+
+    eval_depths_list = parse_eval_scramble_depths(args.eval_scramble_depths, args.scramble_depth)
+    print(
+        f"Train scramble_depth={args.scramble_depth} | "
+        f"Eval scramble_depths={eval_depths_list} (OOD 泛化评估)"
+    )
+
+    # training loop
+    eval_every_iters = max(1, args.num_iterations // args.eval_splits)
+    for iteration in range(1, args.num_iterations + 1):
+        # Anneal LR
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        # accumulate per-iteration episode successes
+        iter_successes = []
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            # Episode stats logging similar to FrozenLake
+            try:
+                mask = None
+                if isinstance(infos, dict):
+                    if "_episode" in infos:
+                        mask = np.asarray(infos["_episode"]).astype(bool)
+                    elif "episode" in infos and isinstance(infos["episode"], dict) and "_l" in infos["episode"]:
+                        mask = np.asarray(infos["episode"]["_l"]).astype(bool)
+                if mask is not None and np.any(mask):
+                    r_arr = np.asarray(infos.get("episode", {}).get("r", np.zeros_like(mask, dtype=float)))
+                    l_arr = np.asarray(infos.get("episode", {}).get("l", np.zeros_like(mask, dtype=int)))
+                    # prefer success from info; fallback to ep return > 0
+                    if "success" in infos:
+                        succ_arr = np.asarray(infos.get("success", np.zeros_like(mask, dtype=bool))).astype(float)
+                    else:
+                        try:
+                            succ_arr = (np.asarray(r_arr) > 0).astype(float)
+                        except Exception:
+                            succ_arr = np.zeros_like(mask, dtype=float)
+                    # collect iteration successes for training success rate
+                    try:
+                        for s in np.asarray(succ_arr)[mask]:
+                            iter_successes.append(float(s))
+                    except Exception:
+                        pass
+                    if args.track:
+                        try:
+                            import wandb
+                            log_dict = {
+                                "global_step": int(global_step),
+                                "rollout/ep_rew_mean": float(np.mean(r_arr[mask])) if np.any(mask) else None,
+                                "rollout/ep_len_mean": float(np.mean(l_arr[mask])) if np.any(mask) else None,
+                                "rollout/success_rate": float(np.mean(succ_arr[mask])) if np.any(mask) else None,
+                            }
+                            wandb.log(log_dict, step=global_step)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        # GAE
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # update
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss = 0.5 * torch.max(v_loss_unclipped, v_loss_clipped).mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        # metrics
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        sps = int(global_step / (time.time() - start_time))
+        train_success_rate = float(np.mean(iter_successes)) if len(iter_successes) else 0.0
+        print(f"Iter {iteration:4d}/{args.num_iterations} | SPS: {sps:5d} | R: {rewards.mean().item():6.3f}")
+        if args.track:
+            try:
+                import wandb
+                wandb.log({
+                    "global_step": int(global_step),
+                    "charts/progress": float(100.0 * iteration / max(1, args.num_iterations)),
+                    "train/value_loss": float(v_loss.item()),
+                    "train/policy_loss": float(pg_loss.item()),
+                    "losses/value_loss": float(v_loss.item()),
+                    "losses/policy_loss": float(pg_loss.item()),
+                    "train/entropy": float(entropy_loss.item()),
+                    "train/old_approx_kl": float(old_approx_kl.item()),
+                    "train/approx_kl": float(approx_kl.item()),
+                    "train/clipfrac": float(np.mean(clipfracs)) if len(clipfracs) else 0.0,
+                    "losses/explained_variance": float(explained_var),
+                    "charts/avg_reward": float(rewards.mean().item()),
+                    "charts/avg_value": float(values.mean().item()),
+                    "perf/SPS": int(sps),
+                    "charts/SPS": int(sps),
+                    "train/success_rate": train_success_rate,
+                    "charts/train_success_rate": train_success_rate,
+                    "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                }, step=global_step)
+            except Exception:
+                pass
+
+        # periodic evaluation collection
+        if iteration % eval_every_iters == 0:
+            try:
+                wb_eval: Dict[str, Any] = {}
+                for ed in eval_depths_list:
+                    subtag = f"scramble{ed}"
+                    eval_thunk = make_env(0, run_name, args.seed + 9999, ed, args.max_steps_env, False)
+                    collect_eval_trajectories(
+                        agent,
+                        eval_thunk,
+                        n_episodes=args.eval_episodes,
+                        step_tag=global_step,
+                        trajectory_subtag=subtag,
+                        scramble_depth_eval=ed,
+                    )
+                    if args.track:
+                        try:
+                            import json as _json
+                            from pathlib import Path as _Path
+                            mpath = _Path(f"runs/{run_name}/trajectories/step_{global_step}_{subtag}/metrics.json")
+                            if mpath.exists():
+                                with mpath.open("r") as mf:
+                                    metrics = _json.load(mf)
+                                pfx = f"eval/scramble_{ed}"
+                                wb_eval[f"{pfx}/success_rate"] = metrics.get("success_rate")
+                                wb_eval[f"{pfx}/avg_return"] = metrics.get("avg_return")
+                                wb_eval[f"{pfx}/std_return"] = metrics.get("std_return")
+                                wb_eval[f"{pfx}/episodes"] = metrics.get("episodes")
+                        except Exception:
+                            pass
+                    print(
+                        f"Eval scramble_depth={ed}: collected {args.eval_episodes} trajectories "
+                        f"at global_step {global_step}"
+                    )
+                if args.track and wb_eval:
+                    try:
+                        import wandb
+                        wb_eval["global_step"] = int(global_step)
+                        wandb.log(wb_eval, step=global_step)
+                    except Exception:
+                        pass
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    envs.close()

cleanrl/cleanrl/ppo_sudoku_actionmask.py

@@ -0,0 +1,588 @@
+# PPO with Action Masking for RAGEN Sudoku (4x4, max_step=20)
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple, Dict, Any, List
+import json
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+
+import sys
+# 假设 ragen 库在两级目录之上，请根据实际情况调整
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.sudoku.env import SudokuEnv
+from ragen.env.sudoku.config import SudokuEnvConfig
+
+
+class SudokuWrapper(gym.Env):
+    """
+    Adapter to use ragen SudokuEnv with Gymnasium vector API.
+    Improvements: Returns a Dict observation with 'action_mask' to prevent
+    the agent from modifying cells that are already filled.
+    """
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: SudokuEnv, grid_size: int):
+        super().__init__()
+        self._env = env
+        self._size = grid_size
+        # 0 denotes empty, 1..grid_size denote values
+        self._val_dim = self._size + 1
+        
+        # Actions: (row, col, num) -> Flattened
+        self._act_n = self._size * self._size * self._size
+        self.action_space = gym.spaces.Discrete(self._act_n)
+
+        # Observation: Dict with mask
+        self.observation_space = gym.spaces.Dict({
+            "observation": gym.spaces.Box(low=0.0, high=1.0, shape=(self._size * self._size * self._val_dim,), dtype=np.float32),
+            "action_mask": gym.spaces.Box(low=0.0, high=1.0, shape=(self._act_n,), dtype=np.float32)
+        })
+
+    def _encode_obs(self, text_obs: str) -> Dict[str, np.ndarray]:
+        # Parse the 'simple' grid format
+        vals: List[int] = []
+        for line in text_obs.splitlines():
+            ls = line.strip()
+            if len(ls) == 0: continue
+            if set(ls) <= {'-'}: continue
+            tokens = [t for t in ls.split() if t != '|']
+            if len(tokens) == 0: continue
+            for t in tokens:
+                if t == '.': vals.append(0)
+                else:
+                    try: v = int(t)
+                    except ValueError: v = 0
+                    vals.append(v)
+        
+        target = self._size * self._size
+        if len(vals) < target: vals.extend([0] * (target - len(vals)))
+        if len(vals) > target: vals = vals[:target]
+        
+        # One-hot encode grid
+        grid = np.zeros((target, self._val_dim), dtype=np.float32)
+        # Initialize mask (1.0 = valid, 0.0 = invalid)
+        mask = np.ones(self._act_n, dtype=np.float32)
+
+        for i, v in enumerate(vals):
+            v_clamped = int(v)
+            if v_clamped < 0 or v_clamped > self._size:
+                v_clamped = 0
+            grid[i, v_clamped] = 1.0
+
+            # If a cell is NOT empty (v_clamped != 0), mask all actions for this cell.
+            # Agent should not overwrite existing numbers.
+            if v_clamped != 0:
+                start_idx = i * self._size
+                end_idx = start_idx + self._size
+                mask[start_idx:end_idx] = 0.0
+
+        return {
+            "observation": grid.reshape(-1),
+            "action_mask": mask
+        }
+
+    @staticmethod
+    def _decode_action(action_id: int, grid_size: int) -> Tuple[int, int, int]:
+        g = grid_size
+        row = action_id // (g * g)
+        rem = action_id % (g * g)
+        col = rem // g
+        num = (rem % g) + 1
+        return row, col, num
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        obs = self._encode_obs(text_obs)
+        return obs, {}
+
+    def step(self, action: int):
+        row, col, num = self._decode_action(int(action), self._size)
+        act_str = f"{row+1},{col+1},{num}"
+        text_obs, reward, done, info = self._env.step(act_str)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, info or {}
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "Sudoku"
+    total_timesteps: int = 2000_000
+    learning_rate: float = 3e-4
+    num_envs: int = 8
+    num_steps: int = 128
+    anneal_lr: bool = True
+    gamma: float = 0.99
+    gae_lambda: float = 0.95
+    num_minibatches: int = 4
+    update_epochs: int = 4
+    norm_adv: bool = True
+    clip_coef: float = 0.2
+    clip_vloss: bool = True
+    ent_coef: float = 0.01
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    target_kl: float | None = None
+
+    # Sudoku specific
+    grid_size: int = 4
+    difficulty: str = "easy"
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+
+    # eval
+    eval_splits: int = 40
+    eval_episodes: int = 10000
+
+
+def make_env(idx, run_name, seed, grid_size, difficulty, capture_video=False):
+    def thunk():
+        config = SudokuEnvConfig(
+            grid_size=grid_size,
+            difficulty=difficulty,
+            render_mode='text',
+            render_format='simple',
+        )
+        env = SudokuEnv(config)
+        env = SudokuWrapper(env, grid_size)
+        # Use env's own max_steps default if available, otherwise a sane cap
+        # Keeping your request for strict step limit logic, although wrapper enforces logic
+        max_steps = 81
+        # max_steps = int(grid_size * grid_size * 6)
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        # Accessing the shape from the Dict space
+        obs_shape = int(np.array(envs.single_observation_space['observation'].shape).prod())
+        hidden = 256 # Increased hidden size slightly for better capacity
+
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None, action_mask=None):
+        logits = self.actor(x)
+        
+        # Apply Action Masking
+        if action_mask is not None:
+            # Set logits of invalid actions to a very large negative number
+            logits = logits + (action_mask - 1.0) * 1e8
+
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    # seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # envs
+    envs = gym.vector.SyncVectorEnv([
+        make_env(i, run_name, args.seed, args.grid_size, args.difficulty, args.capture_video)
+        for i in range(args.num_envs)
+    ])
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete)
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # storage
+    # Note: obs storage now only stores the flattened grid part
+    obs_shape = envs.single_observation_space['observation'].shape
+    mask_shape = envs.single_observation_space['action_mask'].shape
+    
+    obs = torch.zeros((args.num_steps, args.num_envs) + obs_shape).to(device)
+    masks = torch.zeros((args.num_steps, args.num_envs) + mask_shape).to(device) # Storage for masks
+    
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # start
+    global_step = 0
+    start_time = time.time()
+    
+    # envs.reset() returns a Dict of stacked arrays
+    next_obs_dict, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs_dict['observation']).to(device)
+    next_mask = torch.Tensor(next_obs_dict['action_mask']).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+    
+    episode_returns = []
+    episode_steps = []
+    episode_successes = []
+
+    # Eval helper
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                obs_dict, _ = env.reset(seed=args.seed + collected)
+                # Handle single env dict unpacking
+                state = obs_dict['observation']
+                mask = obs_dict['action_mask']
+                
+                traj_states = [state.tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env, '_max_episode_steps', None) or int(args.grid_size * args.grid_size * 6)
+                
+                # Eval loop
+                current_obs = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
+                current_mask = torch.tensor(mask, dtype=torch.float32, device=device).unsqueeze(0)
+
+                while not done:
+                    with torch.no_grad():
+                        # Pass mask to actor during eval
+                        action, _, _, _ = agent_model.get_action_and_value(current_obs, action_mask=current_mask)
+                        action_item = int(action.item())
+                        
+                    next_obs_dict, reward, terminated, truncated, info = env.step(action_item)
+                    
+                    traj_actions.append(action_item)
+                    traj_rewards.append(float(reward))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool(info.get('success', False)))
+                    
+                    state = next_obs_dict['observation']
+                    mask = next_obs_dict['action_mask']
+                    current_obs = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
+                    current_mask = torch.tensor(mask, dtype=torch.float32, device=device).unsqueeze(0)
+                    
+                    traj_states.append(state.tolist())
+                    done = d
+                    
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    eval_every_iters = max(1, args.num_iterations // args.eval_splits)
+
+    # training loop
+    for iteration in range(1, args.num_iterations + 1):
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            optimizer.param_groups[0]["lr"] = frac * args.learning_rate
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            masks[step] = next_mask # Store mask
+            dones[step] = next_done
+
+            with torch.no_grad():
+                # PASS MASK HERE
+                action, logprob, _, value = agent.get_action_and_value(next_obs, action_mask=next_mask)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            next_obs_dict, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            
+            # Unpack dict again
+            next_obs = torch.Tensor(next_obs_dict['observation']).to(device)
+            next_mask = torch.Tensor(next_obs_dict['action_mask']).to(device)
+            next_done = torch.Tensor(next_done).to(device)
+
+            try:
+                mask = None
+                if isinstance(infos, dict):
+                    if "_episode" in infos:
+                        mask = np.asarray(infos["_episode"]).astype(bool)
+                    elif "episode" in infos and isinstance(infos["episode"], dict) and "_l" in infos["episode"]:
+                        mask = np.asarray(infos["episode"]["_l"]).astype(bool)
+                if mask is not None and np.any(mask):
+                    r_arr = np.asarray(infos.get("episode", {}).get("r", np.zeros_like(mask, dtype=float)))
+                    l_arr = np.asarray(infos.get("episode", {}).get("l", np.zeros_like(mask, dtype=int)))
+                    succ_arr = np.asarray(infos.get("success", np.zeros_like(mask, dtype=bool))).astype(float)
+                    for i in np.where(mask)[0]:
+                        episode_returns.append(float(r_arr[i]))
+                        episode_steps.append(global_step)
+                        episode_successes.append(float(succ_arr[i]))
+                    if args.track:
+                        try:
+                            import wandb
+                            log_dict = {
+                                "global_step": int(global_step),
+                                "rollout/ep_rew_mean": float(np.mean(r_arr[mask])) if np.any(mask) else None,
+                                "rollout/ep_len_mean": float(np.mean(l_arr[mask])) if np.any(mask) else None,
+                                "rollout/success_rate": float(np.mean(succ_arr[mask])) if np.any(mask) else None,
+                            }
+                            if np.any(mask):
+                                last_idx = np.where(mask)[0][-1]
+                                log_dict.update({
+                                    "train/episodic_return": float(r_arr[last_idx]),
+                                    "train/episodic_length": int(l_arr[last_idx]),
+                                    "train/success": float(succ_arr[last_idx]),
+                                    "train/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) >= 100 else None,
+                                })
+                            wandb.log(log_dict, step=global_step)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        # GAE
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten batch
+        b_obs = obs.reshape((-1,) + obs_shape)
+        b_masks = masks.reshape((-1,) + mask_shape) # Flatten masks
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # update
+        b_inds = np.arange(args.batch_size)
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                # PASS MASK HERE
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(
+                    b_obs[mb_inds], 
+                    action=b_actions.long()[mb_inds],
+                    action_mask=b_masks[mb_inds]
+                )
+                
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss = 0.5 * torch.max(v_loss_unclipped, v_loss_clipped).mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        # logging
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Val: {values.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        if args.track:
+            try:
+                import wandb
+                wandb.log({
+                    "global_step": int(global_step),
+                    "train/value_loss": float(v_loss.item()),
+                    "train/policy_loss": float(pg_loss.item()),
+                    "train/entropy": float(entropy_loss.item()),
+                    "train/old_approx_kl": float(old_approx_kl.item()),
+                    "train/approx_kl": float(approx_kl.item()),
+                    "losses/explained_variance": float(explained_var),
+                    "charts/avg_reward": float(rewards.mean().item()),
+                    "charts/avg_value": float(values.mean().item()),
+                    "perf/SPS": int(sps),
+                    "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                }, step=global_step)
+            except Exception:
+                pass
+
+        if iteration % eval_every_iters == 0:
+            try:
+                eval_thunk = make_env(0, run_name, args.seed + 9999, args.grid_size, args.difficulty, False)
+                collect_eval_trajectories(agent, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import json as _json
+                        from pathlib import Path as _Path
+                        mpath = _Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = _json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {args.eval_episodes} eval trajectories at global_step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    envs.close()

cleanrl/cleanrl/ppo_sudoku_strongactionmask.py

@@ -0,0 +1,616 @@
+# PPO with Action Masking for RAGEN Sudoku (4x4, max_step=20)
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple, Dict, Any, List
+import json
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+
+import sys
+# 假设 ragen 库在两级目录之上，请根据实际情况调整
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.sudoku.env import SudokuEnv
+from ragen.env.sudoku.config import SudokuEnvConfig
+
+
+class SudokuWrapper(gym.Env):
+    """
+    Adapter to use ragen SudokuEnv with Gymnasium vector API.
+    Improvements: Returns a Dict observation with 'action_mask' to prevent
+    the agent from modifying cells that are already filled.
+    """
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: SudokuEnv, grid_size: int):
+        super().__init__()
+        self._env = env
+        self._size = grid_size
+        # 0 denotes empty, 1..grid_size denote values
+        self._val_dim = self._size + 1
+        
+        # Actions: (row, col, num) -> Flattened
+        self._act_n = self._size * self._size * self._size
+        self.action_space = gym.spaces.Discrete(self._act_n)
+
+        # Observation: Dict with mask
+        self.observation_space = gym.spaces.Dict({
+            "observation": gym.spaces.Box(low=0.0, high=1.0, shape=(self._size * self._size * self._val_dim,), dtype=np.float32),
+            "action_mask": gym.spaces.Box(low=0.0, high=1.0, shape=(self._act_n,), dtype=np.float32)
+        })
+
+    def _encode_obs(self, text_obs: str) -> Dict[str, np.ndarray]:
+        # Parse the 'simple' grid format
+        vals: List[int] = []
+        for line in text_obs.splitlines():
+            ls = line.strip()
+            if len(ls) == 0: continue
+            if set(ls) <= {'-'}: continue
+            tokens = [t for t in ls.split() if t != '|']
+            if len(tokens) == 0: continue
+            for t in tokens:
+                if t == '.': vals.append(0)
+                else:
+                    try: v = int(t)
+                    except ValueError: v = 0
+                    vals.append(v)
+        
+        target = self._size * self._size
+        if len(vals) < target: vals.extend([0] * (target - len(vals)))
+        if len(vals) > target: vals = vals[:target]
+        
+        # One-hot encode grid
+        grid = np.zeros((target, self._val_dim), dtype=np.float32)
+        # Initialize mask (1.0 = valid, 0.0 = invalid)
+        mask = np.zeros(self._act_n, dtype=np.float32)
+
+        for i, v in enumerate(vals):
+            v_clamped = int(v)
+            if v_clamped < 0 or v_clamped > self._size:
+                v_clamped = 0
+            grid[i, v_clamped] = 1.0
+
+            # If a cell is NOT empty (v_clamped != 0), mask all actions for this cell.
+            # Agent should not overwrite existing numbers.
+            if v_clamped != 0:
+                start_idx = i * self._size
+                end_idx = start_idx + self._size
+                mask[start_idx:end_idx] = 0.0
+
+        # Build current grid for validity checks
+        cur = np.array(vals, dtype=np.int64).reshape(self._size, self._size)
+        box = int(np.sqrt(self._size))
+
+        # Set mask=1 only for Sudoku-rule-valid placements on empty cells
+        for i, v in enumerate(vals):
+            if int(v) == 0:
+                r = i // self._size
+                c = i % self._size
+                row_vals = set(cur[r, :].tolist())
+                col_vals = set(cur[:, c].tolist())
+                br = (r // box) * box
+                bc = (c // box) * box
+                box_vals = set(cur[br:br+box, bc:bc+box].reshape(-1).tolist())
+                start_idx = i * self._size
+                for num in range(1, self._size + 1):
+                    if (num not in row_vals) and (num not in col_vals) and (num not in box_vals):
+                        mask[start_idx + (num - 1)] = 1.0
+
+        # Safe fallback: if no valid actions found, allow all actions on empty cells; if still none, allow all
+        if mask.sum() == 0:
+            for i, v in enumerate(vals):
+                if int(v) == 0:
+                    start_idx = i * self._size
+                    end_idx = start_idx + self._size
+                    mask[start_idx:end_idx] = 1.0
+            if mask.sum() == 0:
+                mask[:] = 1.0
+
+        return {
+            "observation": grid.reshape(-1),
+            "action_mask": mask
+        }
+
+    @staticmethod
+    def _decode_action(action_id: int, grid_size: int) -> Tuple[int, int, int]:
+        g = grid_size
+        row = action_id // (g * g)
+        rem = action_id % (g * g)
+        col = rem // g
+        num = (rem % g) + 1
+        return row, col, num
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        obs = self._encode_obs(text_obs)
+        return obs, {}
+
+    def step(self, action: int):
+        row, col, num = self._decode_action(int(action), self._size)
+        act_str = f"{row+1},{col+1},{num}"
+        text_obs, reward, done, info = self._env.step(act_str)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, info or {}
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "Sudoku"
+    total_timesteps: int = 2000_000
+    learning_rate: float = 3e-4
+    num_envs: int = 8
+    num_steps: int = 128
+    anneal_lr: bool = True
+    gamma: float = 0.99
+    gae_lambda: float = 0.95
+    num_minibatches: int = 4
+    update_epochs: int = 4
+    norm_adv: bool = True
+    clip_coef: float = 0.2
+    clip_vloss: bool = True
+    ent_coef: float = 0.01
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    target_kl: float | None = None
+
+    # Sudoku specific
+    grid_size: int = 9
+    difficulty: str = "easy"
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+
+    # eval
+    eval_splits: int = 2
+    eval_episodes: int = 4000
+
+
+def make_env(idx, run_name, seed, grid_size, difficulty, capture_video=False):
+    def thunk():
+        config = SudokuEnvConfig(
+            grid_size=grid_size,
+            difficulty=difficulty,
+            render_mode='text',
+            render_format='simple',
+        )
+        env = SudokuEnv(config)
+        env = SudokuWrapper(env, grid_size)
+        # Use env's own max_steps default if available, otherwise a sane cap
+        # Keeping your request for strict step limit logic, although wrapper enforces logic
+        max_steps = 81
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        # Accessing the shape from the Dict space
+        obs_shape = int(np.array(envs.single_observation_space['observation'].shape).prod())
+        hidden = 256 # Increased hidden size slightly for better capacity
+
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None, action_mask=None):
+        logits = self.actor(x)
+        
+        # Apply Action Masking
+        if action_mask is not None:
+            # Set logits of invalid actions to a very large negative number
+            logits = logits + (action_mask - 1.0) * 1e8
+
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    # seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # envs
+    envs = gym.vector.SyncVectorEnv([
+        make_env(i, run_name, args.seed, args.grid_size, args.difficulty, args.capture_video)
+        for i in range(args.num_envs)
+    ])
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete)
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # storage
+    # Note: obs storage now only stores the flattened grid part
+    obs_shape = envs.single_observation_space['observation'].shape
+    mask_shape = envs.single_observation_space['action_mask'].shape
+    
+    obs = torch.zeros((args.num_steps, args.num_envs) + obs_shape).to(device)
+    masks = torch.zeros((args.num_steps, args.num_envs) + mask_shape).to(device) # Storage for masks
+    
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # start
+    global_step = 0
+    start_time = time.time()
+    
+    # envs.reset() returns a Dict of stacked arrays
+    next_obs_dict, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs_dict['observation']).to(device)
+    next_mask = torch.Tensor(next_obs_dict['action_mask']).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+    
+    episode_returns = []
+    episode_steps = []
+    episode_successes = []
+
+    # Eval helper
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                obs_dict, _ = env.reset(seed=args.seed + collected)
+                # Handle single env dict unpacking
+                state = obs_dict['observation']
+                mask = obs_dict['action_mask']
+                
+                traj_states = [state.tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env, '_max_episode_steps', None) or int(args.grid_size * args.grid_size * 6)
+                
+                # Eval loop
+                current_obs = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
+                current_mask = torch.tensor(mask, dtype=torch.float32, device=device).unsqueeze(0)
+
+                while not done:
+                    with torch.no_grad():
+                        # Pass mask to actor during eval
+                        action, _, _, _ = agent_model.get_action_and_value(current_obs, action_mask=current_mask)
+                        action_item = int(action.item())
+                        
+                    next_obs_dict, reward, terminated, truncated, info = env.step(action_item)
+                    
+                    traj_actions.append(action_item)
+                    traj_rewards.append(float(reward))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool(info.get('success', False)))
+                    
+                    state = next_obs_dict['observation']
+                    mask = next_obs_dict['action_mask']
+                    current_obs = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
+                    current_mask = torch.tensor(mask, dtype=torch.float32, device=device).unsqueeze(0)
+                    
+                    traj_states.append(state.tolist())
+                    done = d
+                    
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    eval_every_iters = max(1, args.num_iterations // args.eval_splits)
+
+    # training loop
+    for iteration in range(1, args.num_iterations + 1):
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            optimizer.param_groups[0]["lr"] = frac * args.learning_rate
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            masks[step] = next_mask # Store mask
+            dones[step] = next_done
+
+            with torch.no_grad():
+                # PASS MASK HERE
+                action, logprob, _, value = agent.get_action_and_value(next_obs, action_mask=next_mask)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            next_obs_dict, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            
+            # Unpack dict again
+            next_obs = torch.Tensor(next_obs_dict['observation']).to(device)
+            next_mask = torch.Tensor(next_obs_dict['action_mask']).to(device)
+            next_done = torch.Tensor(next_done).to(device)
+
+            try:
+                mask = None
+                if isinstance(infos, dict):
+                    if "_episode" in infos:
+                        mask = np.asarray(infos["_episode"]).astype(bool)
+                    elif "episode" in infos and isinstance(infos["episode"], dict) and "_l" in infos["episode"]:
+                        mask = np.asarray(infos["episode"]["_l"]).astype(bool)
+                if mask is not None and np.any(mask):
+                    r_arr = np.asarray(infos.get("episode", {}).get("r", np.zeros_like(mask, dtype=float)))
+                    l_arr = np.asarray(infos.get("episode", {}).get("l", np.zeros_like(mask, dtype=int)))
+                    succ_arr = np.asarray(infos.get("success", np.zeros_like(mask, dtype=bool))).astype(float)
+                    for i in np.where(mask)[0]:
+                        episode_returns.append(float(r_arr[i]))
+                        episode_steps.append(global_step)
+                        episode_successes.append(float(succ_arr[i]))
+                    if args.track:
+                        try:
+                            import wandb
+                            log_dict = {
+                                "global_step": int(global_step),
+                                "rollout/ep_rew_mean": float(np.mean(r_arr[mask])) if np.any(mask) else None,
+                                "rollout/ep_len_mean": float(np.mean(l_arr[mask])) if np.any(mask) else None,
+                                "rollout/success_rate": float(np.mean(succ_arr[mask])) if np.any(mask) else None,
+                            }
+                            if np.any(mask):
+                                last_idx = np.where(mask)[0][-1]
+                                log_dict.update({
+                                    "train/episodic_return": float(r_arr[last_idx]),
+                                    "train/episodic_length": int(l_arr[last_idx]),
+                                    "train/success": float(succ_arr[last_idx]),
+                                    "train/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) >= 100 else None,
+                                })
+                            wandb.log(log_dict, step=global_step)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        # GAE
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten batch
+        b_obs = obs.reshape((-1,) + obs_shape)
+        b_masks = masks.reshape((-1,) + mask_shape) # Flatten masks
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # update
+        b_inds = np.arange(args.batch_size)
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                # PASS MASK HERE
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(
+                    b_obs[mb_inds], 
+                    action=b_actions.long()[mb_inds],
+                    action_mask=b_masks[mb_inds]
+                )
+                
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss = 0.5 * torch.max(v_loss_unclipped, v_loss_clipped).mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        # logging
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Val: {values.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        if args.track:
+            try:
+                import wandb
+                wandb.log({
+                    "global_step": int(global_step),
+                    "train/value_loss": float(v_loss.item()),
+                    "train/policy_loss": float(pg_loss.item()),
+                    "train/entropy": float(entropy_loss.item()),
+                    "train/old_approx_kl": float(old_approx_kl.item()),
+                    "train/approx_kl": float(approx_kl.item()),
+                    "losses/explained_variance": float(explained_var),
+                    "charts/avg_reward": float(rewards.mean().item()),
+                    "charts/avg_value": float(values.mean().item()),
+                    "perf/SPS": int(sps),
+                    "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                }, step=global_step)
+            except Exception:
+                pass
+
+        if iteration % eval_every_iters == 0:
+            try:
+                eval_thunk = make_env(0, run_name, args.seed + 9999, args.grid_size, args.difficulty, False)
+                collect_eval_trajectories(agent, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import json as _json
+                        from pathlib import Path as _Path
+                        mpath = _Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = _json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {args.eval_episodes} eval trajectories at global_step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    envs.close()

cleanrl/cleanrl/ppo_trxl/pom_env.py

@@ -0,0 +1,186 @@
+import gymnasium as gym
+import numpy as np
+import pygame
+from gymnasium import spaces
+
+gym.register(
+    id="ProofofMemory-v0",
+    entry_point="pom_env:PoMEnv",
+    max_episode_steps=16,
+)
+
+
+class PoMEnv(gym.Env):
+    """
+    Proof of Concept Memory Environment
+
+    This environment is intended to assess whether the policy's memory is working.
+    The environment is based on a one dimensional grid where the agent can move left or right.
+    At both ends, a goal is spawned that is either punishing or rewarding.
+    During the very first two steps, the agent gets to know which goal leads to a positive or negative reward.
+    Afterwards, this information is hidden in the agent's observation.
+    The last value of the agent's observation is its current position inside the environment.
+    Optionally and to increase the difficulty of the task, the agent's position can be frozen until the goal information is hidden.
+    To further challenge the agent, the step_size can be decreased.
+    """
+
+    metadata = {"render_modes": ["human", "rgb_array", "debug_rgb_array"], "render_fps": 4}
+
+    def __init__(self, render_mode="human"):
+        self._freeze = True
+        self._step_size = 0.2
+        self._min_steps = int(1.0 / self._step_size) + 1
+        self._time_penalty = 0.1
+        self._num_show_steps = 2
+        self.render_mode = render_mode
+        glob = False
+
+        self.action_space = spaces.Discrete(2)
+        self.observation_space = spaces.Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32)
+
+        # Create an array with possible positions
+        num_steps = int(0.4 / self._step_size)
+        lower = min(-2.0 * self._step_size, -num_steps * self._step_size) if not glob else -1 + self._step_size
+        upper = max(3.0 * self._step_size, self._step_size, (num_steps + 1) * self._step_size) if not glob else 1
+        self.possible_positions = np.arange(lower, upper, self._step_size).clip(-1 + self._step_size, 1 - self._step_size)
+        self.possible_positions = list(map(lambda x: round(x, 2), self.possible_positions))  # fix floating point errors
+
+        # Pygame-related attributes for rendering
+        self.window = None
+        self.clock = None
+        self.width = 400
+        self.height = 80
+        self.cell_width = self.width / (2 * int(1 / self._step_size) + 1)
+
+    def step(self, action):
+        reward = 0.0
+        done = False
+
+        if self._num_show_steps > self._step_count:
+            self._position += self._step_size * (1 - self._freeze) if action == 1 else -self._step_size * (1 - self._freeze)
+            self._position = np.round(self._position, 2)
+
+            obs = np.asarray([self._goals[0], self._position, self._goals[1]], dtype=np.float32)
+
+            if self._freeze:
+                self._step_count += 1
+                return obs, reward, done, False, {}
+
+        else:
+            self._position += self._step_size if action == 1 else -self._step_size
+            self._position = np.round(self._position, 2)
+            obs = np.asarray([0.0, self._position, 0.0], dtype=np.float32)  # mask out goal information
+
+        # Determine reward and termination
+        if self._position == -1.0:
+            if self._goals[0] == 1.0:
+                reward += 1.0 + self._min_steps * self._time_penalty
+            else:
+                reward -= 1.0 + self._min_steps * self._time_penalty
+            done = True
+        elif self._position == 1.0:
+            if self._goals[1] == 1.0:
+                reward += 1.0 + self._min_steps * self._time_penalty
+            else:
+                reward -= 1.0 + self._min_steps * self._time_penalty
+            done = True
+        else:
+            reward -= self._time_penalty
+        self.rewards.append(reward)
+
+        if done:
+            info = {"reward": sum(self.rewards), "length": len(self.rewards)}
+        else:
+            info = {}
+
+        self._step_count += 1
+
+        return obs, reward, done, False, info
+
+    def reset(self, *, seed=None, options=None):
+        super().reset(seed=seed)
+        self.rewards = []
+        self._position = np.random.choice(self.possible_positions)
+        self._step_count = 0
+        goals = np.asarray([-1.0, 1.0])
+        self._goals = goals[np.random.permutation(2)]
+        obs = np.asarray([self._goals[0], self._position, self._goals[1]], dtype=np.float32)
+        return obs, {}
+
+    def render(self):
+        if self.render_mode not in self.metadata["render_modes"]:
+            return
+
+        # Initialize Pygame
+        if not pygame.get_init():
+            pygame.init()
+        if self.window is None and self.render_mode == "human":
+            pygame.display.init()
+            self.window = pygame.display.set_mode((self.width, self.height))
+            pygame.display.set_caption("Proof of Memory Environment")
+        if self.clock is None and self.render_mode == "human":
+            self.clock = pygame.time.Clock()
+
+        # Create surface
+        canvas = pygame.Surface((self.width, self.height))
+        canvas.fill((255, 255, 255))  # Fill the background with white
+
+        # Draw grid
+        num_cells = 2 * int(1 / self._step_size) + 1
+        for i in range(num_cells):
+            x = i * self.cell_width
+            pygame.draw.rect(canvas, (200, 200, 200), pygame.Rect(x, 0, self.cell_width, self.height), 1)
+
+        # Draw agent
+        agent_pos = int((self._position + 1) / self._step_size)
+        agent_x = agent_pos * self.cell_width + self.cell_width / 2
+        pygame.draw.circle(canvas, (0, 0, 255), (agent_x, self.height / 2), 15)
+
+        # Draw goals
+        show_goals = self._num_show_steps > self._step_count
+        if show_goals:
+            left_goal_color = (0, 255, 0) if self._goals[0] > 0 else (255, 0, 0)
+            pygame.draw.rect(canvas, left_goal_color, pygame.Rect(0, 0, self.cell_width, self.height))
+            right_goal_color = (0, 255, 0) if self._goals[1] > 0 else (255, 0, 0)
+            pygame.draw.rect(
+                canvas, right_goal_color, pygame.Rect(self.width - self.cell_width, 0, self.cell_width, self.height)
+            )
+        else:
+            pygame.draw.rect(canvas, (200, 200, 200), pygame.Rect(0, 0, self.cell_width, self.height))
+            pygame.draw.rect(
+                canvas, (200, 200, 200), pygame.Rect(self.width - self.cell_width, 0, self.cell_width, self.height)
+            )
+
+        # Render text information
+        font = pygame.font.SysFont(None, 24)
+        text = font.render(f"Goals are shown: {show_goals}", True, (0, 0, 0))
+        canvas.blit(text, (10, 10))
+
+        if self.render_mode == "human":
+            self.window.blit(canvas, (0, 0))
+            pygame.display.flip()
+            self.clock.tick(self.metadata["render_fps"])
+        elif self.render_mode in ["rgb_array", "debug_rgb_array"]:
+            return np.transpose(np.array(pygame.surfarray.pixels3d(canvas)), axes=(1, 0, 2))
+
+    def close(self):
+        if self.window is not None:
+            pygame.display.quit()
+            pygame.quit()
+            self.window = None
+            self.clock = None
+
+
+if __name__ == "__main__":
+    env = PoMEnv(render_mode="human")
+    o, _ = env.reset()
+    img = env.render()
+    done = False
+    rewards = []
+    const_action = 1
+    while not done:
+        o, r, done, _, _ = env.step(const_action)
+        rewards.append(r)
+        img = env.render()
+    print(f"Total reward: {sum(rewards)}, Steps: {len(rewards)}")
+    env.close()

cleanrl/cleanrl/ppo_trxl/ppo_trxl.py

@@ -0,0 +1,682 @@
+import os
+import random
+import time
+from collections import deque
+from dataclasses import dataclass
+
+import gymnasium as gym
+import memory_gym  # noqa
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from einops import rearrange
+from minigrid.wrappers import ImgObsWrapper, RGBImgPartialObsWrapper
+from pom_env import PoMEnv  # noqa
+from torch.distributions import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_model: bool = False
+    """whether to save model into the `runs/{run_name}` folder"""
+
+    # Algorithm specific arguments
+    env_id: str = "MortarMayhem-Grid-v0"
+    """the id of the environment"""
+    total_timesteps: int = 200000000
+    """total timesteps of the experiments"""
+    init_lr: float = 2.75e-4
+    """the initial learning rate of the optimizer"""
+    final_lr: float = 1.0e-5
+    """the final learning rate of the optimizer after linearly annealing"""
+    num_envs: int = 32
+    """the number of parallel game environments"""
+    num_steps: int = 512
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_steps: int = 32 * 512 * 10000
+    """the number of steps to linearly anneal the learning rate and entropy coefficient from initial to final"""
+    gamma: float = 0.995
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 8
+    """the number of mini-batches"""
+    update_epochs: int = 3
+    """the K epochs to update the policy"""
+    norm_adv: bool = False
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.1
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    init_ent_coef: float = 0.0001
+    """initial coefficient of the entropy bonus"""
+    final_ent_coef: float = 0.000001
+    """final coefficient of the entropy bonus after linearly annealing"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.25
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # Transformer-XL specific arguments
+    trxl_num_layers: int = 3
+    """the number of transformer layers"""
+    trxl_num_heads: int = 4
+    """the number of heads used in multi-head attention"""
+    trxl_dim: int = 384
+    """the dimension of the transformer"""
+    trxl_memory_length: int = 119
+    """the length of TrXL's sliding memory window"""
+    trxl_positional_encoding: str = "absolute"
+    """the positional encoding type of the transformer, choices: "", "absolute", "learned" """
+    reconstruction_coef: float = 0.0
+    """the coefficient of the observation reconstruction loss, if set to 0.0 the reconstruction loss is not used"""
+
+    # To be filled on runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, idx, capture_video, run_name, render_mode="debug_rgb_array"):
+    if "MiniGrid" in env_id:
+        if render_mode == "debug_rgb_array":
+            render_mode = "rgb_array"
+
+    def thunk():
+        if "MiniGrid" in env_id:
+            env = gym.make(env_id, agent_view_size=3, tile_size=28, render_mode=render_mode)
+            env = ImgObsWrapper(RGBImgPartialObsWrapper(env, tile_size=28))
+            env = gym.wrappers.TimeLimit(env, 96)
+        else:
+            env = gym.make(env_id, render_mode=render_mode)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return gym.wrappers.RecordEpisodeStatistics(env)
+
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    # torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+def batched_index_select(input, dim, index):
+    for ii in range(1, len(input.shape)):
+        if ii != dim:
+            index = index.unsqueeze(ii)
+    expanse = list(input.shape)
+    expanse[0] = -1
+    expanse[dim] = -1
+    index = index.expand(expanse)
+    return torch.gather(input, dim, index)
+
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, dim, min_timescale=2.0, max_timescale=1e4):
+        super().__init__()
+        freqs = torch.arange(0, dim, min_timescale)
+        inv_freqs = max_timescale ** (-freqs / dim)
+        self.register_buffer("inv_freqs", inv_freqs)
+
+    def forward(self, seq_len):
+        seq = torch.arange(seq_len - 1, -1, -1.0)
+        sinusoidal_inp = rearrange(seq, "n -> n ()") * rearrange(self.inv_freqs, "d -> () d")
+        pos_emb = torch.cat((sinusoidal_inp.sin(), sinusoidal_inp.cos()), dim=-1)
+        return pos_emb
+
+
+class MultiHeadAttention(nn.Module):
+    """Multi Head Attention without dropout inspired by https://github.com/aladdinpersson/Machine-Learning-Collection"""
+
+    def __init__(self, embed_dim, num_heads):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.head_size = embed_dim // num_heads
+
+        assert self.head_size * num_heads == embed_dim, "Embedding dimension needs to be divisible by the number of heads"
+
+        self.values = nn.Linear(self.head_size, self.head_size, bias=False)
+        self.keys = nn.Linear(self.head_size, self.head_size, bias=False)
+        self.queries = nn.Linear(self.head_size, self.head_size, bias=False)
+        self.fc_out = nn.Linear(self.num_heads * self.head_size, embed_dim)
+
+    def forward(self, values, keys, query, mask):
+        N = query.shape[0]
+        value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1]
+
+        values = values.reshape(N, value_len, self.num_heads, self.head_size)
+        keys = keys.reshape(N, key_len, self.num_heads, self.head_size)
+        query = query.reshape(N, query_len, self.num_heads, self.head_size)
+
+        values = self.values(values)  # (N, value_len, heads, head_dim)
+        keys = self.keys(keys)  # (N, key_len, heads, head_dim)
+        queries = self.queries(query)  # (N, query_len, heads, heads_dim)
+
+        # Dot-product
+        energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys])
+
+        # Mask padded indices so their attention weights become 0
+        if mask is not None:
+            energy = energy.masked_fill(mask.unsqueeze(1).unsqueeze(1) == 0, float("-1e20"))  # -inf causes NaN
+
+        # Normalize energy values and apply softmax to retrieve the attention scores
+        attention = torch.softmax(
+            energy / (self.embed_dim ** (1 / 2)), dim=3
+        )  # attention shape: (N, heads, query_len, key_len)
+
+        # Scale values by attention weights
+        out = torch.einsum("nhql,nlhd->nqhd", [attention, values]).reshape(N, query_len, self.num_heads * self.head_size)
+
+        return self.fc_out(out), attention
+
+
+class TransformerLayer(nn.Module):
+    def __init__(self, dim, num_heads):
+        super().__init__()
+        self.attention = MultiHeadAttention(dim, num_heads)
+        self.layer_norm_q = nn.LayerNorm(dim)
+        self.norm_kv = nn.LayerNorm(dim)
+        self.layer_norm_attn = nn.LayerNorm(dim)
+        self.fc_projection = nn.Sequential(nn.Linear(dim, dim), nn.ReLU())
+
+    def forward(self, value, key, query, mask):
+        # Pre-layer normalization (post-layer normalization is usually less effective)
+        query_ = self.layer_norm_q(query)
+        value = self.norm_kv(value)
+        key = value  # K = V -> self-attention
+        attention, attention_weights = self.attention(value, key, query_, mask)  # MHA
+        x = attention + query  # Skip connection
+        x_ = self.layer_norm_attn(x)  # Pre-layer normalization
+        forward = self.fc_projection(x_)  # Forward projection
+        out = forward + x  # Skip connection
+        return out, attention_weights
+
+
+class Transformer(nn.Module):
+    def __init__(self, num_layers, dim, num_heads, max_episode_steps, positional_encoding):
+        super().__init__()
+        self.max_episode_steps = max_episode_steps
+        self.positional_encoding = positional_encoding
+        if positional_encoding == "absolute":
+            self.pos_embedding = PositionalEncoding(dim)
+        elif positional_encoding == "learned":
+            self.pos_embedding = nn.Parameter(torch.randn(max_episode_steps, dim))
+        self.transformer_layers = nn.ModuleList([TransformerLayer(dim, num_heads) for _ in range(num_layers)])
+
+    def forward(self, x, memories, mask, memory_indices):
+        # Add positional encoding to every transformer layer input
+        if self.positional_encoding == "absolute":
+            pos_embedding = self.pos_embedding(self.max_episode_steps)[memory_indices]
+            memories = memories + pos_embedding.unsqueeze(2)
+        elif self.positional_encoding == "learned":
+            memories = memories + self.pos_embedding[memory_indices].unsqueeze(2)
+
+        # Forward transformer layers and return new memories (i.e. hidden states)
+        out_memories = []
+        for i, layer in enumerate(self.transformer_layers):
+            out_memories.append(x.detach())
+            x, attention_weights = layer(
+                memories[:, :, i], memories[:, :, i], x.unsqueeze(1), mask
+            )  # args: value, key, query, mask
+            x = x.squeeze()
+            if len(x.shape) == 1:
+                x = x.unsqueeze(0)
+        return x, torch.stack(out_memories, dim=1)
+
+
+class Agent(nn.Module):
+    def __init__(self, args, observation_space, action_space_shape, max_episode_steps):
+        super().__init__()
+        self.obs_shape = observation_space.shape
+        self.max_episode_steps = max_episode_steps
+
+        if len(self.obs_shape) > 1:
+            self.encoder = nn.Sequential(
+                layer_init(nn.Conv2d(3, 32, 8, stride=4)),
+                nn.ReLU(),
+                layer_init(nn.Conv2d(32, 64, 4, stride=2)),
+                nn.ReLU(),
+                layer_init(nn.Conv2d(64, 64, 3, stride=1)),
+                nn.ReLU(),
+                nn.Flatten(),
+                layer_init(nn.Linear(64 * 7 * 7, args.trxl_dim)),
+                nn.ReLU(),
+            )
+        else:
+            self.encoder = layer_init(nn.Linear(observation_space.shape[0], args.trxl_dim))
+
+        self.transformer = Transformer(
+            args.trxl_num_layers, args.trxl_dim, args.trxl_num_heads, self.max_episode_steps, args.trxl_positional_encoding
+        )
+
+        self.hidden_post_trxl = nn.Sequential(
+            layer_init(nn.Linear(args.trxl_dim, args.trxl_dim)),
+            nn.ReLU(),
+        )
+
+        self.actor_branches = nn.ModuleList(
+            [
+                layer_init(nn.Linear(args.trxl_dim, out_features=num_actions), np.sqrt(0.01))
+                for num_actions in action_space_shape
+            ]
+        )
+        self.critic = layer_init(nn.Linear(args.trxl_dim, 1), 1)
+
+        if args.reconstruction_coef > 0.0:
+            self.transposed_cnn = nn.Sequential(
+                layer_init(nn.Linear(args.trxl_dim, 64 * 7 * 7)),
+                nn.ReLU(),
+                nn.Unflatten(1, (64, 7, 7)),
+                layer_init(nn.ConvTranspose2d(64, 64, 3, stride=1)),
+                nn.ReLU(),
+                layer_init(nn.ConvTranspose2d(64, 32, 4, stride=2)),
+                nn.ReLU(),
+                layer_init(nn.ConvTranspose2d(32, 3, 8, stride=4)),
+                nn.Sigmoid(),
+            )
+
+    def get_value(self, x, memory, memory_mask, memory_indices):
+        if len(self.obs_shape) > 1:
+            x = self.encoder(x.permute((0, 3, 1, 2)) / 255.0)
+        else:
+            x = self.encoder(x)
+        x, _ = self.transformer(x, memory, memory_mask, memory_indices)
+        x = self.hidden_post_trxl(x)
+        return self.critic(x).flatten()
+
+    def get_action_and_value(self, x, memory, memory_mask, memory_indices, action=None):
+        if len(self.obs_shape) > 1:
+            x = self.encoder(x.permute((0, 3, 1, 2)) / 255.0)
+        else:
+            x = self.encoder(x)
+        x, memory = self.transformer(x, memory, memory_mask, memory_indices)
+        x = self.hidden_post_trxl(x)
+        self.x = x
+        probs = [Categorical(logits=branch(x)) for branch in self.actor_branches]
+        if action is None:
+            action = torch.stack([dist.sample() for dist in probs], dim=1)
+        log_probs = []
+        for i, dist in enumerate(probs):
+            log_probs.append(dist.log_prob(action[:, i]))
+        entropies = torch.stack([dist.entropy() for dist in probs], dim=1).sum(1).reshape(-1)
+        return action, torch.stack(log_probs, dim=1), entropies, self.critic(x).flatten(), memory
+
+    def reconstruct_observation(self):
+        x = self.transposed_cnn(self.x)
+        return x.permute((0, 2, 3, 1))
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    # Determine the device to be used for training and set the default tensor type
+    if args.cuda:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        torch.set_default_device(device)
+    else:
+        device = torch.device("cpu")
+
+    # Environment setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name) for i in range(args.num_envs)],
+    )
+    observation_space = envs.single_observation_space
+    action_space_shape = (
+        (envs.single_action_space.n,)
+        if isinstance(envs.single_action_space, gym.spaces.Discrete)
+        else tuple(envs.single_action_space.nvec)
+    )
+    env_ids = range(args.num_envs)
+    env_current_episode_step = torch.zeros((args.num_envs,), dtype=torch.long)
+    # Determine maximum episode steps
+    max_episode_steps = envs.envs[0].spec.max_episode_steps
+    if not max_episode_steps:
+        envs.envs[0].reset()  # Memory Gym envs need to be reset before accessing max_episode_steps
+        max_episode_steps = envs.envs[0].max_episode_steps
+    if max_episode_steps <= 0:
+        max_episode_steps = 1024  # Memory Gym envs have max_episode_steps set to -1
+    # Set transformer memory length to max episode steps if greater than max episode steps
+    args.trxl_memory_length = min(args.trxl_memory_length, max_episode_steps)
+
+    agent = Agent(args, observation_space, action_space_shape, max_episode_steps).to(device)
+    optimizer = optim.AdamW(agent.parameters(), lr=args.init_lr)
+    bce_loss = nn.BCELoss()  # Binary cross entropy loss for observation reconstruction
+
+    # ALGO Logic: Storage setup
+    rewards = torch.zeros((args.num_steps, args.num_envs))
+    actions = torch.zeros((args.num_steps, args.num_envs, len(action_space_shape)), dtype=torch.long)
+    dones = torch.zeros((args.num_steps, args.num_envs))
+    obs = torch.zeros((args.num_steps, args.num_envs) + observation_space.shape)
+    log_probs = torch.zeros((args.num_steps, args.num_envs, len(action_space_shape)))
+    values = torch.zeros((args.num_steps, args.num_envs))
+    # The length of stored-memories is equal to the number of sampled episodes during training data sampling
+    # (num_episodes, max_episode_length, num_layers, embed_dim)
+    stored_memories = []
+    # Memory mask used during attention
+    stored_memory_masks = torch.zeros((args.num_steps, args.num_envs, args.trxl_memory_length), dtype=torch.bool)
+    # Index to select the correct episode memory from stored_memories
+    stored_memory_index = torch.zeros((args.num_steps, args.num_envs), dtype=torch.long)
+    # Indices to slice the episode memories into windows
+    stored_memory_indices = torch.zeros((args.num_steps, args.num_envs, args.trxl_memory_length), dtype=torch.long)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    episode_infos = deque(maxlen=100)  # Store episode results for monitoring statistics
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs)
+    # Setup placeholders for each environments's current episodic memory
+    next_memory = torch.zeros((args.num_envs, max_episode_steps, args.trxl_num_layers, args.trxl_dim), dtype=torch.float32)
+    # Generate episodic memory mask used in attention
+    memory_mask = torch.tril(torch.ones((args.trxl_memory_length, args.trxl_memory_length)), diagonal=-1)
+    """ e.g. memory mask tensor looks like this if memory_length = 6
+    0, 0, 0, 0, 0, 0
+    1, 0, 0, 0, 0, 0
+    1, 1, 0, 0, 0, 0
+    1, 1, 1, 0, 0, 0
+    1, 1, 1, 1, 0, 0
+    1, 1, 1, 1, 1, 0
+    """
+    # Setup memory window indices to support a sliding window over the episodic memory
+    repetitions = torch.repeat_interleave(
+        torch.arange(0, args.trxl_memory_length).unsqueeze(0), args.trxl_memory_length - 1, dim=0
+    ).long()
+    memory_indices = torch.stack(
+        [torch.arange(i, i + args.trxl_memory_length) for i in range(max_episode_steps - args.trxl_memory_length + 1)]
+    ).long()
+    memory_indices = torch.cat((repetitions, memory_indices))
+    """ e.g. the memory window indices tensor looks like this if memory_length = 4 and max_episode_length = 7:
+    0, 1, 2, 3
+    0, 1, 2, 3
+    0, 1, 2, 3
+    0, 1, 2, 3
+    1, 2, 3, 4
+    2, 3, 4, 5
+    3, 4, 5, 6
+    """
+
+    for iteration in range(1, args.num_iterations + 1):
+        sampled_episode_infos = []
+
+        # Annealing the learning rate and entropy coefficient if instructed to do so
+        do_anneal = args.anneal_steps > 0 and global_step < args.anneal_steps
+        frac = 1 - global_step / args.anneal_steps if do_anneal else 0
+        lr = (args.init_lr - args.final_lr) * frac + args.final_lr
+        for param_group in optimizer.param_groups:
+            param_group["lr"] = lr
+        ent_coef = (args.init_ent_coef - args.final_ent_coef) * frac + args.final_ent_coef
+
+        # Init episodic memory buffer using each environments' current episodic memory
+        stored_memories = [next_memory[e] for e in range(args.num_envs)]
+        for e in range(args.num_envs):
+            stored_memory_index[:, e] = e
+
+        for step in range(args.num_steps):
+            global_step += args.num_envs
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                obs[step] = next_obs
+                dones[step] = next_done
+                stored_memory_masks[step] = memory_mask[torch.clip(env_current_episode_step, 0, args.trxl_memory_length - 1)]
+                stored_memory_indices[step] = memory_indices[env_current_episode_step]
+                # Retrieve the memory window from the entire episodic memory
+                memory_window = batched_index_select(next_memory, 1, stored_memory_indices[step])
+                action, logprob, _, value, new_memory = agent.get_action_and_value(
+                    next_obs, memory_window, stored_memory_masks[step], stored_memory_indices[step]
+                )
+                next_memory[env_ids, env_current_episode_step] = new_memory
+                # Store the action, log_prob, and value in the buffer
+                actions[step], log_probs[step], values[step] = action, logprob, value
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            # Reset and process episodic memory if done
+            for id, done in enumerate(next_done):
+                if done:
+                    # Reset the environment's current timestep
+                    env_current_episode_step[id] = 0
+                    # Break the reference to the environment's episodic memory
+                    mem_index = stored_memory_index[step, id]
+                    stored_memories[mem_index] = stored_memories[mem_index].clone()
+                    # Reset episodic memory
+                    next_memory[id] = torch.zeros(
+                        (max_episode_steps, args.trxl_num_layers, args.trxl_dim), dtype=torch.float32
+                    )
+                    if step < args.num_steps - 1:
+                        # Store memory inside the buffer
+                        stored_memories.append(next_memory[id])
+                        # Store the reference of to the current episodic memory inside the buffer
+                        stored_memory_index[step + 1 :, id] = len(stored_memories) - 1
+                else:
+                    # Increment environment timestep if not done
+                    env_current_episode_step[id] += 1
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        sampled_episode_infos.append(info["episode"])
+
+        # Bootstrap value if not done
+        with torch.no_grad():
+            start = torch.clip(env_current_episode_step - args.trxl_memory_length, 0)
+            end = torch.clip(env_current_episode_step, args.trxl_memory_length)
+            indices = torch.stack([torch.arange(start[b], end[b]) for b in range(args.num_envs)]).long()
+            memory_window = batched_index_select(next_memory, 1, indices)  # Retrieve the memory window from the entire episode
+            next_value = agent.get_value(
+                next_obs,
+                memory_window,
+                memory_mask[torch.clip(env_current_episode_step, 0, args.trxl_memory_length - 1)],
+                stored_memory_indices[-1],
+            )
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # Flatten the batch
+        b_obs = obs.reshape(-1, *obs.shape[2:])
+        b_logprobs = log_probs.reshape(-1, *log_probs.shape[2:])
+        b_actions = actions.reshape(-1, *actions.shape[2:])
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+        b_memory_index = stored_memory_index.reshape(-1)
+        b_memory_indices = stored_memory_indices.reshape(-1, *stored_memory_indices.shape[2:])
+        b_memory_mask = stored_memory_masks.reshape(-1, *stored_memory_masks.shape[2:])
+        stored_memories = torch.stack(stored_memories, dim=0)
+
+        # Remove unnecessary padding from TrXL memory, if applicable
+        actual_max_episode_steps = (stored_memory_indices * stored_memory_masks).max().item() + 1
+        if actual_max_episode_steps < args.trxl_memory_length:
+            b_memory_indices = b_memory_indices[:, :actual_max_episode_steps]
+            b_memory_mask = b_memory_mask[:, :actual_max_episode_steps]
+            stored_memories = stored_memories[:, :actual_max_episode_steps]
+
+        # Optimizing the policy and value network
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            b_inds = torch.randperm(args.batch_size)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+                mb_memories = stored_memories[b_memory_index[mb_inds]]
+                mb_memory_windows = batched_index_select(mb_memories, 1, b_memory_indices[mb_inds])
+
+                _, newlogprob, entropy, newvalue, _ = agent.get_action_and_value(
+                    b_obs[mb_inds], mb_memory_windows, b_memory_mask[mb_inds], b_memory_indices[mb_inds], b_actions[mb_inds]
+                )
+
+                # Policy loss
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+                mb_advantages = mb_advantages.unsqueeze(1).repeat(
+                    1, len(action_space_shape)
+                )  # Repeat is necessary for multi-discrete action spaces
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = torch.exp(logratio)
+                pgloss1 = -mb_advantages * ratio
+                pgloss2 = -mb_advantages * torch.clamp(ratio, 1.0 - args.clip_coef, 1.0 + args.clip_coef)
+                pg_loss = torch.max(pgloss1, pgloss2).mean()
+
+                # Value loss
+                v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                if args.clip_vloss:
+                    v_loss_clipped = b_values[mb_inds] + (newvalue - b_values[mb_inds]).clamp(
+                        min=-args.clip_coef, max=args.clip_coef
+                    )
+                    v_loss = torch.max(v_loss_unclipped, (v_loss_clipped - b_returns[mb_inds]) ** 2).mean()
+                else:
+                    v_loss = v_loss_unclipped.mean()
+
+                # Entropy loss
+                entropy_loss = entropy.mean()
+
+                # Combined losses
+                loss = pg_loss - ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                # Add reconstruction loss if used
+                r_loss = torch.tensor(0.0)
+                if args.reconstruction_coef > 0.0:
+                    r_loss = bce_loss(agent.reconstruct_observation(), b_obs[mb_inds] / 255.0)
+                    loss += args.reconstruction_coef * r_loss
+
+                optimizer.zero_grad()
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(agent.parameters(), max_norm=args.max_grad_norm)
+                optimizer.step()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # Log and monitor training statistics
+        episode_infos.extend(sampled_episode_infos)
+        episode_result = {}
+        if len(episode_infos) > 0:
+            for key in episode_infos[0].keys():
+                episode_result[key + "_mean"] = np.mean([info[key] for info in episode_infos])
+
+        print(
+            "{:9} SPS={:4} return={:.2f} length={:.1f} pi_loss={:.3f} v_loss={:.3f} entropy={:.3f} r_loss={:.3f} value={:.3f} adv={:.3f}".format(
+                iteration,
+                int(global_step / (time.time() - start_time)),
+                episode_result["r_mean"],
+                episode_result["l_mean"],
+                pg_loss.item(),
+                v_loss.item(),
+                entropy_loss.item(),
+                r_loss.item(),
+                torch.mean(values),
+                torch.mean(advantages),
+            )
+        )
+
+        if episode_result:
+            for key in episode_result:
+                writer.add_scalar("episode/" + key, episode_result[key], global_step)
+        writer.add_scalar("episode/value_mean", torch.mean(values), global_step)
+        writer.add_scalar("episode/advantage_mean", torch.mean(advantages), global_step)
+        writer.add_scalar("charts/learning_rate", lr, global_step)
+        writer.add_scalar("charts/entropy_coefficient", ent_coef, global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/loss", loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/reconstruction_loss", r_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    if args.save_model:
+        model_path = f"runs/{run_name}/{args.exp_name}.cleanrl_model"
+        model_data = {
+            "model_weights": agent.state_dict(),
+            "args": vars(args),
+        }
+        torch.save(model_data, model_path)
+        print(f"model saved to {model_path}")
+
+    writer.close()
+    envs.close()

cleanrl/cleanrl/ppo_trxl/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "ppo-trxl"
+version = "1.0.1"
+description = ""
+authors = [{ name = "Marco Pleines", email = "marco.pleines@tu-dortmund.de" }]
+requires-python = "~=3.10"
+license = "MIT"
+dependencies = [
+    "memory-gym>=1.0.2,<2",
+    "einops>=0.7.0,<0.8",
+    "minigrid>=2.3.1,<3",
+    "reprint>=0.6.0,<0.7",
+    "opencv-python>=4.9.0.80,<5",
+    "torch>=2.0.0,<3",
+    "torchaudio>=2.0.0,<3",
+    "wandb>=0.16.6,<0.17",
+    "tyro>=0.8.3,<0.9",
+    "tensorboard>=2.16.2,<3",
+]
+
+[tool.uv]
+
+[[tool.uv.index]]
+name = "pytorch"
+url = "https://download.pytorch.org/whl/cu118"
+explicit = true
+
+[tool.uv.sources]
+torch = { index = "pytorch" }
+torchaudio = { index = "pytorch" }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

cleanrl/cleanrl/ppo_ultrahorizon.py

@@ -0,0 +1,490 @@
+# PPO implementation for Ultrahorizon Grid Environment
+# Adapted from ppo_atari.py for text-based grid environment
+import os
+import random
+import time
+from dataclasses import dataclass
+import sys
+
+# Add parent directory to path to import the wrapper
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+from tqdm import tqdm
+from ultrahorizon_gym_wrapper import make_ultrahorizon_env, Difficulty
+import json
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = True
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "Ultrahorizon-v0"
+    """the id of the environment"""
+    difficulty: str = "EASY"
+    """difficulty level: EASY, MEDIUM, or HARD"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 4
+    """the number of parallel game environments"""
+    num_steps: int = 512
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    """
+    Neural network agent for Ultrahorizon environment.
+    Uses MLP instead of CNN since observations are feature vectors, not images.
+    """
+    def __init__(self, envs):
+        super().__init__()
+        # Get observation space dimension
+        obs_dim = np.array(envs.single_observation_space.shape).prod()
+        
+        # MLP network for processing feature vectors
+        self.network = nn.Sequential(
+            layer_init(nn.Linear(obs_dim, 256)),
+            nn.ReLU(),
+            layer_init(nn.Linear(256, 256)),
+            nn.ReLU(),
+            layer_init(nn.Linear(256, 128)),
+            nn.ReLU(),
+        )
+        self.actor = layer_init(nn.Linear(128, envs.single_action_space.n), std=0.01)
+        self.critic = layer_init(nn.Linear(128, 1), std=1)
+
+    def get_value(self, x):
+        return self.critic(self.network(x))
+
+    def get_action_and_value(self, x, action=None):
+        hidden = self.network(x)
+        logits = self.actor(hidden)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(hidden)
+
+
+def test_policy(agent, difficulty, device, num_episodes=10, seed=None):
+    """
+    Test the current policy and collect trajectories and rewards.
+    
+    Args:
+        agent: The trained agent
+        difficulty: Difficulty level for the environment
+        device: torch device
+        num_episodes: Number of episodes to test
+        seed: Random seed for testing
+    
+    Returns:
+        dict: Dictionary containing test results including trajectories and rewards
+    """
+    # Create a single test environment
+    test_env = make_ultrahorizon_env(difficulty=difficulty, free=True)()
+    
+    test_results = {
+        'episode_returns': [],
+        'episode_lengths': [],
+        'final_scores': [],
+        'trajectories': []  # Store trajectories for each episode
+    }
+    
+    agent.eval()  # Set agent to evaluation mode
+    
+    for episode in range(num_episodes):
+        obs, _ = test_env.reset(seed=seed + episode if seed is not None else None)
+        done = False
+        episode_return = 0
+        episode_length = 0
+        trajectory = {
+            'observations': [],
+            'actions': [],
+            'rewards': [],
+            'dones': []
+        }
+        
+        while not done:
+            # Store observation
+            trajectory['observations'].append(obs.tolist())
+            
+            # Get action from policy
+            with torch.no_grad():
+                obs_tensor = torch.Tensor(obs).unsqueeze(0).to(device)
+                action, _, _, _ = agent.get_action_and_value(obs_tensor)
+                action = action.cpu().numpy()[0]
+            
+            # Take action in environment
+            next_obs, reward, terminated, truncated, info = test_env.step(action)
+            done = terminated or truncated
+            
+            # Store trajectory data
+            trajectory['actions'].append(int(action))
+            trajectory['rewards'].append(float(reward))
+            trajectory['dones'].append(done)
+            
+            episode_return += reward
+            episode_length += 1
+            obs = next_obs
+        
+        # Store episode results
+        test_results['episode_returns'].append(float(episode_return))
+        test_results['episode_lengths'].append(episode_length)
+        test_results['final_scores'].append(float(info.get('final_score', 0.0)))
+        test_results['trajectories'].append(trajectory)
+    
+    agent.train()  # Set agent back to training mode
+    test_env.close()
+    
+    # Calculate statistics
+    test_results['mean_return'] = np.mean(test_results['episode_returns'])
+    test_results['std_return'] = np.std(test_results['episode_returns'])
+    test_results['mean_length'] = np.mean(test_results['episode_lengths'])
+    test_results['mean_final_score'] = np.mean(test_results['final_scores'])
+    test_results['std_final_score'] = np.std(test_results['final_scores'])
+    
+    return test_results
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}_{args.difficulty.upper()}__{int(time.time())}"
+    
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup - convert difficulty string to enum
+    difficulty_map = {
+        "EASY": Difficulty.EASY,
+        "MEDIUM": Difficulty.MEDIUM,
+        "HARD": Difficulty.HARD
+    }
+
+    difficulty = difficulty_map.get(args.difficulty.upper(), Difficulty.EASY)
+    
+    envs = gym.vector.SyncVectorEnv(
+        [make_ultrahorizon_env(difficulty=difficulty, free=True) for i in range(args.num_envs)],
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+    
+    # Setup for testing at 10% intervals
+    test_interval = args.num_iterations // 10
+    test_results_history = []  # Store all test results
+    test_save_dir = f"runs/{run_name}/test_results"
+    os.makedirs(test_save_dir, exist_ok=True)
+
+    for iteration in tqdm(range(1, args.num_iterations + 1)):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            # Handle terminal observations correctly
+            # When an episode ends, next_obs is the initial state of the new episode
+            # We need to use the final observation from the terminated episode for bootstrapping
+            if "final_observation" in infos:
+                for idx, final_obs in enumerate(infos["final_observation"]):
+                    if final_obs is not None:
+                        # Replace the reset observation with the actual final observation
+                        next_obs[idx] = torch.Tensor(final_obs).to(device)
+
+            # import pdb;pdb.set_trace()
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        episode_return = info['episode']['r']
+                        episode_length = info['episode']['l']
+                        final_score = info.get('final_score', 0.0)  # Get cumulative score from environment
+                        # import pdb;pdb.set_trace()
+                        # print(f"global_step={global_step}, episodic_return={episode_return}, episodic_length={episode_length},final_score={final_score}")
+                        writer.add_scalar("charts/episodic_return", episode_return, global_step)
+                        writer.add_scalar("charts/episodic_length", episode_length, global_step)
+                        writer.add_scalar("charts/final_score", final_score, global_step)
+
+        # import pdb;pdb.set_trace()
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        
+        # Additional useful metrics
+        writer.add_scalar("charts/avg_reward", rewards.mean().item(), global_step)
+        writer.add_scalar("charts/avg_value", values.mean().item(), global_step)
+        writer.add_scalar("charts/max_reward", rewards.max().item(), global_step)
+        writer.add_scalar("charts/min_reward", rewards.min().item(), global_step)
+        
+        # Console output with key metrics
+        sps = int(global_step / (time.time() - start_time))
+        print(f"Iter {iteration}/{args.num_iterations} | SPS: {sps} | "
+              f"Avg Reward: {rewards.mean().item():.3f} | "
+              f"Value Loss: {v_loss.item():.4f} | "
+              f"Policy Loss: {pg_loss.item():.4f} | "
+              f"Entropy: {entropy_loss.item():.4f}")
+        print(f"global_step={global_step}, episodic_return={episode_return}, episodic_length={episode_length},final_score={final_score}")
+        writer.add_scalar("charts/SPS", sps, global_step)
+        
+        # Test policy at 10% intervals
+        if iteration % test_interval == 0 or iteration == args.num_iterations:
+            print(f"\n{'='*60}")
+            print(f"Testing policy at iteration {iteration}/{args.num_iterations} ({100*iteration//args.num_iterations}%)")
+            print(f"{'='*60}")
+            
+            test_results = test_policy(
+                agent=agent,
+                difficulty=difficulty,
+                device=device,
+                num_episodes=10,
+                seed=args.seed
+            )
+            
+            # Log test results to tensorboard
+            writer.add_scalar("test/mean_return", test_results['mean_return'], global_step)
+            writer.add_scalar("test/std_return", test_results['std_return'], global_step)
+            writer.add_scalar("test/mean_length", test_results['mean_length'], global_step)
+            writer.add_scalar("test/mean_final_score", test_results['mean_final_score'], global_step)
+            writer.add_scalar("test/std_final_score", test_results['std_final_score'], global_step)
+            
+            # Print test results
+            print(f"Test Results (10 episodes):")
+            print(f"  Mean Return: {test_results['mean_return']:.2f} ± {test_results['std_return']:.2f}")
+            print(f"  Mean Length: {test_results['mean_length']:.2f}")
+            print(f"  Mean Final Score: {test_results['mean_final_score']:.2f} ± {test_results['std_final_score']:.2f}")
+            print(f"{'='*60}\n")
+            
+            # Save test results to file
+            test_results_with_metadata = {
+                'iteration': iteration,
+                'global_step': global_step,
+                'training_progress': iteration / args.num_iterations,
+                'test_results': test_results
+            }
+            test_results_history.append(test_results_with_metadata)
+            
+            # Save individual test result
+            test_file = f"{test_save_dir}/test_iter_{iteration}.json"
+            with open(test_file, 'w') as f:
+                json.dump(test_results_with_metadata, f, indent=2)
+            print(f"Saved test results to {test_file}")
+
+    envs.close()
+    writer.close()
+    torch.save(agent.state_dict(), f"runs/{run_name}/agent_{global_step}.pt")
+    print(f"Saved model at global_step={global_step}")
+    
+    # Save all test results history
+    test_history_file = f"{test_save_dir}/test_history.json"
+    with open(test_history_file, 'w') as f:
+        json.dump(test_results_history, f, indent=2)
+    print(f"Saved complete test history to {test_history_file}")

cleanrl/cleanrl/pqn.py

@@ -0,0 +1,248 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/pqn/#pqnpy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import tyro
+from torch.utils.tensorboard import SummaryWriter
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "CartPole-v1"
+    """the id of the environment"""
+    total_timesteps: int = 500000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 4
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run for each environment per update"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    start_e: float = 1
+    """the starting epsilon for exploration"""
+    end_e: float = 0.05
+    """the ending epsilon for exploration"""
+    exploration_fraction: float = 0.5
+    """the fraction of `total_timesteps` it takes from start_e to end_e"""
+    max_grad_norm: float = 10.0
+    """the maximum norm for the gradient clipping"""
+    q_lambda: float = 0.65
+    """the lambda for Q(lambda)"""
+
+
+def make_env(env_id, seed, idx, capture_video, run_name):
+    def thunk():
+        if capture_video and idx == 0:
+            env = gym.make(env_id, render_mode="rgb_array")
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        else:
+            env = gym.make(env_id)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        env.action_space.seed(seed)
+
+        return env
+
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+# ALGO LOGIC: initialize agent here:
+class QNetwork(nn.Module):
+    def __init__(self, env):
+        super().__init__()
+
+        self.network = nn.Sequential(
+            layer_init(nn.Linear(np.array(env.single_observation_space.shape).prod(), 120)),
+            nn.LayerNorm(120),
+            nn.ReLU(),
+            layer_init(nn.Linear(120, 84)),
+            nn.LayerNorm(84),
+            nn.ReLU(),
+            layer_init(nn.Linear(84, env.single_action_space.n)),
+        )
+
+    def forward(self, x):
+        return self.network(x)
+
+
+def linear_schedule(start_e: float, end_e: float, duration: int, t: int):
+    slope = (end_e - start_e) / duration
+    return max(slope * t + start_e, end_e)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, args.seed + i, i, args.capture_video, run_name) for i in range(args.num_envs)]
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    # agent setup
+    q_network = QNetwork(envs).to(device)
+    optimizer = optim.RAdam(q_network.parameters(), lr=args.learning_rate)
+
+    # storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            epsilon = linear_schedule(args.start_e, args.end_e, args.exploration_fraction * args.total_timesteps, global_step)
+            random_actions = torch.randint(0, envs.single_action_space.n, (args.num_envs,)).to(device)
+            with torch.no_grad():
+                q_values = q_network(next_obs)
+                max_actions = torch.argmax(q_values, dim=1)
+                values[step] = q_values[torch.arange(args.num_envs), max_actions].flatten()
+
+            explore = torch.rand((args.num_envs,)).to(device) < epsilon
+            action = torch.where(explore, random_actions, max_actions)
+            actions[step] = action
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+
+        # Compute Q(lambda) targets
+        with torch.no_grad():
+            returns = torch.zeros_like(rewards).to(device)
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    next_value, _ = torch.max(q_network(next_obs), dim=-1)
+                    nextnonterminal = 1.0 - next_done
+                    returns[t] = rewards[t] + args.gamma * next_value * nextnonterminal
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    next_value = values[t + 1]
+                    returns[t] = (
+                        rewards[t]
+                        + args.gamma * (args.q_lambda * returns[t + 1] + (1 - args.q_lambda) * next_value) * nextnonterminal
+                    )
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_returns = returns.reshape(-1)
+
+        # Optimizing the Q-network
+        b_inds = np.arange(args.batch_size)
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                old_val = q_network(b_obs[mb_inds]).gather(1, b_actions[mb_inds].unsqueeze(-1).long()).squeeze()
+                loss = F.mse_loss(b_returns[mb_inds], old_val)
+
+                # optimize the model
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(q_network.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+        writer.add_scalar("losses/td_loss", loss, global_step)
+        writer.add_scalar("losses/q_values", old_val.mean().item(), global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/pqn_atari_envpool_lstm.py

@@ -0,0 +1,339 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/pqn/#pqn_atari_envpool_lstmpy
+import os
+import random
+import time
+from collections import deque
+from dataclasses import dataclass
+
+import envpool
+import gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import tyro
+from torch.utils.tensorboard import SummaryWriter
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "Breakout-v5"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 8
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    start_e: float = 1
+    """the starting epsilon for exploration"""
+    end_e: float = 0.01
+    """the ending epsilon for exploration"""
+    exploration_fraction: float = 0.10
+    """the fraction of `total_timesteps` it takes from start_e to end_e"""
+    q_lambda: float = 0.65
+    """the lambda for the Q-Learning algorithm"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+class RecordEpisodeStatistics(gym.Wrapper):
+    def __init__(self, env, deque_size=100):
+        super().__init__(env)
+        self.num_envs = getattr(env, "num_envs", 1)
+        self.episode_returns = None
+        self.episode_lengths = None
+
+    def reset(self, **kwargs):
+        observations = super().reset(**kwargs)
+        self.episode_returns = np.zeros(self.num_envs, dtype=np.float32)
+        self.episode_lengths = np.zeros(self.num_envs, dtype=np.int32)
+        self.lives = np.zeros(self.num_envs, dtype=np.int32)
+        self.returned_episode_returns = np.zeros(self.num_envs, dtype=np.float32)
+        self.returned_episode_lengths = np.zeros(self.num_envs, dtype=np.int32)
+        return observations
+
+    def step(self, action):
+        observations, rewards, dones, infos = super().step(action)
+        self.episode_returns += infos["reward"]
+        self.episode_lengths += 1
+        self.returned_episode_returns[:] = self.episode_returns
+        self.returned_episode_lengths[:] = self.episode_lengths
+        self.episode_returns *= 1 - infos["terminated"]
+        self.episode_lengths *= 1 - infos["terminated"]
+        infos["r"] = self.returned_episode_returns
+        infos["l"] = self.returned_episode_lengths
+        return (
+            observations,
+            rewards,
+            dones,
+            infos,
+        )
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class QNetwork(nn.Module):
+    def __init__(self, env):
+        super().__init__()
+        self.network = nn.Sequential(
+            layer_init(nn.Conv2d(1, 32, 8, stride=4)),
+            nn.LayerNorm([32, 20, 20]),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(32, 64, 4, stride=2)),
+            nn.LayerNorm([64, 9, 9]),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 64, 3, stride=1)),
+            nn.LayerNorm([64, 7, 7]),
+            nn.ReLU(),
+            nn.Flatten(),
+            layer_init(nn.Linear(3136, 512)),
+            nn.LayerNorm(512),
+            nn.ReLU(),
+        )
+        self.lstm = nn.LSTM(512, 128)
+        for name, param in self.lstm.named_parameters():
+            if "bias" in name:
+                nn.init.constant_(param, 0)
+            elif "weight" in name:
+                nn.init.orthogonal_(param, 1.0)
+        self.q_func = layer_init(nn.Linear(128, env.single_action_space.n))
+
+    def get_states(self, x, lstm_state, done):
+        hidden = self.network(x / 255.0)
+
+        # LSTM logic
+        batch_size = lstm_state[0].shape[1]
+        hidden = hidden.reshape((-1, batch_size, self.lstm.input_size))
+        done = done.reshape((-1, batch_size))
+        new_hidden = []
+        for h, d in zip(hidden, done):
+            h, lstm_state = self.lstm(
+                h.unsqueeze(0),
+                (
+                    (1.0 - d).view(1, -1, 1) * lstm_state[0],
+                    (1.0 - d).view(1, -1, 1) * lstm_state[1],
+                ),
+            )
+            new_hidden += [h]
+        new_hidden = torch.flatten(torch.cat(new_hidden), 0, 1)
+        return new_hidden, lstm_state
+
+    def forward(self, x, lstm_state, done):
+        hidden, lstm_state = self.get_states(x, lstm_state, done)
+        return self.q_func(hidden), lstm_state
+
+
+def linear_schedule(start_e: float, end_e: float, duration: int, t: int):
+    slope = (end_e - start_e) / duration
+    return max(slope * t + start_e, end_e)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = envpool.make(
+        args.env_id,
+        env_type="gym",
+        num_envs=args.num_envs,
+        episodic_life=True,
+        reward_clip=True,
+        seed=args.seed,
+        stack_num=1,
+    )
+    envs.num_envs = args.num_envs
+    envs.single_action_space = envs.action_space
+    envs.single_observation_space = envs.observation_space
+    envs = RecordEpisodeStatistics(envs)
+    assert isinstance(envs.action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    q_network = QNetwork(envs).to(device)
+    optimizer = optim.RAdam(q_network.parameters(), lr=args.learning_rate)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    avg_returns = deque(maxlen=20)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs = torch.Tensor(envs.reset()).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    next_lstm_state = (
+        torch.zeros(q_network.lstm.num_layers, args.num_envs, q_network.lstm.hidden_size).to(device),
+        torch.zeros(q_network.lstm.num_layers, args.num_envs, q_network.lstm.hidden_size).to(device),
+    )  # hidden and cell states (see https://youtu.be/8HyCNIVRbSU)
+
+    for iteration in range(1, args.num_iterations + 1):
+        initial_lstm_state = (next_lstm_state[0].clone(), next_lstm_state[1].clone())
+
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            epsilon = linear_schedule(args.start_e, args.end_e, args.exploration_fraction * args.total_timesteps, global_step)
+
+            random_actions = torch.randint(0, envs.single_action_space.n, (args.num_envs,)).to(device)
+            with torch.no_grad():
+                q_values, next_lstm_state = q_network(next_obs, next_lstm_state, next_done)
+                max_actions = torch.argmax(q_values, dim=1)
+                values[step] = q_values[torch.arange(args.num_envs), max_actions].flatten()
+
+            explore = torch.rand((args.num_envs,)).to(device) < epsilon
+            action = torch.where(explore, random_actions, max_actions)
+            actions[step] = action
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, next_done, info = envs.step(action.cpu().numpy())
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            for idx, d in enumerate(next_done):
+                if d and info["lives"][idx] == 0:
+                    print(f"global_step={global_step}, episodic_return={info['r'][idx]}")
+                    avg_returns.append(info["r"][idx])
+                    writer.add_scalar("charts/avg_episodic_return", np.average(avg_returns), global_step)
+                    writer.add_scalar("charts/episodic_return", info["r"][idx], global_step)
+                    writer.add_scalar("charts/episodic_length", info["l"][idx], global_step)
+
+        # Compute Q(lambda) targets
+        with torch.no_grad():
+            returns = torch.zeros_like(rewards).to(device)
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    next_value, _ = torch.max(q_network(next_obs, next_lstm_state, next_done)[0], dim=-1)
+                    nextnonterminal = 1.0 - next_done
+                    returns[t] = rewards[t] + args.gamma * next_value * nextnonterminal
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    next_value = values[t + 1]
+                    returns[t] = (
+                        rewards[t]
+                        + args.gamma * (args.q_lambda * returns[t + 1] + (1 - args.q_lambda) * next_value) * nextnonterminal
+                    )
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_returns = returns.reshape(-1)
+        b_dones = dones.reshape(-1)
+
+        assert args.num_envs % args.num_minibatches == 0
+        envsperbatch = args.num_envs // args.num_minibatches
+        envinds = np.arange(args.num_envs)
+        flatinds = np.arange(args.batch_size).reshape(args.num_steps, args.num_envs)
+
+        # Optimizing the Q-network
+        b_inds = np.arange(args.batch_size)
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(envinds)
+            for start in range(0, args.num_envs, envsperbatch):
+                end = start + envsperbatch
+                mbenvinds = envinds[start:end]
+                mb_inds = flatinds[:, mbenvinds].ravel()  # be really careful about the index
+
+                old_val, _ = q_network(
+                    b_obs[mb_inds],
+                    (initial_lstm_state[0][:, mbenvinds], initial_lstm_state[1][:, mbenvinds]),
+                    b_dones[mb_inds],
+                )
+                old_val = old_val.gather(1, b_actions[mb_inds].unsqueeze(-1).long()).squeeze()
+
+                loss = F.mse_loss(b_returns[mb_inds], old_val)
+
+                # optimize the model
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(q_network.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+        writer.add_scalar("losses/td_loss", loss, global_step)
+        writer.add_scalar("losses/q_values", old_val.mean().item(), global_step)
+        print("SPS:", int(global_step / (time.time() - start_time)))
+        writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/qdagger_dqn_atari_impalacnn.py

@@ -0,0 +1,466 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/qdagger/#qdagger_dqn_atari_jax_impalacnnpy
+import os
+import random
+import time
+from collections import deque
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import tyro
+from huggingface_hub import hf_hub_download
+from rich.progress import track
+from torch.utils.tensorboard import SummaryWriter
+
+from cleanrl.dqn_atari import QNetwork as TeacherModel
+from cleanrl_utils.atari_wrappers import (
+    ClipRewardEnv,
+    EpisodicLifeEnv,
+    FireResetEnv,
+    MaxAndSkipEnv,
+    NoopResetEnv,
+)
+from cleanrl_utils.buffers import ReplayBuffer
+from cleanrl_utils.evals.dqn_eval import evaluate
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_model: bool = False
+    """whether to save model into the `runs/{run_name}` folder"""
+    upload_model: bool = False
+    """whether to upload the saved model to huggingface"""
+    hf_entity: str = ""
+    """the user or org name of the model repository from the Hugging Face Hub"""
+
+    # Algorithm specific arguments
+    env_id: str = "BreakoutNoFrameskip-v4"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 1e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 1
+    """the number of parallel game environments"""
+    buffer_size: int = 1000000
+    """the replay memory buffer size"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    tau: float = 1.0
+    """the target network update rate"""
+    target_network_frequency: int = 1000
+    """the timesteps it takes to update the target network"""
+    batch_size: int = 32
+    """the batch size of sample from the reply memory"""
+    start_e: float = 1.0
+    """the starting epsilon for exploration"""
+    end_e: float = 0.01
+    """the ending epsilon for exploration"""
+    exploration_fraction: float = 0.10
+    """the fraction of `total-timesteps` it takes from start-e to go end-e"""
+    learning_starts: int = 80000
+    """timestep to start learning"""
+    train_frequency: int = 4
+    """the frequency of training"""
+
+    # QDagger specific arguments
+    teacher_policy_hf_repo: str = None
+    """the huggingface repo of the teacher policy"""
+    teacher_model_exp_name: str = "dqn_atari"
+    """the experiment name of the teacher model"""
+    teacher_eval_episodes: int = 10
+    """the number of episodes to run the teacher policy evaluate"""
+    teacher_steps: int = 500000
+    """the number of steps to run the teacher policy to generate the replay buffer"""
+    offline_steps: int = 500000
+    """the number of steps to run the student policy with the teacher's replay buffer"""
+    temperature: float = 1.0
+    """the temperature parameter for qdagger"""
+
+
+def make_env(env_id, seed, idx, capture_video, run_name):
+    def thunk():
+        if capture_video and idx == 0:
+            env = gym.make(env_id, render_mode="rgb_array")
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        else:
+            env = gym.make(env_id)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        env = NoopResetEnv(env, noop_max=30)
+        env = MaxAndSkipEnv(env, skip=4)
+        env = EpisodicLifeEnv(env)
+        if "FIRE" in env.unwrapped.get_action_meanings():
+            env = FireResetEnv(env)
+        env = ClipRewardEnv(env)
+        env = gym.wrappers.ResizeObservation(env, (84, 84))
+        env = gym.wrappers.GrayScaleObservation(env)
+        env = gym.wrappers.FrameStack(env, 4)
+        env.action_space.seed(seed)
+
+        return env
+
+    return thunk
+
+
+# taken from https://github.com/AIcrowd/neurips2020-procgen-starter-kit/blob/142d09586d2272a17f44481a115c4bd817cf6a94/models/impala_cnn_torch.py
+class ResidualBlock(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.conv0 = nn.Conv2d(in_channels=channels, out_channels=channels, kernel_size=3, padding=1)
+        self.conv1 = nn.Conv2d(in_channels=channels, out_channels=channels, kernel_size=3, padding=1)
+
+    def forward(self, x):
+        inputs = x
+        x = nn.functional.relu(x)
+        x = self.conv0(x)
+        x = nn.functional.relu(x)
+        x = self.conv1(x)
+        return x + inputs
+
+
+class ConvSequence(nn.Module):
+    def __init__(self, input_shape, out_channels):
+        super().__init__()
+        self._input_shape = input_shape
+        self._out_channels = out_channels
+        self.conv = nn.Conv2d(in_channels=self._input_shape[0], out_channels=self._out_channels, kernel_size=3, padding=1)
+        self.res_block0 = ResidualBlock(self._out_channels)
+        self.res_block1 = ResidualBlock(self._out_channels)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = nn.functional.max_pool2d(x, kernel_size=3, stride=2, padding=1)
+        x = self.res_block0(x)
+        x = self.res_block1(x)
+        assert x.shape[1:] == self.get_output_shape()
+        return x
+
+    def get_output_shape(self):
+        _c, h, w = self._input_shape
+        return (self._out_channels, (h + 1) // 2, (w + 1) // 2)
+
+
+# ALGO LOGIC: initialize agent here:
+class QNetwork(nn.Module):
+    def __init__(self, env):
+        super().__init__()
+        c, h, w = envs.single_observation_space.shape
+        shape = (c, h, w)
+        conv_seqs = []
+        for out_channels in [16, 32, 32]:
+            conv_seq = ConvSequence(shape, out_channels)
+            shape = conv_seq.get_output_shape()
+            conv_seqs.append(conv_seq)
+        conv_seqs += [
+            nn.Flatten(),
+            nn.ReLU(),
+            nn.Linear(in_features=shape[0] * shape[1] * shape[2], out_features=256),
+            nn.ReLU(),
+            nn.Linear(in_features=256, out_features=env.single_action_space.n),
+        ]
+        self.network = nn.Sequential(*conv_seqs)
+
+    def forward(self, x):
+        return self.network(x / 255.0)
+
+
+def linear_schedule(start_e: float, end_e: float, duration: int, t: int):
+    slope = (end_e - start_e) / duration
+    return max(slope * t + start_e, end_e)
+
+
+def kl_divergence_with_logits(target_logits, prediction_logits):
+    """Implementation of on-policy distillation loss."""
+    out = -F.softmax(target_logits, dim=-1) * (F.log_softmax(prediction_logits, dim=-1) - F.log_softmax(target_logits, dim=-1))
+    return torch.sum(out)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    assert args.num_envs == 1, "vectorized envs are not supported at the moment"
+    if args.teacher_policy_hf_repo is None:
+        args.teacher_policy_hf_repo = f"cleanrl/{args.env_id}-{args.teacher_model_exp_name}-seed1"
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, args.seed + i, i, args.capture_video, run_name) for i in range(args.num_envs)]
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    q_network = QNetwork(envs).to(device)
+    optimizer = optim.Adam(q_network.parameters(), lr=args.learning_rate)
+    target_network = QNetwork(envs).to(device)
+    target_network.load_state_dict(q_network.state_dict())
+
+    # QDAGGER LOGIC:
+    teacher_model_path = hf_hub_download(
+        repo_id=args.teacher_policy_hf_repo, filename=f"{args.teacher_model_exp_name}.cleanrl_model"
+    )
+    teacher_model = TeacherModel(envs).to(device)
+    teacher_model.load_state_dict(torch.load(teacher_model_path, map_location=device))
+    teacher_model.eval()
+
+    # evaluate the teacher model
+    teacher_episodic_returns = evaluate(
+        teacher_model_path,
+        make_env,
+        args.env_id,
+        eval_episodes=args.teacher_eval_episodes,
+        run_name=f"{run_name}-teacher-eval",
+        Model=TeacherModel,
+        epsilon=args.end_e,
+        capture_video=False,
+    )
+    writer.add_scalar("charts/teacher/avg_episodic_return", np.mean(teacher_episodic_returns), 0)
+
+    # collect teacher data for args.teacher_steps
+    # we assume we don't have access to the teacher's replay buffer
+    # see Fig. A.19 in Agarwal et al. 2022 for more detail
+    teacher_rb = ReplayBuffer(
+        args.buffer_size,
+        envs.single_observation_space,
+        envs.single_action_space,
+        device,
+        optimize_memory_usage=True,
+        handle_timeout_termination=False,
+    )
+
+    obs, _ = envs.reset(seed=args.seed)
+    for global_step in track(range(args.teacher_steps), description="filling teacher's replay buffer"):
+        epsilon = linear_schedule(args.start_e, args.end_e, args.teacher_steps, global_step)
+        if random.random() < epsilon:
+            actions = np.array([envs.single_action_space.sample() for _ in range(envs.num_envs)])
+        else:
+            q_values = teacher_model(torch.Tensor(obs).to(device))
+            actions = torch.argmax(q_values, dim=1).cpu().numpy()
+        next_obs, rewards, terminations, truncations, infos = envs.step(actions)
+        real_next_obs = next_obs.copy()
+        for idx, trunc in enumerate(truncations):
+            if trunc:
+                real_next_obs[idx] = infos["final_observation"][idx]
+        teacher_rb.add(obs, real_next_obs, actions, rewards, terminations, infos)
+        obs = next_obs
+
+    # offline training phase: train the student model using the qdagger loss
+    for global_step in track(range(args.offline_steps), description="offline student training"):
+        data = teacher_rb.sample(args.batch_size)
+        # perform a gradient-descent step
+        with torch.no_grad():
+            target_max, _ = target_network(data.next_observations).max(dim=1)
+            td_target = data.rewards.flatten() + args.gamma * target_max * (1 - data.dones.flatten())
+            teacher_q_values = teacher_model(data.observations) / args.temperature
+
+        student_q_values = q_network(data.observations)
+        old_val = student_q_values.gather(1, data.actions).squeeze()
+        q_loss = F.mse_loss(td_target, old_val)
+
+        student_q_values = student_q_values / args.temperature
+        distill_loss = torch.mean(kl_divergence_with_logits(teacher_q_values, student_q_values))
+
+        loss = q_loss + 1.0 * distill_loss
+
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+        # update the target network
+        if global_step % args.target_network_frequency == 0:
+            for target_network_param, q_network_param in zip(target_network.parameters(), q_network.parameters()):
+                target_network_param.data.copy_(args.tau * q_network_param.data + (1.0 - args.tau) * target_network_param.data)
+
+        if global_step % 100 == 0:
+            writer.add_scalar("charts/offline/loss", loss, global_step)
+            writer.add_scalar("charts/offline/q_loss", q_loss, global_step)
+            writer.add_scalar("charts/offline/distill_loss", distill_loss, global_step)
+
+        if global_step % 100000 == 0:
+            # evaluate the student model
+            model_path = f"runs/{run_name}/{args.exp_name}-offline-{global_step}.cleanrl_model"
+            torch.save(q_network.state_dict(), model_path)
+            print(f"model saved to {model_path}")
+
+            episodic_returns = evaluate(
+                model_path,
+                make_env,
+                args.env_id,
+                eval_episodes=10,
+                run_name=f"{run_name}-eval",
+                Model=QNetwork,
+                device=device,
+                epsilon=args.end_e,
+            )
+            print(episodic_returns)
+            writer.add_scalar("charts/offline/avg_episodic_return", np.mean(episodic_returns), global_step)
+
+    rb = ReplayBuffer(
+        args.buffer_size,
+        envs.single_observation_space,
+        envs.single_action_space,
+        device,
+        optimize_memory_usage=True,
+        handle_timeout_termination=False,
+    )
+    start_time = time.time()
+
+    # TRY NOT TO MODIFY: start the game
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, args.seed + i, i, args.capture_video, run_name) for i in range(args.num_envs)]
+    )
+    obs, _ = envs.reset(seed=args.seed)
+    episodic_returns = deque(maxlen=10)
+    # online training phase
+    for global_step in track(range(args.total_timesteps), description="online student training"):
+        global_step += args.offline_steps
+        # ALGO LOGIC: put action logic here
+        epsilon = linear_schedule(args.start_e, args.end_e, args.exploration_fraction * args.total_timesteps, global_step)
+        if random.random() < epsilon:
+            actions = np.array([envs.single_action_space.sample() for _ in range(envs.num_envs)])
+        else:
+            q_values = q_network(torch.Tensor(obs).to(device))
+            actions = torch.argmax(q_values, dim=1).cpu().numpy()
+
+        # TRY NOT TO MODIFY: execute the game and log data.
+        next_obs, rewards, terminations, truncations, infos = envs.step(actions)
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        if "final_info" in infos:
+            for info in infos["final_info"]:
+                # Skip the envs that are not done
+                if "episode" not in info:
+                    continue
+                print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+                writer.add_scalar("charts/epsilon", epsilon, global_step)
+                episodic_returns.append(info["episode"]["r"])
+                break
+
+        # TRY NOT TO MODIFY: save data to reply buffer; handle `final_observation`
+        real_next_obs = next_obs.copy()
+        for idx, trunc in enumerate(truncations):
+            if trunc:
+                real_next_obs[idx] = infos["final_observation"][idx]
+        rb.add(obs, real_next_obs, actions, rewards, terminations, infos)
+
+        # TRY NOT TO MODIFY: CRUCIAL step easy to overlook
+        obs = next_obs
+
+        # ALGO LOGIC: training.
+        if global_step > args.learning_starts:
+            if global_step % args.train_frequency == 0:
+                data = rb.sample(args.batch_size)
+                # perform a gradient-descent step
+                if len(episodic_returns) < 10:
+                    distill_coeff = 1.0
+                else:
+                    distill_coeff = max(1 - np.mean(episodic_returns) / np.mean(teacher_episodic_returns), 0)
+                with torch.no_grad():
+                    target_max, _ = target_network(data.next_observations).max(dim=1)
+                    td_target = data.rewards.flatten() + args.gamma * target_max * (1 - data.dones.flatten())
+                    teacher_q_values = teacher_model(data.observations) / args.temperature
+
+                student_q_values = q_network(data.observations)
+                old_val = student_q_values.gather(1, data.actions).squeeze()
+                q_loss = F.mse_loss(td_target, old_val)
+
+                student_q_values = student_q_values / args.temperature
+                distill_loss = torch.mean(kl_divergence_with_logits(teacher_q_values, student_q_values))
+
+                loss = q_loss + distill_coeff * distill_loss
+
+                if global_step % 100 == 0:
+                    writer.add_scalar("losses/loss", loss, global_step)
+                    writer.add_scalar("losses/td_loss", q_loss, global_step)
+                    writer.add_scalar("losses/distill_loss", distill_loss, global_step)
+                    writer.add_scalar("losses/q_values", old_val.mean().item(), global_step)
+                    writer.add_scalar("charts/distill_coeff", distill_coeff, global_step)
+                    print("SPS:", int(global_step / (time.time() - start_time)))
+                    print(distill_coeff)
+                    writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+                # optimize the model
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+
+            # update the target network
+            if global_step % args.target_network_frequency == 0:
+                for target_network_param, q_network_param in zip(target_network.parameters(), q_network.parameters()):
+                    target_network_param.data.copy_(
+                        args.tau * q_network_param.data + (1.0 - args.tau) * target_network_param.data
+                    )
+
+    if args.save_model:
+        model_path = f"runs/{run_name}/{args.exp_name}.cleanrl_model"
+        torch.save(q_network.state_dict(), model_path)
+        print(f"model saved to {model_path}")
+        from cleanrl_utils.evals.dqn_eval import evaluate
+
+        episodic_returns = evaluate(
+            model_path,
+            make_env,
+            args.env_id,
+            eval_episodes=10,
+            run_name=f"{run_name}-eval",
+            Model=QNetwork,
+            device=device,
+            epsilon=args.end_e,
+        )
+        for idx, episodic_return in enumerate(episodic_returns):
+            writer.add_scalar("eval/episodic_return", episodic_return, idx)
+
+        if args.upload_model:
+            from cleanrl_utils.huggingface import push_to_hub
+
+            repo_name = f"{args.env_id}-{args.exp_name}-seed{args.seed}"
+            repo_id = f"{args.hf_entity}/{repo_name}" if args.hf_entity else repo_name
+            push_to_hub(args, episodic_returns, repo_id, "Qdagger", f"runs/{run_name}", f"videos/{run_name}-eval")
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/ragen_wrappers.py

@@ -0,0 +1,235 @@
+"""
+Gymnasium-compatible wrappers for RAGEN environments to enable traditional RL training.
+These wrappers convert text-based observations to numerical representations suitable for MLP networks.
+"""
+import gymnasium as gym
+import numpy as np
+from typing import Any, Dict, Tuple
+
+
+class BanditWrapper(gym.Wrapper):
+    """
+    Wrapper for RAGEN Bandit that uses only observable text.
+    Converts text observations to a fixed-size one-hot hash vector.
+    Does not alter episode semantics and does not inspect env internals.
+    """
+    def __init__(self, env, feature_dim_per_name: int = 16):
+        super().__init__(env)
+        # Two name slots (first/second), each hashed to one-hot of size K
+        self.k = feature_dim_per_name
+        self.observation_space = gym.spaces.Box(low=0, high=1, shape=(2 * self.k,), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(2)
+
+    def _parse_names(self, text_obs: str):
+        """Extract the two arm names from the prompt text purely via regex/string ops."""
+        # Heuristic: look for the segment after "named " and split by " and "
+        try:
+            anchor = "named "
+            if anchor in text_obs:
+                segment = text_obs.split(anchor, 1)[1]
+                # Cut at newline if present
+                segment = segment.split("\n", 1)[0]
+                # Now split by " and " to get two names; also strip punctuation
+                parts = segment.split(" and ")
+                if len(parts) >= 2:
+                    name_a = parts[0].strip().strip(' .!?,')
+                    name_b = parts[1].strip().strip(' .!?,')
+                    return name_a, name_b
+        except Exception:
+            pass
+        # Fallback: no names found
+        return "", ""
+
+    def _names_to_vector(self, name_a: str, name_b: str) -> np.ndarray:
+        vec = np.zeros(2 * self.k, dtype=np.float32)
+        idx_a = (hash(name_a) % self.k)
+        idx_b = (hash(name_b) % self.k)
+        vec[idx_a] = 1.0
+        vec[self.k + idx_b] = 1.0
+        return vec
+
+    def reset(self, **kwargs):
+        seed = kwargs.get('seed', None)
+        mode = kwargs.get('mode', None)
+        text_obs = self.env.reset(seed=seed, mode=mode)
+        name_a, name_b = self._parse_names(text_obs)
+        return self._names_to_vector(name_a, name_b), {}
+
+    def step(self, action):
+        ragen_action = int(action) + 1
+        text_obs, reward, done, info = self.env.step(ragen_action)
+        name_a, name_b = self._parse_names(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return self._names_to_vector(name_a, name_b), reward, terminated, truncated, info
+
+
+class FrozenLakeWrapper(gym.Wrapper):
+    """
+    Wrapper for RAGEN FrozenLake environment.
+    Converts grid-based text observations to numerical state representation.
+    """
+    def __init__(self, env):
+        super().__init__(env)
+        # Bootstrap an observation to determine grid size from text only
+        bootstrap_text = self.env.reset()
+        flat, _ = self._parse_observation_and_meta(bootstrap_text)
+        self.observation_space = gym.spaces.Box(low=0, high=1, shape=(flat.shape[0],), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+        # Serve the bootstrapped obs on first reset without calling env.reset again
+        self._bootstrap_obs = flat
+        self._bootstrap_ready = True
+        
+    def _parse_observation_and_meta(self, text_obs: str) -> Tuple[np.ndarray, Tuple[int, int]]:
+        """Parse text observation into numerical state (one-hot grid + player pos)."""
+        lines = text_obs.strip().split('\n')
+        grid = []
+        player_pos = None
+        rows = len(lines)
+        cols = max(len(line) for line in lines) if rows > 0 else 0
+        # Parse grid
+        for i, line in enumerate(lines):
+            row = []
+            for j, char in enumerate(line):
+                if char == 'P':  # Player
+                    row.append(0)
+                    player_pos = (i, j)
+                elif char == '_':  # Frozen
+                    row.append(1)
+                elif char == 'O':  # Hole
+                    row.append(2)
+                elif char == 'G':  # Goal
+                    row.append(3)
+                elif char == 'X':  # Player in hole
+                    row.append(2)
+                    player_pos = (i, j)
+                elif char == '√':  # Player on goal
+                    row.append(3)
+                    player_pos = (i, j)
+                else:
+                    row.append(1)  # Default to frozen
+            grid.append(row)
+        # Pad ragged rows if needed
+        grid = np.array([r + [1] * (cols - len(r)) for r in grid], dtype=np.int32)
+        grid_size = (rows, cols)
+        # One-hot encode grid over 4 cell types
+        # One-hot encode grid
+        one_hot_grid = np.zeros((rows, cols, 4), dtype=np.float32)
+        for i in range(rows):
+            for j in range(cols):
+                cell_type = grid[i, j]
+                one_hot_grid[i, j, cell_type] = 1.0
+        # Flatten grid
+        flat_grid = one_hot_grid.flatten()
+        # Add normalized player position
+        if player_pos is None:
+            player_pos = (0, 0)
+        player_pos_norm = np.array([
+            0.0 if rows <= 1 else player_pos[0] / max(1, rows - 1),
+            0.0 if cols <= 1 else player_pos[1] / max(1, cols - 1),
+        ], dtype=np.float32)
+        flat = np.concatenate([flat_grid, player_pos_norm])
+        return flat, grid_size
+    
+    def reset(self, **kwargs):
+        # Filter out 'options' parameter that gymnasium passes but RAGEN doesn't support
+        if self._bootstrap_ready:
+            # First call returns the bootstrapped observation to avoid double reset
+            self._bootstrap_ready = False
+            return self._bootstrap_obs.copy(), {}
+        seed = kwargs.get('seed', None)
+        mode = kwargs.get('mode', None)
+        text_obs = self.env.reset(seed=seed, mode=mode)
+        state, _ = self._parse_observation_and_meta(text_obs)
+        return state, {}
+    
+    def step(self, action):
+        # Map action from 0,1,2,3 to 1,2,3,4 (RAGEN uses 1-indexed actions)
+        ragen_action = action + 1
+        text_obs, reward, done, info = self.env.step(ragen_action)
+        state, _ = self._parse_observation_and_meta(text_obs)
+        
+        terminated = done
+        truncated = False
+        
+        return state, reward, terminated, truncated, info
+
+
+class SokobanWrapper(gym.Wrapper):
+    """
+    Wrapper for RAGEN Sokoban environment.
+    Converts grid-based text observations to numerical state representation.
+    Note: Does not inherit from gym.Wrapper due to old gym vs gymnasium compatibility.
+    """
+    def __init__(self, env):
+        super().__init__(env)
+        # Bootstrap an observation to determine room size from text only
+        bootstrap_text = self.env.reset()
+        flat, rows, cols = self._parse_observation_and_meta(bootstrap_text)
+        self.observation_space = gym.spaces.Box(low=0, high=1, shape=(flat.shape[0],), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+        self.metadata = getattr(env, 'metadata', {})
+        self._bootstrap_obs = flat
+        self._bootstrap_ready = True
+        
+    def _parse_observation_and_meta(self, text_obs: str) -> Tuple[np.ndarray, int, int]:
+        """Parse text observation into numerical state and return dims."""
+        lines = text_obs.strip().split('\n')
+        grid = []
+        rows = len(lines)
+        cols = max(len(line) for line in lines) if rows > 0 else 0
+        # Mapping from characters to cell types
+        char_to_type = {
+            '#': 0,  # wall
+            '_': 1,  # empty
+            'O': 2,  # target
+            '√': 3,  # box on target
+            'X': 4,  # box
+            'P': 5,  # player
+            'S': 6,  # player on target
+        }
+        
+        for line in lines:
+            row = []
+            for char in line:
+                row.append(char_to_type.get(char, 1))  # Default to empty
+            grid.append(row)
+        # Pad ragged rows
+        grid = np.array([r + [1] * (cols - len(r)) for r in grid], dtype=np.int32)
+        # One-hot encode grid
+        one_hot_grid = np.zeros((rows, cols, 7), dtype=np.float32)
+        for i in range(rows):
+            for j in range(cols):
+                cell_type = grid[i, j]
+                one_hot_grid[i, j, cell_type] = 1.0
+        return one_hot_grid.flatten(), rows, cols
+    
+    def reset(self, **kwargs):
+        if self._bootstrap_ready:
+            self._bootstrap_ready = False
+            return self._bootstrap_obs.copy(), {}
+        seed = kwargs.get('seed', None)
+        mode = kwargs.get('mode', None)
+        text_obs = self.env.reset(seed=seed, mode=mode)
+        state, _, _ = self._parse_observation_and_meta(text_obs)
+        return state, {}
+    
+    def step(self, action):
+        # Map action from 0,1,2,3 to 1,2,3,4 (RAGEN uses 1-indexed actions)
+        ragen_action = action + 1
+        text_obs, reward, done, info = self.env.step(ragen_action)
+        state, _, _ = self._parse_observation_and_meta(text_obs)
+        
+        terminated = done
+        truncated = False
+        
+        return state, reward, terminated, truncated, info
+    
+    def close(self):
+        if hasattr(self.env, 'close'):
+            self.env.close()
+    
+    def render(self):
+        if hasattr(self.env, 'render'):
+            return self.env.render()
+        return None

cleanrl/cleanrl/sac_atari.py

@@ -0,0 +1,343 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/sac/#sac_ataripy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+from cleanrl_utils.atari_wrappers import (
+    ClipRewardEnv,
+    EpisodicLifeEnv,
+    FireResetEnv,
+    MaxAndSkipEnv,
+    NoopResetEnv,
+)
+from cleanrl_utils.buffers import ReplayBuffer
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "BeamRiderNoFrameskip-v4"
+    """the id of the environment"""
+    total_timesteps: int = 5000000
+    """total timesteps of the experiments"""
+    buffer_size: int = int(1e6)
+    """the replay memory buffer size"""  # smaller than in original paper but evaluation is done only for 100k steps anyway
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    tau: float = 1.0
+    """target smoothing coefficient (default: 1)"""
+    batch_size: int = 64
+    """the batch size of sample from the reply memory"""
+    learning_starts: int = 2e4
+    """timestep to start learning"""
+    policy_lr: float = 3e-4
+    """the learning rate of the policy network optimizer"""
+    q_lr: float = 3e-4
+    """the learning rate of the Q network network optimizer"""
+    update_frequency: int = 4
+    """the frequency of training updates"""
+    target_network_frequency: int = 8000
+    """the frequency of updates for the target networks"""
+    alpha: float = 0.2
+    """Entropy regularization coefficient."""
+    autotune: bool = True
+    """automatic tuning of the entropy coefficient"""
+    target_entropy_scale: float = 0.89
+    """coefficient for scaling the autotune entropy target"""
+
+
+def make_env(env_id, seed, idx, capture_video, run_name):
+    def thunk():
+        if capture_video and idx == 0:
+            env = gym.make(env_id, render_mode="rgb_array")
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        else:
+            env = gym.make(env_id)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+
+        env = NoopResetEnv(env, noop_max=30)
+        env = MaxAndSkipEnv(env, skip=4)
+        env = EpisodicLifeEnv(env)
+        if "FIRE" in env.unwrapped.get_action_meanings():
+            env = FireResetEnv(env)
+        env = ClipRewardEnv(env)
+        env = gym.wrappers.ResizeObservation(env, (84, 84))
+        env = gym.wrappers.GrayScaleObservation(env)
+        env = gym.wrappers.FrameStack(env, 4)
+
+        env.action_space.seed(seed)
+        return env
+
+    return thunk
+
+
+def layer_init(layer, bias_const=0.0):
+    nn.init.kaiming_normal_(layer.weight)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+# ALGO LOGIC: initialize agent here:
+# NOTE: Sharing a CNN encoder between Actor and Critics is not recommended for SAC without stopping actor gradients
+# See the SAC+AE paper https://arxiv.org/abs/1910.01741 for more info
+# TL;DR The actor's gradients mess up the representation when using a joint encoder
+class SoftQNetwork(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        obs_shape = envs.single_observation_space.shape
+        self.conv = nn.Sequential(
+            layer_init(nn.Conv2d(obs_shape[0], 32, kernel_size=8, stride=4)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(32, 64, kernel_size=4, stride=2)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 64, kernel_size=3, stride=1)),
+            nn.Flatten(),
+        )
+
+        with torch.inference_mode():
+            output_dim = self.conv(torch.zeros(1, *obs_shape)).shape[1]
+
+        self.fc1 = layer_init(nn.Linear(output_dim, 512))
+        self.fc_q = layer_init(nn.Linear(512, envs.single_action_space.n))
+
+    def forward(self, x):
+        x = F.relu(self.conv(x / 255.0))
+        x = F.relu(self.fc1(x))
+        q_vals = self.fc_q(x)
+        return q_vals
+
+
+class Actor(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        obs_shape = envs.single_observation_space.shape
+        self.conv = nn.Sequential(
+            layer_init(nn.Conv2d(obs_shape[0], 32, kernel_size=8, stride=4)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(32, 64, kernel_size=4, stride=2)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 64, kernel_size=3, stride=1)),
+            nn.Flatten(),
+        )
+
+        with torch.inference_mode():
+            output_dim = self.conv(torch.zeros(1, *obs_shape)).shape[1]
+
+        self.fc1 = layer_init(nn.Linear(output_dim, 512))
+        self.fc_logits = layer_init(nn.Linear(512, envs.single_action_space.n))
+
+    def forward(self, x):
+        x = F.relu(self.conv(x))
+        x = F.relu(self.fc1(x))
+        logits = self.fc_logits(x)
+
+        return logits
+
+    def get_action(self, x):
+        logits = self(x / 255.0)
+        policy_dist = Categorical(logits=logits)
+        action = policy_dist.sample()
+        # Action probabilities for calculating the adapted soft-Q loss
+        action_probs = policy_dist.probs
+        log_prob = F.log_softmax(logits, dim=1)
+        return action, log_prob, action_probs
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv([make_env(args.env_id, args.seed, 0, args.capture_video, run_name)])
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    actor = Actor(envs).to(device)
+    qf1 = SoftQNetwork(envs).to(device)
+    qf2 = SoftQNetwork(envs).to(device)
+    qf1_target = SoftQNetwork(envs).to(device)
+    qf2_target = SoftQNetwork(envs).to(device)
+    qf1_target.load_state_dict(qf1.state_dict())
+    qf2_target.load_state_dict(qf2.state_dict())
+    # TRY NOT TO MODIFY: eps=1e-4 increases numerical stability
+    q_optimizer = optim.Adam(list(qf1.parameters()) + list(qf2.parameters()), lr=args.q_lr, eps=1e-4)
+    actor_optimizer = optim.Adam(list(actor.parameters()), lr=args.policy_lr, eps=1e-4)
+
+    # Automatic entropy tuning
+    if args.autotune:
+        target_entropy = -args.target_entropy_scale * torch.log(1 / torch.tensor(envs.single_action_space.n))
+        log_alpha = torch.zeros(1, requires_grad=True, device=device)
+        alpha = log_alpha.exp().item()
+        a_optimizer = optim.Adam([log_alpha], lr=args.q_lr, eps=1e-4)
+    else:
+        alpha = args.alpha
+
+    rb = ReplayBuffer(
+        args.buffer_size,
+        envs.single_observation_space,
+        envs.single_action_space,
+        device,
+        handle_timeout_termination=False,
+    )
+    start_time = time.time()
+
+    # TRY NOT TO MODIFY: start the game
+    obs, _ = envs.reset(seed=args.seed)
+    for global_step in range(args.total_timesteps):
+        # ALGO LOGIC: put action logic here
+        if global_step < args.learning_starts:
+            actions = np.array([envs.single_action_space.sample() for _ in range(envs.num_envs)])
+        else:
+            actions, _, _ = actor.get_action(torch.Tensor(obs).to(device))
+            actions = actions.detach().cpu().numpy()
+
+        # TRY NOT TO MODIFY: execute the game and log data.
+        next_obs, rewards, terminations, truncations, infos = envs.step(actions)
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        if "final_info" in infos:
+            for info in infos["final_info"]:
+                # Skip the envs that are not done
+                if "episode" not in info:
+                    continue
+                print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+                break
+
+        # TRY NOT TO MODIFY: save data to reply buffer; handle `final_observation`
+        real_next_obs = next_obs.copy()
+        for idx, trunc in enumerate(truncations):
+            if trunc:
+                real_next_obs[idx] = infos["final_observation"][idx]
+        rb.add(obs, real_next_obs, actions, rewards, terminations, infos)
+
+        # TRY NOT TO MODIFY: CRUCIAL step easy to overlook
+        obs = next_obs
+
+        # ALGO LOGIC: training.
+        if global_step > args.learning_starts:
+            if global_step % args.update_frequency == 0:
+                data = rb.sample(args.batch_size)
+                # CRITIC training
+                with torch.no_grad():
+                    _, next_state_log_pi, next_state_action_probs = actor.get_action(data.next_observations)
+                    qf1_next_target = qf1_target(data.next_observations)
+                    qf2_next_target = qf2_target(data.next_observations)
+                    # we can use the action probabilities instead of MC sampling to estimate the expectation
+                    min_qf_next_target = next_state_action_probs * (
+                        torch.min(qf1_next_target, qf2_next_target) - alpha * next_state_log_pi
+                    )
+                    # adapt Q-target for discrete Q-function
+                    min_qf_next_target = min_qf_next_target.sum(dim=1)
+                    next_q_value = data.rewards.flatten() + (1 - data.dones.flatten()) * args.gamma * (min_qf_next_target)
+
+                # use Q-values only for the taken actions
+                qf1_values = qf1(data.observations)
+                qf2_values = qf2(data.observations)
+                qf1_a_values = qf1_values.gather(1, data.actions.long()).view(-1)
+                qf2_a_values = qf2_values.gather(1, data.actions.long()).view(-1)
+                qf1_loss = F.mse_loss(qf1_a_values, next_q_value)
+                qf2_loss = F.mse_loss(qf2_a_values, next_q_value)
+                qf_loss = qf1_loss + qf2_loss
+
+                q_optimizer.zero_grad()
+                qf_loss.backward()
+                q_optimizer.step()
+
+                # ACTOR training
+                _, log_pi, action_probs = actor.get_action(data.observations)
+                with torch.no_grad():
+                    qf1_values = qf1(data.observations)
+                    qf2_values = qf2(data.observations)
+                    min_qf_values = torch.min(qf1_values, qf2_values)
+                # no need for reparameterization, the expectation can be calculated for discrete actions
+                actor_loss = (action_probs * ((alpha * log_pi) - min_qf_values)).mean()
+
+                actor_optimizer.zero_grad()
+                actor_loss.backward()
+                actor_optimizer.step()
+
+                if args.autotune:
+                    # reuse action probabilities for temperature loss
+                    alpha_loss = (action_probs.detach() * (-log_alpha.exp() * (log_pi + target_entropy).detach())).mean()
+
+                    a_optimizer.zero_grad()
+                    alpha_loss.backward()
+                    a_optimizer.step()
+                    alpha = log_alpha.exp().item()
+
+            # update the target networks
+            if global_step % args.target_network_frequency == 0:
+                for param, target_param in zip(qf1.parameters(), qf1_target.parameters()):
+                    target_param.data.copy_(args.tau * param.data + (1 - args.tau) * target_param.data)
+                for param, target_param in zip(qf2.parameters(), qf2_target.parameters()):
+                    target_param.data.copy_(args.tau * param.data + (1 - args.tau) * target_param.data)
+
+            if global_step % 100 == 0:
+                writer.add_scalar("losses/qf1_values", qf1_a_values.mean().item(), global_step)
+                writer.add_scalar("losses/qf2_values", qf2_a_values.mean().item(), global_step)
+                writer.add_scalar("losses/qf1_loss", qf1_loss.item(), global_step)
+                writer.add_scalar("losses/qf2_loss", qf2_loss.item(), global_step)
+                writer.add_scalar("losses/qf_loss", qf_loss.item() / 2.0, global_step)
+                writer.add_scalar("losses/actor_loss", actor_loss.item(), global_step)
+                writer.add_scalar("losses/alpha", alpha, global_step)
+                print("SPS:", int(global_step / (time.time() - start_time)))
+                writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+                if args.autotune:
+                    writer.add_scalar("losses/alpha_loss", alpha_loss.item(), global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/scout_dqn/dqn_bandit_nochangeenv.py

@@ -0,0 +1,422 @@
+# DQN with small MLP for RAGEN Bandit using the existing env (no env edits)
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Deque, Tuple
+from collections import deque
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+import json
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.bandit.env import BanditEnv
+from ragen.env.bandit.config import BanditEnvConfig
+from ragen_wrappers import BanditWrapper
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "Subagent"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "BanditDQN"
+    total_timesteps: int = 50_000
+    learning_rate: float = 1e-3
+    gamma: float = 0.0  # bandit is single-step
+    batch_size: int = 64
+    buffer_size: int = 10_000
+    target_network_frequency: int = 500
+    train_frequency: int = 1
+
+    # Epsilon-greedy
+    start_e: float = 1.0
+    end_e: float = 0.05
+    exploration_fraction: float = 0.2  # fraction of total timesteps over which to anneal epsilon
+
+    # Model size
+    hidden_size: int = 32
+    feature_dim_per_name: int = 16
+
+
+def make_env(run_name: str, seed: int, feature_dim_per_name: int, capture_video: bool = False):
+    cfg = BanditEnvConfig()
+    env = BanditEnv(cfg)
+    env = BanditWrapper(env, feature_dim_per_name=feature_dim_per_name)
+    env = gym.wrappers.RecordEpisodeStatistics(env)
+    if capture_video:
+        env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+    return env
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class QNetwork(nn.Module):
+    def __init__(self, obs_dim: int, act_dim: int, hidden: int):
+        super().__init__()
+        self.net = nn.Sequential(
+            layer_init(nn.Linear(obs_dim, hidden)),
+            nn.ReLU(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.ReLU(),
+            layer_init(nn.Linear(hidden, act_dim), std=0.01),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.net(x)
+
+
+class ReplayBuffer:
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.ptr = 0
+        self.full = False
+        self.obs_buf = None
+        self.next_obs_buf = None
+        self.act_buf = None
+        self.rew_buf = None
+        self.done_buf = None
+
+    def add(self, obs: np.ndarray, act: int, rew: float, done: bool, next_obs: np.ndarray):
+        if self.obs_buf is None:
+            obs_shape = obs.shape
+            self.obs_buf = np.zeros((self.capacity,) + obs_shape, dtype=np.float32)
+            self.next_obs_buf = np.zeros((self.capacity,) + obs_shape, dtype=np.float32)
+            self.act_buf = np.zeros((self.capacity,), dtype=np.int64)
+            self.rew_buf = np.zeros((self.capacity,), dtype=np.float32)
+            self.done_buf = np.zeros((self.capacity,), dtype=np.float32)
+        self.obs_buf[self.ptr] = obs
+        self.next_obs_buf[self.ptr] = next_obs
+        self.act_buf[self.ptr] = act
+        self.rew_buf[self.ptr] = rew
+        self.done_buf[self.ptr] = 1.0 if done else 0.0
+        self.ptr = (self.ptr + 1) % self.capacity
+        if self.ptr == 0:
+            self.full = True
+
+    def can_sample(self, batch_size: int) -> bool:
+        return (self.capacity if self.full else self.ptr) >= batch_size
+
+    def sample(self, batch_size: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        size = self.capacity if self.full else self.ptr
+        idxs = np.random.randint(0, size, size=batch_size)
+        return (
+            self.obs_buf[idxs],
+            self.act_buf[idxs],
+            self.rew_buf[idxs],
+            self.done_buf[idxs],
+            self.next_obs_buf[idxs],
+        )
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    # seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env
+    env = make_env(run_name, args.seed, args.feature_dim_per_name, args.capture_video)
+    obs_shape = env.observation_space.shape
+    act_dim = env.action_space.n
+
+    # networks
+    policy_net = QNetwork(int(np.prod(obs_shape)), act_dim, args.hidden_size).to(device)
+    target_net = QNetwork(int(np.prod(obs_shape)), act_dim, args.hidden_size).to(device)
+    target_net.load_state_dict(policy_net.state_dict())
+    target_net.eval()
+
+    optimizer = optim.Adam(policy_net.parameters(), lr=args.learning_rate)
+    criterion = nn.SmoothL1Loss()
+
+    rb = ReplayBuffer(args.buffer_size)
+
+    # epsilon schedule
+    exploration_steps = max(1, int(args.exploration_fraction * args.total_timesteps))
+    epsilon_by_step = lambda t: args.end_e + (args.start_e - args.end_e) * max(0.0, (exploration_steps - t) / exploration_steps)
+
+    # periodic eval setup (mirrors noisy_dqn_sokoban_small.py)
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes: int, step_tag: int):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env_eval = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, _ = env_eval.reset(seed=args.seed + 100000 + collected)
+                # try to fetch the original prompt text from underlying env
+                prompt_text = None
+                try:
+                    if hasattr(env_eval, 'env') and hasattr(env_eval.env, 'render'):
+                        p = env_eval.env.render()
+                        if isinstance(p, str):
+                            prompt_text = p
+                except Exception:
+                    pass
+                # lightweight name parser (aligned with converter/wrapper)
+                def _parse_names(text: str):
+                    try:
+                        anchor = "named "
+                        if isinstance(text, str) and anchor in text:
+                            segment = text.split(anchor, 1)[1]
+                            segment = segment.split("\n", 1)[0]
+                            parts = segment.split(" and ")
+                            if len(parts) >= 2:
+                                a = parts[0].strip().strip(' .!?,')
+                                b = parts[1].strip().strip(' .!?,')
+                                if a and b:
+                                    return a, b
+                    except Exception:
+                        pass
+                    return None
+                names_tuple = _parse_names(prompt_text) if prompt_text else None
+                traj_states = [np.asarray(state).tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                # bandit is single-step, but keep loop for generality
+                while not done:
+                    with torch.no_grad():
+                        q = agent_model(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0))
+                        action = int(torch.argmax(q, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env_eval.step(action)
+                    d = bool(terminated) or bool(truncated)
+                    traj_actions.append(int(action))
+                    traj_rewards.append(float(reward))
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_state
+                    traj_states.append(np.asarray(state).tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                    "prompt": prompt_text,
+                    "names": list(names_tuple) if names_tuple is not None else None,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env_eval.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    # choose periodicity similar to reference
+    eval_splits = 2
+    eval_episodes = 4000
+    eval_every_steps = max(1, args.total_timesteps // eval_splits)
+
+    # training loop
+    global_step = 0
+    start_time = time.time()
+
+    obs, _ = env.reset(seed=args.seed)
+    # success tracking
+    ep_success_window = deque(maxlen=100)
+    total_episodes = 0
+    total_successes = 0
+
+    while global_step < args.total_timesteps:
+        epsilon = epsilon_by_step(global_step)
+        if np.random.rand() < epsilon:
+            action = env.action_space.sample()
+        else:
+            with torch.no_grad():
+                q_values = policy_net(torch.tensor(obs, dtype=torch.float32, device=device).unsqueeze(0))
+                action = int(torch.argmax(q_values, dim=1).item())
+        next_obs, reward, terminated, truncated, info = env.step(action)
+        done = bool(terminated) or bool(truncated)
+
+        rb.add(obs.astype(np.float32), action, float(reward), done, next_obs.astype(np.float32))
+
+        obs = next_obs
+        global_step += 1
+
+        # Bandit episodes end in one step; reset immediately
+        if done:
+            # record success
+            succ = bool(info.get('success', False))
+            ep_success_window.append(1.0 if succ else 0.0)
+            total_episodes += 1
+            total_successes += (1 if succ else 0)
+            if args.track:
+                try:
+                    import wandb
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "rollout/success": float(1.0 if succ else 0.0),
+                        "rollout/success_rate_100": float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else None,
+                        "rollout/episodes": int(total_episodes),
+                    }, step=global_step)
+                except Exception:
+                    pass
+            obs, _ = env.reset()
+
+        # optimize
+        if rb.can_sample(args.batch_size) and (global_step % args.train_frequency == 0):
+            batch_obs, batch_act, batch_rew, batch_done, batch_next_obs = rb.sample(args.batch_size)
+            b_obs = torch.tensor(batch_obs, dtype=torch.float32, device=device)
+            b_act = torch.tensor(batch_act, dtype=torch.int64, device=device)
+            b_rew = torch.tensor(batch_rew, dtype=torch.float32, device=device)
+            b_done = torch.tensor(batch_done, dtype=torch.float32, device=device)
+            b_next_obs = torch.tensor(batch_next_obs, dtype=torch.float32, device=device)
+
+            # Q-learning target: r + gamma * max_a' Q_target(s', a') * (1-done)
+            with torch.no_grad():
+                next_q = target_net(b_next_obs).max(dim=1)[0]
+                target_q = b_rew + args.gamma * (1.0 - b_done) * next_q
+
+            current_q = policy_net(b_obs).gather(1, b_act.view(-1, 1)).squeeze(1)
+            loss = criterion(current_q, target_q)
+
+            optimizer.zero_grad()
+            loss.backward()
+            nn.utils.clip_grad_norm_(policy_net.parameters(), max_norm=10.0)
+            optimizer.step()
+
+            if args.track:
+                try:
+                    import wandb
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "train/loss": float(loss.item()),
+                        "charts/epsilon": float(epsilon),
+                        "perf/SPS": int(global_step / (time.time() - start_time)),
+                    }, step=global_step)
+                except Exception:
+                    pass
+
+        # target network update
+        if global_step % args.target_network_frequency == 0:
+            target_net.load_state_dict(policy_net.state_dict())
+
+        # occasional print
+        if global_step % 1000 == 0:
+            sps = int(global_step / (time.time() - start_time))
+            sr100 = float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else 0.0
+            print(f"Step {global_step} | SPS: {sps} | Epsilon: {epsilon:.3f} | SR@100: {sr100:.3f}")
+
+        # periodic evaluation and trajectory dump (mirrors reference)
+        if global_step == 1 or (global_step % eval_every_steps == 0):
+            try:
+                def eval_thunk():
+                    return make_env(run_name, args.seed + 9999, args.feature_dim_per_name, False)
+                collect_eval_trajectories(policy_net, eval_thunk, n_episodes=eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import wandb
+                        mpath = Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {eval_episodes} eval trajectories at step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    # simple evaluation after training
+    def evaluate(n_episodes=200):
+        returns = []
+        successes = []
+        for i in range(n_episodes):
+            s, _ = env.reset(seed=args.seed + 100000 + i)
+            done = False
+            G = 0.0
+            while not done:
+                with torch.no_grad():
+                    q = policy_net(torch.tensor(s, dtype=torch.float32, device=device).unsqueeze(0))
+                    a = int(torch.argmax(q, dim=1).item())
+                s, r, term, trunc, info = env.step(a)
+                G += float(r)
+                done = bool(term) or bool(trunc)
+            successes.append(1.0 if bool(info.get('success', False)) else 0.0)
+            returns.append(G)
+        return float(np.mean(returns)), float(np.std(returns)), float(np.mean(successes))
+
+    avg_ret, std_ret, succ_rate = evaluate(4000)
+    if args.track:
+        try:
+            import wandb
+            wandb.log({
+                "global_step": int(global_step),
+                "eval/avg_return": float(avg_ret),
+                "eval/std_return": float(std_ret),
+                "eval/episodes": int(4000),
+                "eval/success_rate": float(succ_rate),
+            }, step=global_step)
+        except Exception:
+            pass
+
+    env.close()

cleanrl/cleanrl/scout_dqn/dqn_frozenlake.py

@@ -0,0 +1,428 @@
+# DQN with small MLP for RAGEN FrozenLake using the existing env (no env edits)
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple, Dict, Any
+import json
+import re  # Added for ANSI strip
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.frozen_lake.env import FrozenLakeEnv
+from ragen.env.frozen_lake.config import FrozenLakeEnvConfig
+
+
+class FrozenLakeWrapper(gym.Env):
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: FrozenLakeEnv):
+        super().__init__()
+        self._env = env
+        self._size = int(self._env.nrow)
+        self._tokens = ['P', '_', 'O', 'G', 'X', '√']
+        self._token_to_idx = {t: i for i, t in enumerate(self._tokens)}
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(self._size * self._size * len(self._tokens),), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+
+    def _encode_obs(self, text_obs: str) -> np.ndarray:
+        # 1. 去除 ANSI 颜色代码
+        ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+        text_obs = ansi_escape.sub('', text_obs)
+
+        # 2. 清理边框和分割行
+        raw_rows = text_obs.split('\n')
+        rows = []
+        for r in raw_rows:
+            clean_r = r.strip()
+            # 跳过边框行 (如 +---+) 或空行
+            if not clean_r or set(clean_r).issubset({'+', '-', ' '}):
+                continue
+            # 去除行首行尾的竖线 (如 | P | ->  P )
+            clean_r = clean_r.strip('|')
+            rows.append(list(clean_r))
+
+        # 3. 构建 Grid
+        h = self._size
+        w = self._size
+        grid = np.zeros((h, w, len(self._tokens)), dtype=np.float32)
+        
+        # 安全填充，防止索引越界
+        for i in range(min(h, len(rows))):
+            for j in range(min(w, len(rows[i]))):
+                ch = rows[i][j]
+                # 修复: 只有在 token 列表中才置1，遇到未知字符(如墙壁)不默认为 Player(0)
+                if ch in self._token_to_idx:
+                    idx = self._token_to_idx[ch]
+                    grid[i, j, idx] = 1.0
+                    
+        return grid.reshape(-1).astype(np.float32)
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        obs = self._encode_obs(text_obs)
+        return obs, {}
+
+    def step(self, action: int):
+        mapped = int(action) + 1
+        text_obs, reward, done, info = self._env.step(mapped)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, info or {}
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "FrozenLakeDQN"
+    total_timesteps: int = 4000_000
+    learning_rate: float = 2.5e-4
+    gamma: float = 0.99
+    batch_size: int = 128
+    buffer_size: int = 200_000
+    target_network_frequency: int = 2000
+    train_frequency: int = 4
+    learning_starts: int = 5000
+
+    # Epsilon-greedy
+    start_e: float = 1.0
+    end_e: float = 0.05
+    exploration_fraction: float = 0.2
+
+    # Model size
+    hidden_size: int = 128
+
+    # FrozenLake specific
+    grid_size: int = 4
+    is_slippery: bool = False
+
+    # Eval
+    eval_splits: int = 1
+    eval_episodes: int = 4000
+
+
+def make_env(idx, run_name, seed, grid_size, is_slippery, capture_video=False):
+    def thunk():
+        config = FrozenLakeEnvConfig(size=grid_size, p=0.9, success_rate=0.8, is_slippery=is_slippery, map_seed=seed + idx, render_mode='text')
+        env = FrozenLakeEnv(config)
+        env = FrozenLakeWrapper(env)
+        max_steps = int(grid_size * grid_size * 4)
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class QNetwork(nn.Module):
+    def __init__(self, obs_dim: int, act_dim: int, hidden: int):
+        super().__init__()
+        self.net = nn.Sequential(
+            layer_init(nn.Linear(obs_dim, hidden)),
+            nn.ReLU(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.ReLU(),
+            layer_init(nn.Linear(hidden, act_dim), std=0.01),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.net(x)
+
+
+class ReplayBuffer:
+    def __init__(self, capacity: int, obs_shape: Tuple[int, ...]):
+        self.capacity = capacity
+        self.ptr = 0
+        self.full = False
+        self.obs_buf = np.zeros((capacity,) + obs_shape, dtype=np.float32)
+        self.next_obs_buf = np.zeros((capacity,) + obs_shape, dtype=np.float32)
+        self.act_buf = np.zeros((capacity,), dtype=np.int64)
+        self.rew_buf = np.zeros((capacity,), dtype=np.float32)
+        self.done_buf = np.zeros((capacity,), dtype=np.float32)
+
+    def add(self, obs: np.ndarray, act: int, rew: float, done: bool, next_obs: np.ndarray):
+        i = self.ptr
+        self.obs_buf[i] = obs
+        self.next_obs_buf[i] = next_obs
+        self.act_buf[i] = act
+        self.rew_buf[i] = rew
+        self.done_buf[i] = 1.0 if done else 0.0
+        self.ptr = (self.ptr + 1) % self.capacity
+        if self.ptr == 0:
+            self.full = True
+
+    def can_sample(self, batch_size: int) -> bool:
+        return (self.capacity if self.full else self.ptr) >= batch_size
+
+    def sample(self, batch_size: int):
+        size = self.capacity if self.full else self.ptr
+        idxs = np.random.randint(0, size, size=batch_size)
+        return (
+            self.obs_buf[idxs],
+            self.act_buf[idxs],
+            self.rew_buf[idxs],
+            self.done_buf[idxs],
+            self.next_obs_buf[idxs],
+        )
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    env = make_env(0, run_name, args.seed, args.grid_size, args.is_slippery, args.capture_video)()
+    obs_shape = env.observation_space.shape
+    act_dim = env.action_space.n
+
+    policy_net = QNetwork(int(np.prod(obs_shape)), act_dim, args.hidden_size).to(device)
+    target_net = QNetwork(int(np.prod(obs_shape)), act_dim, args.hidden_size).to(device)
+    target_net.load_state_dict(policy_net.state_dict())
+    target_net.eval()
+
+    optimizer = optim.Adam(policy_net.parameters(), lr=args.learning_rate)
+    criterion = nn.SmoothL1Loss()
+
+    rb = ReplayBuffer(args.buffer_size, obs_shape)
+
+    exploration_steps = max(1, int(args.exploration_fraction * args.total_timesteps))
+    epsilon_by_step = lambda t: args.end_e + (args.start_e - args.end_e) * max(0.0, (exploration_steps - t) / exploration_steps)
+
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env_eval = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, _ = env_eval.reset(seed=args.seed + 100000 + collected)
+                traj_states = [np.asarray(state).tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env_eval, '_max_episode_steps', None) or int(args.grid_size * args.grid_size * 4)
+                while not done:
+                    with torch.no_grad():
+                        q = agent_model(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0))
+                        action = int(torch.argmax(q, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env_eval.step(action)
+                    traj_actions.append(int(action))
+                    traj_rewards.append(float(reward))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_state
+                    traj_states.append(np.asarray(state).tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env_eval.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    global_step = 0
+    start_time = time.time()
+
+    obs, _ = env.reset(seed=args.seed)
+    ep_success_window = []
+    ep_return = 0.0
+    ep_len = 0
+
+    eval_every_steps = max(1, args.total_timesteps // args.eval_splits)
+
+    while global_step < args.total_timesteps:
+        epsilon = epsilon_by_step(global_step)
+        if np.random.rand() < epsilon or global_step < args.learning_starts:
+            action = env.action_space.sample()
+        else:
+            with torch.no_grad():
+                q_values = policy_net(torch.tensor(obs, dtype=torch.float32, device=device).unsqueeze(0))
+                action = int(torch.argmax(q_values, dim=1).item())
+
+        next_obs, reward, terminated, truncated, info = env.step(action)
+        # 注意：这里 done 仅用于控制循环和 logging，不用于 ReplayBuffer 的逻辑判断
+        done = bool(terminated) or bool(truncated)
+
+        # 修复：Buffer 中只存储真正的 termination (死亡或到达)，不存 truncation (超时)
+        # 这样 Q-learning 在超时时不会错误地认为价值归零
+        rb.add(obs.astype(np.float32), int(action), float(reward), bool(terminated), next_obs.astype(np.float32))
+
+        obs = next_obs
+        ep_return += float(reward)
+        ep_len += 1
+        global_step += 1
+
+        if done:
+            succ = bool((info or {}).get('success', False))
+            ep_success_window.append(1.0 if succ else 0.0)
+            if len(ep_success_window) > 100:
+                ep_success_window.pop(0)
+            if args.track:
+                try:
+                    import wandb
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "rollout/success": float(1.0 if succ else 0.0),
+                        "rollout/success_rate_100": float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else None,
+                        # PPO-compatible episodic keys
+                        "train/episodic_return": float(ep_return),
+                        "train/episodic_length": int(ep_len),
+                        "train/success": float(1.0 if succ else 0.0),
+                        "train/success_rate_100": float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else None,
+                    }, step=global_step)
+                except Exception:
+                    pass
+            obs, _ = env.reset()
+            ep_return, ep_len = 0.0, 0
+
+        if rb.can_sample(args.batch_size) and (global_step % args.train_frequency == 0) and (global_step > args.learning_starts):
+            batch_obs, batch_act, batch_rew, batch_done, batch_next_obs = rb.sample(args.batch_size)
+            b_obs = torch.tensor(batch_obs, dtype=torch.float32, device=device)
+            b_act = torch.tensor(batch_act, dtype=torch.int64, device=device)
+            b_rew = torch.tensor(batch_rew, dtype=torch.float32, device=device)
+            b_done = torch.tensor(batch_done, dtype=torch.float32, device=device)
+            b_next_obs = torch.tensor(batch_next_obs, dtype=torch.float32, device=device)
+
+            with torch.no_grad():
+                next_q = target_net(b_next_obs).max(dim=1)[0]
+                target_q = b_rew + args.gamma * (1.0 - b_done) * next_q
+
+            current_q = policy_net(b_obs).gather(1, b_act.view(-1, 1)).squeeze(1)
+            loss = criterion(current_q, target_q)
+
+            optimizer.zero_grad()
+            loss.backward()
+            nn.utils.clip_grad_norm_(policy_net.parameters(), max_norm=10.0)
+            optimizer.step()
+
+            if args.track:
+                try:
+                    import wandb
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "train/loss": float(loss.item()),
+                        "charts/epsilon": float(epsilon),
+                        "perf/SPS": int(global_step / (time.time() - start_time)),
+                        "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                    }, step=global_step)
+                except Exception:
+                    pass
+
+        if global_step % args.target_network_frequency == 0:
+            target_net.load_state_dict(policy_net.state_dict())
+
+        if global_step % 1000 == 0:
+            sps = int(global_step / (time.time() - start_time))
+            sr100 = float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else 0.0
+            print(f"Step {global_step} | SPS: {sps} | Epsilon: {epsilon:.3f} | SR@100: {sr100:.3f}")
+
+        if global_step == 1 or (global_step % eval_every_steps == 0):
+            try:
+                def eval_thunk():
+                    return make_env(0, run_name, args.seed + 9999, args.grid_size, args.is_slippery, False)()
+                collect_eval_trajectories(policy_net, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import wandb
+                        mpath = Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {args.eval_episodes} eval trajectories at step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    env.close()

cleanrl/cleanrl/scout_dqn/dqn_rubikscube.py

@@ -0,0 +1,454 @@
+# DQN with Step Penalty & Time Limit Bootstrap for RAGEN Rubik's Cube 2x2
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple, Dict, Any, List
+import json
+import re
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+
+import sys
+# 假设 ragen 库在当前目录的上两级，请根据实际情况调整
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.rubikscube.env import RubiksCube2x2Env
+from ragen.env.rubikscube.config import RubiksCube2x2Config
+
+
+class RubiksCubeWrapper(gym.Env):
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: RubiksCube2x2Env):
+        super().__init__()
+        self._env = env
+        self._colors = ['W', 'O', 'G', 'R', 'B', 'Y']
+        self._color_to_idx = {c: i for i, c in enumerate(self._colors)}
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(24 * len(self._colors),), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(12)
+        self._face_pat = re.compile(r"\[(?:\s*([A-Z])\s*,\s*([A-Z])\s*\])\n\s*\[(?:\s*([A-Z])\s*,\s*([A-Z])\s*\])")
+        
+        # [关键修改] 每步惩罚
+        # 如果20步都没解出来，累计惩罚是 20 * -0.05 = -1.0，抵消掉最后可能获得的 +1.0
+        # 这迫使 agent 寻找更短路径
+        self.step_penalty = -0.044
+
+    def _encode_obs(self, text_obs: str) -> np.ndarray:
+        faces_order = ["Up (U):", "Left (L):", "Front (F):", "Right (R):", "Back (B):", "Down (D):"]
+        lines = text_obs.splitlines()
+        blocks: List[str] = []
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            for header in faces_order:
+                if line.startswith(header):
+                    content = line[len(header):].strip()
+                    next_line = lines[i + 1] if i + 1 < len(lines) else ""
+                    block = f"{content}\n{next_line}"
+                    blocks.append(block)
+                    break
+            i += 1
+        if len(blocks) != 6:
+            return np.zeros(24 * len(self._colors), dtype=np.float32)
+        stickers: List[int] = []
+        for blk in blocks:
+            m = self._face_pat.search(blk)
+            if not m:
+                return np.zeros(24 * len(self._colors), dtype=np.float32)
+            c0, c1, c2, c3 = m.group(1), m.group(2), m.group(3), m.group(4)
+            stickers.extend([c0, c1, c2, c3])
+        grid = np.zeros((24, len(self._colors)), dtype=np.float32)
+        for idx, ch in enumerate(stickers):
+            cidx = self._color_to_idx.get(ch, None)
+            if cidx is not None:
+                grid[idx, cidx] = 1.0
+        return grid.reshape(-1)
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        obs = self._encode_obs(text_obs)
+        return obs, {}
+
+    def step(self, action: int):
+        mapped = int(action) + 1
+        text_obs, reward, done, info = self._env.step(mapped)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        
+        # [关键修改] 应用惩罚
+        # 此时 reward 包含原本的稀疏奖励 (0 或 1) 加上每步惩罚
+        reward = float(reward) + self.step_penalty
+        
+        return obs, reward, terminated, truncated, info or {}
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "RubiksCube2x2DQN"
+    total_timesteps: int = 400_000
+    learning_rate: float = 2.5e-4
+    gamma: float = 0.99
+    batch_size: int = 128
+    buffer_size: int = 200_000
+    target_network_frequency: int = 4000
+    train_frequency: int = 4
+    learning_starts: int = 5000
+
+    # Epsilon-greedy
+    start_e: float = 1.0
+    end_e: float = 0.05
+    exploration_fraction: float = 0.2
+
+    # Model size
+    hidden_size: int = 256
+
+    # Rubik specific
+    scramble_depth: int = 3 # 初始难度
+    max_steps_env: int = 20 # 硬性时间限制
+
+    # Eval
+    eval_splits: int = 2
+    eval_episodes: int = 4000
+
+
+def make_env(idx, run_name, seed, scramble_depth, max_steps_env, capture_video=False):
+    def thunk():
+        # [关键修改] 内部 max_steps 设为 1000，防止 env 内部发出 done=True
+        # 我们完全依赖外部 TimeLimit wrapper 来处理超时
+        config = RubiksCube2x2Config(scramble_depth=scramble_depth, max_steps=20, render_mode='text')
+        env = RubiksCube2x2Env(config)
+        env = RubiksCubeWrapper(env)
+        # 外部限制设为 20
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps_env)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class QNetwork(nn.Module):
+    def __init__(self, obs_dim: int, act_dim: int, hidden: int):
+        super().__init__()
+        self.net = nn.Sequential(
+            layer_init(nn.Linear(obs_dim, hidden)),
+            nn.ReLU(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.ReLU(),
+            layer_init(nn.Linear(hidden, act_dim), std=0.01),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.net(x)
+
+
+class ReplayBuffer:
+    def __init__(self, capacity: int, obs_shape: Tuple[int, ...]):
+        self.capacity = capacity
+        self.ptr = 0
+        self.full = False
+        self.obs_buf = np.zeros((capacity,) + obs_shape, dtype=np.float32)
+        self.next_obs_buf = np.zeros((capacity,) + obs_shape, dtype=np.float32)
+        self.act_buf = np.zeros((capacity,), dtype=np.int64)
+        self.rew_buf = np.zeros((capacity,), dtype=np.float32)
+        self.done_buf = np.zeros((capacity,), dtype=np.float32)
+
+    def add(self, obs: np.ndarray, act: int, rew: float, done: bool, next_obs: np.ndarray):
+        i = self.ptr
+        self.obs_buf[i] = obs
+        self.next_obs_buf[i] = next_obs
+        self.act_buf[i] = act
+        self.rew_buf[i] = rew
+        self.done_buf[i] = 1.0 if done else 0.0
+        self.ptr = (self.ptr + 1) % self.capacity
+        if self.ptr == 0:
+            self.full = True
+
+    def can_sample(self, batch_size: int) -> bool:
+        return (self.capacity if self.full else self.ptr) >= batch_size
+
+    def sample(self, batch_size: int):
+        size = self.capacity if self.full else self.ptr
+        idxs = np.random.randint(0, size, size=batch_size)
+        return (
+            self.obs_buf[idxs],
+            self.act_buf[idxs],
+            self.rew_buf[idxs],
+            self.done_buf[idxs],
+            self.next_obs_buf[idxs],
+        )
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    env = make_env(0, run_name, args.seed, args.scramble_depth, args.max_steps_env, args.capture_video)()
+    obs_shape = env.observation_space.shape
+    act_dim = env.action_space.n
+
+    policy_net = QNetwork(int(np.prod(obs_shape)), act_dim, args.hidden_size).to(device)
+    target_net = QNetwork(int(np.prod(obs_shape)), act_dim, args.hidden_size).to(device)
+    target_net.load_state_dict(policy_net.state_dict())
+    target_net.eval()
+
+    optimizer = optim.Adam(policy_net.parameters(), lr=args.learning_rate)
+    criterion = nn.SmoothL1Loss()
+
+    rb = ReplayBuffer(args.buffer_size, obs_shape)
+
+    exploration_steps = max(1, int(args.exploration_fraction * args.total_timesteps))
+    epsilon_by_step = lambda t: args.end_e + (args.start_e - args.end_e) * max(0.0, (exploration_steps - t) / exploration_steps)
+
+    # 评估函数
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env_eval = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, _ = env_eval.reset(seed=args.seed + 100000 + collected)
+                traj_states = [np.asarray(state).tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env_eval, '_max_episode_steps', None) or int(args.max_steps_env)
+                while not done:
+                    with torch.no_grad():
+                        q = agent_model(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0))
+                        action = int(torch.argmax(q, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env_eval.step(action)
+                    
+                    traj_actions.append(int(action))
+                    traj_rewards.append(float(reward))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_state
+                    traj_states.append(np.asarray(state).tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env_eval.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    # 主训练循环
+    global_step = 0
+    start_time = time.time()
+
+    obs, _ = env.reset(seed=args.seed)
+    ep_return = 0.0
+    ep_len = 0
+    ep_success_window: List[float] = []
+
+    eval_every_steps = max(1, args.total_timesteps // args.eval_splits)
+
+    while global_step < args.total_timesteps:
+        epsilon = epsilon_by_step(global_step)
+        if np.random.rand() < epsilon or global_step < args.learning_starts:
+            action = env.action_space.sample()
+        else:
+            with torch.no_grad():
+                q_values = policy_net(torch.tensor(obs, dtype=torch.float32, device=device).unsqueeze(0))
+                action = int(torch.argmax(q_values, dim=1).item())
+
+        next_obs, reward, terminated, truncated, info = env.step(action)
+        
+        # 判断是否需要 Reset (任何结束都 Reset)
+        real_done = bool(terminated) or bool(truncated)
+
+        # [核心逻辑]
+        # 1. 即使是 truncated (超时)，done 也记为 False，以便进行 bootstrap (计算未来价值)
+        # 2. 只有 terminated (真正解开了)，done 才记为 True
+        # 3. Step Penalty 已经包含在 reward 中，DQN 会学到"为了避免扣分，必须在未来几步内解决"
+        rb.add(
+            obs.astype(np.float32), 
+            int(action), 
+            float(reward), 
+            bool(terminated), # 注意：只用 terminated
+            next_obs.astype(np.float32)
+        )
+
+        obs = next_obs
+        ep_return += float(reward)
+        ep_len += 1
+        global_step += 1
+
+        # 训练过程
+        if rb.can_sample(args.batch_size) and (global_step % args.train_frequency == 0) and (global_step > args.learning_starts):
+            batch_obs, batch_act, batch_rew, batch_done, batch_next_obs = rb.sample(args.batch_size)
+            b_obs = torch.tensor(batch_obs, dtype=torch.float32, device=device)
+            b_act = torch.tensor(batch_act, dtype=torch.int64, device=device)
+            b_rew = torch.tensor(batch_rew, dtype=torch.float32, device=device)
+            b_done = torch.tensor(batch_done, dtype=torch.float32, device=device)
+            b_next_obs = torch.tensor(batch_next_obs, dtype=torch.float32, device=device)
+
+            with torch.no_grad():
+                next_q = target_net(b_next_obs).max(dim=1)[0]
+                target_q = b_rew + args.gamma * (1.0 - b_done) * next_q
+
+            current_q = policy_net(b_obs).gather(1, b_act.view(-1, 1)).squeeze(1)
+            loss = criterion(current_q, target_q)
+
+            optimizer.zero_grad()
+            loss.backward()
+            nn.utils.clip_grad_norm_(policy_net.parameters(), max_norm=10.0)
+            optimizer.step()
+
+            if args.track:
+                try:
+                    import wandb
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "train/loss": float(loss.item()),
+                        "charts/epsilon": float(epsilon),
+                        "perf/SPS": int(global_step / (time.time() - start_time)),
+                        "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                    }, step=global_step)
+                except Exception:
+                    pass
+
+        # 结束时 Reset
+        if real_done:
+            succ = bool((info or {}).get('success', False))
+            ep_success_window.append(1.0 if succ else 0.0)
+            if len(ep_success_window) > 100:
+                ep_success_window.pop(0)
+            if args.track:
+                try:
+                    import wandb
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "train/episodic_return": float(ep_return),
+                        "train/episodic_length": int(ep_len),
+                        "train/success": float(1.0 if succ else 0.0),
+                        "train/success_rate_100": float(np.mean(ep_success_window)) if len(ep_success_window) >= 1 else None,
+                    }, step=global_step)
+                except Exception:
+                    pass
+            obs, _ = env.reset()
+            ep_return, ep_len = 0.0, 0
+
+        # 更新目标网络
+        if global_step % args.target_network_frequency == 0:
+            target_net.load_state_dict(policy_net.state_dict())
+
+        # 打印日志
+        if global_step % 1000 == 0:
+            sps = int(global_step / (time.time() - start_time))
+            sr100 = float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else 0.0
+            print(f"Step {global_step} | SPS: {sps} | Epsilon: {epsilon:.3f} | SR@100: {sr100:.3f}")
+
+        # 评估
+        if global_step == 1 or (global_step % eval_every_steps == 0):
+            try:
+                def eval_thunk():
+                    # 评估环境也同样设置：内部1000，外部20
+                    return make_env(0, run_name, args.seed + 9999, args.scramble_depth, args.max_steps_env, False)()
+                collect_eval_trajectories(policy_net, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import wandb
+                        mpath = Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {args.eval_episodes} eval trajectories at step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    env.close()

cleanrl/cleanrl/scout_dqn/dqn_sudoku.py

@@ -0,0 +1,485 @@
+# DQN with Action Masking for RAGEN Sudoku (4x4, max_step=20)
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple, Dict, Any, List
+import json
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.sudoku.env import SudokuEnv
+from ragen.env.sudoku.config import SudokuEnvConfig
+
+
+class SudokuWrapper(gym.Env):
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: SudokuEnv, grid_size: int):
+        super().__init__()
+        self._env = env
+        self._size = grid_size
+        self._val_dim = self._size + 1
+        self._act_n = self._size * self._size * self._size
+        self.action_space = gym.spaces.Discrete(self._act_n)
+        self.observation_space = gym.spaces.Dict({
+            "observation": gym.spaces.Box(low=0.0, high=1.0, shape=(self._size * self._size * self._val_dim,), dtype=np.float32),
+            "action_mask": gym.spaces.Box(low=0.0, high=1.0, shape=(self._act_n,), dtype=np.float32)
+        })
+
+    def _encode_obs(self, text_obs: str) -> Dict[str, np.ndarray]:
+        vals: List[int] = []
+        for line in text_obs.splitlines():
+            ls = line.strip()
+            if len(ls) == 0:
+                continue
+            if set(ls) <= {'-'}:
+                continue
+            tokens = [t for t in ls.split() if t != '|']
+            if len(tokens) == 0:
+                continue
+            for t in tokens:
+                if t == '.':
+                    vals.append(0)
+                else:
+                    try:
+                        v = int(t)
+                    except ValueError:
+                        v = 0
+                    vals.append(v)
+        target = self._size * self._size
+        if len(vals) < target:
+            vals.extend([0] * (target - len(vals)))
+        if len(vals) > target:
+            vals = vals[:target]
+        grid = np.zeros((target, self._val_dim), dtype=np.float32)
+        mask = np.zeros(self._act_n, dtype=np.float32)
+        for i, v in enumerate(vals):
+            v_clamped = int(v)
+            if v_clamped < 0 or v_clamped > self._size:
+                v_clamped = 0
+            grid[i, v_clamped] = 1.0
+            if v_clamped != 0:
+                start_idx = i * self._size
+                end_idx = start_idx + self._size
+                mask[start_idx:end_idx] = 0.0
+        cur = np.array(vals, dtype=np.int64).reshape(self._size, self._size)
+        box = int(np.sqrt(self._size))
+        for i, v in enumerate(vals):
+            if int(v) == 0:
+                r = i // self._size
+                c = i % self._size
+                row_vals = set(cur[r, :].tolist())
+                col_vals = set(cur[:, c].tolist())
+                br = (r // box) * box
+                bc = (c // box) * box
+                box_vals = set(cur[br:br + box, bc:bc + box].reshape(-1).tolist())
+                start_idx = i * self._size
+                for num in range(1, self._size + 1):
+                    if (num not in row_vals) and (num not in col_vals) and (num not in box_vals):
+                        mask[start_idx + (num - 1)] = 1.0
+        if mask.sum() == 0:
+            for i, v in enumerate(vals):
+                if int(v) == 0:
+                    start_idx = i * self._size
+                    end_idx = start_idx + self._size
+                    mask[start_idx:end_idx] = 1.0
+            if mask.sum() == 0:
+                mask[:] = 1.0
+        return {
+            "observation": grid.reshape(-1),
+            "action_mask": mask,
+        }
+
+    @staticmethod
+    def _decode_action(action_id: int, grid_size: int) -> Tuple[int, int, int]:
+        g = grid_size
+        row = action_id // (g * g)
+        rem = action_id % (g * g)
+        col = rem // g
+        num = (rem % g) + 1
+        return row, col, num
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        obs = self._encode_obs(text_obs)
+        return obs, {}
+
+    def step(self, action: int):
+        row, col, num = self._decode_action(int(action), self._size)
+        act_str = f"{row + 1},{col + 1},{num}"
+        text_obs, reward, done, info = self._env.step(act_str)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, info or {}
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "SudokuDQN"
+    total_timesteps: int = 200000
+    learning_rate: float = 3e-4
+    gamma: float = 0.99
+    batch_size: int = 128
+    buffer_size: int = 400_000
+    target_network_frequency: int = 4000
+    train_frequency: int = 1
+    learning_starts: int = 10000
+
+    # Epsilon-greedy
+    start_e: float = 1.0
+    end_e: float = 0.05
+    exploration_fraction: float = 0.2
+
+    # Model size
+    hidden_size: int = 256
+
+    # Sudoku specific
+    grid_size: int = 4
+    difficulty: str = "easy"
+
+    # Eval
+    eval_splits: int = 2
+    eval_episodes: int = 4000
+
+
+def make_env(idx, run_name, seed, grid_size, difficulty, capture_video=False):
+    def thunk():
+        config = SudokuEnvConfig(
+            grid_size=grid_size,
+            difficulty=difficulty,
+            render_mode='text',
+            render_format='simple',
+        )
+        env = SudokuEnv(config)
+        env = SudokuWrapper(env, grid_size)
+        max_steps = 20
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class QNetwork(nn.Module):
+    def __init__(self, obs_dim: int, act_dim: int, hidden: int):
+        super().__init__()
+        self.net = nn.Sequential(
+            layer_init(nn.Linear(obs_dim, hidden)),
+            nn.ReLU(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.ReLU(),
+            layer_init(nn.Linear(hidden, act_dim), std=0.01),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.net(x)
+
+
+class ReplayBuffer:
+    def __init__(self, capacity: int, obs_dim: int):
+        self.capacity = capacity
+        self.ptr = 0
+        self.full = False
+        self.obs_buf = np.zeros((capacity, obs_dim), dtype=np.float32)
+        self.next_obs_buf = np.zeros((capacity, obs_dim), dtype=np.float32)
+        self.act_buf = np.zeros((capacity,), dtype=np.int64)
+        self.rew_buf = np.zeros((capacity,), dtype=np.float32)
+        self.done_buf = np.zeros((capacity,), dtype=np.float32)
+
+    def add(self, obs: np.ndarray, act: int, rew: float, done: bool, next_obs: np.ndarray):
+        i = self.ptr
+        self.obs_buf[i] = obs
+        self.next_obs_buf[i] = next_obs
+        self.act_buf[i] = act
+        self.rew_buf[i] = rew
+        self.done_buf[i] = 1.0 if done else 0.0
+        self.ptr = (self.ptr + 1) % self.capacity
+        if self.ptr == 0:
+            self.full = True
+
+    def can_sample(self, batch_size: int) -> bool:
+        return (self.capacity if self.full else self.ptr) >= batch_size
+
+    def sample(self, batch_size: int):
+        size = self.capacity if self.full else self.ptr
+        idxs = np.random.randint(0, size, size=batch_size)
+        return (
+            self.obs_buf[idxs],
+            self.act_buf[idxs],
+            self.rew_buf[idxs],
+            self.done_buf[idxs],
+            self.next_obs_buf[idxs],
+        )
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    env = make_env(0, run_name, args.seed, args.grid_size, args.difficulty, args.capture_video)()
+    # Flattened grid only from Dict observation
+    sample_obs, _ = env.reset(seed=args.seed)
+    obs_dim = int(np.prod(sample_obs["observation"].shape))
+    act_dim = env.action_space.n
+
+    policy_net = QNetwork(obs_dim, act_dim, args.hidden_size).to(device)
+    target_net = QNetwork(obs_dim, act_dim, args.hidden_size).to(device)
+    target_net.load_state_dict(policy_net.state_dict())
+    target_net.eval()
+
+    optimizer = optim.Adam(policy_net.parameters(), lr=args.learning_rate)
+    criterion = nn.SmoothL1Loss()
+
+    rb = ReplayBuffer(args.buffer_size, obs_dim)
+
+    exploration_steps = max(1, int(args.exploration_fraction * args.total_timesteps))
+    epsilon_by_step = lambda t: args.end_e + (args.start_e - args.end_e) * max(0.0, (exploration_steps - t) / exploration_steps)
+
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env_eval = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                obs_dict, _ = env_eval.reset(seed=args.seed + 100000 + collected)
+                state = obs_dict['observation']
+                mask = obs_dict['action_mask']
+                traj_states = [state.tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env_eval, '_max_episode_steps', None) or int(args.grid_size * args.grid_size * 6)
+                while not done:
+                    with torch.no_grad():
+                        q = agent_model(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0))
+                        mask_t = torch.tensor(mask, dtype=torch.float32, device=device).unsqueeze(0)
+                        masked_q = q + (mask_t - 1.0) * 1e8
+                        action = int(torch.argmax(masked_q, dim=1).item())
+                    next_obs_dict, reward, terminated, truncated, info = env_eval.step(action)
+                    traj_actions.append(int(action))
+                    traj_rewards.append(float(reward))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_obs_dict['observation']
+                    mask = next_obs_dict['action_mask']
+                    traj_states.append(state.tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env_eval.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    global_step = 0
+    start_time = time.time()
+
+    obs_dict, _ = env.reset(seed=args.seed)
+    obs = obs_dict['observation']
+    mask = obs_dict['action_mask']
+    ep_success_window: List[float] = []
+
+    eval_every_steps = max(1, args.total_timesteps // args.eval_splits)
+
+    while global_step < args.total_timesteps:
+        epsilon = epsilon_by_step(global_step)
+        with torch.no_grad():
+            q_values = policy_net(torch.tensor(obs, dtype=torch.float32, device=device).unsqueeze(0))
+            mask_t = torch.tensor(mask, dtype=torch.float32, device=device).unsqueeze(0)
+            masked_q = q_values + (mask_t - 1.0) * 1e8
+            greedy_action = int(torch.argmax(masked_q, dim=1).item())
+        if (np.random.rand() < epsilon) or (global_step < args.learning_starts):
+            valid = np.where(mask > 0.5)[0]
+            if len(valid) > 0:
+                action = int(np.random.choice(valid))
+            else:
+                action = int(np.random.randint(0, act_dim))
+        else:
+            action = greedy_action
+
+        next_obs_dict, reward, terminated, truncated, info = env.step(action)
+        done = bool(terminated) or bool(truncated)
+
+        next_obs = next_obs_dict['observation']
+        next_mask = next_obs_dict['action_mask']
+
+        rb.add(obs.astype(np.float32), int(action), float(reward), bool(done), next_obs.astype(np.float32))
+
+        obs = next_obs
+        mask = next_mask
+        global_step += 1
+
+        if done:
+            succ = bool((info or {}).get('success', False))
+            ep_success_window.append(1.0 if succ else 0.0)
+            if len(ep_success_window) > 100:
+                ep_success_window.pop(0)
+            if args.track:
+                try:
+                    import wandb
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "rollout/success": float(1.0 if succ else 0.0),
+                        "rollout/success_rate_100": float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else None,
+                    }, step=global_step)
+                except Exception:
+                    pass
+            obs_dict, _ = env.reset()
+            obs = obs_dict['observation']
+            mask = obs_dict['action_mask']
+
+        if rb.can_sample(args.batch_size) and (global_step % args.train_frequency == 0) and (global_step > args.learning_starts):
+            batch_obs, batch_act, batch_rew, batch_done, batch_next_obs = rb.sample(args.batch_size)
+            b_obs = torch.tensor(batch_obs, dtype=torch.float32, device=device)
+            b_act = torch.tensor(batch_act, dtype=torch.int64, device=device)
+            b_rew = torch.tensor(batch_rew, dtype=torch.float32, device=device)
+            b_done = torch.tensor(batch_done, dtype=torch.float32, device=device)
+            b_next_obs = torch.tensor(batch_next_obs, dtype=torch.float32, device=device)
+
+            with torch.no_grad():
+                next_q = target_net(b_next_obs).max(dim=1)[0]
+                target_q = b_rew + args.gamma * (1.0 - b_done) * next_q
+
+            current_q = policy_net(b_obs).gather(1, b_act.view(-1, 1)).squeeze(1)
+            loss = criterion(current_q, target_q)
+
+            optimizer.zero_grad()
+            loss.backward()
+            nn.utils.clip_grad_norm_(policy_net.parameters(), max_norm=10.0)
+            optimizer.step()
+
+            if args.track:
+                try:
+                    import wandb
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "train/loss": float(loss.item()),
+                        "charts/epsilon": float(epsilon),
+                        "perf/SPS": int(global_step / (time.time() - start_time)),
+                        "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                    }, step=global_step)
+                except Exception:
+                    pass
+
+        if global_step % args.target_network_frequency == 0:
+            target_net.load_state_dict(policy_net.state_dict())
+
+        if global_step % 1000 == 0:
+            sps = int(global_step / (time.time() - start_time))
+            sr100 = float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else 0.0
+            print(f"Step {global_step} | SPS: {sps} | Epsilon: {epsilon:.3f} | SR@100: {sr100:.3f}")
+
+        if global_step == 1 or (global_step % eval_every_steps == 0):
+            try:
+                def eval_thunk():
+                    return make_env(0, run_name, args.seed + 9999, args.grid_size, args.difficulty, False)()
+                collect_eval_trajectories(policy_net, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import wandb
+                        mpath = Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {args.eval_episodes} eval trajectories at step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    env.close()

cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py

@@ -0,0 +1,541 @@
+# NoisyNet DQN (dueling CNN) for RAGEN Sokoban, tuned for box=2
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Any, Tuple
+from collections import deque
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+import json
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.sokoban.env import SokobanEnv
+from ragen.env.sokoban.config import SokobanEnvConfig
+
+
+class SokobanWrapper(gym.Env):
+    metadata = {"render_modes": ["rgb_array", "human", "ansi", "text"]}
+
+    def __init__(self, env: SokobanEnv):
+        super().__init__()
+        self._env = env
+        self._h = int(self._env.dim_room[0])
+        self._w = int(self._env.dim_room[1])
+        self._tokens = ['#', '_', 'O', '√', 'X', 'P', 'S']
+        self._token_to_idx = {t: i for i, t in enumerate(self._tokens)}
+        self._c = len(self._tokens)
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(self._c, self._h, self._w), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+
+    def _encode_obs(self, text_obs: str) -> np.ndarray:
+        rows = text_obs.split('\n')
+        rows = [list(r) for r in rows if len(r) > 0]
+        h = len(rows)
+        w = len(rows[0]) if h > 0 else self._w
+        grid = np.zeros((self._c, self._h, self._w), dtype=np.float32)
+        for i in range(min(h, self._h)):
+            for j in range(min(w, self._w)):
+                ch = rows[i][j]
+                idx = self._token_to_idx.get(ch, 0)
+                grid[idx, i, j] = 1.0
+        return grid
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        obs = self._encode_obs(text_obs)
+        return obs, {}
+
+    def step(self, action: int):
+        mapped = int(action) + 1  # env expects 1..4
+        text_obs, reward, done, info = self._env.step(mapped)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, info or {}
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "SokobanNoisyDQN"
+    total_timesteps: int = 1_000_000
+    learning_rate: float = 2.5e-4
+    gamma: float = 0.99
+    batch_size: int = 128
+    buffer_size: int = 200_000
+    target_network_frequency: int = 8000
+    train_frequency: int = 4
+    learning_starts: int = 20_000
+
+    # Epsilon-greedy (used lightly for warmup)
+    start_e: float = 1.0
+    end_e: float = 0.1
+    exploration_fraction: float = 0.8
+
+    # Model
+    dueling: bool = True
+    reward_clip_abs: float | None = 1.0
+
+    # Eval config
+    eval_splits: int = 2
+    eval_episodes: int = 8000
+
+    # Sokoban env config (default for harder task)
+    grid_h: int = 6
+    grid_w: int = 6
+    num_boxes: int = 2
+    max_steps_env: int = 100
+    search_depth: int = 300
+
+
+def make_env(run_name: str, seed: int, args: Args, capture_video: bool = False):
+    cfg = SokobanEnvConfig(
+        dim_room=(args.grid_h, args.grid_w),
+        max_steps=args.max_steps_env,
+        num_boxes=args.num_boxes,
+        search_depth=args.search_depth,
+        render_mode='text',
+        observation_format='grid',
+    )
+    env = SokobanEnv(cfg)
+    env = SokobanWrapper(env)
+    env = gym.wrappers.RecordEpisodeStatistics(env)
+    if capture_video:
+        env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+    return env
+
+
+class NoisyLinear(nn.Module):
+    def __init__(self, in_features: int, out_features: int, std_init: float = 0.5):
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight_mu = nn.Parameter(torch.empty(out_features, in_features))
+        self.weight_sigma = nn.Parameter(torch.empty(out_features, in_features))
+        self.register_buffer('weight_epsilon', torch.empty(out_features, in_features))
+        self.bias_mu = nn.Parameter(torch.empty(out_features))
+        self.bias_sigma = nn.Parameter(torch.empty(out_features))
+        self.register_buffer('bias_epsilon', torch.empty(out_features))
+        self.std_init = std_init / np.sqrt(in_features)
+        self.reset_parameters()
+        self.reset_noise()
+
+    def reset_parameters(self):
+        mu_range = 1 / np.sqrt(self.in_features)
+        self.weight_mu.data.uniform_(-mu_range, mu_range)
+        self.weight_sigma.data.fill_(self.std_init)
+        self.bias_mu.data.uniform_(-mu_range, mu_range)
+        self.bias_sigma.data.fill_(self.std_init)
+
+    def reset_noise(self):
+        epsilon_in = torch.randn(self.in_features, device=self.weight_mu.device)
+        epsilon_out = torch.randn(self.out_features, device=self.weight_mu.device)
+        self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))
+        self.bias_epsilon.copy_(epsilon_out)
+
+    def forward(self, x):
+        if self.training:
+            w = self.weight_mu + self.weight_sigma * self.weight_epsilon
+            b = self.bias_mu + self.bias_sigma * self.bias_epsilon
+        else:
+            w = self.weight_mu
+            b = self.bias_mu
+        return torch.nn.functional.linear(x, w, b)
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    if isinstance(layer, NoisyLinear):
+        nn.init.orthogonal_(layer.weight_mu, std)
+        nn.init.constant_(layer.bias_mu, bias_const)
+        layer.weight_sigma.data.fill_(layer.std_init)
+        layer.bias_sigma.data.fill_(layer.std_init)
+    else:
+        nn.init.orthogonal_(layer.weight, std)
+        nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class QConvNoisy(nn.Module):
+    def __init__(self, obs_shape: Tuple[int, int, int], act_dim: int, dueling: bool = True):
+        super().__init__()
+        c, h, w = obs_shape
+        self.dueling = dueling
+        self._act_dim = act_dim
+        self.features = nn.Sequential(
+            layer_init(nn.Conv2d(c, 32, 3, 1, 1)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(32, 64, 3, 1, 1)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 64, 3, 1, 1)),
+            nn.ReLU(),
+            nn.Flatten(),
+        )
+        fc_in = 64 * h * w
+        if self.dueling:
+            self.adv_head = nn.Sequential(
+                layer_init(NoisyLinear(fc_in, 512)),
+                nn.ReLU(),
+                layer_init(NoisyLinear(512, act_dim), std=0.01),
+            )
+            self.val_head = nn.Sequential(
+                layer_init(NoisyLinear(fc_in, 512)),
+                nn.ReLU(),
+                layer_init(NoisyLinear(512, 1), std=0.01),
+            )
+        else:
+            self.head = nn.Sequential(
+                layer_init(NoisyLinear(fc_in, 512)),
+                nn.ReLU(),
+                layer_init(NoisyLinear(512, act_dim), std=0.01),
+            )
+
+    def reset_noise(self):
+        for m in self.modules():
+            if isinstance(m, NoisyLinear):
+                m.reset_noise()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.features(x)
+        if self.dueling:
+            adv = self.adv_head(x)
+            val = self.val_head(x)
+            q = val + adv - adv.mean(dim=1, keepdim=True)
+            return q
+        else:
+            q = self.head(x)
+            return q
+
+
+class ReplayBuffer:
+    def __init__(self, capacity: int, obs_shape: Tuple[int, int, int]):
+        self.capacity = capacity
+        self.ptr = 0
+        self.full = False
+        self.obs_buf = np.zeros((capacity,) + obs_shape, dtype=np.float32)
+        self.next_obs_buf = np.zeros((capacity,) + obs_shape, dtype=np.float32)
+        self.act_buf = np.zeros((capacity,), dtype=np.int64)
+        self.rew_buf = np.zeros((capacity,), dtype=np.float32)
+        self.done_buf = np.zeros((capacity,), dtype=np.float32)
+
+    def add(self, obs: np.ndarray, act: int, rew: float, done: bool, next_obs: np.ndarray):
+        self.obs_buf[self.ptr] = obs
+        self.next_obs_buf[self.ptr] = next_obs
+        self.act_buf[self.ptr] = act
+        self.rew_buf[self.ptr] = rew
+        self.done_buf[self.ptr] = 1.0 if done else 0.0
+        self.ptr = (self.ptr + 1) % self.capacity
+        if self.ptr == 0:
+            self.full = True
+
+    def can_sample(self, batch_size: int) -> bool:
+        return (self.capacity if self.full else self.ptr) >= batch_size
+
+    def sample(self, batch_size: int):
+        size = self.capacity if self.full else self.ptr
+        idxs = np.random.randint(0, size, size=batch_size)
+        return (
+            self.obs_buf[idxs],
+            self.act_buf[idxs],
+            self.rew_buf[idxs],
+            self.done_buf[idxs],
+            self.next_obs_buf[idxs],
+        )
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    # seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env
+    env = make_env(run_name, args.seed, args, args.capture_video)
+    obs_shape = env.observation_space.shape  # (C,H,W)
+    act_dim = env.action_space.n
+
+    # networks
+    policy_net = QConvNoisy(obs_shape, act_dim, dueling=args.dueling).to(device)
+    target_net = QConvNoisy(obs_shape, act_dim, dueling=args.dueling).to(device)
+    target_net.load_state_dict(policy_net.state_dict())
+    target_net.eval()
+
+    optimizer = optim.Adam(policy_net.parameters(), lr=args.learning_rate)
+    criterion = nn.SmoothL1Loss()
+
+    rb = ReplayBuffer(args.buffer_size, obs_shape)
+
+    # periodic eval setup
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes: int, step_tag: int):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env_eval = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, _ = env_eval.reset(seed=args.seed + 100000 + collected)
+                traj_states = [np.asarray(state).tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env_eval, '_max_episode_steps', None) or (args.grid_h * args.grid_w * 6)
+                while not done:
+                    with torch.no_grad():
+                        q = agent_model(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0))
+                        action = int(torch.argmax(q, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env_eval.step(action)
+                    traj_actions.append(int(action))
+                    traj_rewards.append(float(reward))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_state
+                    traj_states.append(np.asarray(state).tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env_eval.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    # epsilon schedule (log only; noisy nets handle exploration)
+    exploration_steps = max(1, int(args.exploration_fraction * args.total_timesteps))
+    def epsilon_by_step(t: int):
+        return args.end_e + (args.start_e - args.end_e) * max(0.0, (exploration_steps - t) / exploration_steps)
+
+    # training loop
+    global_step = 0
+    start_time = time.time()
+
+    obs, _ = env.reset(seed=args.seed)
+    ep_return = 0.0
+    ep_len = 0
+    ep_success_window = deque(maxlen=100)
+
+    eval_every_steps = max(1, args.total_timesteps // args.eval_splits)
+
+    while global_step < args.total_timesteps:
+        epsilon = epsilon_by_step(global_step)
+        with torch.no_grad():
+            q_values = policy_net(torch.tensor(obs, dtype=torch.float32, device=device).unsqueeze(0))
+            action_greedy = int(torch.argmax(q_values, dim=1).item())
+        if (global_step < args.learning_starts) and (np.random.rand() < 0.5):
+            action = env.action_space.sample()
+        else:
+            action = action_greedy
+        next_obs, reward, terminated, truncated, info = env.step(action)
+        done = bool(terminated) or bool(truncated)
+
+        r = float(reward)
+        if args.reward_clip_abs is not None:
+            cap = float(args.reward_clip_abs)
+            r = max(-cap, min(cap, r))
+
+        rb.add(obs.astype(np.float32), action, r, done, next_obs.astype(np.float32))
+
+        obs = next_obs
+        ep_return += float(reward)
+        ep_len += 1
+        global_step += 1
+
+        # optimize
+        if (global_step > args.learning_starts) and rb.can_sample(args.batch_size) and (global_step % args.train_frequency == 0):
+            batch_obs, batch_act, batch_rew, batch_done, batch_next_obs = rb.sample(args.batch_size)
+            b_obs = torch.tensor(batch_obs, dtype=torch.float32, device=device)
+            b_act = torch.tensor(batch_act, dtype=torch.int64, device=device)
+            b_rew = torch.tensor(batch_rew, dtype=torch.float32, device=device)
+            b_done = torch.tensor(batch_done, dtype=torch.float32, device=device)
+            b_next_obs = torch.tensor(batch_next_obs, dtype=torch.float32, device=device)
+
+            with torch.no_grad():
+                next_actions = policy_net(b_next_obs).argmax(dim=1)
+                next_q = target_net(b_next_obs).gather(1, next_actions.view(-1, 1)).squeeze(1)
+                target_q = b_rew + args.gamma * (1.0 - b_done) * next_q
+
+            current_q = policy_net(b_obs).gather(1, b_act.view(-1, 1)).squeeze(1)
+            loss = criterion(current_q, target_q)
+
+            optimizer.zero_grad()
+            loss.backward()
+            nn.utils.clip_grad_norm_(policy_net.parameters(), max_norm=10.0)
+            optimizer.step()
+
+            # reset noisy parameters
+            policy_net.reset_noise()
+            target_net.reset_noise()
+
+            if args.track:
+                try:
+                    import wandb
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "train/loss": float(loss.item()),
+                        "charts/epsilon": float(epsilon),
+                        "perf/SPS": int(global_step / (time.time() - start_time)),
+                    }, step=global_step)
+                except Exception:
+                    pass
+
+        # target network update
+        if global_step % args.target_network_frequency == 0:
+            target_net.load_state_dict(policy_net.state_dict())
+
+        if done:
+            succ = bool((info or {}).get('success', False))
+            ep_success_window.append(1.0 if succ else 0.0)
+            if args.track:
+                try:
+                    import wandb
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "rollout/episodic_return": float(ep_return),
+                        "rollout/episodic_length": int(ep_len),
+                        "rollout/success": float(1.0 if succ else 0.0),
+                        "rollout/success_rate_100": float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else None,
+                    }, step=global_step)
+                except Exception:
+                    pass
+            obs, _ = env.reset()
+            ep_return, ep_len = 0.0, 0
+
+        # occasional print
+        if global_step % 1000 == 0:
+            sps = int(global_step / (time.time() - start_time))
+            sr100 = float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else 0.0
+            print(f"Step {global_step} | SPS: {sps} | Epsilon: {epsilon:.3f} | SR@100: {sr100:.3f}")
+
+        # periodic evaluation and trajectory dump
+        if global_step==0 or (global_step % eval_every_steps == 0):
+            try:
+                def eval_thunk():
+                    return make_env(run_name, args.seed + 9999, args, False)
+                collect_eval_trajectories(policy_net, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import wandb
+                        mpath = Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {args.eval_episodes} eval trajectories at step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    # simple evaluation after training
+    def evaluate(n_episodes=200):
+        returns = []
+        successes = []
+        for i in range(n_episodes):
+            s, _ = env.reset(seed=args.seed + 100000 + i)
+            done = False
+            G = 0.0
+            while not done:
+                with torch.no_grad():
+                    q = policy_net(torch.tensor(s, dtype=torch.float32, device=device).unsqueeze(0))
+                    a = int(torch.argmax(q, dim=1).item())
+                s, r, term, trunc, info = env.step(a)
+                G += float(r)
+                done = bool(term) or bool(trunc)
+            successes.append(1.0 if bool((info or {}).get('success', False)) else 0.0)
+            returns.append(G)
+        return float(np.mean(returns)), float(np.std(returns)), float(np.mean(successes))
+
+    avg_ret, std_ret, succ_rate = evaluate(400)
+    if args.track:
+        try:
+            import wandb
+            wandb.log({
+                "global_step": int(global_step),
+                "eval/avg_return": float(avg_ret),
+                "eval/std_return": float(std_ret),
+                "eval/episodes": int(400),
+                "eval/success_rate": float(succ_rate),
+            }, step=global_step)
+        except Exception:
+            pass
+
+    env.close()

cleanrl/cleanrl/scout_dqn/ragen_wrappers.py

@@ -0,0 +1,235 @@
+"""
+Gymnasium-compatible wrappers for RAGEN environments to enable traditional RL training.
+These wrappers convert text-based observations to numerical representations suitable for MLP networks.
+"""
+import gymnasium as gym
+import numpy as np
+from typing import Any, Dict, Tuple
+
+
+class BanditWrapper(gym.Wrapper):
+    """
+    Wrapper for RAGEN Bandit that uses only observable text.
+    Converts text observations to a fixed-size one-hot hash vector.
+    Does not alter episode semantics and does not inspect env internals.
+    """
+    def __init__(self, env, feature_dim_per_name: int = 16):
+        super().__init__(env)
+        # Two name slots (first/second), each hashed to one-hot of size K
+        self.k = feature_dim_per_name
+        self.observation_space = gym.spaces.Box(low=0, high=1, shape=(2 * self.k,), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(2)
+
+    def _parse_names(self, text_obs: str):
+        """Extract the two arm names from the prompt text purely via regex/string ops."""
+        # Heuristic: look for the segment after "named " and split by " and "
+        try:
+            anchor = "named "
+            if anchor in text_obs:
+                segment = text_obs.split(anchor, 1)[1]
+                # Cut at newline if present
+                segment = segment.split("\n", 1)[0]
+                # Now split by " and " to get two names; also strip punctuation
+                parts = segment.split(" and ")
+                if len(parts) >= 2:
+                    name_a = parts[0].strip().strip(' .!?,')
+                    name_b = parts[1].strip().strip(' .!?,')
+                    return name_a, name_b
+        except Exception:
+            pass
+        # Fallback: no names found
+        return "", ""
+
+    def _names_to_vector(self, name_a: str, name_b: str) -> np.ndarray:
+        vec = np.zeros(2 * self.k, dtype=np.float32)
+        idx_a = (hash(name_a) % self.k)
+        idx_b = (hash(name_b) % self.k)
+        vec[idx_a] = 1.0
+        vec[self.k + idx_b] = 1.0
+        return vec
+
+    def reset(self, **kwargs):
+        seed = kwargs.get('seed', None)
+        mode = kwargs.get('mode', None)
+        text_obs = self.env.reset(seed=seed, mode=mode)
+        name_a, name_b = self._parse_names(text_obs)
+        return self._names_to_vector(name_a, name_b), {}
+
+    def step(self, action):
+        ragen_action = int(action) + 1
+        text_obs, reward, done, info = self.env.step(ragen_action)
+        name_a, name_b = self._parse_names(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return self._names_to_vector(name_a, name_b), reward, terminated, truncated, info
+
+
+class FrozenLakeWrapper(gym.Wrapper):
+    """
+    Wrapper for RAGEN FrozenLake environment.
+    Converts grid-based text observations to numerical state representation.
+    """
+    def __init__(self, env):
+        super().__init__(env)
+        # Bootstrap an observation to determine grid size from text only
+        bootstrap_text = self.env.reset()
+        flat, _ = self._parse_observation_and_meta(bootstrap_text)
+        self.observation_space = gym.spaces.Box(low=0, high=1, shape=(flat.shape[0],), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+        # Serve the bootstrapped obs on first reset without calling env.reset again
+        self._bootstrap_obs = flat
+        self._bootstrap_ready = True
+        
+    def _parse_observation_and_meta(self, text_obs: str) -> Tuple[np.ndarray, Tuple[int, int]]:
+        """Parse text observation into numerical state (one-hot grid + player pos)."""
+        lines = text_obs.strip().split('\n')
+        grid = []
+        player_pos = None
+        rows = len(lines)
+        cols = max(len(line) for line in lines) if rows > 0 else 0
+        # Parse grid
+        for i, line in enumerate(lines):
+            row = []
+            for j, char in enumerate(line):
+                if char == 'P':  # Player
+                    row.append(0)
+                    player_pos = (i, j)
+                elif char == '_':  # Frozen
+                    row.append(1)
+                elif char == 'O':  # Hole
+                    row.append(2)
+                elif char == 'G':  # Goal
+                    row.append(3)
+                elif char == 'X':  # Player in hole
+                    row.append(2)
+                    player_pos = (i, j)
+                elif char == '√':  # Player on goal
+                    row.append(3)
+                    player_pos = (i, j)
+                else:
+                    row.append(1)  # Default to frozen
+            grid.append(row)
+        # Pad ragged rows if needed
+        grid = np.array([r + [1] * (cols - len(r)) for r in grid], dtype=np.int32)
+        grid_size = (rows, cols)
+        # One-hot encode grid over 4 cell types
+        # One-hot encode grid
+        one_hot_grid = np.zeros((rows, cols, 4), dtype=np.float32)
+        for i in range(rows):
+            for j in range(cols):
+                cell_type = grid[i, j]
+                one_hot_grid[i, j, cell_type] = 1.0
+        # Flatten grid
+        flat_grid = one_hot_grid.flatten()
+        # Add normalized player position
+        if player_pos is None:
+            player_pos = (0, 0)
+        player_pos_norm = np.array([
+            0.0 if rows <= 1 else player_pos[0] / max(1, rows - 1),
+            0.0 if cols <= 1 else player_pos[1] / max(1, cols - 1),
+        ], dtype=np.float32)
+        flat = np.concatenate([flat_grid, player_pos_norm])
+        return flat, grid_size
+    
+    def reset(self, **kwargs):
+        # Filter out 'options' parameter that gymnasium passes but RAGEN doesn't support
+        if self._bootstrap_ready:
+            # First call returns the bootstrapped observation to avoid double reset
+            self._bootstrap_ready = False
+            return self._bootstrap_obs.copy(), {}
+        seed = kwargs.get('seed', None)
+        mode = kwargs.get('mode', None)
+        text_obs = self.env.reset(seed=seed, mode=mode)
+        state, _ = self._parse_observation_and_meta(text_obs)
+        return state, {}
+    
+    def step(self, action):
+        # Map action from 0,1,2,3 to 1,2,3,4 (RAGEN uses 1-indexed actions)
+        ragen_action = action + 1
+        text_obs, reward, done, info = self.env.step(ragen_action)
+        state, _ = self._parse_observation_and_meta(text_obs)
+        
+        terminated = done
+        truncated = False
+        
+        return state, reward, terminated, truncated, info
+
+
+class SokobanWrapper(gym.Wrapper):
+    """
+    Wrapper for RAGEN Sokoban environment.
+    Converts grid-based text observations to numerical state representation.
+    Note: Does not inherit from gym.Wrapper due to old gym vs gymnasium compatibility.
+    """
+    def __init__(self, env):
+        super().__init__(env)
+        # Bootstrap an observation to determine room size from text only
+        bootstrap_text = self.env.reset()
+        flat, rows, cols = self._parse_observation_and_meta(bootstrap_text)
+        self.observation_space = gym.spaces.Box(low=0, high=1, shape=(flat.shape[0],), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+        self.metadata = getattr(env, 'metadata', {})
+        self._bootstrap_obs = flat
+        self._bootstrap_ready = True
+        
+    def _parse_observation_and_meta(self, text_obs: str) -> Tuple[np.ndarray, int, int]:
+        """Parse text observation into numerical state and return dims."""
+        lines = text_obs.strip().split('\n')
+        grid = []
+        rows = len(lines)
+        cols = max(len(line) for line in lines) if rows > 0 else 0
+        # Mapping from characters to cell types
+        char_to_type = {
+            '#': 0,  # wall
+            '_': 1,  # empty
+            'O': 2,  # target
+            '√': 3,  # box on target
+            'X': 4,  # box
+            'P': 5,  # player
+            'S': 6,  # player on target
+        }
+        
+        for line in lines:
+            row = []
+            for char in line:
+                row.append(char_to_type.get(char, 1))  # Default to empty
+            grid.append(row)
+        # Pad ragged rows
+        grid = np.array([r + [1] * (cols - len(r)) for r in grid], dtype=np.int32)
+        # One-hot encode grid
+        one_hot_grid = np.zeros((rows, cols, 7), dtype=np.float32)
+        for i in range(rows):
+            for j in range(cols):
+                cell_type = grid[i, j]
+                one_hot_grid[i, j, cell_type] = 1.0
+        return one_hot_grid.flatten(), rows, cols
+    
+    def reset(self, **kwargs):
+        if self._bootstrap_ready:
+            self._bootstrap_ready = False
+            return self._bootstrap_obs.copy(), {}
+        seed = kwargs.get('seed', None)
+        mode = kwargs.get('mode', None)
+        text_obs = self.env.reset(seed=seed, mode=mode)
+        state, _, _ = self._parse_observation_and_meta(text_obs)
+        return state, {}
+    
+    def step(self, action):
+        # Map action from 0,1,2,3 to 1,2,3,4 (RAGEN uses 1-indexed actions)
+        ragen_action = action + 1
+        text_obs, reward, done, info = self.env.step(ragen_action)
+        state, _, _ = self._parse_observation_and_meta(text_obs)
+        
+        terminated = done
+        truncated = False
+        
+        return state, reward, terminated, truncated, info
+    
+    def close(self):
+        if hasattr(self.env, 'close'):
+            self.env.close()
+    
+    def render(self):
+        if hasattr(self.env, 'render'):
+            return self.env.render()
+        return None

cleanrl/cleanrl/scout_ppo/ppo_2048.py

@@ -0,0 +1,514 @@
+# PPO (CNN actor-critic) for RAGEN 2048, matching NoisyNet DQN args and wandb logging
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Any, Tuple
+from collections import deque
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+import tyro
+import json
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+# env and config
+from ragen.env.game_2048.env import Game2048Env
+from ragen.env.game_2048.config import Game2048EnvConfig
+
+
+class Game2048Wrapper(gym.Env):
+    metadata = {"render_modes": ["text"]}
+
+    def __init__(self, env: Game2048Env, n_channels: int = 16):
+        super().__init__()
+        self._env = env
+        self._n_channels = int(n_channels)
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(self._n_channels, 4, 4), dtype=np.float32)
+        self.action_space = self._env.action_space
+        self._last_info: Dict[str, Any] | None = None
+
+    def _encode_grid(self, grid: np.ndarray) -> np.ndarray:
+        grid_flat = grid.flatten()
+        with np.errstate(divide='ignore'):
+            power_grid = np.log2(grid_flat, where=(grid_flat > 0)).astype(int)
+            power_grid[grid_flat == 0] = 0
+            power_grid = np.clip(power_grid, 0, self._n_channels - 1)
+            one_hot = np.eye(self._n_channels)[power_grid]
+            obs = one_hot.reshape(4, 4, self._n_channels).transpose(2, 0, 1)
+        return obs.astype(np.float32)
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs, info = self._env.reset(seed=seed, options=options)
+        self._last_info = info
+        grid = info.get('grid', np.zeros((4, 4), dtype=np.int64))
+        obs = self._encode_grid(grid)
+        ret_info = {k: v for k, v in (info or {}).items() if k != 'grid'}
+        try:
+            ret_info['max_tile'] = int(np.max(grid))
+        except Exception:
+            ret_info['max_tile'] = int(ret_info.get('max_tile', 0))
+        return obs, ret_info
+
+    def step(self, action: int):
+        text_obs, reward, done, info = self._env.step(int(action))
+        self._last_info = info
+        grid = info.get('grid', np.zeros((4, 4), dtype=np.int64))
+        obs = self._encode_grid(grid)
+        ret_info = {k: v for k, v in (info or {}).items() if k != 'grid'}
+        try:
+            ret_info['max_tile'] = int(np.max(grid))
+        except Exception:
+            ret_info['max_tile'] = int(ret_info.get('max_tile', 0))
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, ret_info
+
+    def get_action_mask(self) -> np.ndarray:
+        if self._last_info is None:
+            return np.ones((4,), dtype=bool)
+        mask = self._last_info.get('action_mask', None)
+        if mask is None:
+            return np.ones((4,), dtype=bool)
+        return np.asarray(mask, dtype=bool)
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    # mirror DQN args for wandb compatibility
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "2048-RL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm identifiers
+    env_id: str = "Game2048PPO"
+    total_timesteps: int = 3_000_000
+    learning_rate: float = 2.5e-4
+    gamma: float = 0.997
+
+    # DQN-only args kept for wandb/backward-compat (unused here)
+    batch_size: int = 512
+    buffer_size: int = 2400_000
+    target_network_frequency: int = 15000
+    train_frequency: int = 4
+    learning_starts: int = 20_000
+    start_e: float = 1.0
+    end_e: float = 0.05
+    exploration_fraction: float = 0.8
+    dueling: bool = True
+    n_step: int = 10
+    per_alpha: float = 0.5
+    per_beta_start: float = 0.4
+    per_beta_frames: int = 1_000_000
+    per_eps: float = 1e-6
+
+    # Env config
+    two_prob: float = 0.9
+    max_steps_env: int = 1000
+
+    # Eval config
+    eval_splits: int = 1
+    eval_episodes: int = 400
+
+    # PPO specific
+    num_steps: int = 256
+    num_minibatches: int = 8
+    update_epochs: int = 4
+    gae_lambda: float = 0.95
+    clip_coef: float = 0.2
+    ent_coef: float = 0.01
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    anneal_lr: bool = True
+
+
+def make_env(run_name: str, seed: int, args: Args, capture_video: bool = False):
+    cfg = Game2048EnvConfig(size=4, two_prob=args.two_prob, use_log_reward=True)
+    base = Game2048Env(cfg)
+    env = Game2048Wrapper(base)
+    env = gym.wrappers.TimeLimit(env, max_episode_steps=args.max_steps_env)
+    env = gym.wrappers.RecordEpisodeStatistics(env)
+    if capture_video:
+        env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+    return env
+
+
+class ActorCriticCNN(nn.Module):
+    def __init__(self, obs_shape: Tuple[int, int, int], act_dim: int):
+        super().__init__()
+        c, h, w = obs_shape
+        self.features = nn.Sequential(
+            nn.Conv2d(c, 64, 2, 1, 0),
+            nn.ReLU(),
+            nn.Conv2d(64, 128, 2, 1, 1),
+            nn.ReLU(),
+            nn.Conv2d(128, 128, 2, 1, 0),
+            nn.ReLU(),
+            nn.Flatten(),
+        )
+        with torch.no_grad():
+            fc_in = int(self.features(torch.zeros(1, *obs_shape)).shape[1])
+        self.pi = nn.Sequential(
+            nn.Linear(fc_in, 512), nn.ReLU(), nn.Linear(512, act_dim)
+        )
+        self.v = nn.Sequential(
+            nn.Linear(fc_in, 512), nn.ReLU(), nn.Linear(512, 1)
+        )
+
+    def get_value(self, x):
+        x = self.features(x)
+        return self.v(x).squeeze(-1)
+
+    def get_action_and_value(self, x, action=None, action_mask=None):
+        x = self.features(x)
+        logits = self.pi(x)
+        if action_mask is not None:
+            mask = action_mask.bool()
+            logits = torch.where(mask, logits, torch.full_like(logits, -1e9))
+        probs = torch.distributions.Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.v(x).squeeze(-1)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    try:
+        wandb.define_metric("global_step")
+        for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+            wandb.define_metric(prefix, step_metric="global_step")
+    except Exception:
+        pass
+
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    env = make_env(run_name, args.seed, args, args.capture_video)
+    obs_shape = env.observation_space.shape
+    act_dim = env.action_space.n
+
+    agent = ActorCriticCNN(obs_shape, act_dim).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # Storage
+    num_steps = args.num_steps
+    obs = np.zeros((num_steps,) + obs_shape, dtype=np.float32)
+    actions = np.zeros((num_steps,), dtype=np.int64)
+    logprobs = np.zeros((num_steps,), dtype=np.float32)
+    rewards = np.zeros((num_steps,), dtype=np.float32)
+    dones = np.zeros((num_steps,), dtype=np.float32)
+    values = np.zeros((num_steps,), dtype=np.float32)
+    masks_buf = np.zeros((num_steps, act_dim), dtype=bool)
+
+    global_step = 0
+    start_time = time.time()
+
+    next_obs, info = env.reset(seed=args.seed)
+    current_info = info or {}
+    next_done = False
+
+    ep_return = 0.0
+    ep_len = 0
+    ep_success_window = deque(maxlen=100)
+    ep_return_window = deque(maxlen=100)
+    step_reward_window = deque(maxlen=2048)
+
+    eval_every_steps = max(1, args.total_timesteps // args.eval_splits)
+
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes: int, step_tag: int):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env_eval = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, info = env_eval.reset(seed=args.seed + 100000 + collected)
+                current_info = info or {}
+                traj_states = [np.asarray(state).tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env_eval, '_max_episode_steps', None) or args.max_steps_env
+                while not done:
+                    with torch.no_grad():
+                        s = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
+                        mask_np = current_info.get('action_mask', np.ones(act_dim, dtype=bool))
+                        mask = torch.tensor(mask_np, dtype=torch.bool, device=device).unsqueeze(0)
+                        logits = agent_model.pi(agent_model.features(s))
+                        logits = torch.where(mask, logits, torch.full_like(logits, -1e9))
+                        action = int(torch.argmax(logits, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env_eval.step(action)
+                    traj_actions.append(int(action))
+                    raw_r = info.get('raw_reward', reward) if info else reward
+                    traj_rewards.append(float(raw_r))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_state
+                    current_info = info or {}
+                    traj_states.append(np.asarray(state).tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env_eval.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    num_updates = args.total_timesteps // num_steps
+
+    for update in range(1, num_updates + 1):
+        if args.anneal_lr:
+            frac = 1.0 - (update - 1.0) / float(max(1, num_updates))
+            lrnow = args.learning_rate * frac
+            for pg in optimizer.param_groups:
+                pg['lr'] = lrnow
+
+        for step in range(num_steps):
+            obs[step] = next_obs
+            dones[step] = float(next_done)
+            with torch.no_grad():
+                s = torch.tensor(next_obs, dtype=torch.float32, device=device).unsqueeze(0)
+                mask_np = current_info.get('action_mask', np.ones(act_dim, dtype=bool))
+                masks_buf[step] = mask_np
+                mask = torch.tensor(mask_np, dtype=torch.bool, device=device).unsqueeze(0)
+                a, lp, ent, val = agent.get_action_and_value(s, action_mask=mask)
+            action = int(a.item())
+            next_obs, reward, terminated, truncated, info = env.step(action)
+            done = bool(terminated) or bool(truncated)
+
+            rewards[step] = float(reward)  # training reward (log-scale per env)
+            actions[step] = action
+            logprobs[step] = float(lp.item())
+            values[step] = float(val.item())
+
+            # logging raw reward for charts
+            raw_r = float((info or {}).get('raw_reward', reward))
+            ep_return += raw_r
+            try:
+                step_reward_window.append(float(reward))
+            except Exception:
+                pass
+            ep_len += 1
+            global_step += 1
+
+            if done:
+                succ = bool((info or {}).get('success', False))
+                max_tile = int((info or {}).get('max_tile', 0))
+                ep_success_window.append(1.0 if succ else 0.0)
+                ep_return_window.append(float(ep_return))
+                try:
+                    if max_tile is not None:
+                        print(f"global_step={global_step}, episodic_return={ep_return:.1f}, length={ep_len}, max_tile={int(max_tile)}, success={succ}")
+                    else:
+                        print(f"global_step={global_step}, episodic_return={ep_return:.1f}, length={ep_len}, success={succ}")
+                except Exception:
+                    pass
+                if args.track:
+                    try:
+                        import wandb
+                        avg_ep_ret = float(np.mean(ep_return_window)) if len(ep_return_window) > 0 else 0.0
+                        wandb.log({
+                            "global_step": int(global_step),
+                            "rollout/episodic_return": float(ep_return),
+                            "rollout/episodic_length": int(ep_len),
+                            "rollout/success": float(1.0 if succ else 0.0),
+                            "rollout/max_tile": int(max_tile),
+                            "rollout/success_rate_100": float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else None,
+                            "charts/episodic_return": float(ep_return),
+                            "charts/episodic_length": int(ep_len),
+                            "charts/success": float(1.0 if succ else 0.0),
+                            "charts/max_tile": int(max_tile),
+                            "charts/avg_episode_return": avg_ep_ret,
+                        }, step=global_step)
+                    except Exception:
+                        pass
+                next_obs, info = env.reset()
+                current_info = info or {}
+                ep_return, ep_len = 0.0, 0
+            else:
+                current_info = info or {}
+                next_done = False
+
+            if global_step % 1000 == 0:
+                sps = int(global_step / (time.time() - start_time))
+                sr100 = float(np.mean(ep_success_window)) if len(ep_success_window) > 0 else 0.0
+                print(f"Step {global_step} | SPS: {sps} | SR@100: {sr100:.3f}")
+
+            if (global_step % eval_every_steps == 0):
+                try:
+                    def eval_thunk():
+                        return make_env(run_name, args.seed + 9999, args, False)
+                    collect_eval_trajectories(agent, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                    if args.track:
+                        try:
+                            import wandb
+                            mpath = Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                            if mpath.exists():
+                                with mpath.open("r") as mf:
+                                    metrics = json.load(mf)
+                                wandb.log({
+                                    "eval/success_rate": metrics.get("success_rate"),
+                                    "eval/avg_return": metrics.get("avg_return"),
+                                    "eval/std_return": metrics.get("std_return"),
+                                    "eval/episodes": metrics.get("episodes"),
+                                }, step=global_step)
+                        except Exception:
+                            pass
+                    print(f"Collected {args.eval_episodes} eval trajectories at step {global_step}")
+                except Exception as e:
+                    print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+        # Compute GAE
+        with torch.no_grad():
+            s = torch.tensor(next_obs, dtype=torch.float32, device=device).unsqueeze(0)
+            next_value = agent.get_value(s).item()
+        advantages = np.zeros_like(rewards)
+        lastgaelam = 0.0
+        for t in reversed(range(num_steps)):
+            if t == num_steps - 1:
+                nextnonterminal = 1.0 - next_done
+                nextvalues = next_value
+            else:
+                nextnonterminal = 1.0 - dones[t + 1]
+                nextvalues = values[t + 1]
+            delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+            advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+        returns = advantages + values
+
+        # Flatten
+        b_obs = torch.tensor(obs, dtype=torch.float32, device=device)
+        b_actions = torch.tensor(actions, dtype=torch.int64, device=device)
+        b_logprobs = torch.tensor(logprobs, dtype=torch.float32, device=device)
+        b_returns = torch.tensor(returns, dtype=torch.float32, device=device)
+        b_values = torch.tensor(values, dtype=torch.float32, device=device)
+        b_advantages = torch.tensor(advantages, dtype=torch.float32, device=device)
+        b_masks = torch.tensor(masks_buf, dtype=torch.bool, device=device)
+
+        b_advantages = (b_advantages - b_advantages.mean()) / (b_advantages.std() + 1e-8)
+
+        # PPO epochs
+        batch_size = num_steps
+        minibatch_size = batch_size // args.num_minibatches
+        inds = np.arange(batch_size)
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(inds)
+            for start in range(0, batch_size, minibatch_size):
+                end = start + minibatch_size
+                mb_inds = inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(
+                    b_obs[mb_inds], action=b_actions[mb_inds], action_mask=b_masks[mb_inds]
+                )
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+                with torch.no_grad():
+                    approx_kl = ((ratio - 1) - logratio).mean().item()
+                mb_adv = b_advantages[mb_inds]
+                pg_loss1 = -mb_adv * ratio
+                pg_loss2 = -mb_adv * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                v_clipped = b_values[mb_inds] + torch.clamp(
+                    newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef
+                )
+                v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped).mean()
+                v_loss = 0.5 * v_loss_max
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + args.vf_coef * v_loss
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.track:
+                try:
+                    import wandb
+                    try:
+                        avg_reward_val = float(np.mean(step_reward_window)) if len(step_reward_window) > 0 else 0.0
+                    except Exception:
+                        avg_reward_val = 0.0
+                    wandb.log({
+                        "global_step": int(global_step),
+                        "train/loss": float(loss.item()),
+                        "train/value_loss": float(v_loss.item()),
+                        "train/policy_loss": float(pg_loss.item()),
+                        "train/entropy": float(entropy_loss.item()),
+                        "losses/explained_variance": None,
+                        "charts/avg_reward": avg_reward_val,
+                        "charts/avg_value": float(b_values.mean().item()) if b_values.numel() > 0 else None,
+                        "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                        "charts/epsilon": None,
+                        "perf/SPS": int(global_step / (time.time() - start_time)),
+                    }, step=global_step)
+                except Exception:
+                    pass
+
+    env.close()

cleanrl/cleanrl/scout_ppo/ppo_bandit_small.py

@@ -0,0 +1,410 @@
+# PPO with small MLP for RAGEN Bandit using the existing env (no env edits)
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict
+import json
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.bandit.env import BanditEnv
+from ragen.env.bandit.config import BanditEnvConfig
+from ragen.env.base import BaseDiscreteActionEnv
+from ragen_wrappers import BanditWrapper
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "Bandit"
+    total_timesteps: int = 50_000
+    learning_rate: float = 3e-4
+    num_envs: int = 16
+    num_steps: int = 16
+    anneal_lr: bool = True
+    gamma: float = 0.0  # single-step bandit; no bootstrapping
+    gae_lambda: float = 0.95
+    num_minibatches: int = 4
+    update_epochs: int = 4
+    norm_adv: bool = True
+    clip_coef: float = 0.2
+    clip_vloss: bool = True
+    ent_coef: float = 0.01
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    target_kl: float | None = None
+
+    # Model size
+    hidden_size: int = 32
+    feature_dim_per_name: int = 16  # BanditWrapper setting
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+
+
+def make_env(idx, run_name, seed, feature_dim_per_name: int, capture_video=False):
+    def thunk():
+        cfg = BanditEnvConfig()
+        env = BanditEnv(cfg)
+        env = BanditWrapper(env, feature_dim_per_name=feature_dim_per_name)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs, hidden: int):
+        super().__init__()
+        obs_shape = int(np.array(envs.single_observation_space.shape).prod())
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    # seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # envs
+    envs = gym.vector.SyncVectorEnv([
+        make_env(i, run_name, args.seed, args.feature_dim_per_name, args.capture_video)
+        for i in range(args.num_envs)
+    ])
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete)
+
+    agent = Agent(envs, hidden=args.hidden_size).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # storage
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # start
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    eval_out_dir = Path(f"runs/{run_name}/trajectories")
+    eval_out_dir.mkdir(parents=True, exist_ok=True)
+    episode_successes = []
+
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, _ = env.reset(seed=args.seed + 200000 + collected)
+                traj_rewards = []
+                done = False
+                while not done:
+                    with torch.no_grad():
+                        logits = agent_model.actor(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0))
+                        action = int(torch.argmax(logits, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env.step(action)
+                    traj_rewards.append(float(reward))
+                    done = bool(terminated) or bool(truncated)
+                    state = next_state
+                ep_ret = float(sum(traj_rewards))
+                succ = False
+                try:
+                    succ = bool((info or {}).get('success', False))
+                except Exception:
+                    pass
+                f.write(json.dumps({"episode_return": ep_ret, "success": succ}) + "\n")
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if succ else 0.0)
+                collected += 1
+        env.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    eval_splits = 2
+    eval_episodes = 4000
+    eval_every_iters = max(1, (args.total_timesteps // args.batch_size) // eval_splits)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Anneal LR
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+            # Episode stats logging: compute success and success_rate_100 if available
+            try:
+                mask = None
+                if isinstance(infos, dict):
+                    if "_episode" in infos:
+                        mask = np.asarray(infos["_episode"]).astype(bool)
+                    elif "episode" in infos and isinstance(infos["episode"], dict) and "_l" in infos["episode"]:
+                        mask = np.asarray(infos["episode"]["_l"]).astype(bool)
+                if mask is not None and np.any(mask):
+                    r_arr = np.asarray(infos.get("episode", {}).get("r", np.zeros_like(mask, dtype=float)))
+                    l_arr = np.asarray(infos.get("episode", {}).get("l", np.zeros_like(mask, dtype=int)))
+                    if "success" in infos:
+                        succ_arr = np.asarray(infos.get("success", np.zeros_like(mask, dtype=bool))).astype(float)
+                    else:
+                        try:
+                            succ_arr = (np.asarray(r_arr) > 0).astype(float)
+                        except Exception:
+                            succ_arr = np.zeros_like(mask, dtype=float)
+                    for s in np.asarray(succ_arr)[mask]:
+                        episode_successes.append(float(s))
+                    if args.track:
+                        try:
+                            import wandb
+                            log_dict = {
+                                "global_step": int(global_step),
+                                "rollout/ep_rew_mean": float(np.mean(r_arr[mask])) if np.any(mask) else None,
+                                "rollout/ep_len_mean": float(np.mean(l_arr[mask])) if np.any(mask) else None,
+                                "rollout/success_rate": float(np.mean(succ_arr[mask])) if np.any(mask) else None,
+                            }
+                            if np.any(mask):
+                                last_idx = np.where(mask)[0][-1]
+                                log_dict.update({
+                                    "train/episodic_return": float(r_arr[last_idx]),
+                                    "train/episodic_length": int(l_arr[last_idx]),
+                                    "train/success": float(succ_arr[last_idx]),
+                                    "train/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) >= 1 else None,
+                                })
+                            wandb.log(log_dict, step=global_step)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        # Since gamma=0 for bandit, GAE simplifies but we keep general code
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # update
+        b_inds = np.arange(args.batch_size)
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss = 0.5 * torch.max(v_loss_unclipped, v_loss_clipped).mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Value: {values.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        if args.track:
+            try:
+                import wandb
+                wandb.log({
+                    "global_step": int(global_step),
+                    "train/value_loss": float(v_loss.item()),
+                    "train/policy_loss": float(pg_loss.item()),
+                    "train/entropy": float(entropy_loss.item()),
+                    "losses/explained_variance": float(explained_var),
+                    "charts/avg_reward": float(rewards.mean().item()),
+                    "charts/avg_value": float(values.mean().item()),
+                    "perf/SPS": int(sps),
+                    "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                }, step=global_step)
+            except Exception:
+                pass
+
+        # periodic evaluation collection
+        if iteration % eval_every_iters == 0:
+            try:
+                eval_thunk = make_env(0, run_name, args.seed + 9999, args.feature_dim_per_name, False)
+                collect_eval_trajectories(agent, eval_thunk, n_episodes=eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import json as _json
+                        from pathlib import Path as _Path
+                        mpath = _Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = _json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    envs.close()

cleanrl/cleanrl/scout_ppo/ppo_sokoban.py

@@ -0,0 +1,501 @@
+import os
+import random
+import time
+from dataclasses import dataclass
+from typing import Dict, Any, Tuple
+from pathlib import Path
+import json
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.distributions.categorical import Categorical
+import tyro
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.sokoban.env import SokobanEnv
+from ragen.env.sokoban.config import SokobanEnvConfig
+
+
+class SokobanWrapper(gym.Env):
+    metadata = {"render_modes": ["rgb_array", "human", "ansi", "text"]}
+
+    def __init__(self, env: SokobanEnv):
+        super().__init__()
+        self._env = env
+        self._h = int(self._env.dim_room[0])
+        self._w = int(self._env.dim_room[1])
+        self._tokens = ['#', '_', 'O', '√', 'X', 'P', 'S']
+        self._token_to_idx = {t: i for i, t in enumerate(self._tokens)}
+        self._c = len(self._tokens)
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(self._c, self._h, self._w), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+
+    def _encode_obs(self, text_obs: str) -> np.ndarray:
+        rows = text_obs.split('\n')
+        rows = [list(r) for r in rows if len(r) > 0]
+        h = len(rows)
+        w = len(rows[0]) if h > 0 else self._w
+        grid = np.zeros((self._c, self._h, self._w), dtype=np.float32)
+        for i in range(min(h, self._h)):
+            for j in range(min(w, self._w)):
+                ch = rows[i][j]
+                idx = self._token_to_idx.get(ch, 0)
+                grid[idx, i, j] = 1.0
+        return grid
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        obs = self._encode_obs(text_obs)
+        return obs, {}
+
+    def step(self, action: int):
+        mapped = int(action) + 1
+        text_obs, reward, done, info = self._env.step(mapped)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, info or {}
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    env_id: str = "Sokoban"
+    total_timesteps: int = 10_000_000
+    learning_rate: float = 2.5e-4
+    num_envs: int = 8
+    num_steps: int = 128
+    anneal_lr: bool = True
+    gamma: float = 0.99
+    gae_lambda: float = 0.95
+    num_minibatches: int = 4
+    update_epochs: int = 4
+    norm_adv: bool = True
+    clip_coef: float = 0.2
+    clip_vloss: bool = True
+    ent_coef: float = 0.05
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    target_kl: float | None = None
+
+    grid_h: int = 6
+    grid_w: int = 6
+    num_boxes: int = 2
+    max_steps_env: int = 150
+    search_depth: int = 500
+
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+    # eval config to mirror reference script
+    eval_splits: int = 20
+    eval_episodes: int = 400
+
+
+def make_env(idx: int, run_name: str, seed: int, args: Args, capture_video=False):
+    def thunk():
+        cfg = SokobanEnvConfig(
+            dim_room=(args.grid_h, args.grid_w),
+            max_steps=args.max_steps_env,
+            num_boxes=args.num_boxes,
+            search_depth=args.search_depth,
+            render_mode='text',
+            observation_format='grid',
+        )
+        env = SokobanEnv(cfg)
+        env = SokobanWrapper(env)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    nn.init.orthogonal_(layer.weight, std)
+    nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        c, h, w = envs.single_observation_space.shape
+        hidden = 1024
+        self.net = nn.Sequential(
+            layer_init(nn.Conv2d(c, 64, kernel_size=3, stride=1, padding=1)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1)),
+            nn.ReLU(),
+            nn.Flatten(),
+            layer_init(nn.Linear(128 * h * w, hidden)),
+            nn.ReLU(),
+        )
+        # twin critics (double value heads)
+        self.critic1 = layer_init(nn.Linear(hidden, 1), std=1.0)
+        self.critic2 = layer_init(nn.Linear(hidden, 1), std=1.0)
+        self.actor = layer_init(nn.Linear(hidden, envs.single_action_space.n), std=0.01)
+
+    def get_values(self, x):
+        x = self.net(x)
+        return self.critic1(x), self.critic2(x)
+
+    def get_action_and_value(self, x, action=None):
+        x = self.net(x)
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        v1 = self.critic1(x)
+        v2 = self.critic2(x)
+        return action, probs.log_prob(action), probs.entropy(), v1, v2
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    envs = gym.vector.SyncVectorEnv([
+        make_env(i, run_name, args.seed, args, args.capture_video) for i in range(args.num_envs)
+    ])
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete)
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values1 = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values2 = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.tensor(next_obs, dtype=torch.float32).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+    
+    episode_returns = []
+    episode_steps = []
+    episode_successes = []
+
+    # Eval helper mirroring reference implementation
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                state, _ = env.reset(seed=args.seed + 100000 + collected)
+                traj_states = [np.asarray(state).tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                # rely on env internal max steps; add a safety cap
+                max_eval_steps = getattr(env, '_max_episode_steps', None) or (args.grid_h * args.grid_w * 6)
+                while not done:
+                    with torch.no_grad():
+                        logits = agent_model.actor(agent_model.net(torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)))
+                        action = int(torch.argmax(logits, dim=1).item())
+                    next_state, reward, terminated, truncated, info = env.step(action)
+                    traj_actions.append(int(action))
+                    traj_rewards.append(float(reward))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool((info or {}).get('success', False)))
+                    state = next_state
+                    traj_states.append(np.asarray(state).tolist())
+                    done = d
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    # Eval cadence identical to reference style
+    eval_every_iters = max(1, args.num_iterations // args.eval_splits)
+
+    for iteration in range(1, args.num_iterations + 1):
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            with torch.no_grad():
+                action, logprob, _, v1, v2 = agent.get_action_and_value(next_obs)
+                values1[step] = v1.flatten()
+                values2[step] = v2.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            next_obs_np, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs = torch.tensor(next_obs_np, dtype=torch.float32).to(device)
+            next_done = torch.tensor(next_done, dtype=torch.float32).to(device)
+
+            # Episode stats logging using Gymnasium vector env final_info
+            try:
+                if isinstance(infos, dict) and "final_info" in infos and infos["final_info"] is not None:
+                    finals = infos["final_info"]
+                    for fi in finals:
+                        if fi is None:
+                            continue
+                        ep_r = float(fi.get("episode", {}).get("r", 0.0)) if isinstance(fi.get("episode"), dict) else float(fi.get("reward", 0.0))
+                        ep_l = int(fi.get("episode", {}).get("l", 0)) if isinstance(fi.get("episode"), dict) else int(fi.get("length", 0))
+                        # infer success from positive episodic return if the env doesn't set it
+                        ep_succ = float(fi.get("success", 1.0 if ep_r > 0.0 else 0.0))
+                        episode_returns.append(ep_r)
+                        episode_steps.append(global_step)
+                        episode_successes.append(ep_succ)
+                        if args.track:
+                            try:
+                                import wandb
+                                wandb.log({
+                                    "global_step": int(global_step),
+                                    # DQN-aligned episodic keys
+                                    "rollout/episodic_return": float(ep_r),
+                                    "rollout/episodic_length": int(ep_l),
+                                    "rollout/success": float(ep_succ),
+                                    "rollout/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) >= 100 else None,
+                                    # duplicate train-prefixed keys as in DQN
+                                    "train/episodic_return": float(ep_r),
+                                    "train/episodic_length": int(ep_l),
+                                    "train/success": float(ep_succ),
+                                    "train/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) >= 100 else None,
+                                }, step=global_step)
+                            except Exception:
+                                pass
+            except Exception:
+                pass
+
+        with torch.no_grad():
+            nv1, nv2 = agent.get_values(next_obs)
+            next_value_min = torch.minimum(nv1, nv2).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues_min = next_value_min
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues_min = torch.minimum(values1[t + 1], values2[t + 1])
+                values_min_t = torch.minimum(values1[t], values2[t])
+                delta = rewards[t] + args.gamma * nextvalues_min * nextnonterminal - values_min_t
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            values_min = torch.minimum(values1, values2)
+            returns = advantages + values_min
+
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values1 = values1.reshape(-1)
+        b_values2 = values2.reshape(-1)
+        b_values_min = torch.minimum(b_values1, b_values2)
+
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue1, newvalue2 = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                newvalue1 = newvalue1.view(-1)
+                newvalue2 = newvalue2.view(-1)
+                if args.clip_vloss:
+                    # head 1
+                    v1_unclipped = (newvalue1 - b_returns[mb_inds]) ** 2
+                    v1_clipped_old = b_values1[mb_inds]
+                    v1_clipped = v1_clipped_old + torch.clamp(newvalue1 - v1_clipped_old, -args.clip_coef, args.clip_coef)
+                    v1_loss = torch.max(v1_unclipped, (v1_clipped - b_returns[mb_inds]) ** 2).mean()
+                    # head 2
+                    v2_unclipped = (newvalue2 - b_returns[mb_inds]) ** 2
+                    v2_clipped_old = b_values2[mb_inds]
+                    v2_clipped = v2_clipped_old + torch.clamp(newvalue2 - v2_clipped_old, -args.clip_coef, args.clip_coef)
+                    v2_loss = torch.max(v2_unclipped, (v2_clipped - b_returns[mb_inds]) ** 2).mean()
+                    v_loss = 0.5 * (v1_loss + v2_loss)
+                else:
+                    v1_loss = ((newvalue1 - b_returns[mb_inds]) ** 2).mean()
+                    v2_loss = ((newvalue2 - b_returns[mb_inds]) ** 2).mean()
+                    v_loss = 0.5 * (v1_loss + v2_loss)
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values_min.detach().cpu().numpy(), b_returns.detach().cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Value(min): {b_values_min.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        if args.track:
+            try:
+                import wandb
+                wandb.log({
+                    "global_step": int(global_step),
+                    "train/loss": float(loss.item()),
+                    "charts/epsilon": None,
+                    "perf/SPS": int(sps),
+                    "train/value_loss": float(v_loss.item()),
+                    "train/policy_loss": float(pg_loss.item()),
+                    "train/entropy": float(entropy_loss.item()),
+                    "losses/explained_variance": float(explained_var),
+                    "charts/avg_reward": float(rewards.mean().item()),
+                    "charts/avg_value": float(b_values_min.mean().item()),
+                    "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                    # training success rate over all finished episodes so far
+                    "train/success_rate": float(np.mean(episode_successes)) if len(episode_successes) > 0 else None,
+                    # keep a short-horizon success rate to monitor recent progress
+                    "train/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) > 0 else None,
+                }, step=global_step)
+            except Exception:
+                pass
+
+        # periodic evaluation collection and logging
+        if iteration % eval_every_iters == 0:
+            try:
+                def eval_thunk():
+                    # reuse same config and wrapper as training, but single env
+                    return make_env(0, run_name, args.seed + 9999, args, False)()
+                collect_eval_trajectories(agent, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        mpath = Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {args.eval_episodes} eval trajectories at global_step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    envs.close()

cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py

@@ -0,0 +1,588 @@
+# PPO with Action Masking for RAGEN Sudoku (4x4, max_step=20)
+import os
+import random
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple, Dict, Any, List
+import json
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+
+import sys
+# 假设 ragen 库在两级目录之上，请根据实际情况调整
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.sudoku.env import SudokuEnv
+from ragen.env.sudoku.config import SudokuEnvConfig
+
+
+class SudokuWrapper(gym.Env):
+    """
+    Adapter to use ragen SudokuEnv with Gymnasium vector API.
+    Improvements: Returns a Dict observation with 'action_mask' to prevent
+    the agent from modifying cells that are already filled.
+    """
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: SudokuEnv, grid_size: int):
+        super().__init__()
+        self._env = env
+        self._size = grid_size
+        # 0 denotes empty, 1..grid_size denote values
+        self._val_dim = self._size + 1
+        
+        # Actions: (row, col, num) -> Flattened
+        self._act_n = self._size * self._size * self._size
+        self.action_space = gym.spaces.Discrete(self._act_n)
+
+        # Observation: Dict with mask
+        self.observation_space = gym.spaces.Dict({
+            "observation": gym.spaces.Box(low=0.0, high=1.0, shape=(self._size * self._size * self._val_dim,), dtype=np.float32),
+            "action_mask": gym.spaces.Box(low=0.0, high=1.0, shape=(self._act_n,), dtype=np.float32)
+        })
+
+    def _encode_obs(self, text_obs: str) -> Dict[str, np.ndarray]:
+        # Parse the 'simple' grid format
+        vals: List[int] = []
+        for line in text_obs.splitlines():
+            ls = line.strip()
+            if len(ls) == 0: continue
+            if set(ls) <= {'-'}: continue
+            tokens = [t for t in ls.split() if t != '|']
+            if len(tokens) == 0: continue
+            for t in tokens:
+                if t == '.': vals.append(0)
+                else:
+                    try: v = int(t)
+                    except ValueError: v = 0
+                    vals.append(v)
+        
+        target = self._size * self._size
+        if len(vals) < target: vals.extend([0] * (target - len(vals)))
+        if len(vals) > target: vals = vals[:target]
+        
+        # One-hot encode grid
+        grid = np.zeros((target, self._val_dim), dtype=np.float32)
+        # Initialize mask (1.0 = valid, 0.0 = invalid)
+        mask = np.ones(self._act_n, dtype=np.float32)
+
+        for i, v in enumerate(vals):
+            v_clamped = int(v)
+            if v_clamped < 0 or v_clamped > self._size:
+                v_clamped = 0
+            grid[i, v_clamped] = 1.0
+
+            # If a cell is NOT empty (v_clamped != 0), mask all actions for this cell.
+            # Agent should not overwrite existing numbers.
+            if v_clamped != 0:
+                start_idx = i * self._size
+                end_idx = start_idx + self._size
+                mask[start_idx:end_idx] = 0.0
+
+        return {
+            "observation": grid.reshape(-1),
+            "action_mask": mask
+        }
+
+    @staticmethod
+    def _decode_action(action_id: int, grid_size: int) -> Tuple[int, int, int]:
+        g = grid_size
+        row = action_id // (g * g)
+        rem = action_id % (g * g)
+        col = rem // g
+        num = (rem % g) + 1
+        return row, col, num
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        obs = self._encode_obs(text_obs)
+        return obs, {}
+
+    def step(self, action: int):
+        row, col, num = self._decode_action(int(action), self._size)
+        act_str = f"{row+1},{col+1},{num}"
+        text_obs, reward, done, info = self._env.step(act_str)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return obs, float(reward), terminated, truncated, info or {}
+
+    def render(self):
+        return self._env.render()
+
+    def close(self):
+        self._env.close()
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    seed: int = 1
+    torch_deterministic: bool = True
+    cuda: bool = True
+    track: bool = True
+    wandb_project_name: str = "cleanRL"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "Sudoku"
+    total_timesteps: int = 10000_000
+    learning_rate: float = 3e-4
+    num_envs: int = 8
+    num_steps: int = 128
+    anneal_lr: bool = True
+    gamma: float = 0.99
+    gae_lambda: float = 0.95
+    num_minibatches: int = 4
+    update_epochs: int = 4
+    norm_adv: bool = True
+    clip_coef: float = 0.2
+    clip_vloss: bool = True
+    ent_coef: float = 0.01
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    target_kl: float | None = None
+
+    # Sudoku specific
+    grid_size: int = 4
+    difficulty: str = "easy"
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+
+    # eval
+    eval_splits: int = 2
+    eval_episodes: int = 4000
+
+
+def make_env(idx, run_name, seed, grid_size, difficulty, capture_video=False):
+    def thunk():
+        config = SudokuEnvConfig(
+            grid_size=grid_size,
+            difficulty=difficulty,
+            render_mode='text',
+            render_format='simple',
+        )
+        env = SudokuEnv(config)
+        env = SudokuWrapper(env, grid_size)
+        # Use env's own max_steps default if available, otherwise a sane cap
+        # Keeping your request for strict step limit logic, although wrapper enforces logic
+        max_steps = 81
+        # max_steps = int(grid_size * grid_size * 6)
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        # Accessing the shape from the Dict space
+        obs_shape = int(np.array(envs.single_observation_space['observation'].shape).prod())
+        hidden = 256 # Increased hidden size slightly for better capacity
+
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, hidden)),
+            nn.Tanh(),
+            layer_init(nn.Linear(hidden, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None, action_mask=None):
+        logits = self.actor(x)
+        
+        # Apply Action Masking
+        if action_mask is not None:
+            # Set logits of invalid actions to a very large negative number
+            logits = logits + (action_mask - 1.0) * 1e8
+
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+
+    if args.track:
+        import wandb
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+        try:
+            wandb.define_metric("global_step")
+            for prefix in ["train/*", "rollout/*", "eval/*", "losses/*", "charts/*", "perf/*"]:
+                wandb.define_metric(prefix, step_metric="global_step")
+        except Exception:
+            pass
+
+    # seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # envs
+    envs = gym.vector.SyncVectorEnv([
+        make_env(i, run_name, args.seed, args.grid_size, args.difficulty, args.capture_video)
+        for i in range(args.num_envs)
+    ])
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete)
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # storage
+    # Note: obs storage now only stores the flattened grid part
+    obs_shape = envs.single_observation_space['observation'].shape
+    mask_shape = envs.single_observation_space['action_mask'].shape
+    
+    obs = torch.zeros((args.num_steps, args.num_envs) + obs_shape).to(device)
+    masks = torch.zeros((args.num_steps, args.num_envs) + mask_shape).to(device) # Storage for masks
+    
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # start
+    global_step = 0
+    start_time = time.time()
+    
+    # envs.reset() returns a Dict of stacked arrays
+    next_obs_dict, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs_dict['observation']).to(device)
+    next_mask = torch.Tensor(next_obs_dict['action_mask']).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+    
+    episode_returns = []
+    episode_steps = []
+    episode_successes = []
+
+    # Eval helper
+    def collect_eval_trajectories(agent_model, make_env_fn, n_episodes, step_tag):
+        out_dir = Path(f"runs/{run_name}/trajectories/step_{step_tag}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / "trajectories.jsonl"
+        env = make_env_fn()
+        collected = 0
+        summary_returns = []
+        summary_success = []
+        with out_path.open("w") as f:
+            while collected < n_episodes:
+                obs_dict, _ = env.reset(seed=args.seed + collected)
+                # Handle single env dict unpacking
+                state = obs_dict['observation']
+                mask = obs_dict['action_mask']
+                
+                traj_states = [state.tolist()]
+                traj_actions = []
+                traj_rewards = []
+                traj_dones = []
+                traj_success = []
+                done = False
+                step_count = 0
+                max_eval_steps = getattr(env, '_max_episode_steps', None) or int(args.grid_size * args.grid_size * 6)
+                
+                # Eval loop
+                current_obs = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
+                current_mask = torch.tensor(mask, dtype=torch.float32, device=device).unsqueeze(0)
+
+                while not done:
+                    with torch.no_grad():
+                        # Pass mask to actor during eval
+                        action, _, _, _ = agent_model.get_action_and_value(current_obs, action_mask=current_mask)
+                        action_item = int(action.item())
+                        
+                    next_obs_dict, reward, terminated, truncated, info = env.step(action_item)
+                    
+                    traj_actions.append(action_item)
+                    traj_rewards.append(float(reward))
+                    step_count += 1
+                    d = bool(terminated) or bool(truncated) or (step_count >= max_eval_steps)
+                    traj_dones.append(d)
+                    traj_success.append(bool(info.get('success', False)))
+                    
+                    state = next_obs_dict['observation']
+                    mask = next_obs_dict['action_mask']
+                    current_obs = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
+                    current_mask = torch.tensor(mask, dtype=torch.float32, device=device).unsqueeze(0)
+                    
+                    traj_states.append(state.tolist())
+                    done = d
+                    
+                ep_ret = float(sum(traj_rewards))
+                ep_succ = bool(any(traj_success))
+                record = {
+                    "states": traj_states,
+                    "actions": traj_actions,
+                    "rewards": traj_rewards,
+                    "dones": traj_dones,
+                    "success": traj_success,
+                    "episode_return": ep_ret,
+                    "episode_success": ep_succ,
+                }
+                f.write(json.dumps(record) + "\n")
+                collected += 1
+                summary_returns.append(ep_ret)
+                summary_success.append(1.0 if ep_succ else 0.0)
+        env.close()
+        try:
+            metrics = {
+                "global_step": int(step_tag),
+                "episodes": int(n_episodes),
+                "success_rate": float(np.mean(summary_success)) if len(summary_success) else 0.0,
+                "avg_return": float(np.mean(summary_returns)) if len(summary_returns) else 0.0,
+                "std_return": float(np.std(summary_returns)) if len(summary_returns) else 0.0,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+
+    eval_every_iters = max(1, args.num_iterations // args.eval_splits)
+
+    # training loop
+    for iteration in range(1, args.num_iterations + 1):
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            optimizer.param_groups[0]["lr"] = frac * args.learning_rate
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            masks[step] = next_mask # Store mask
+            dones[step] = next_done
+
+            with torch.no_grad():
+                # PASS MASK HERE
+                action, logprob, _, value = agent.get_action_and_value(next_obs, action_mask=next_mask)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            next_obs_dict, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            
+            # Unpack dict again
+            next_obs = torch.Tensor(next_obs_dict['observation']).to(device)
+            next_mask = torch.Tensor(next_obs_dict['action_mask']).to(device)
+            next_done = torch.Tensor(next_done).to(device)
+
+            try:
+                mask = None
+                if isinstance(infos, dict):
+                    if "_episode" in infos:
+                        mask = np.asarray(infos["_episode"]).astype(bool)
+                    elif "episode" in infos and isinstance(infos["episode"], dict) and "_l" in infos["episode"]:
+                        mask = np.asarray(infos["episode"]["_l"]).astype(bool)
+                if mask is not None and np.any(mask):
+                    r_arr = np.asarray(infos.get("episode", {}).get("r", np.zeros_like(mask, dtype=float)))
+                    l_arr = np.asarray(infos.get("episode", {}).get("l", np.zeros_like(mask, dtype=int)))
+                    succ_arr = np.asarray(infos.get("success", np.zeros_like(mask, dtype=bool))).astype(float)
+                    for i in np.where(mask)[0]:
+                        episode_returns.append(float(r_arr[i]))
+                        episode_steps.append(global_step)
+                        episode_successes.append(float(succ_arr[i]))
+                    if args.track:
+                        try:
+                            import wandb
+                            log_dict = {
+                                "global_step": int(global_step),
+                                "rollout/ep_rew_mean": float(np.mean(r_arr[mask])) if np.any(mask) else None,
+                                "rollout/ep_len_mean": float(np.mean(l_arr[mask])) if np.any(mask) else None,
+                                "rollout/success_rate": float(np.mean(succ_arr[mask])) if np.any(mask) else None,
+                            }
+                            if np.any(mask):
+                                last_idx = np.where(mask)[0][-1]
+                                log_dict.update({
+                                    "train/episodic_return": float(r_arr[last_idx]),
+                                    "train/episodic_length": int(l_arr[last_idx]),
+                                    "train/success": float(succ_arr[last_idx]),
+                                    "train/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) >= 100 else None,
+                                })
+                            wandb.log(log_dict, step=global_step)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+        # GAE
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten batch
+        b_obs = obs.reshape((-1,) + obs_shape)
+        b_masks = masks.reshape((-1,) + mask_shape) # Flatten masks
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # update
+        b_inds = np.arange(args.batch_size)
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                # PASS MASK HERE
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(
+                    b_obs[mb_inds], 
+                    action=b_actions.long()[mb_inds],
+                    action_mask=b_masks[mb_inds]
+                )
+                
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds], -args.clip_coef, args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss = 0.5 * torch.max(v_loss_unclipped, v_loss_clipped).mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        # logging
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Val: {values.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        if args.track:
+            try:
+                import wandb
+                wandb.log({
+                    "global_step": int(global_step),
+                    "train/value_loss": float(v_loss.item()),
+                    "train/policy_loss": float(pg_loss.item()),
+                    "train/entropy": float(entropy_loss.item()),
+                    "train/old_approx_kl": float(old_approx_kl.item()),
+                    "train/approx_kl": float(approx_kl.item()),
+                    "losses/explained_variance": float(explained_var),
+                    "charts/avg_reward": float(rewards.mean().item()),
+                    "charts/avg_value": float(values.mean().item()),
+                    "perf/SPS": int(sps),
+                    "train/learning_rate": float(optimizer.param_groups[0]["lr"]),
+                }, step=global_step)
+            except Exception:
+                pass
+
+        if iteration % eval_every_iters == 0:
+            try:
+                eval_thunk = make_env(0, run_name, args.seed + 9999, args.grid_size, args.difficulty, False)
+                collect_eval_trajectories(agent, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    try:
+                        import json as _json
+                        from pathlib import Path as _Path
+                        mpath = _Path(f"runs/{run_name}/trajectories/step_{global_step}/metrics.json")
+                        if mpath.exists():
+                            with mpath.open("r") as mf:
+                                metrics = _json.load(mf)
+                            wandb.log({
+                                "eval/success_rate": metrics.get("success_rate"),
+                                "eval/avg_return": metrics.get("avg_return"),
+                                "eval/std_return": metrics.get("std_return"),
+                                "eval/episodes": metrics.get("episodes"),
+                            }, step=global_step)
+                    except Exception:
+                        pass
+                print(f"Collected {args.eval_episodes} eval trajectories at global_step {global_step}")
+            except Exception as e:
+                print(f"Warning: eval trajectory collection failed at step {global_step}: {e}")
+
+    envs.close()

cleanrl/cleanrl/scout_ppo/ragen_wrappers.py

@@ -0,0 +1,235 @@
+"""
+Gymnasium-compatible wrappers for RAGEN environments to enable traditional RL training.
+These wrappers convert text-based observations to numerical representations suitable for MLP networks.
+"""
+import gymnasium as gym
+import numpy as np
+from typing import Any, Dict, Tuple
+
+
+class BanditWrapper(gym.Wrapper):
+    """
+    Wrapper for RAGEN Bandit that uses only observable text.
+    Converts text observations to a fixed-size one-hot hash vector.
+    Does not alter episode semantics and does not inspect env internals.
+    """
+    def __init__(self, env, feature_dim_per_name: int = 16):
+        super().__init__(env)
+        # Two name slots (first/second), each hashed to one-hot of size K
+        self.k = feature_dim_per_name
+        self.observation_space = gym.spaces.Box(low=0, high=1, shape=(2 * self.k,), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(2)
+
+    def _parse_names(self, text_obs: str):
+        """Extract the two arm names from the prompt text purely via regex/string ops."""
+        # Heuristic: look for the segment after "named " and split by " and "
+        try:
+            anchor = "named "
+            if anchor in text_obs:
+                segment = text_obs.split(anchor, 1)[1]
+                # Cut at newline if present
+                segment = segment.split("\n", 1)[0]
+                # Now split by " and " to get two names; also strip punctuation
+                parts = segment.split(" and ")
+                if len(parts) >= 2:
+                    name_a = parts[0].strip().strip(' .!?,')
+                    name_b = parts[1].strip().strip(' .!?,')
+                    return name_a, name_b
+        except Exception:
+            pass
+        # Fallback: no names found
+        return "", ""
+
+    def _names_to_vector(self, name_a: str, name_b: str) -> np.ndarray:
+        vec = np.zeros(2 * self.k, dtype=np.float32)
+        idx_a = (hash(name_a) % self.k)
+        idx_b = (hash(name_b) % self.k)
+        vec[idx_a] = 1.0
+        vec[self.k + idx_b] = 1.0
+        return vec
+
+    def reset(self, **kwargs):
+        seed = kwargs.get('seed', None)
+        mode = kwargs.get('mode', None)
+        text_obs = self.env.reset(seed=seed, mode=mode)
+        name_a, name_b = self._parse_names(text_obs)
+        return self._names_to_vector(name_a, name_b), {}
+
+    def step(self, action):
+        ragen_action = int(action) + 1
+        text_obs, reward, done, info = self.env.step(ragen_action)
+        name_a, name_b = self._parse_names(text_obs)
+        terminated = bool(done)
+        truncated = False
+        return self._names_to_vector(name_a, name_b), reward, terminated, truncated, info
+
+
+class FrozenLakeWrapper(gym.Wrapper):
+    """
+    Wrapper for RAGEN FrozenLake environment.
+    Converts grid-based text observations to numerical state representation.
+    """
+    def __init__(self, env):
+        super().__init__(env)
+        # Bootstrap an observation to determine grid size from text only
+        bootstrap_text = self.env.reset()
+        flat, _ = self._parse_observation_and_meta(bootstrap_text)
+        self.observation_space = gym.spaces.Box(low=0, high=1, shape=(flat.shape[0],), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+        # Serve the bootstrapped obs on first reset without calling env.reset again
+        self._bootstrap_obs = flat
+        self._bootstrap_ready = True
+        
+    def _parse_observation_and_meta(self, text_obs: str) -> Tuple[np.ndarray, Tuple[int, int]]:
+        """Parse text observation into numerical state (one-hot grid + player pos)."""
+        lines = text_obs.strip().split('\n')
+        grid = []
+        player_pos = None
+        rows = len(lines)
+        cols = max(len(line) for line in lines) if rows > 0 else 0
+        # Parse grid
+        for i, line in enumerate(lines):
+            row = []
+            for j, char in enumerate(line):
+                if char == 'P':  # Player
+                    row.append(0)
+                    player_pos = (i, j)
+                elif char == '_':  # Frozen
+                    row.append(1)
+                elif char == 'O':  # Hole
+                    row.append(2)
+                elif char == 'G':  # Goal
+                    row.append(3)
+                elif char == 'X':  # Player in hole
+                    row.append(2)
+                    player_pos = (i, j)
+                elif char == '√':  # Player on goal
+                    row.append(3)
+                    player_pos = (i, j)
+                else:
+                    row.append(1)  # Default to frozen
+            grid.append(row)
+        # Pad ragged rows if needed
+        grid = np.array([r + [1] * (cols - len(r)) for r in grid], dtype=np.int32)
+        grid_size = (rows, cols)
+        # One-hot encode grid over 4 cell types
+        # One-hot encode grid
+        one_hot_grid = np.zeros((rows, cols, 4), dtype=np.float32)
+        for i in range(rows):
+            for j in range(cols):
+                cell_type = grid[i, j]
+                one_hot_grid[i, j, cell_type] = 1.0
+        # Flatten grid
+        flat_grid = one_hot_grid.flatten()
+        # Add normalized player position
+        if player_pos is None:
+            player_pos = (0, 0)
+        player_pos_norm = np.array([
+            0.0 if rows <= 1 else player_pos[0] / max(1, rows - 1),
+            0.0 if cols <= 1 else player_pos[1] / max(1, cols - 1),
+        ], dtype=np.float32)
+        flat = np.concatenate([flat_grid, player_pos_norm])
+        return flat, grid_size
+    
+    def reset(self, **kwargs):
+        # Filter out 'options' parameter that gymnasium passes but RAGEN doesn't support
+        if self._bootstrap_ready:
+            # First call returns the bootstrapped observation to avoid double reset
+            self._bootstrap_ready = False
+            return self._bootstrap_obs.copy(), {}
+        seed = kwargs.get('seed', None)
+        mode = kwargs.get('mode', None)
+        text_obs = self.env.reset(seed=seed, mode=mode)
+        state, _ = self._parse_observation_and_meta(text_obs)
+        return state, {}
+    
+    def step(self, action):
+        # Map action from 0,1,2,3 to 1,2,3,4 (RAGEN uses 1-indexed actions)
+        ragen_action = action + 1
+        text_obs, reward, done, info = self.env.step(ragen_action)
+        state, _ = self._parse_observation_and_meta(text_obs)
+        
+        terminated = done
+        truncated = False
+        
+        return state, reward, terminated, truncated, info
+
+
+class SokobanWrapper(gym.Wrapper):
+    """
+    Wrapper for RAGEN Sokoban environment.
+    Converts grid-based text observations to numerical state representation.
+    Note: Does not inherit from gym.Wrapper due to old gym vs gymnasium compatibility.
+    """
+    def __init__(self, env):
+        super().__init__(env)
+        # Bootstrap an observation to determine room size from text only
+        bootstrap_text = self.env.reset()
+        flat, rows, cols = self._parse_observation_and_meta(bootstrap_text)
+        self.observation_space = gym.spaces.Box(low=0, high=1, shape=(flat.shape[0],), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+        self.metadata = getattr(env, 'metadata', {})
+        self._bootstrap_obs = flat
+        self._bootstrap_ready = True
+        
+    def _parse_observation_and_meta(self, text_obs: str) -> Tuple[np.ndarray, int, int]:
+        """Parse text observation into numerical state and return dims."""
+        lines = text_obs.strip().split('\n')
+        grid = []
+        rows = len(lines)
+        cols = max(len(line) for line in lines) if rows > 0 else 0
+        # Mapping from characters to cell types
+        char_to_type = {
+            '#': 0,  # wall
+            '_': 1,  # empty
+            'O': 2,  # target
+            '√': 3,  # box on target
+            'X': 4,  # box
+            'P': 5,  # player
+            'S': 6,  # player on target
+        }
+        
+        for line in lines:
+            row = []
+            for char in line:
+                row.append(char_to_type.get(char, 1))  # Default to empty
+            grid.append(row)
+        # Pad ragged rows
+        grid = np.array([r + [1] * (cols - len(r)) for r in grid], dtype=np.int32)
+        # One-hot encode grid
+        one_hot_grid = np.zeros((rows, cols, 7), dtype=np.float32)
+        for i in range(rows):
+            for j in range(cols):
+                cell_type = grid[i, j]
+                one_hot_grid[i, j, cell_type] = 1.0
+        return one_hot_grid.flatten(), rows, cols
+    
+    def reset(self, **kwargs):
+        if self._bootstrap_ready:
+            self._bootstrap_ready = False
+            return self._bootstrap_obs.copy(), {}
+        seed = kwargs.get('seed', None)
+        mode = kwargs.get('mode', None)
+        text_obs = self.env.reset(seed=seed, mode=mode)
+        state, _, _ = self._parse_observation_and_meta(text_obs)
+        return state, {}
+    
+    def step(self, action):
+        # Map action from 0,1,2,3 to 1,2,3,4 (RAGEN uses 1-indexed actions)
+        ragen_action = action + 1
+        text_obs, reward, done, info = self.env.step(ragen_action)
+        state, _, _ = self._parse_observation_and_meta(text_obs)
+        
+        terminated = done
+        truncated = False
+        
+        return state, reward, terminated, truncated, info
+    
+    def close(self):
+        if hasattr(self.env, 'close'):
+            self.env.close()
+    
+    def render(self):
+        if hasattr(self.env, 'render'):
+            return self.env.render()
+        return None

cleanrl/cleanrl/td3_continuous_action.py

@@ -0,0 +1,317 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/td3/#td3_continuous_actionpy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import tyro
+from torch.utils.tensorboard import SummaryWriter
+
+from cleanrl_utils.buffers import ReplayBuffer
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_model: bool = False
+    """whether to save model into the `runs/{run_name}` folder"""
+    upload_model: bool = False
+    """whether to upload the saved model to huggingface"""
+    hf_entity: str = ""
+    """the user or org name of the model repository from the Hugging Face Hub"""
+
+    # Algorithm specific arguments
+    env_id: str = "Hopper-v4"
+    """the id of the environment"""
+    total_timesteps: int = 1000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 3e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 1
+    """the number of parallel game environments"""
+    buffer_size: int = int(1e6)
+    """the replay memory buffer size"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    tau: float = 0.005
+    """target smoothing coefficient (default: 0.005)"""
+    batch_size: int = 256
+    """the batch size of sample from the reply memory"""
+    policy_noise: float = 0.2
+    """the scale of policy noise"""
+    exploration_noise: float = 0.1
+    """the scale of exploration noise"""
+    learning_starts: int = 25e3
+    """timestep to start learning"""
+    policy_frequency: int = 2
+    """the frequency of training policy (delayed)"""
+    noise_clip: float = 0.5
+    """noise clip parameter of the Target Policy Smoothing Regularization"""
+
+
+def make_env(env_id, seed, idx, capture_video, run_name):
+    def thunk():
+        if capture_video and idx == 0:
+            env = gym.make(env_id, render_mode="rgb_array")
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        else:
+            env = gym.make(env_id)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        env.action_space.seed(seed)
+        return env
+
+    return thunk
+
+
+# ALGO LOGIC: initialize agent here:
+class QNetwork(nn.Module):
+    def __init__(self, env):
+        super().__init__()
+        self.fc1 = nn.Linear(
+            np.array(env.single_observation_space.shape).prod() + np.prod(env.single_action_space.shape),
+            256,
+        )
+        self.fc2 = nn.Linear(256, 256)
+        self.fc3 = nn.Linear(256, 1)
+
+    def forward(self, x, a):
+        x = torch.cat([x, a], 1)
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+
+class Actor(nn.Module):
+    def __init__(self, env):
+        super().__init__()
+        self.fc1 = nn.Linear(np.array(env.single_observation_space.shape).prod(), 256)
+        self.fc2 = nn.Linear(256, 256)
+        self.fc_mu = nn.Linear(256, np.prod(env.single_action_space.shape))
+        # action rescaling
+        self.register_buffer(
+            "action_scale",
+            torch.tensor(
+                (env.single_action_space.high - env.single_action_space.low) / 2.0,
+                dtype=torch.float32,
+            ),
+        )
+        self.register_buffer(
+            "action_bias",
+            torch.tensor(
+                (env.single_action_space.high + env.single_action_space.low) / 2.0,
+                dtype=torch.float32,
+            ),
+        )
+
+    def forward(self, x):
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = torch.tanh(self.fc_mu(x))
+        return x * self.action_scale + self.action_bias
+
+
+if __name__ == "__main__":
+
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, args.seed + i, i, args.capture_video, run_name) for i in range(args.num_envs)]
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Box), "only continuous action space is supported"
+
+    actor = Actor(envs).to(device)
+    qf1 = QNetwork(envs).to(device)
+    qf2 = QNetwork(envs).to(device)
+    qf1_target = QNetwork(envs).to(device)
+    qf2_target = QNetwork(envs).to(device)
+    target_actor = Actor(envs).to(device)
+    target_actor.load_state_dict(actor.state_dict())
+    qf1_target.load_state_dict(qf1.state_dict())
+    qf2_target.load_state_dict(qf2.state_dict())
+    q_optimizer = optim.Adam(list(qf1.parameters()) + list(qf2.parameters()), lr=args.learning_rate)
+    actor_optimizer = optim.Adam(list(actor.parameters()), lr=args.learning_rate)
+
+    envs.single_observation_space.dtype = np.float32
+    rb = ReplayBuffer(
+        args.buffer_size,
+        envs.single_observation_space,
+        envs.single_action_space,
+        device,
+        n_envs=args.num_envs,
+        handle_timeout_termination=False,
+    )
+    start_time = time.time()
+
+    # TRY NOT TO MODIFY: start the game
+    obs, _ = envs.reset(seed=args.seed)
+    for global_step in range(args.total_timesteps):
+        # ALGO LOGIC: put action logic here
+        if global_step < args.learning_starts:
+            actions = np.array([envs.single_action_space.sample() for _ in range(envs.num_envs)])
+        else:
+            with torch.no_grad():
+                actions = actor(torch.Tensor(obs).to(device))
+                actions += torch.normal(0, actor.action_scale * args.exploration_noise)
+                actions = actions.cpu().numpy().clip(envs.single_action_space.low, envs.single_action_space.high)
+
+        # TRY NOT TO MODIFY: execute the game and log data.
+        next_obs, rewards, terminations, truncations, infos = envs.step(actions)
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        if "final_info" in infos:
+            for info in infos["final_info"]:
+                if info is not None:
+                    print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                    writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                    writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+                    break
+
+        # TRY NOT TO MODIFY: save data to reply buffer; handle `final_observation`
+        real_next_obs = next_obs.copy()
+        for idx, trunc in enumerate(truncations):
+            if trunc:
+                real_next_obs[idx] = infos["final_observation"][idx]
+        rb.add(obs, real_next_obs, actions, rewards, terminations, infos)
+
+        # TRY NOT TO MODIFY: CRUCIAL step easy to overlook
+        obs = next_obs
+
+        # ALGO LOGIC: training.
+        if global_step > args.learning_starts:
+            data = rb.sample(args.batch_size)
+            with torch.no_grad():
+                clipped_noise = (torch.randn_like(data.actions, device=device) * args.policy_noise).clamp(
+                    -args.noise_clip, args.noise_clip
+                ) * target_actor.action_scale
+
+                next_state_actions = (target_actor(data.next_observations) + clipped_noise).clamp(
+                    envs.single_action_space.low[0], envs.single_action_space.high[0]
+                )
+                qf1_next_target = qf1_target(data.next_observations, next_state_actions)
+                qf2_next_target = qf2_target(data.next_observations, next_state_actions)
+                min_qf_next_target = torch.min(qf1_next_target, qf2_next_target)
+                next_q_value = data.rewards.flatten() + (1 - data.dones.flatten()) * args.gamma * (min_qf_next_target).view(-1)
+
+            qf1_a_values = qf1(data.observations, data.actions).view(-1)
+            qf2_a_values = qf2(data.observations, data.actions).view(-1)
+            qf1_loss = F.mse_loss(qf1_a_values, next_q_value)
+            qf2_loss = F.mse_loss(qf2_a_values, next_q_value)
+            qf_loss = qf1_loss + qf2_loss
+
+            # optimize the model
+            q_optimizer.zero_grad()
+            qf_loss.backward()
+            q_optimizer.step()
+
+            if global_step % args.policy_frequency == 0:
+                actor_loss = -qf1(data.observations, actor(data.observations)).mean()
+                actor_optimizer.zero_grad()
+                actor_loss.backward()
+                actor_optimizer.step()
+
+                # update the target network
+                for param, target_param in zip(actor.parameters(), target_actor.parameters()):
+                    target_param.data.copy_(args.tau * param.data + (1 - args.tau) * target_param.data)
+                for param, target_param in zip(qf1.parameters(), qf1_target.parameters()):
+                    target_param.data.copy_(args.tau * param.data + (1 - args.tau) * target_param.data)
+                for param, target_param in zip(qf2.parameters(), qf2_target.parameters()):
+                    target_param.data.copy_(args.tau * param.data + (1 - args.tau) * target_param.data)
+
+            if global_step % 100 == 0:
+                writer.add_scalar("losses/qf1_values", qf1_a_values.mean().item(), global_step)
+                writer.add_scalar("losses/qf2_values", qf2_a_values.mean().item(), global_step)
+                writer.add_scalar("losses/qf1_loss", qf1_loss.item(), global_step)
+                writer.add_scalar("losses/qf2_loss", qf2_loss.item(), global_step)
+                writer.add_scalar("losses/qf_loss", qf_loss.item() / 2.0, global_step)
+                writer.add_scalar("losses/actor_loss", actor_loss.item(), global_step)
+                print("SPS:", int(global_step / (time.time() - start_time)))
+                writer.add_scalar(
+                    "charts/SPS",
+                    int(global_step / (time.time() - start_time)),
+                    global_step,
+                )
+
+    if args.save_model:
+        model_path = f"runs/{run_name}/{args.exp_name}.cleanrl_model"
+        torch.save((actor.state_dict(), qf1.state_dict(), qf2.state_dict()), model_path)
+        print(f"model saved to {model_path}")
+        from cleanrl_utils.evals.td3_eval import evaluate
+
+        episodic_returns = evaluate(
+            model_path,
+            make_env,
+            args.env_id,
+            eval_episodes=10,
+            run_name=f"{run_name}-eval",
+            Model=(Actor, QNetwork),
+            device=device,
+            exploration_noise=args.exploration_noise,
+        )
+        for idx, episodic_return in enumerate(episodic_returns):
+            writer.add_scalar("eval/episodic_return", episodic_return, idx)
+
+        if args.upload_model:
+            from cleanrl_utils.huggingface import push_to_hub
+
+            repo_name = f"{args.env_id}-{args.exp_name}-seed{args.seed}"
+            repo_id = f"{args.hf_entity}/{repo_name}" if args.hf_entity else repo_name
+            push_to_hub(
+                args,
+                episodic_returns,
+                repo_id,
+                "TD3",
+                f"runs/{run_name}",
+                f"videos/{run_name}-eval",
+            )
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/td3_continuous_action_jax.py

@@ -0,0 +1,361 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/td3/#td3_continuous_action_jaxpy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import flax
+import flax.linen as nn
+import gymnasium as gym
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import tyro
+from flax.training.train_state import TrainState
+from torch.utils.tensorboard import SummaryWriter
+
+from cleanrl_utils.buffers import ReplayBuffer
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_model: bool = False
+    """whether to save model into the `runs/{run_name}` folder"""
+    upload_model: bool = False
+    """whether to upload the saved model to huggingface"""
+    hf_entity: str = ""
+    """the user or org name of the model repository from the Hugging Face Hub"""
+
+    # Algorithm specific arguments
+    env_id: str = "Hopper-v4"
+    """the id of the environment"""
+    total_timesteps: int = 1000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 3e-4
+    """the learning rate of the optimizer"""
+    buffer_size: int = int(1e6)
+    """the replay memory buffer size"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    tau: float = 0.005
+    """target smoothing coefficient (default: 0.005)"""
+    batch_size: int = 256
+    """the batch size of sample from the reply memory"""
+    policy_noise: float = 0.2
+    """the scale of policy noise"""
+    exploration_noise: float = 0.1
+    """the scale of exploration noise"""
+    learning_starts: int = 25e3
+    """timestep to start learning"""
+    policy_frequency: int = 2
+    """the frequency of training policy (delayed)"""
+    noise_clip: float = 0.5
+    """noise clip parameter of the Target Policy Smoothing Regularization"""
+
+
+def make_env(env_id, seed, idx, capture_video, run_name):
+    def thunk():
+        if capture_video and idx == 0:
+            env = gym.make(env_id, render_mode="rgb_array")
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        else:
+            env = gym.make(env_id)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        env.action_space.seed(seed)
+        return env
+
+    return thunk
+
+
+# ALGO LOGIC: initialize agent here:
+class QNetwork(nn.Module):
+    @nn.compact
+    def __call__(self, x: jnp.ndarray, a: jnp.ndarray):
+        x = jnp.concatenate([x, a], -1)
+        x = nn.Dense(256)(x)
+        x = nn.relu(x)
+        x = nn.Dense(256)(x)
+        x = nn.relu(x)
+        x = nn.Dense(1)(x)
+        return x
+
+
+class Actor(nn.Module):
+    action_dim: int
+    action_scale: jnp.ndarray
+    action_bias: jnp.ndarray
+
+    @nn.compact
+    def __call__(self, x):
+        x = nn.Dense(256)(x)
+        x = nn.relu(x)
+        x = nn.Dense(256)(x)
+        x = nn.relu(x)
+        x = nn.Dense(self.action_dim)(x)
+        x = nn.tanh(x)
+        x = x * self.action_scale + self.action_bias
+        return x
+
+
+class TrainState(TrainState):
+    target_params: flax.core.FrozenDict
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    key = jax.random.PRNGKey(args.seed)
+    key, actor_key, qf1_key, qf2_key = jax.random.split(key, 4)
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv([make_env(args.env_id, args.seed, 0, args.capture_video, run_name)])
+    assert isinstance(envs.single_action_space, gym.spaces.Box), "only continuous action space is supported"
+
+    max_action = float(envs.single_action_space.high[0])
+    envs.single_observation_space.dtype = np.float32
+    rb = ReplayBuffer(
+        args.buffer_size,
+        envs.single_observation_space,
+        envs.single_action_space,
+        device="cpu",
+        handle_timeout_termination=False,
+    )
+
+    # TRY NOT TO MODIFY: start the game
+    obs, _ = envs.reset(seed=args.seed)
+
+    actor = Actor(
+        action_dim=np.prod(envs.single_action_space.shape),
+        action_scale=jnp.array((envs.action_space.high - envs.action_space.low) / 2.0),
+        action_bias=jnp.array((envs.action_space.high + envs.action_space.low) / 2.0),
+    )
+    actor_state = TrainState.create(
+        apply_fn=actor.apply,
+        params=actor.init(actor_key, obs),
+        target_params=actor.init(actor_key, obs),
+        tx=optax.adam(learning_rate=args.learning_rate),
+    )
+    qf = QNetwork()
+    qf1_state = TrainState.create(
+        apply_fn=qf.apply,
+        params=qf.init(qf1_key, obs, envs.action_space.sample()),
+        target_params=qf.init(qf1_key, obs, envs.action_space.sample()),
+        tx=optax.adam(learning_rate=args.learning_rate),
+    )
+    qf2_state = TrainState.create(
+        apply_fn=qf.apply,
+        params=qf.init(qf2_key, obs, envs.action_space.sample()),
+        target_params=qf.init(qf2_key, obs, envs.action_space.sample()),
+        tx=optax.adam(learning_rate=args.learning_rate),
+    )
+    actor.apply = jax.jit(actor.apply)
+    qf.apply = jax.jit(qf.apply)
+
+    @jax.jit
+    def update_critic(
+        actor_state: TrainState,
+        qf1_state: TrainState,
+        qf2_state: TrainState,
+        observations: np.ndarray,
+        actions: np.ndarray,
+        next_observations: np.ndarray,
+        rewards: np.ndarray,
+        terminations: np.ndarray,
+        key: jnp.ndarray,
+    ):
+        # TODO Maybe pre-generate a lot of random keys
+        # also check https://jax.readthedocs.io/en/latest/jax.random.html
+        key, noise_key = jax.random.split(key, 2)
+        clipped_noise = (
+            jnp.clip(
+                (jax.random.normal(noise_key, actions.shape) * args.policy_noise),
+                -args.noise_clip,
+                args.noise_clip,
+            )
+            * actor.action_scale
+        )
+        next_state_actions = jnp.clip(
+            actor.apply(actor_state.target_params, next_observations) + clipped_noise,
+            envs.single_action_space.low,
+            envs.single_action_space.high,
+        )
+        qf1_next_target = qf.apply(qf1_state.target_params, next_observations, next_state_actions).reshape(-1)
+        qf2_next_target = qf.apply(qf2_state.target_params, next_observations, next_state_actions).reshape(-1)
+        min_qf_next_target = jnp.minimum(qf1_next_target, qf2_next_target)
+        next_q_value = (rewards + (1 - terminations) * args.gamma * (min_qf_next_target)).reshape(-1)
+
+        def mse_loss(params):
+            qf_a_values = qf.apply(params, observations, actions).squeeze()
+            return ((qf_a_values - next_q_value) ** 2).mean(), qf_a_values.mean()
+
+        (qf1_loss_value, qf1_a_values), grads1 = jax.value_and_grad(mse_loss, has_aux=True)(qf1_state.params)
+        (qf2_loss_value, qf2_a_values), grads2 = jax.value_and_grad(mse_loss, has_aux=True)(qf2_state.params)
+        qf1_state = qf1_state.apply_gradients(grads=grads1)
+        qf2_state = qf2_state.apply_gradients(grads=grads2)
+
+        return (qf1_state, qf2_state), (qf1_loss_value, qf2_loss_value), (qf1_a_values, qf2_a_values), key
+
+    @jax.jit
+    def update_actor(
+        actor_state: TrainState,
+        qf1_state: TrainState,
+        qf2_state: TrainState,
+        observations: np.ndarray,
+    ):
+        def actor_loss(params):
+            return -qf.apply(qf1_state.params, observations, actor.apply(params, observations)).mean()
+
+        actor_loss_value, grads = jax.value_and_grad(actor_loss)(actor_state.params)
+        actor_state = actor_state.apply_gradients(grads=grads)
+        actor_state = actor_state.replace(
+            target_params=optax.incremental_update(actor_state.params, actor_state.target_params, args.tau)
+        )
+
+        qf1_state = qf1_state.replace(
+            target_params=optax.incremental_update(qf1_state.params, qf1_state.target_params, args.tau)
+        )
+        qf2_state = qf2_state.replace(
+            target_params=optax.incremental_update(qf2_state.params, qf2_state.target_params, args.tau)
+        )
+        return actor_state, (qf1_state, qf2_state), actor_loss_value
+
+    start_time = time.time()
+    for global_step in range(args.total_timesteps):
+        # ALGO LOGIC: put action logic here
+        if global_step < args.learning_starts:
+            actions = np.array([envs.single_action_space.sample() for _ in range(envs.num_envs)])
+        else:
+            actions = actor.apply(actor_state.params, obs)
+            actions = np.array(
+                [
+                    (
+                        jax.device_get(actions)[0]
+                        + np.random.normal(0, max_action * args.exploration_noise, size=envs.single_action_space.shape)
+                    ).clip(envs.single_action_space.low, envs.single_action_space.high)
+                ]
+            )
+
+        # TRY NOT TO MODIFY: execute the game and log data.
+        next_obs, rewards, terminations, truncations, infos = envs.step(actions)
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        if "final_info" in infos:
+            for info in infos["final_info"]:
+                print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+                break
+
+        # TRY NOT TO MODIFY: save data to replay buffer; handle `final_observation`
+        real_next_obs = next_obs.copy()
+        for idx, trunc in enumerate(truncations):
+            if trunc:
+                real_next_obs[idx] = infos["final_observation"][idx]
+        rb.add(obs, real_next_obs, actions, rewards, terminations, infos)
+
+        # TRY NOT TO MODIFY: CRUCIAL step easy to overlook
+        obs = next_obs
+
+        # ALGO LOGIC: training.
+        if global_step > args.learning_starts:
+            data = rb.sample(args.batch_size)
+
+            (qf1_state, qf2_state), (qf1_loss_value, qf2_loss_value), (qf1_a_values, qf2_a_values), key = update_critic(
+                actor_state,
+                qf1_state,
+                qf2_state,
+                data.observations.numpy(),
+                data.actions.numpy(),
+                data.next_observations.numpy(),
+                data.rewards.flatten().numpy(),
+                data.dones.flatten().numpy(),
+                key,
+            )
+
+            if global_step % args.policy_frequency == 0:
+                actor_state, (qf1_state, qf2_state), actor_loss_value = update_actor(
+                    actor_state,
+                    qf1_state,
+                    qf2_state,
+                    data.observations.numpy(),
+                )
+
+            if global_step % 100 == 0:
+                writer.add_scalar("losses/qf1_loss", qf1_loss_value.item(), global_step)
+                writer.add_scalar("losses/qf2_loss", qf2_loss_value.item(), global_step)
+                writer.add_scalar("losses/qf1_values", qf1_a_values.item(), global_step)
+                writer.add_scalar("losses/qf2_values", qf2_a_values.item(), global_step)
+                writer.add_scalar("losses/actor_loss", actor_loss_value.item(), global_step)
+                print("SPS:", int(global_step / (time.time() - start_time)))
+                writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+    if args.save_model:
+        model_path = f"runs/{run_name}/{args.exp_name}.cleanrl_model"
+        with open(model_path, "wb") as f:
+            f.write(
+                flax.serialization.to_bytes(
+                    [
+                        actor_state.params,
+                        qf1_state.params,
+                        qf2_state.params,
+                    ]
+                )
+            )
+        print(f"model saved to {model_path}")
+        from cleanrl_utils.evals.td3_jax_eval import evaluate
+
+        episodic_returns = evaluate(
+            model_path,
+            make_env,
+            args.env_id,
+            eval_episodes=10,
+            run_name=f"{run_name}-eval",
+            Model=(Actor, QNetwork),
+            exploration_noise=args.exploration_noise,
+        )
+        for idx, episodic_return in enumerate(episodic_returns):
+            writer.add_scalar("eval/episodic_return", episodic_return, idx)
+
+        if args.upload_model:
+            from cleanrl_utils.huggingface import push_to_hub
+
+            repo_name = f"{args.env_id}-{args.exp_name}-seed{args.seed}"
+            repo_id = f"{args.hf_entity}/{repo_name}" if args.hf_entity else repo_name
+            push_to_hub(args, episodic_returns, repo_id, "TD3", f"runs/{run_name}", f"videos/{run_name}-eval")
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/wandb/debug-internal.log

@@ -0,0 +1,15 @@
+{"time":"2025-11-07T12:56:47.957309906+08:00","level":"INFO","msg":"stream: starting","core version":"0.22.3"}
+{"time":"2025-11-07T12:56:48.33142385+08:00","level":"INFO","msg":"stream: created new stream","id":"g1edw7ov"}
+{"time":"2025-11-07T12:56:48.331674194+08:00","level":"INFO","msg":"handler: started","stream_id":"g1edw7ov"}
+{"time":"2025-11-07T12:56:48.335368381+08:00","level":"INFO","msg":"stream: started","id":"g1edw7ov"}
+{"time":"2025-11-07T12:56:48.335386015+08:00","level":"INFO","msg":"writer: started","stream_id":"g1edw7ov"}
+{"time":"2025-11-07T12:56:48.335389832+08:00","level":"INFO","msg":"sender: started","stream_id":"g1edw7ov"}
+{"time":"2025-11-07T12:56:48.726770104+08:00","level":"ERROR","msg":"git repo not found","error":"repository does not exist"}
+{"time":"2025-11-07T12:56:58.861202459+08:00","level":"WARN","msg":"tensorboard: no root directory","error":"timed out after 10s"}
+{"time":"2025-11-07T12:56:58.862839009+08:00","level":"INFO","msg":"tensorboard: tracking new log directory","rootDir":{},"logDir":"LocalOrCloudPath(LocalPath=\"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/Bandit__dqn_bandit__1__1762491400\")","namespace":""}
+{"time":"2025-11-07T12:56:58.864923146+08:00","level":"INFO","msg":"tensorboard: saving file","fileLocation":"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/Bandit__dqn_bandit__1__1762491400/events.out.tfevents.1762491408.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.234009.0","runPath":"runs/Bandit__dqn_bandit__1__1762491400/events.out.tfevents.1762491408.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.234009.0"}
+{"time":"2025-11-07T12:56:58.868040818+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":122}
+{"time":"2025-11-07T12:56:58.871369044+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":311}
+{"time":"2025-11-07T12:57:03.576733669+08:00","level":"INFO","msg":"stream: closing","id":"g1edw7ov"}
+{"time":"2025-11-07T12:57:03.579454439+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":506}
+{"time":"2025-11-07T12:57:03.581505913+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":20}

cleanrl/cleanrl/wandb/debug.log

@@ -0,0 +1,388 @@
+2025-11-07 12:56:47,735 INFO    MainThread:234009 [wandb_setup.py:_flush():81] Current SDK version is 0.22.3
+2025-11-07 12:56:47,736 INFO    MainThread:234009 [wandb_setup.py:_flush():81] Configure stats pid to 234009
+2025-11-07 12:56:47,736 INFO    MainThread:234009 [wandb_setup.py:_flush():81] Loading settings from /root/.config/wandb/settings
+2025-11-07 12:56:47,736 INFO    MainThread:234009 [wandb_setup.py:_flush():81] Loading settings from /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/settings
+2025-11-07 12:56:47,736 INFO    MainThread:234009 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2025-11-07 12:56:47,736 INFO    MainThread:234009 [wandb_init.py:setup_run_log_directory():706] Logging user logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_125647-g1edw7ov/logs/debug.log
+2025-11-07 12:56:47,737 INFO    MainThread:234009 [wandb_init.py:setup_run_log_directory():707] Logging internal logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_125647-g1edw7ov/logs/debug-internal.log
+2025-11-07 12:56:47,738 INFO    MainThread:234009 [wandb_init.py:init():833] calling init triggers
+2025-11-07 12:56:47,738 INFO    MainThread:234009 [wandb_init.py:init():838] wandb.init called with sweep_config: {}
+config: {'exp_name': 'dqn_bandit', 'seed': 1, 'torch_deterministic': True, 'cuda': True, 'track': True, 'wandb_project_name': 'ragen-bandit', 'wandb_entity': None, 'capture_video': False, 'save_model': False, 'env_id': 'Bandit', 'total_timesteps': 100000, 'learning_rate': 0.001, 'num_envs': 1, 'buffer_size': 10000, 'gamma': 0.99, 'tau': 1.0, 'target_network_frequency': 500, 'batch_size': 32, 'start_e': 1.0, 'end_e': 0.05, 'exploration_fraction': 0.5, 'learning_starts': 1000, 'train_frequency': 1, 'steps_per_episode': 10, '_wandb': {'code_path': 'code/cleanrl/dqn_bandit.py'}}
+2025-11-07 12:56:47,738 INFO    MainThread:234009 [wandb_init.py:init():881] starting backend
+2025-11-07 12:56:47,944 INFO    MainThread:234009 [wandb_init.py:init():884] sending inform_init request
+2025-11-07 12:56:47,954 INFO    MainThread:234009 [wandb_init.py:init():892] backend started and connected
+2025-11-07 12:56:47,956 INFO    MainThread:234009 [wandb_init.py:init():962] updated telemetry
+2025-11-07 12:56:47,990 INFO    MainThread:234009 [wandb_init.py:init():986] communicating run to backend with 90.0 second timeout
+2025-11-07 12:56:48,714 INFO    MainThread:234009 [wandb_init.py:init():1033] starting run threads in backend
+2025-11-07 12:56:48,856 INFO    MainThread:234009 [wandb_run.py:_console_start():2506] atexit reg
+2025-11-07 12:56:48,857 INFO    MainThread:234009 [wandb_run.py:_redirect():2354] redirect: wrap_raw
+2025-11-07 12:56:48,857 INFO    MainThread:234009 [wandb_run.py:_redirect():2423] Wrapping output streams.
+2025-11-07 12:56:48,857 INFO    MainThread:234009 [wandb_run.py:_redirect():2446] Redirects installed.
+2025-11-07 12:56:48,859 INFO    MainThread:234009 [wandb_init.py:init():1073] run started, returning control to user process
+2025-11-07 12:56:48,860 INFO    MainThread:234009 [wandb_run.py:_tensorboard_callback():1598] tensorboard callback: runs/Bandit__dqn_bandit__1__1762491400, True
+2025-11-07 12:57:03,576 INFO    wandb-AsyncioManager-main:234009 [service_client.py:_forward_responses():80] Reached EOF.
+2025-11-07 12:57:03,577 INFO    wandb-AsyncioManager-main:234009 [mailbox.py:close():137] Closing mailbox, abandoning 1 handles.
+2025-11-07 12:57:03,925 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,933 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,933 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,934 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,934 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,935 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,935 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,935 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,936 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,936 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,937 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,937 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,937 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,938 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,938 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,938 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,939 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,939 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,948 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,948 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,950 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,951 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,952 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,953 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,954 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,955 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,955 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost
+2025-11-07 12:57:03,957 ERROR   wandb-AsyncioManager-main:234009 [asyncio_manager.py:fn_wrap_exceptions():183] Uncaught exception in run_soon callback.
+Traceback (most recent call last):
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/asyncio_manager.py", line 181, in fn_wrap_exceptions
+    await fn()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 38, in publish
+    await self._send_server_request(request)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/wandb/sdk/lib/service/service_client.py", line 64, in _send_server_request
+    await self._writer.drain()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 392, in drain
+    await self._protocol._drain_helper()
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/asyncio/streams.py", line 166, in _drain_helper
+    raise ConnectionResetError('Connection lost')
+ConnectionResetError: Connection lost

cleanrl/cleanrl/wandb/run-20251107_102633-lu2iu68t/files/config.yaml

@@ -0,0 +1,153 @@
+_wandb:
+    value:
+        cli_version: 0.22.3
+        code_path: code/cleanrl/ppo_bandit.py
+        e:
+            6ymqnqubvr99vvj2hajaxngee30bwzdk:
+                args:
+                    - --track
+                    - --wandb-project-name
+                    - ragen-bandit
+                codePath: cleanrl/ppo_bandit.py
+                codePathLocal: ppo_bandit.py
+                cpu_count: 64
+                cpu_count_logical: 128
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "5153960755200"
+                        used: "30509887488"
+                email: haoyu-wa22@mails.tsinghua.edu.cn
+                executable: /root/local/miniconda3/envs/ragen/bin/python
+                git:
+                    commit: 004f8a086a892a2a180f4dd332b90d83a968aa7a
+                    remote: https://github.com/vwxyzjn/cleanrl.git
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-35e2d43d-4067-82ce-90d4-def9e389bf28
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-af4135e3-88f2-e9ac-518d-502c75a85429
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b7cf0ec6-7c29-1179-dceb-09565da51890
+                host: pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0
+                memory:
+                    total: "2163642122240"
+                os: Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35
+                program: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_bandit.py
+                python: CPython 3.12.12
+                root: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl
+                startedAt: "2025-11-07T02:26:33.725426Z"
+                writerId: 6ymqnqubvr99vvj2hajaxngee30bwzdk
+        m: []
+        python_version: 3.12.12
+        t:
+            "1":
+                - 1
+                - 49
+                - 51
+                - 105
+            "2":
+                - 1
+                - 49
+                - 51
+                - 105
+            "3":
+                - 13
+                - 16
+                - 35
+            "4": 3.12.12
+            "5": 0.22.3
+            "12": 0.22.3
+            "13": linux-x86_64
+anneal_lr:
+    value: true
+batch_size:
+    value: 16384
+capture_video:
+    value: false
+clip_coef:
+    value: 0.2
+clip_vloss:
+    value: true
+cuda:
+    value: true
+ent_coef:
+    value: 0.01
+env_id:
+    value: Bandit
+exp_name:
+    value: ppo_bandit
+gae_lambda:
+    value: 0.95
+gamma:
+    value: 0.99
+learning_rate:
+    value: 0.00025
+max_grad_norm:
+    value: 0.5
+minibatch_size:
+    value: 4096
+norm_adv:
+    value: true
+num_envs:
+    value: 32
+num_iterations:
+    value: 610
+num_minibatches:
+    value: 4
+num_steps:
+    value: 512
+seed:
+    value: 1
+target_kl:
+    value: null
+torch_deterministic:
+    value: true
+total_timesteps:
+    value: 10000000
+track:
+    value: true
+update_epochs:
+    value: 4
+vf_coef:
+    value: 0.5
+wandb_entity:
+    value: null
+wandb_project_name:
+    value: ragen-bandit

cleanrl/cleanrl/wandb/run-20251107_102633-lu2iu68t/files/wandb-summary.json

@@ -0,0 +1 @@
+{"losses/value_loss":0.044632442,"charts/min_reward":0,"losses/old_approx_kl":-1.379085e-07,"charts/avg_reward":0.089166254,"_wandb":{"runtime":353},"losses/clipfrac":0,"global_step":9994240,"losses/policy_loss":-2.789311e-07,"_step":7929,"_runtime":353,"losses/approx_kl":3.2465323e-08,"losses/explained_variance":5.1021576e-05,"charts/max_reward":1,"losses/entropy":0.69236815,"_timestamp":1.7624827486915712e+09,"charts/SPS":28390,"charts/learning_rate":4.0983608e-07,"charts/avg_value":0.17397192}

cleanrl/cleanrl/wandb/run-20251107_103331-e2e7wd2b/files/code/cleanrl/ppo_frozenlake.py

@@ -0,0 +1,347 @@
+# PPO implementation for RAGEN FrozenLake environment
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.frozen_lake.env import FrozenLakeEnv
+from ragen.env.frozen_lake.config import FrozenLakeEnvConfig
+from ragen_wrappers import FrozenLakeWrapper
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "FrozenLake"
+    """the id of the environment"""
+    total_timesteps: int = 1000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 8
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+    
+    # FrozenLake specific
+    grid_size: int = 4
+    """size of the frozen lake grid"""
+    is_slippery: bool = True
+    """whether the ice is slippery"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, idx, capture_video, run_name, seed, grid_size, is_slippery):
+    def thunk():
+        config = FrozenLakeEnvConfig(
+            size=grid_size,
+            p=0.8,
+            is_slippery=is_slippery,
+            map_seed=seed + idx
+        )
+        env = FrozenLakeEnv(config)
+        env = FrozenLakeWrapper(env)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        obs_shape = np.array(envs.single_observation_space.shape).prod()
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name, args.seed, args.grid_size, args.is_slippery) 
+         for i in range(args.num_envs)],
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        
+        # Additional useful metrics
+        writer.add_scalar("charts/avg_reward", rewards.mean().item(), global_step)
+        writer.add_scalar("charts/avg_value", values.mean().item(), global_step)
+        writer.add_scalar("charts/max_reward", rewards.max().item(), global_step)
+        writer.add_scalar("charts/min_reward", rewards.min().item(), global_step)
+        
+        # Console output with key metrics
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Value: {values.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        writer.add_scalar("charts/SPS", sps, global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/wandb/run-20251107_103331-e2e7wd2b/files/config.yaml

@@ -0,0 +1,157 @@
+_wandb:
+    value:
+        cli_version: 0.22.3
+        code_path: code/cleanrl/ppo_frozenlake.py
+        e:
+            e26crksekquh3exjmxygxro2irogd3e1:
+                args:
+                    - --track
+                    - --wandb-project-name
+                    - ragen-bandit
+                codePath: cleanrl/ppo_frozenlake.py
+                codePathLocal: ppo_frozenlake.py
+                cpu_count: 64
+                cpu_count_logical: 128
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "5153960755200"
+                        used: "30509891584"
+                email: haoyu-wa22@mails.tsinghua.edu.cn
+                executable: /root/local/miniconda3/envs/ragen/bin/python
+                git:
+                    commit: 004f8a086a892a2a180f4dd332b90d83a968aa7a
+                    remote: https://github.com/vwxyzjn/cleanrl.git
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-35e2d43d-4067-82ce-90d4-def9e389bf28
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-af4135e3-88f2-e9ac-518d-502c75a85429
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b7cf0ec6-7c29-1179-dceb-09565da51890
+                host: pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0
+                memory:
+                    total: "2163642122240"
+                os: Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35
+                program: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_frozenlake.py
+                python: CPython 3.12.12
+                root: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl
+                startedAt: "2025-11-07T02:33:31.320641Z"
+                writerId: e26crksekquh3exjmxygxro2irogd3e1
+        m: []
+        python_version: 3.12.12
+        t:
+            "1":
+                - 1
+                - 49
+                - 51
+                - 105
+            "2":
+                - 1
+                - 49
+                - 51
+                - 105
+            "3":
+                - 13
+                - 16
+                - 35
+            "4": 3.12.12
+            "5": 0.22.3
+            "12": 0.22.3
+            "13": linux-x86_64
+anneal_lr:
+    value: true
+batch_size:
+    value: 1024
+capture_video:
+    value: false
+clip_coef:
+    value: 0.2
+clip_vloss:
+    value: true
+cuda:
+    value: true
+ent_coef:
+    value: 0.01
+env_id:
+    value: FrozenLake
+exp_name:
+    value: ppo_frozenlake
+gae_lambda:
+    value: 0.95
+gamma:
+    value: 0.99
+grid_size:
+    value: 4
+is_slippery:
+    value: true
+learning_rate:
+    value: 0.00025
+max_grad_norm:
+    value: 0.5
+minibatch_size:
+    value: 256
+norm_adv:
+    value: true
+num_envs:
+    value: 8
+num_iterations:
+    value: 976
+num_minibatches:
+    value: 4
+num_steps:
+    value: 128
+seed:
+    value: 1
+target_kl:
+    value: null
+torch_deterministic:
+    value: true
+total_timesteps:
+    value: 1000000
+track:
+    value: true
+update_epochs:
+    value: 4
+vf_coef:
+    value: 0.5
+wandb_entity:
+    value: null
+wandb_project_name:
+    value: ragen-bandit

cleanrl/cleanrl/wandb/run-20251107_103331-e2e7wd2b/files/wandb-metadata.json

@@ -0,0 +1,94 @@
+{
+  "os":  "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python":  "CPython 3.12.12",
+  "startedAt":  "2025-11-07T02:33:31.320641Z",
+  "args":  [
+    "--track",
+    "--wandb-project-name",
+    "ragen-bandit"
+  ],
+  "program":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_frozenlake.py",
+  "codePath":  "cleanrl/ppo_frozenlake.py",
+  "codePathLocal":  "ppo_frozenlake.py",
+  "git":  {
+    "remote":  "https://github.com/vwxyzjn/cleanrl.git",
+    "commit":  "004f8a086a892a2a180f4dd332b90d83a968aa7a"
+  },
+  "email":  "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl",
+  "host":  "pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0",
+  "executable":  "/root/local/miniconda3/envs/ragen/bin/python",
+  "cpu_count":  64,
+  "cpu_count_logical":  128,
+  "gpu":  "NVIDIA H100 80GB HBM3",
+  "gpu_count":  8,
+  "disk":  {
+    "/":  {
+      "total":  "5153960755200",
+      "used":  "30509891584"
+    }
+  },
+  "memory":  {
+    "total":  "2163642122240"
+  },
+  "gpu_nvidia":  [
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-35e2d43d-4067-82ce-90d4-def9e389bf28"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-af4135e3-88f2-e9ac-518d-502c75a85429"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-b7cf0ec6-7c29-1179-dceb-09565da51890"
+    }
+  ],
+  "cudaVersion":  "12.4",
+  "writerId":  "e26crksekquh3exjmxygxro2irogd3e1"
+}

cleanrl/cleanrl/wandb/run-20251107_112647-9utis4xx/files/code/cleanrl/ppo_sokoban.py

@@ -0,0 +1,352 @@
+# PPO implementation for RAGEN Sokoban environment
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.sokoban.env import SokobanEnv
+from ragen.env.sokoban.config import SokobanEnvConfig
+from ragen_wrappers import SokobanWrapper
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "Sokoban"
+    """the id of the environment"""
+    total_timesteps: int = 5000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 8
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+    
+    # Sokoban specific
+    dim_room: tuple = (6, 6)
+    """dimensions of the sokoban room"""
+    num_boxes: int = 1
+    """number of boxes in sokoban"""
+    max_steps: int = 100
+    """maximum steps per episode"""
+    search_depth: int = 100
+    """search depth for sokoban level generation"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, idx, capture_video, run_name, seed, dim_room, num_boxes, max_steps, search_depth):
+    def thunk():
+        config = SokobanEnvConfig(
+            dim_room=dim_room,
+            num_boxes=num_boxes,
+            max_steps=max_steps,
+            search_depth=search_depth
+        )
+        env = SokobanEnv(config)
+        env = SokobanWrapper(env)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        obs_shape = np.array(envs.single_observation_space.shape).prod()
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name, args.seed, 
+                  args.dim_room, args.num_boxes, args.max_steps, args.search_depth) 
+         for i in range(args.num_envs)],
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        
+        # Additional useful metrics
+        writer.add_scalar("charts/avg_reward", rewards.mean().item(), global_step)
+        writer.add_scalar("charts/avg_value", values.mean().item(), global_step)
+        writer.add_scalar("charts/max_reward", rewards.max().item(), global_step)
+        writer.add_scalar("charts/min_reward", rewards.min().item(), global_step)
+        
+        # Console output with key metrics
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Value: {values.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        writer.add_scalar("charts/SPS", sps, global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/wandb/run-20251107_112647-9utis4xx/files/config.yaml

@@ -0,0 +1,163 @@
+_wandb:
+    value:
+        cli_version: 0.22.3
+        code_path: code/cleanrl/ppo_sokoban.py
+        e:
+            z96hq3pus2sxc7xhydj92rmnpv0sy2t0:
+                args:
+                    - --track
+                    - --wandb-project-name
+                    - ragen-sokoban
+                codePath: cleanrl/ppo_sokoban.py
+                codePathLocal: ppo_sokoban.py
+                cpu_count: 64
+                cpu_count_logical: 128
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "5153960755200"
+                        used: "31672418304"
+                email: haoyu-wa22@mails.tsinghua.edu.cn
+                executable: /root/local/miniconda3/envs/ragen/bin/python
+                git:
+                    commit: 004f8a086a892a2a180f4dd332b90d83a968aa7a
+                    remote: https://github.com/vwxyzjn/cleanrl.git
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-35e2d43d-4067-82ce-90d4-def9e389bf28
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-af4135e3-88f2-e9ac-518d-502c75a85429
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b7cf0ec6-7c29-1179-dceb-09565da51890
+                host: pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0
+                memory:
+                    total: "2163642122240"
+                os: Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35
+                program: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_sokoban.py
+                python: CPython 3.12.12
+                root: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl
+                startedAt: "2025-11-07T03:26:47.139012Z"
+                writerId: z96hq3pus2sxc7xhydj92rmnpv0sy2t0
+        m: []
+        python_version: 3.12.12
+        t:
+            "1":
+                - 1
+                - 49
+                - 51
+                - 105
+            "2":
+                - 1
+                - 49
+                - 51
+                - 105
+            "3":
+                - 13
+                - 16
+                - 35
+            "4": 3.12.12
+            "5": 0.22.3
+            "12": 0.22.3
+            "13": linux-x86_64
+anneal_lr:
+    value: true
+batch_size:
+    value: 1024
+capture_video:
+    value: false
+clip_coef:
+    value: 0.2
+clip_vloss:
+    value: true
+cuda:
+    value: true
+dim_room:
+    value:
+        - 6
+        - 6
+ent_coef:
+    value: 0.01
+env_id:
+    value: Sokoban
+exp_name:
+    value: ppo_sokoban
+gae_lambda:
+    value: 0.95
+gamma:
+    value: 0.99
+learning_rate:
+    value: 0.00025
+max_grad_norm:
+    value: 0.5
+max_steps:
+    value: 100
+minibatch_size:
+    value: 256
+norm_adv:
+    value: true
+num_boxes:
+    value: 1
+num_envs:
+    value: 8
+num_iterations:
+    value: 4882
+num_minibatches:
+    value: 4
+num_steps:
+    value: 128
+search_depth:
+    value: 100
+seed:
+    value: 1
+target_kl:
+    value: null
+torch_deterministic:
+    value: true
+total_timesteps:
+    value: 5000000
+track:
+    value: true
+update_epochs:
+    value: 4
+vf_coef:
+    value: 0.5
+wandb_entity:
+    value: null
+wandb_project_name:
+    value: ragen-sokoban

cleanrl/cleanrl/wandb/run-20251107_112647-9utis4xx/files/output.log

@@ -0,0 +1,16 @@
+Traceback (most recent call last):
+  File "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_sokoban.py", line 184, in <module>
+    envs = gym.vector.SyncVectorEnv(
+           ^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/gymnasium/vector/sync_vector_env.py", line 97, in __init__
+    self.envs = [env_fn() for env_fn in env_fns]
+                 ^^^^^^^^
+  File "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_sokoban.py", line 108, in thunk
+    env = gym.wrappers.RecordEpisodeStatistics(env)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/gymnasium/wrappers/common.py", line 496, in __init__
+    gym.Wrapper.__init__(self, env)
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/gymnasium/core.py", line 313, in __init__
+    assert isinstance(
+           ^^^^^^^^^^^
+AssertionError: Expected env to be a `gymnasium.Env` but got <class 'ragen_wrappers.SokobanWrapper'>

cleanrl/cleanrl/wandb/run-20251107_112647-9utis4xx/files/requirements.txt

@@ -0,0 +1,305 @@
+ragen==0.1
+setuptools==80.9.0
+wheel==0.45.1
+pip==25.2
+zipp==3.23.0
+verl==0.2.0.dev0
+ragen==0.1
+triton==3.2.0
+nvidia-cusparselt-cu12==0.6.2
+mpmath==1.3.0
+typing_extensions==4.15.0
+sympy==1.13.1
+nvidia-nvtx-cu12==12.4.127
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nccl-cu12==2.21.5
+nvidia-curand-cu12==10.3.5.147
+nvidia-cufft-cu12==11.2.1.3
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cublas-cu12==12.4.5.8
+networkx==3.5
+MarkupSafe==2.1.5
+fsspec==2025.9.0
+filelock==3.19.1
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-cudnn-cu12==9.1.0.70
+Jinja2==3.1.6
+nvidia-cusolver-cu12==11.6.1.9
+torch==2.6.0+cu124
+einops==0.8.1
+flash_attn==2.7.4.post1
+pytz==2025.2
+pyperclip==1.11.0
+pylatexenc==2.10
+pyjnius==1.7.0
+py-cpuinfo==9.0.0
+pure_eval==0.2.3
+ptyprocess==0.7.0
+gym-notices==0.1.0
+flatbuffers==25.9.23
+fastrlock==0.8.3
+Farama-Notifications==0.0.4
+cymem==2.0.11
+antlr4-python3-runtime==4.9.3
+xxhash==3.6.0
+wrapt==2.0.0
+Werkzeug==3.1.3
+websockets==15.0.1
+wcwidth==0.2.14
+wasabi==1.1.3
+uvloop==0.22.1
+urllib3==2.5.0
+tzdata==2025.2
+typing-inspection==0.4.2
+traitlets==5.14.3
+tqdm==4.67.1
+threadpoolctl==3.6.0
+tabulate==0.9.0
+spacy-loggers==1.0.5
+spacy-legacy==3.0.12
+soupsieve==2.8
+sniffio==1.3.1
+smmap==5.0.2
+six==1.17.0
+shellingham==1.5.4
+sentencepiece==0.2.1
+safetensors==0.6.2
+rpds-py==0.28.0
+rignore==0.7.6
+regex==2025.11.3
+RapidFuzz==3.14.3
+pyzmq==27.1.0
+PyYAML==6.0.3
+pytokens==0.3.0
+python-multipart==0.0.20
+python-json-logger==4.0.0
+python-dotenv==1.2.1
+PySocks==1.7.1
+pyparsing==3.2.5
+PyJWT==2.10.1
+Pygments==2.19.2
+pygame==2.6.1
+pydantic_core==2.41.5
+pycparser==2.23
+pycountry==24.6.1
+pybind11==3.0.1
+pyarrow==22.0.0
+psutil==7.1.3
+protobuf==6.33.0
+propcache==0.4.1
+prometheus_client==0.23.1
+platformdirs==4.5.0
+pillow==11.3.0
+pexpect==4.9.0
+pathvalidate==3.3.1
+pathspec==0.12.1
+pathable==0.4.4
+partial-json-parser==0.2.1.1.post6
+parso==0.8.5
+packaging==25.0
+orjson==3.11.4
+numpy==1.26.4
+ninja==1.13.0
+nest-asyncio==1.6.0
+mypy_extensions==1.1.0
+murmurhash==1.0.13
+multidict==6.7.0
+msgspec==0.19.0
+msgpack==1.1.2
+more-itertools==10.8.0
+mdurl==0.1.2
+marisa-trie==1.3.1
+llvmlite==0.43.0
+llguidance==0.7.30
+lark==1.2.2
+kiwisolver==1.4.9
+joblib==1.5.2
+jiter==0.11.1
+jeepney==0.9.0
+jaraco.context==6.0.1
+itsdangerous==2.2.0
+interegular==0.3.3
+idna==3.11
+humanfriendly==10.0
+httpx-sse==0.4.3
+httptools==0.7.1
+html2text==2025.4.15
+hf-xet==1.2.0
+h11==0.16.0
+frozenlist==1.8.0
+fonttools==4.60.1
+executing==2.2.1
+exceptiongroup==1.3.0
+eval_type_backport==0.2.2
+docutils==0.22.3
+docstring_parser==0.17.0
+dnspython==2.8.0
+distro==1.9.0
+diskcache==5.6.3
+dill==0.4.0
+decorator==5.2.1
+debugpy==1.8.17
+Cython==3.2.0
+cycler==0.12.1
+codetiming==1.4.0
+cloudpickle==3.1.2
+cloudpathlib==0.23.0
+click==8.2.1
+charset-normalizer==3.4.4
+certifi==2025.10.5
+catalogue==2.0.10
+cachetools==6.2.1
+blinker==1.9.0
+blake3==1.0.8
+beartype==0.22.5
+attrs==25.4.0
+asttokens==3.0.0
+astor==0.8.1
+annotated-types==0.7.0
+annotated-doc==0.0.3
+airportsdata==20250909
+aiohappyeyeballs==2.6.1
+yarl==1.22.0
+uvicorn==0.38.0
+typer-slim==0.20.0
+thefuzz==0.22.1
+stack-data==0.6.3
+srsly==2.5.1
+smart_open==7.4.4
+sentry-sdk==2.43.0
+scipy==1.16.3
+requests==2.32.5
+referencing==0.36.2
+rank-bm25==0.2.2
+python-dateutil==2.9.0.post0
+pydantic==2.12.4
+py-key-value-shared==0.2.8
+prompt_toolkit==3.0.52
+preshed==3.0.10
+opencv-python-headless==4.11.0.86
+omegaconf==2.3.0
+numba==0.60.0
+nltk==3.9.2
+multiprocess==0.70.18
+matplotlib-inline==0.2.1
+markdown-it-py==4.0.0
+language_data==1.3.0
+jedi==0.19.2
+jaraco.functools==4.3.0
+jaraco.classes==3.4.0
+ipython_pygments_lexers==1.1.1
+importlib_metadata==8.7.0
+ImageIO==2.37.2
+httpcore==1.0.9
+gymnasium==1.2.2
+gym==0.26.2
+gitdb==4.0.12
+gguf==0.10.0
+Flask==3.1.2
+faiss-cpu==1.12.0
+email-validator==2.3.0
+depyf==0.18.0
+cupy-cuda12x==13.6.0
+contourpy==1.3.3
+coloredlogs==15.0.1
+cffi==2.0.0
+blis==1.3.0
+black==25.9.0
+beautifulsoup4==4.14.2
+anyio==4.11.0
+aiosignal==1.4.0
+watchfiles==1.1.1
+tiktoken==0.12.0
+starlette==0.49.3
+sse-starlette==3.0.3
+scikit-learn==1.7.2
+rich==14.2.0
+pydantic-settings==2.11.0
+pydantic-extra-types==2.10.6
+py-key-value-aio==0.2.8
+pandas==2.3.3
+openapi-pydantic==0.5.1
+onnxruntime==1.23.2
+matplotlib==3.10.7
+lm-format-enforcer==0.10.12
+langcodes==3.5.0
+jsonschema-specifications==2025.9.1
+jsonschema-path==0.3.4
+ipython==9.7.0
+hydra-core==1.3.2
+huggingface-hub==0.36.0
+httpx==0.28.1
+gym-sokoban==0.0.6
+GitPython==3.1.45
+cryptography==46.0.3
+confection==0.1.5
+cleantext==1.1.4
+aiohttp==3.13.2
+xformers==0.0.29.post2
+weasel==0.4.2
+wandb==0.22.3
+typer==0.19.2
+torchvision==0.21.0
+torchdata==0.11.0
+torchaudio==2.6.0
+tokenizers==0.22.1
+thinc==8.3.7
+tensordict==0.8.3
+SecretStorage==3.4.0
+rich-toolkit==0.15.1
+rich-rst==1.3.2
+prometheus-fastapi-instrumentator==7.1.0
+openai==2.7.1
+jsonschema==4.25.1
+gdown==5.2.0
+fastapi==0.121.0
+Authlib==1.6.5
+anthropic==0.72.0
+accelerate==1.11.0
+transformers==4.57.1
+together==1.5.30
+spacy==3.8.7
+ray==2.51.1
+outlines_core==0.1.26
+mistral_common==1.8.5
+mcp==1.20.0
+keyring==25.6.0
+fastapi-cloud-cli==0.3.1
+fastapi-cli==0.0.14
+datasets==4.4.1
+cyclopts==4.2.1
+xgrammar==0.1.16
+peft==0.17.1
+outlines==0.1.11
+compressed-tensors==0.9.2
+fastmcp==2.13.0.2
+vllm==0.8.2
+pyserini==1.3.0
+typeguard==4.4.4
+shtab==1.7.2
+tyro==0.9.35
+tensorboard-data-server==0.7.2
+Markdown==3.10
+grpcio==1.76.0
+absl-py==2.3.1
+tensorboard==2.20.0
+ragen==0.1
+verl==0.2.0.dev0
+autocommand==2.2.2
+backports.tarfile==1.2.0
+importlib_metadata==8.0.0
+inflect==7.3.1
+jaraco.collections==5.1.0
+jaraco.context==5.3.0
+jaraco.functools==4.0.1
+jaraco.text==3.12.1
+more-itertools==10.3.0
+packaging==24.2
+platformdirs==4.2.2
+tomli==2.0.1
+typeguard==4.3.0
+typing_extensions==4.12.2
+wheel==0.45.1
+zipp==3.19.2

cleanrl/cleanrl/wandb/run-20251107_112647-9utis4xx/files/wandb-metadata.json

@@ -0,0 +1,94 @@
+{
+  "os":  "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python":  "CPython 3.12.12",
+  "startedAt":  "2025-11-07T03:26:47.139012Z",
+  "args":  [
+    "--track",
+    "--wandb-project-name",
+    "ragen-sokoban"
+  ],
+  "program":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_sokoban.py",
+  "codePath":  "cleanrl/ppo_sokoban.py",
+  "codePathLocal":  "ppo_sokoban.py",
+  "git":  {
+    "remote":  "https://github.com/vwxyzjn/cleanrl.git",
+    "commit":  "004f8a086a892a2a180f4dd332b90d83a968aa7a"
+  },
+  "email":  "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl",
+  "host":  "pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0",
+  "executable":  "/root/local/miniconda3/envs/ragen/bin/python",
+  "cpu_count":  64,
+  "cpu_count_logical":  128,
+  "gpu":  "NVIDIA H100 80GB HBM3",
+  "gpu_count":  8,
+  "disk":  {
+    "/":  {
+      "total":  "5153960755200",
+      "used":  "31672418304"
+    }
+  },
+  "memory":  {
+    "total":  "2163642122240"
+  },
+  "gpu_nvidia":  [
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-35e2d43d-4067-82ce-90d4-def9e389bf28"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-af4135e3-88f2-e9ac-518d-502c75a85429"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-b7cf0ec6-7c29-1179-dceb-09565da51890"
+    }
+  ],
+  "cudaVersion":  "12.4",
+  "writerId":  "z96hq3pus2sxc7xhydj92rmnpv0sy2t0"
+}

cleanrl/cleanrl/wandb/run-20251107_112647-9utis4xx/logs/debug.log

@@ -0,0 +1,24 @@
+2025-11-07 11:26:47,186 INFO    MainThread:212707 [wandb_setup.py:_flush():81] Current SDK version is 0.22.3
+2025-11-07 11:26:47,186 INFO    MainThread:212707 [wandb_setup.py:_flush():81] Configure stats pid to 212707
+2025-11-07 11:26:47,186 INFO    MainThread:212707 [wandb_setup.py:_flush():81] Loading settings from /root/.config/wandb/settings
+2025-11-07 11:26:47,186 INFO    MainThread:212707 [wandb_setup.py:_flush():81] Loading settings from /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/settings
+2025-11-07 11:26:47,187 INFO    MainThread:212707 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2025-11-07 11:26:47,187 INFO    MainThread:212707 [wandb_init.py:setup_run_log_directory():706] Logging user logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_112647-9utis4xx/logs/debug.log
+2025-11-07 11:26:47,187 INFO    MainThread:212707 [wandb_init.py:setup_run_log_directory():707] Logging internal logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_112647-9utis4xx/logs/debug-internal.log
+2025-11-07 11:26:47,189 INFO    MainThread:212707 [wandb_init.py:init():833] calling init triggers
+2025-11-07 11:26:47,189 INFO    MainThread:212707 [wandb_init.py:init():838] wandb.init called with sweep_config: {}
+config: {'exp_name': 'ppo_sokoban', 'seed': 1, 'torch_deterministic': True, 'cuda': True, 'track': True, 'wandb_project_name': 'ragen-sokoban', 'wandb_entity': None, 'capture_video': False, 'env_id': 'Sokoban', 'total_timesteps': 5000000, 'learning_rate': 0.00025, 'num_envs': 8, 'num_steps': 128, 'anneal_lr': True, 'gamma': 0.99, 'gae_lambda': 0.95, 'num_minibatches': 4, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': True, 'ent_coef': 0.01, 'vf_coef': 0.5, 'max_grad_norm': 0.5, 'target_kl': None, 'dim_room': (6, 6), 'num_boxes': 1, 'max_steps': 100, 'search_depth': 100, 'batch_size': 1024, 'minibatch_size': 256, 'num_iterations': 4882, '_wandb': {'code_path': 'code/cleanrl/ppo_sokoban.py'}}
+2025-11-07 11:26:47,189 INFO    MainThread:212707 [wandb_init.py:init():881] starting backend
+2025-11-07 11:26:47,395 INFO    MainThread:212707 [wandb_init.py:init():884] sending inform_init request
+2025-11-07 11:26:47,406 INFO    MainThread:212707 [wandb_init.py:init():892] backend started and connected
+2025-11-07 11:26:47,407 INFO    MainThread:212707 [wandb_init.py:init():962] updated telemetry
+2025-11-07 11:26:47,441 INFO    MainThread:212707 [wandb_init.py:init():986] communicating run to backend with 90.0 second timeout
+2025-11-07 11:26:48,271 INFO    MainThread:212707 [wandb_init.py:init():1033] starting run threads in backend
+2025-11-07 11:26:48,414 INFO    MainThread:212707 [wandb_run.py:_console_start():2506] atexit reg
+2025-11-07 11:26:48,414 INFO    MainThread:212707 [wandb_run.py:_redirect():2354] redirect: wrap_raw
+2025-11-07 11:26:48,415 INFO    MainThread:212707 [wandb_run.py:_redirect():2423] Wrapping output streams.
+2025-11-07 11:26:48,415 INFO    MainThread:212707 [wandb_run.py:_redirect():2446] Redirects installed.
+2025-11-07 11:26:48,417 INFO    MainThread:212707 [wandb_init.py:init():1073] run started, returning control to user process
+2025-11-07 11:26:48,417 INFO    MainThread:212707 [wandb_run.py:_tensorboard_callback():1598] tensorboard callback: runs/Sokoban__ppo_sokoban__1__1762486000, True
+2025-11-07 11:26:48,527 INFO    wandb-AsyncioManager-main:212707 [service_client.py:_forward_responses():80] Reached EOF.
+2025-11-07 11:26:48,527 INFO    wandb-AsyncioManager-main:212707 [mailbox.py:close():137] Closing mailbox, abandoning 2 handles.

cleanrl/cleanrl/wandb/run-20251107_112903-8xop3upl/files/wandb-metadata.json

@@ -0,0 +1,94 @@
+{
+  "os":  "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python":  "CPython 3.12.12",
+  "startedAt":  "2025-11-07T03:29:03.539841Z",
+  "args":  [
+    "--track",
+    "--wandb-project-name",
+    "ragen-bandit"
+  ],
+  "program":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_frozenlake.py",
+  "codePath":  "cleanrl/ppo_frozenlake.py",
+  "codePathLocal":  "ppo_frozenlake.py",
+  "git":  {
+    "remote":  "https://github.com/vwxyzjn/cleanrl.git",
+    "commit":  "004f8a086a892a2a180f4dd332b90d83a968aa7a"
+  },
+  "email":  "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl",
+  "host":  "pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0",
+  "executable":  "/root/local/miniconda3/envs/ragen/bin/python",
+  "cpu_count":  64,
+  "cpu_count_logical":  128,
+  "gpu":  "NVIDIA H100 80GB HBM3",
+  "gpu_count":  8,
+  "disk":  {
+    "/":  {
+      "total":  "5153960755200",
+      "used":  "31673995264"
+    }
+  },
+  "memory":  {
+    "total":  "2163642122240"
+  },
+  "gpu_nvidia":  [
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-35e2d43d-4067-82ce-90d4-def9e389bf28"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-af4135e3-88f2-e9ac-518d-502c75a85429"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-b7cf0ec6-7c29-1179-dceb-09565da51890"
+    }
+  ],
+  "cudaVersion":  "12.4",
+  "writerId":  "27m01iw4c1djia38oq0povle1209kj1y"
+}

cleanrl/cleanrl/wandb/run-20251107_113856-k31oio6c/files/code/cleanrl/ppo_frozenlake.py

@@ -0,0 +1,347 @@
+# PPO implementation for RAGEN FrozenLake environment
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.frozen_lake.env import FrozenLakeEnv
+from ragen.env.frozen_lake.config import FrozenLakeEnvConfig
+from ragen_wrappers import FrozenLakeWrapper
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+
+    # Algorithm specific arguments
+    env_id: str = "FrozenLake"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 2.5e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 8
+    """the number of parallel game environments"""
+    num_steps: int = 128
+    """the number of steps to run in each environment per policy rollout"""
+    anneal_lr: bool = True
+    """Toggle learning rate annealing for policy and value networks"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    norm_adv: bool = True
+    """Toggles advantages normalization"""
+    clip_coef: float = 0.2
+    """the surrogate clipping coefficient"""
+    clip_vloss: bool = True
+    """Toggles whether or not to use a clipped loss for the value function, as per the paper."""
+    ent_coef: float = 0.01
+    """coefficient of the entropy"""
+    vf_coef: float = 0.5
+    """coefficient of the value function"""
+    max_grad_norm: float = 0.5
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+    
+    # FrozenLake specific
+    grid_size: int = 4
+    """size of the frozen lake grid"""
+    is_slippery: bool = True
+    """whether the ice is slippery"""
+
+    # to be filled in runtime
+    batch_size: int = 0
+    """the batch size (computed in runtime)"""
+    minibatch_size: int = 0
+    """the mini-batch size (computed in runtime)"""
+    num_iterations: int = 0
+    """the number of iterations (computed in runtime)"""
+
+
+def make_env(env_id, idx, capture_video, run_name, seed, grid_size, is_slippery):
+    def thunk():
+        config = FrozenLakeEnvConfig(
+            size=grid_size,
+            p=0.8,
+            is_slippery=is_slippery,
+            map_seed=seed + idx
+        )
+        env = FrozenLakeEnv(config)
+        env = FrozenLakeWrapper(env)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    def __init__(self, envs):
+        super().__init__()
+        obs_shape = np.array(envs.single_observation_space.shape).prod()
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, envs.single_action_space.n), std=0.01),
+        )
+
+    def get_value(self, x):
+        return self.critic(x)
+
+    def get_action_and_value(self, x, action=None):
+        logits = self.actor(x)
+        probs = Categorical(logits=logits)
+        if action is None:
+            action = probs.sample()
+        return action, probs.log_prob(action), probs.entropy(), self.critic(x)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    args.num_iterations = args.total_timesteps // args.batch_size
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name, args.seed, args.grid_size, args.is_slippery) 
+         for i in range(args.num_envs)],
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs)).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs, _ = envs.reset(seed=args.seed)
+    next_obs = torch.Tensor(next_obs).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+
+    for iteration in range(1, args.num_iterations + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            lrnow = frac * args.learning_rate
+            optimizer.param_groups[0]["lr"] = lrnow
+
+        for step in range(0, args.num_steps):
+            global_step += args.num_envs
+            obs[step] = next_obs
+            dones[step] = next_done
+
+            # ALGO LOGIC: action logic
+            with torch.no_grad():
+                action, logprob, _, value = agent.get_action_and_value(next_obs)
+                values[step] = value.flatten()
+            actions[step] = action
+            logprobs[step] = logprob
+
+            # TRY NOT TO MODIFY: execute the game and log data.
+            next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+            next_done = np.logical_or(terminations, truncations)
+            rewards[step] = torch.tensor(reward).to(device).view(-1)
+            next_obs, next_done = torch.Tensor(next_obs).to(device), torch.Tensor(next_done).to(device)
+
+            if "final_info" in infos:
+                for info in infos["final_info"]:
+                    if info and "episode" in info:
+                        print(f"global_step={global_step}, episodic_return={info['episode']['r']}")
+                        writer.add_scalar("charts/episodic_return", info["episode"]["r"], global_step)
+                        writer.add_scalar("charts/episodic_length", info["episode"]["l"], global_step)
+
+        # bootstrap value if not done
+        with torch.no_grad():
+            next_value = agent.get_value(next_obs).reshape(1, -1)
+            advantages = torch.zeros_like(rewards).to(device)
+            lastgaelam = 0
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    nextnonterminal = 1.0 - next_done
+                    nextvalues = next_value
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    nextvalues = values[t + 1]
+                delta = rewards[t] + args.gamma * nextvalues * nextnonterminal - values[t]
+                advantages[t] = lastgaelam = delta + args.gamma * args.gae_lambda * nextnonterminal * lastgaelam
+            returns = advantages + values
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_logprobs = logprobs.reshape(-1)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_advantages = advantages.reshape(-1)
+        b_returns = returns.reshape(-1)
+        b_values = values.reshape(-1)
+
+        # Optimizing the policy and value network
+        b_inds = np.arange(args.batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.batch_size, args.minibatch_size):
+                end = start + args.minibatch_size
+                mb_inds = b_inds[start:end]
+
+                _, newlogprob, entropy, newvalue = agent.get_action_and_value(b_obs[mb_inds], b_actions.long()[mb_inds])
+                logratio = newlogprob - b_logprobs[mb_inds]
+                ratio = logratio.exp()
+
+                with torch.no_grad():
+                    # calculate approx_kl http://joschu.net/blog/kl-approx.html
+                    old_approx_kl = (-logratio).mean()
+                    approx_kl = ((ratio - 1) - logratio).mean()
+                    clipfracs += [((ratio - 1.0).abs() > args.clip_coef).float().mean().item()]
+
+                mb_advantages = b_advantages[mb_inds]
+                if args.norm_adv:
+                    mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)
+
+                # Policy loss
+                pg_loss1 = -mb_advantages * ratio
+                pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - args.clip_coef, 1 + args.clip_coef)
+                pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+                # Value loss
+                newvalue = newvalue.view(-1)
+                if args.clip_vloss:
+                    v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2
+                    v_clipped = b_values[mb_inds] + torch.clamp(
+                        newvalue - b_values[mb_inds],
+                        -args.clip_coef,
+                        args.clip_coef,
+                    )
+                    v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2
+                    v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)
+                    v_loss = 0.5 * v_loss_max.mean()
+                else:
+                    v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()
+
+                entropy_loss = entropy.mean()
+                loss = pg_loss - args.ent_coef * entropy_loss + v_loss * args.vf_coef
+
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(agent.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+            if args.target_kl is not None and approx_kl > args.target_kl:
+                break
+
+        y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()
+        var_y = np.var(y_true)
+        explained_var = np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        writer.add_scalar("charts/learning_rate", optimizer.param_groups[0]["lr"], global_step)
+        writer.add_scalar("losses/value_loss", v_loss.item(), global_step)
+        writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step)
+        writer.add_scalar("losses/entropy", entropy_loss.item(), global_step)
+        writer.add_scalar("losses/old_approx_kl", old_approx_kl.item(), global_step)
+        writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step)
+        writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step)
+        writer.add_scalar("losses/explained_variance", explained_var, global_step)
+        
+        # Additional useful metrics
+        writer.add_scalar("charts/avg_reward", rewards.mean().item(), global_step)
+        writer.add_scalar("charts/avg_value", values.mean().item(), global_step)
+        writer.add_scalar("charts/max_reward", rewards.max().item(), global_step)
+        writer.add_scalar("charts/min_reward", rewards.min().item(), global_step)
+        
+        # Console output with key metrics
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        print(f"[{progress:5.1f}%] Iter {iteration:4d}/{args.num_iterations} | "
+              f"SPS: {sps:5d} | "
+              f"Reward: {rewards.mean().item():6.3f} | "
+              f"Value: {values.mean().item():6.3f} | "
+              f"VLoss: {v_loss.item():.4f} | "
+              f"PLoss: {pg_loss.item():.4f} | "
+              f"Ent: {entropy_loss.item():.4f}")
+        writer.add_scalar("charts/SPS", sps, global_step)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/wandb/run-20251107_113856-k31oio6c/files/wandb-metadata.json

@@ -0,0 +1,94 @@
+{
+  "os":  "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python":  "CPython 3.12.12",
+  "startedAt":  "2025-11-07T03:38:56.139668Z",
+  "args":  [
+    "--track",
+    "--wandb-project-name",
+    "ragen-bandit"
+  ],
+  "program":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_frozenlake.py",
+  "codePath":  "cleanrl/ppo_frozenlake.py",
+  "codePathLocal":  "ppo_frozenlake.py",
+  "git":  {
+    "remote":  "https://github.com/vwxyzjn/cleanrl.git",
+    "commit":  "004f8a086a892a2a180f4dd332b90d83a968aa7a"
+  },
+  "email":  "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root":  "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl",
+  "host":  "pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0",
+  "executable":  "/root/local/miniconda3/envs/ragen/bin/python",
+  "cpu_count":  64,
+  "cpu_count_logical":  128,
+  "gpu":  "NVIDIA H100 80GB HBM3",
+  "gpu_count":  8,
+  "disk":  {
+    "/":  {
+      "total":  "5153960755200",
+      "used":  "31684485120"
+    }
+  },
+  "memory":  {
+    "total":  "2163642122240"
+  },
+  "gpu_nvidia":  [
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-35e2d43d-4067-82ce-90d4-def9e389bf28"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-af4135e3-88f2-e9ac-518d-502c75a85429"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1"
+    },
+    {
+      "name":  "NVIDIA H100 80GB HBM3",
+      "memoryTotal":  "85520809984",
+      "cudaCores":  16896,
+      "architecture":  "Hopper",
+      "uuid":  "GPU-b7cf0ec6-7c29-1179-dceb-09565da51890"
+    }
+  ],
+  "cudaVersion":  "12.4",
+  "writerId":  "qcnee8s40otwmmxavjc9wsiwf1cq85oc"
+}

cleanrl/cleanrl/wandb/run-20251107_113856-k31oio6c/logs/debug.log

@@ -0,0 +1,24 @@
+2025-11-07 11:38:56,186 INFO    MainThread:214168 [wandb_setup.py:_flush():81] Current SDK version is 0.22.3
+2025-11-07 11:38:56,186 INFO    MainThread:214168 [wandb_setup.py:_flush():81] Configure stats pid to 214168
+2025-11-07 11:38:56,186 INFO    MainThread:214168 [wandb_setup.py:_flush():81] Loading settings from /root/.config/wandb/settings
+2025-11-07 11:38:56,186 INFO    MainThread:214168 [wandb_setup.py:_flush():81] Loading settings from /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/settings
+2025-11-07 11:38:56,186 INFO    MainThread:214168 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2025-11-07 11:38:56,187 INFO    MainThread:214168 [wandb_init.py:setup_run_log_directory():706] Logging user logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_113856-k31oio6c/logs/debug.log
+2025-11-07 11:38:56,187 INFO    MainThread:214168 [wandb_init.py:setup_run_log_directory():707] Logging internal logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_113856-k31oio6c/logs/debug-internal.log
+2025-11-07 11:38:56,188 INFO    MainThread:214168 [wandb_init.py:init():833] calling init triggers
+2025-11-07 11:38:56,188 INFO    MainThread:214168 [wandb_init.py:init():838] wandb.init called with sweep_config: {}
+config: {'exp_name': 'ppo_frozenlake', 'seed': 1, 'torch_deterministic': True, 'cuda': True, 'track': True, 'wandb_project_name': 'ragen-bandit', 'wandb_entity': None, 'capture_video': False, 'env_id': 'FrozenLake', 'total_timesteps': 10000000, 'learning_rate': 0.00025, 'num_envs': 8, 'num_steps': 128, 'anneal_lr': True, 'gamma': 0.99, 'gae_lambda': 0.95, 'num_minibatches': 4, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': True, 'ent_coef': 0.01, 'vf_coef': 0.5, 'max_grad_norm': 0.5, 'target_kl': None, 'grid_size': 4, 'is_slippery': True, 'batch_size': 1024, 'minibatch_size': 256, 'num_iterations': 9765, '_wandb': {'code_path': 'code/cleanrl/ppo_frozenlake.py'}}
+2025-11-07 11:38:56,188 INFO    MainThread:214168 [wandb_init.py:init():881] starting backend
+2025-11-07 11:38:56,395 INFO    MainThread:214168 [wandb_init.py:init():884] sending inform_init request
+2025-11-07 11:38:56,406 INFO    MainThread:214168 [wandb_init.py:init():892] backend started and connected
+2025-11-07 11:38:56,408 INFO    MainThread:214168 [wandb_init.py:init():962] updated telemetry
+2025-11-07 11:38:56,438 INFO    MainThread:214168 [wandb_init.py:init():986] communicating run to backend with 90.0 second timeout
+2025-11-07 11:38:57,166 INFO    MainThread:214168 [wandb_init.py:init():1033] starting run threads in backend
+2025-11-07 11:38:57,309 INFO    MainThread:214168 [wandb_run.py:_console_start():2506] atexit reg
+2025-11-07 11:38:57,310 INFO    MainThread:214168 [wandb_run.py:_redirect():2354] redirect: wrap_raw
+2025-11-07 11:38:57,310 INFO    MainThread:214168 [wandb_run.py:_redirect():2423] Wrapping output streams.
+2025-11-07 11:38:57,310 INFO    MainThread:214168 [wandb_run.py:_redirect():2446] Redirects installed.
+2025-11-07 11:38:57,312 INFO    MainThread:214168 [wandb_init.py:init():1073] run started, returning control to user process
+2025-11-07 11:38:57,312 INFO    MainThread:214168 [wandb_run.py:_tensorboard_callback():1598] tensorboard callback: runs/FrozenLake__ppo_frozenlake__1__1762486729, True
+2025-11-07 12:38:45,543 INFO    wandb-AsyncioManager-main:214168 [service_client.py:_forward_responses():80] Reached EOF.
+2025-11-07 12:38:45,543 INFO    wandb-AsyncioManager-main:214168 [mailbox.py:close():137] Closing mailbox, abandoning 1 handles.

cleanrl/cleanrl/wandb/run-20251107_125210-py6fnjml/files/code/cleanrl/dqn_bandit.py

@@ -0,0 +1,274 @@
+# DQN implementation for RAGEN Bandit Environment
+# Adapted from dqn_atari.py for single-step bandit problem
+import os
+import random
+import sys
+import time
+from dataclasses import dataclass
+
+# Add parent directory to path to import the wrapper
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import tyro
+from torch.utils.tensorboard import SummaryWriter
+
+from ragen.env.bandit.env import BanditEnv
+from ragen.env.bandit.config import BanditEnvConfig
+from ragen_wrappers import BanditWrapper
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    torch_deterministic: bool = True
+    """if toggled, `torch.backends.cudnn.deterministic=False`"""
+    cuda: bool = True
+    """if toggled, cuda will be enabled by default"""
+    track: bool = False
+    """if toggled, this experiment will be tracked with Weights and Biases"""
+    wandb_project_name: str = "cleanRL"
+    """the wandb's project name"""
+    wandb_entity: str = None
+    """the entity (team) of wandb's project"""
+    capture_video: bool = False
+    """whether to capture videos of the agent performances (check out `videos` folder)"""
+    save_model: bool = False
+    """whether to save model into the `runs/{run_name}` folder"""
+
+    # Algorithm specific arguments
+    env_id: str = "Bandit"
+    """the id of the environment"""
+    total_timesteps: int = 100000
+    """total timesteps of the experiments"""
+    learning_rate: float = 1e-3
+    """the learning rate of the optimizer"""
+    num_envs: int = 1
+    """the number of parallel game environments (DQN typically uses 1)"""
+    buffer_size: int = 10000
+    """the replay memory buffer size"""
+    gamma: float = 0.0
+    """the discount factor gamma (0 for bandit since it's single-step)"""
+    tau: float = 1.0
+    """the target network update rate"""
+    target_network_frequency: int = 500
+    """the timesteps it takes to update the target network"""
+    batch_size: int = 32
+    """the batch size of sample from the reply memory"""
+    start_e: float = 1.0
+    """the starting epsilon for exploration"""
+    end_e: float = 0.05
+    """the ending epsilon for exploration"""
+    exploration_fraction: float = 0.5
+    """the fraction of `total-timesteps` it takes from start-e to go end-e"""
+    learning_starts: int = 1000
+    """timestep to start learning"""
+    train_frequency: int = 1
+    """the frequency of training"""
+    steps_per_episode: int = 10
+    """number of steps per episode for multi-step bandit"""
+
+
+def make_env(env_id, idx, capture_video, run_name, seed, steps_per_episode):
+    def thunk():
+        config = BanditEnvConfig()
+        env = BanditEnv(config)
+        env = BanditWrapper(env, steps_per_episode=steps_per_episode)
+        env = gym.wrappers.RecordEpisodeStatistics(env)
+        if capture_video and idx == 0:
+            env = gym.wrappers.RecordVideo(env, f"videos/{run_name}")
+        return env
+    return thunk
+
+
+# ALGO LOGIC: initialize agent here:
+class QNetwork(nn.Module):
+    """
+    Q-Network for Bandit environment.
+    Input: [arm0_pulls, arm0_avg_reward, arm1_pulls, arm1_avg_reward]
+    Output: Q-values for each arm
+    """
+    def __init__(self, env):
+        super().__init__()
+        obs_shape = np.array(env.single_observation_space.shape).prod()
+        self.network = nn.Sequential(
+            nn.Linear(obs_shape, 128),
+            nn.ReLU(),
+            nn.Linear(128, 128),
+            nn.ReLU(),
+            nn.Linear(128, env.single_action_space.n),
+        )
+
+    def forward(self, x):
+        return self.network(x)
+
+
+def linear_schedule(start_e: float, end_e: float, duration: int, t: int):
+    slope = (end_e - start_e) / duration
+    return max(slope * t + start_e, end_e)
+
+
+if __name__ == "__main__":
+    args = tyro.cli(Args)
+    assert args.num_envs == 1, "vectorized envs are not supported at the moment"
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    
+    if args.track:
+        import wandb
+
+        wandb.init(
+            project=args.wandb_project_name,
+            entity=args.wandb_entity,
+            sync_tensorboard=True,
+            config=vars(args),
+            name=run_name,
+            monitor_gym=True,
+            save_code=True,
+        )
+    writer = SummaryWriter(f"runs/{run_name}")
+    writer.add_text(
+        "hyperparameters",
+        "|param|value|\n|-|-|\n%s" % ("\n".join([f"|{key}|{value}|" for key, value in vars(args).items()])),
+    )
+
+    # TRY NOT TO MODIFY: seeding
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, i, args.capture_video, run_name, args.seed + i, args.steps_per_episode) 
+         for i in range(args.num_envs)]
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    q_network = QNetwork(envs).to(device)
+    optimizer = optim.Adam(q_network.parameters(), lr=args.learning_rate)
+    target_network = QNetwork(envs).to(device)
+    target_network.load_state_dict(q_network.state_dict())
+
+    # Use simple replay buffer (no special memory optimization needed for bandit)
+    from cleanrl_utils.buffers import ReplayBuffer
+    rb = ReplayBuffer(
+        args.buffer_size,
+        envs.single_observation_space,
+        envs.single_action_space,
+        device,
+        optimize_memory_usage=False,
+        handle_timeout_termination=False,
+    )
+    
+    start_time = time.time()
+    
+    # Track episode returns
+    episode_returns = []
+    recent_episode_returns = []
+
+    # TRY NOT TO MODIFY: start the game
+    obs, _ = envs.reset(seed=args.seed)
+    for global_step in range(args.total_timesteps):
+        # ALGO LOGIC: put action logic here
+        epsilon = linear_schedule(args.start_e, args.end_e, args.exploration_fraction * args.total_timesteps, global_step)
+        if random.random() < epsilon:
+            actions = np.array([envs.single_action_space.sample() for _ in range(envs.num_envs)])
+        else:
+            q_values = q_network(torch.Tensor(obs).to(device))
+            actions = torch.argmax(q_values, dim=1).cpu().numpy()
+
+        # TRY NOT TO MODIFY: execute the game and log data.
+        next_obs, rewards, terminations, truncations, infos = envs.step(actions)
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        if "final_info" in infos:
+            for info in infos["final_info"]:
+                if info and "episode" in info:
+                    episode_return = info['episode']['r']
+                    episode_length = info['episode']['l']
+                    episode_returns.append(episode_return)
+                    recent_episode_returns.append(episode_return)
+                    if len(recent_episode_returns) > 10:
+                        recent_episode_returns.pop(0)
+                    writer.add_scalar("charts/episodic_return", episode_return, global_step)
+                    writer.add_scalar("charts/episodic_length", episode_length, global_step)
+
+        # TRY NOT TO MODIFY: save data to reply buffer; handle `final_observation`
+        real_next_obs = next_obs.copy()
+        for idx, trunc in enumerate(truncations):
+            if trunc:
+                real_next_obs[idx] = infos["final_observation"][idx]
+        rb.add(obs, real_next_obs, actions, rewards, terminations, infos)
+
+        # TRY NOT TO MODIFY: CRUCIAL step easy to overlook
+        obs = next_obs
+
+        # ALGO LOGIC: training.
+        if global_step > args.learning_starts:
+            if global_step % args.train_frequency == 0:
+                data = rb.sample(args.batch_size)
+                with torch.no_grad():
+                    target_max, _ = target_network(data.next_observations).max(dim=1)
+                    td_target = data.rewards.flatten() + args.gamma * target_max * (1 - data.dones.flatten())
+                old_val = q_network(data.observations).gather(1, data.actions).squeeze()
+                loss = F.mse_loss(td_target, old_val)
+
+                if global_step % 100 == 0:
+                    writer.add_scalar("losses/td_loss", loss, global_step)
+                    writer.add_scalar("losses/q_values", old_val.mean().item(), global_step)
+                    writer.add_scalar("charts/epsilon", epsilon, global_step)
+                    
+                    # Console output with key metrics
+                    sps = int(global_step / (time.time() - start_time))
+                    progress = 100 * global_step / args.total_timesteps
+                    avg_episode_return = np.mean(recent_episode_returns) if recent_episode_returns else 0.0
+                    
+                    print(f"[{progress:5.1f}%] Step {global_step:6d}/{args.total_timesteps} | "
+                          f"SPS: {sps:5d} | "
+                          f"EpRet: {avg_episode_return:7.3f} | "
+                          f"Loss: {loss.item():.4f} | "
+                          f"Q-val: {old_val.mean().item():.4f} | "
+                          f"Eps: {epsilon:.3f}")
+                    
+                    writer.add_scalar("charts/SPS", sps, global_step)
+                    if recent_episode_returns:
+                        writer.add_scalar("charts/avg_episodic_return", avg_episode_return, global_step)
+
+                # optimize the model
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+
+            # update target network
+            if global_step % args.target_network_frequency == 0:
+                for target_network_param, q_network_param in zip(target_network.parameters(), q_network.parameters()):
+                    target_network_param.data.copy_(
+                        args.tau * q_network_param.data + (1.0 - args.tau) * target_network_param.data
+                    )
+
+    if args.save_model:
+        model_path = f"runs/{run_name}/{args.exp_name}.cleanrl_model"
+        torch.save(q_network.state_dict(), model_path)
+        print(f"model saved to {model_path}")
+
+    envs.close()
+    writer.close()
+    
+    print("\n" + "="*60)
+    print("Training Complete!")
+    print("="*60)
+    if episode_returns:
+        print(f"Final Average Episode Return (last 10): {np.mean(recent_episode_returns):.3f}")
+        print(f"Overall Average Episode Return: {np.mean(episode_returns):.3f}")
+        print(f"Best Episode Return: {max(episode_returns):.3f}")
+    print("="*60)

cleanrl/cleanrl/wandb/run-20251107_125210-py6fnjml/files/config.yaml

@@ -0,0 +1,145 @@
+_wandb:
+    value:
+        cli_version: 0.22.3
+        code_path: code/cleanrl/dqn_bandit.py
+        e:
+            tkb6lq3xdk95jdrk8itil4tq7t5n4mli:
+                args:
+                    - --track
+                    - --wandb-project-name
+                    - ragen-bandit
+                codePath: cleanrl/dqn_bandit.py
+                codePathLocal: dqn_bandit.py
+                cpu_count: 64
+                cpu_count_logical: 128
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "5153960755200"
+                        used: "31715360768"
+                email: haoyu-wa22@mails.tsinghua.edu.cn
+                executable: /root/local/miniconda3/envs/ragen/bin/python
+                git:
+                    commit: 004f8a086a892a2a180f4dd332b90d83a968aa7a
+                    remote: https://github.com/vwxyzjn/cleanrl.git
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-35e2d43d-4067-82ce-90d4-def9e389bf28
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-af4135e3-88f2-e9ac-518d-502c75a85429
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-d7fdeeba-fe9b-ec03-d9f7-6724fe4266b5
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-ccc4f668-3882-5a8e-2c07-c5cd08f6f666
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-7b73c0cf-d3d5-e10c-7176-a43be1e41001
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-81b58d94-5d1f-8ec2-f9d2-fd56172ed177
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-03e8bc66-3b44-6794-49fd-5392fbdda6d1
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b7cf0ec6-7c29-1179-dceb-09565da51890
+                host: pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0
+                memory:
+                    total: "2163642122240"
+                os: Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35
+                program: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/dqn_bandit.py
+                python: CPython 3.12.12
+                root: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl
+                startedAt: "2025-11-07T04:52:10.930319Z"
+                writerId: tkb6lq3xdk95jdrk8itil4tq7t5n4mli
+        m: []
+        python_version: 3.12.12
+        t:
+            "1":
+                - 1
+                - 49
+                - 51
+                - 105
+            "2":
+                - 1
+                - 49
+                - 51
+                - 105
+            "3":
+                - 13
+                - 16
+                - 35
+            "4": 3.12.12
+            "5": 0.22.3
+            "12": 0.22.3
+            "13": linux-x86_64
+batch_size:
+    value: 32
+buffer_size:
+    value: 10000
+capture_video:
+    value: false
+cuda:
+    value: true
+end_e:
+    value: 0.05
+env_id:
+    value: Bandit
+exp_name:
+    value: dqn_bandit
+exploration_fraction:
+    value: 0.5
+gamma:
+    value: 0
+learning_rate:
+    value: 0.001
+learning_starts:
+    value: 1000
+num_envs:
+    value: 1
+save_model:
+    value: false
+seed:
+    value: 1
+start_e:
+    value: 1
+steps_per_episode:
+    value: 10
+target_network_frequency:
+    value: 500
+tau:
+    value: 1
+torch_deterministic:
+    value: true
+total_timesteps:
+    value: 100000
+track:
+    value: true
+train_frequency:
+    value: 1
+wandb_entity:
+    value: null
+wandb_project_name:
+    value: ragen-bandit