Add files using upload-large-folder tool

.gitattributes

@@ -697,3 +697,17 @@ wandb/run-20260326_215306-tlib8xqc/run-tlib8xqc.wandb filter=lfs diff=lfs merge=
 wandb/run-20260326_225030-whxg2wea/run-whxg2wea.wandb filter=lfs diff=lfs merge=lfs -text
 wandb/run-20260327_090328-71iezltg/run-71iezltg.wandb filter=lfs diff=lfs merge=lfs -text
 wandb/run-20260327_093603-1fkf5bo1/run-1fkf5bo1.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260513_141834-qumom4e1/run-qumom4e1.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260513_143037-5nbglqlm/run-5nbglqlm.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260515_161238-gu8o8dz5/run-gu8o8dz5.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260515_162634-oma8h4e9/run-oma8h4e9.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260602_163908-h5c4lnf8/run-h5c4lnf8.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260602_211333-zvukmwu2/run-zvukmwu2.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260603_105223-opxt7tw0/run-opxt7tw0.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260605_101802-qcsqassg/run-qcsqassg.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260605_111512-v5vrcyea/run-v5vrcyea.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260605_115215-djwhmaa2/run-djwhmaa2.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260605_144602-tk4fb9fa/run-tk4fb9fa.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260607_140550-p3p2165s/run-p3p2165s.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260607_161952-vml1gpcz/run-vml1gpcz.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/run-20260608_142648-jhnr4zhm/run-jhnr4zhm.wandb filter=lfs diff=lfs merge=lfs -text

wandb/run-20260513_141834-qumom4e1/files/code/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 = 4
+    eval_episodes: int = 4000
+
+    # 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()

wandb/run-20260513_141834-qumom4e1/files/config.yaml

@@ -0,0 +1,193 @@
+_wandb:
+    value:
+        cli_version: 0.25.1
+        code_path: code/cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py
+        e:
+            swzgj3glyzjumc8fct6a24j895q3ndhx:
+                codePath: cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py
+                codePathLocal: cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py
+                cpu_count: 64
+                cpu_count_logical: 128
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "60129542144000"
+                        used: "67061088256"
+                email: haoyu-wa22@mails.tsinghua.edu.cn
+                executable: /opt/conda/envs/ragen_new/bin/python
+                git:
+                    commit: b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0
+                    remote: https://github.com/Harry-mic/SCOUT
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-97b3b912-40cf-f573-ffce-8275a656891f
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-5e4acc7a-f7ab-1a15-312e-4e2a39c43b2c
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b36695ed-370a-2556-79d8-b0a2c2659271
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b3e13ca7-237c-931f-894b-798f9cfa5620
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-64647b1f-5d55-1b7e-bf3d-64fae3871140
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-fe8b9b7e-82a4-1238-4843-bbfd0269d746
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-4523d4e1-5745-8224-7bcd-44cf59b76bae
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-9262bcbd-a29f-d761-3330-ac2ce9f15e82
+                host: pt-a7f17fedde804edca572f81ace5fcaf3-worker-0
+                memory:
+                    total: "2159579672576"
+                os: Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35
+                program: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py
+                python: CPython 3.10.20
+                root: /mnt/general/wanghy/RAGEN
+                startedAt: "2026-05-13T06:18:34.898817Z"
+                writerId: swzgj3glyzjumc8fct6a24j895q3ndhx
+        m:
+            - "1": global_step
+              "6":
+                - 3
+              "7": []
+            - "2": eval/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": losses/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": charts/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": perf/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": train/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": rollout/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+        python_version: 3.10.20
+        t:
+            "1":
+                - 1
+                - 11
+                - 30
+                - 49
+                - 50
+                - 51
+                - 105
+            "2":
+                - 1
+                - 11
+                - 30
+                - 49
+                - 50
+                - 51
+                - 105
+            "3":
+                - 7
+                - 13
+                - 16
+                - 61
+            "4": 3.10.20
+            "5": 0.25.1
+            "6": 4.51.1
+            "12": 0.25.1
+            "13": linux-x86_64
+batch_size:
+    value: 128
+buffer_size:
+    value: 200000
+capture_video:
+    value: false
+cuda:
+    value: true
+dueling:
+    value: true
+end_e:
+    value: 0.1
+env_id:
+    value: SokobanNoisyDQN
+eval_episodes:
+    value: 4000
+eval_splits:
+    value: 4
+exp_name:
+    value: noisy_dqn_sokoban
+exploration_fraction:
+    value: 0.8
+gamma:
+    value: 0.99
+grid_h:
+    value: 6
+grid_w:
+    value: 6
+learning_rate:
+    value: 0.00025
+learning_starts:
+    value: 20000
+max_steps_env:
+    value: 100
+num_boxes:
+    value: 2
+reward_clip_abs:
+    value: 1
+search_depth:
+    value: 300
+seed:
+    value: 1
+start_e:
+    value: 1
+target_network_frequency:
+    value: 8000
+torch_deterministic:
+    value: true
+total_timesteps:
+    value: 1000000
+track:
+    value: true
+train_frequency:
+    value: 4
+wandb_entity:
+    value: null
+wandb_project_name:
+    value: cleanRL

wandb/run-20260513_141834-qumom4e1/files/diff.patch

@@ -0,0 +1,536 @@
+diff --git a/config/_10_rubikscube.yaml b/config/_10_rubikscube.yaml
+index 277a8b1..a99b6a8 100644
+--- a/config/_10_rubikscube.yaml
++++ b/config/_10_rubikscube.yaml
+@@ -5,7 +5,7 @@ system:
+   CUDA_VISIBLE_DEVICES: "0,1,2,3"
+ 
+ trainer:
+-  experiment_name: 2048
++  experiment_name: rubikscube
+   n_gpus_per_node: 4
+ 
+ actor_rollout_ref:
+diff --git a/config/base.yaml b/config/base.yaml
+index 6029703..c10ab55 100644
+--- a/config/base.yaml
++++ b/config/base.yaml
+@@ -10,8 +10,8 @@ seed:
+   val: 123
+ 
+ micro_batch_size_per_gpu: 1
+-ppo_mini_batch_size: 32
+-model_path: 
++ppo_mini_batch_size: 16 #****
++model_path: /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ # /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ enable_response_mask: True # Enabling response mask could improve stability of rollout/old_log_prob, as P(st|history) are no longer calculated in loss here. See https://docs.google.com/document/d/1bg7obeiKTExuHHBl5uOiSpec5uLDZ2Tgvxy6li5pHX4/edit?usp=sharing for more details.
+ grpo_advantage_length_weight: False # if you do not enable this and critic/advantage_estimator is GRPO, and the critic/advantages/mean is too low, then you can try enabling this to encourage reasoning and forbid collapse
+@@ -48,11 +48,11 @@ actor_rollout_ref:
+     name: vllm
+     log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu} # following micro_batch_size_per_gpu
+     tensor_model_parallel_size: 1
+-    max_model_len: 16384 #3600 why** 14400
++    max_model_len: 16384 #3600 why** 14400 
+     prompt_length: 1 # useless. Just put it here
+-    response_length: 400 # single-turn response length
+-    gpu_memory_utilization: 0.7
+-    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true
++    response_length: 128 # single-turn response length 400 ****
++    gpu_memory_utilization: 0.6
++    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true 
+     temperature: 1
+     rollout_filter_ratio: 0.25
+     rollout_filter_type: largest # smallest or largest
+@@ -111,7 +111,7 @@ trainer:
+ 
+ agent_proxy:
+   max_context_window: -1 # set a value > 0 to enable context window for long trajectory
+-  max_turn: 25 #25 why** 700
++  max_turn: 15 #25 why** 700
+   action_sep: "||"
+   max_actions_per_turn: 1 # how many actions can be output at most in a single turn
+   use_turn_scores: False # important to GAE when applying token-level rewards to token-level advantages. If False, will take the sum of scores as the reward for the last turn.
+@@ -123,7 +123,7 @@ agent_proxy:
+ es_manager:
+   format_penalty: -0.1
+   train:
+-    env_groups: 8
++    env_groups: 8 
+     # under the same group, the env config and env seed are ensured to be equal
+     group_size: 16
+     env_configs:
+diff --git a/config/envs.yaml b/config/envs.yaml
+index d258d15..d7d687d 100644
+--- a/config/envs.yaml
++++ b/config/envs.yaml
+@@ -231,7 +231,7 @@ custom_envs:
+       Example: <answer>U</answer>
+     max_tokens: 96
+     env_config:
+-      scramble_depth: 3
++      scramble_depth: 5
+       max_steps: 20
+       render_mode: "text"
+   
+diff --git a/config/eval.yaml b/config/eval.yaml
+index 0802a0d..98d71dd 100644
+--- a/config/eval.yaml
++++ b/config/eval.yaml
+@@ -8,7 +8,7 @@ seed:
+   train: 10000
+   val: 123
+ 
+-model_path: /mnt/general/wanghy/RAGEN/saves/qwen3b_it_fromit_think_sudoku_sequence_multitask/global_step_200/qwen2.5_3b_actor_hf
++model_path: /mnt/general/wanghy/RAGEN/saves/qwen3B_it_think_rubikscube2_frommlpsave/global_step_50/qwen2.5_7B_actor_hf
+ # /mnt/general/share/model/tyzhu/SPA-frozenlake-qwen2.5-1.5b-instruct
+ 
+ lora:
+diff --git a/config/evaluate_api_llm.yaml b/config/evaluate_api_llm.yaml
+index bcbf206..9fe6f71 100644
+--- a/config/evaluate_api_llm.yaml
++++ b/config/evaluate_api_llm.yaml
+@@ -5,7 +5,7 @@ defaults:
+   - base # this is a symbolic link to the verl/verl/trainer/config/ppo_trainer.yaml file
+ 
+ model_config:
+-  model_name: TA/openai/gpt-oss-120b # should be registered in model_info
++  model_name: ark-deepseek-v3-250324 # should be registered in model_info
+   max_concurrency: 16
+ 
+ model_info:
+@@ -39,27 +39,21 @@ model_info:
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  ark-deepseek-v3-250324:
+-    provider_name: openai
+-    model_name: ark-deepseek-v3-250324
+-    generation_kwargs:
+-      temperature: 0
+-      max_completion_tokens: 512
+   deepseek-v3:
+     provider_name: deepseek
+     model_name: deepseek-chat
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  glm-4.6:
++  ark-deepseek-v3-250324:
+     provider_name: openai
+-    model_name: glm-4.6
++    model_name: ark-deepseek-v3-250324
+     generation_kwargs:
+       temperature: 0
+-      max_completion_tokens: 512
+-  TA/openai/gpt-oss-120b:
++      max_tokens: 8192
++  gemini-2.5-pro:
+     provider_name: openai
+-    model_name: TA/openai/gpt-oss-120b
++    model_name: gemini-2.5-pro
+     generation_kwargs:
+       temperature: 0
+       max_tokens: 8192
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+deleted file mode 120000
+index e1061c0..0000000
+--- a/config/ppo_trainer.yaml
++++ /dev/null
+@@ -1 +0,0 @@
+-../verl/verl/trainer/config/ppo_trainer.yaml
+
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+new file mode 100644
+index 0000000..c821483
+--- /dev/null
++++ b/config/ppo_trainer.yaml
+@@ -0,0 +1,308 @@
++# Format checks enforced on CI:
++# 1. Comments must appear above each field.
++# 2. There must be a blank line between each field.
++# 3. Inline comments (after a field on the same line) are not allowed.
++# 4. Indentation level is respected for nested fields.
++
++# specify the default per-component configs
++defaults:
++
++  # <folder_name>@<field_name>.<field_name>: <yaml_file_name>
++  # actor_rollout_ref.actor: trainer/config/actor/dp_actor.yaml
++  - actor@actor_rollout_ref.actor: dp_actor
++
++  # data: trainer/config/data/legacy_data.yaml
++  - data@data: legacy_data
++
++  # Reference model config.
++  # Reference model will be enabled when actor.use_kl_loss or/and algorithm.use_kl_in_reward is/are True.
++  - ref@actor_rollout_ref.ref: dp_ref
++
++  # Rollout model config.
++  - rollout@actor_rollout_ref.rollout: rollout
++
++  # Model config.
++  - model@actor_rollout_ref.model: hf_model
++
++  # Critic model config.
++  - critic@critic: dp_critic
++
++  # Reward model config.
++  - reward_model@reward_model: dp_reward_model
++
++  # load the reference default config, then apply the fields in the current yaml
++  # self config override anything above
++  - _self_
++
++# config for actor, rollout and reference model
++actor_rollout_ref:
++
++  # Whether it's a hybrid engine, currently only supports hybrid engine
++  hybrid_engine: true
++
++  # Timeout for operations executed against the process group
++  nccl_timeout: 600
++
++  # Rollout model config.
++  rollout:
++
++    # for huge model, layered summon can save memory (prevent OOM) but make it slower
++    layered_summon: False
++
++# custom reward function definition
++custom_reward_function:
++
++  # The path to the file containing your customized reward function.
++  # If not specified, pre-implemented reward functions will be used.
++  path: null
++
++  # The name of the reward function within the specified file. Default is 'compute_score'.
++  name: compute_score
++
++# config for the algorithm
++algorithm:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.trainer.config.AlgoConfig
++
++  # Discount factor for future rewards
++  gamma: 1.0
++
++  # Trade-off between bias and variance in the GAE estimator
++  lam: 1.0
++
++  # Advantage estimator type: "gae", "grpo", "reinforce_plus_plus", etc.
++  adv_estimator: gae
++
++  # Whether to normalize advantages by std (specific to GRPO)
++  norm_adv_by_std_in_grpo: True
++
++  # Whether to enable in-reward KL penalty
++  use_kl_in_reward: False
++
++  # How to estimate KL divergence: "kl", "abs", "mse", "low_var_kl", or "full"
++  kl_penalty: kl
++
++  # KL control configuration
++  kl_ctrl:
++
++    # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++    _target_: verl.trainer.config.KLControlConfig
++
++    # KL control type: "fixed" or "adaptive"
++    type: fixed
++
++    # Initial coefficient for KL penalty
++    kl_coef: 0.001
++
++    # Horizon value for adaptive controller (if enabled)
++    horizon: 10000
++
++    # Target KL divergence (used for adaptive controller)
++    target_kl: 0.1
++
++  # Whether to enable preference feedback PPO
++  use_pf_ppo: False
++
++  # Preference feedback PPO settings
++  pf_ppo:
++
++    # Method for reweighting samples: "pow", "max_min", or "max_random"
++    reweight_method: pow
++
++    # Power used for weight scaling in "pow" method
++    weight_pow: 2.0
++
++# config for the trainer
++trainer:
++
++  # Whether to balance batch sizes across distributed workers
++  balance_batch: True
++
++  # Number of epochs in training
++  total_epochs: 30
++
++  # Total training steps (can be set explicitly or derived from epochs)
++  total_training_steps: null
++
++  # Project name for experiment tracking (e.g., wandb)
++  project_name: verl_examples
++
++  # Experiment name for run identification in tracking tools
++  experiment_name: gsm8k
++
++  # Logging backends to use: "console", "wandb", etc.
++  logger: ["console", "wandb"]
++
++  # Number of generations to log during validation
++  log_val_generations: 0
++
++  # Directory for logging rollout data; no dump if null
++  rollout_data_dir: null
++
++  # Directory for logging validation data; no dump if null
++  validation_data_dir: null
++
++  # Number of nodes used in the training
++  nnodes: 1
++
++  # Number of GPUs per node
++  n_gpus_per_node: 8
++
++  # Save frequency (by iteration) for model checkpoints
++  save_freq: -1
++
++  # ESI refers to the elastic server instance used during training, similar to the training plan. For example,
++  # if you purchase 10 hours of computing power, the ESI will automatically shut down after 10 hours of training.
++  # To ensure a checkpoint is saved before ESI shuts down, the system will start saving a checkpoint in advance.
++  # The advance time is calculated as: Advance Time = Longest historical step duration + Checkpoint save duration + esi_redundant_time.
++  # Here, esi_redundant_time is a user-defined value that further extends the advance time for added safety.
++  esi_redundant_time: 0
++
++  # Resume mode: "auto", "disable", or "resume_path"
++  # "auto": resume from last checkpoint if available
++  # "disable": start from scratch
++  # "resume_path": resume from a user-defined path
++  resume_mode: auto
++
++  # Path to resume training from (only used when resume_mode is "resume_path")
++  resume_from_path: null
++
++  # Whether to run validation before training begins
++  val_before_train: True
++
++  # Whether to run validation only
++  val_only: False
++
++  # Validation frequency (in training iterations)
++  test_freq: -1
++
++  # Number of iterations to warm up the critic before updating policy
++  critic_warmup: 0
++
++  # Default path to distributed filesystem for saving checkpoints
++  default_hdfs_dir: null
++
++  # Whether to delete local checkpoints after loading
++  del_local_ckpt_after_load: False
++
++  # Default local directory for saving checkpoints
++  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
++
++  # Maximum number of actor checkpoints to keep
++  max_actor_ckpt_to_keep: null
++
++  # Maximum number of critic checkpoints to keep
++  max_critic_ckpt_to_keep: null
++
++  # Timeout (in seconds) for Ray worker to wait for registration
++  ray_wait_register_center_timeout: 300
++
++  # Device to run training on (e.g., "cuda", "cpu")
++  device: cuda
++
++  # whether to use legacy worker implementation
++  #  mode: "auto", "enable", or "disable"
++  use_legacy_worker_impl: auto
++
++# profiler configs
++global_profiler:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.utils.profiler.ProfilerConfig
++
++  # Profiling tool: choose between nsys, npu, torch, torch_memory
++  tool: null
++
++  # profile steps
++  steps: null
++
++  # Whether to combine continuous steps into one database.
++  ## If True, worker.profiler.discrete must be False, [1,2] in one, [5] in another.
++  ## If False, [1] in one, [2] in another, [5] in another.
++  profile_continuous_steps: False
++
++  # Path to save profiling contents
++  save_path: "outputs/profile"
++
++  # Specific tool configs, can use +profiler.tool_config.[tool].xxx to config
++  global_tool_config:
++
++    # nsys config
++    nsys:
++
++      # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++      _target_: verl.utils.profiler.config.NsightToolConfig
++
++      # True for each task has its own database, False for all tasks in one training step share one database.
++      discrete: False
++
++      # controller Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      ## reference https://docs.nvidia.com/nsight-systems/UserGuide/index.html
++      ## reference https://docs.ray.io/en/latest/ray-observability/user-guides/profiling.html
++      controller_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++      # worker Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      worker_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++        # Profiling only in a range of torch.cuda.profiler.start and stop. Do not change this config.
++        capture-range: "cudaProfilerApi"
++
++        # Specify the desired behavior when a capture range ends.
++        # In verl we need the torch.cuda.profiler.start/stop pair to repeats n times.
++        # valid values are "repeat-shutdown:n" or null.
++        # For normal whole step profiling, n = len(profile_steps);
++        # but for discrete profiling, n = len(profile_steps) * Number(subtasks).
++        # Or you can just leave it null and the program will use n = len(profile_steps) * 6;
++        capture-range-end: null
++
++        # Send signal to the target application's process group. We let the program to exit by itself.
++        kill: none
++
++    # enable memory visualization for debugging memory usage
++    torch_memory:
++
++      #  Maximum number of allocation entries to record
++      trace_alloc_max_entries: 100_000
++
++      # The depth of the call stack to capture for each allocation
++      stack_depth: 32
++
++      # 'alloc': records only allocation events || 'state': records memory state changes || 'all': records both.
++      context: "all"
++
++      # 'python': records Python stacks || 'cpp': records C++ stacks (available in some versions) || 'all': records both.
++      stacks: "all"
++
++      # devices, record_context etc.
++      kw_args: {}
++
++# configs related to ray
++ray_kwargs:
++
++  # configs related to ray initialization
++  ray_init:
++
++    # Number of CPUs for Ray. Use a fixed number instead of null when using SLURM.
++    num_cpus: null
++
++  # Path to save Ray timeline JSON for performance profiling
++  timeline_json_file: null
+Submodule external/kimina-lean-server contains modified content
+diff --git a/external/kimina-lean-server/setup.sh b/external/kimina-lean-server/setup.sh
+old mode 100755
+new mode 100644
+Submodule external/webshop-minimal contains modified content
+diff --git a/external/webshop-minimal/requirements.txt b/external/webshop-minimal/requirements.txt
+index 5a1b04f..238ed5a 100644
+--- a/external/webshop-minimal/requirements.txt
++++ b/external/webshop-minimal/requirements.txt
+@@ -4,7 +4,7 @@ flask
+ html2text
+ rank_bm25
+ pyserini
+-faiss-cpu
++faiss-gpu
+ thefuzz
+ gdown
+ spacy
+diff --git a/ragen/env/frozen_lake/config.py b/ragen/env/frozen_lake/config.py
+index 9950c34..de054f4 100644
+--- a/ragen/env/frozen_lake/config.py
++++ b/ragen/env/frozen_lake/config.py
+@@ -8,7 +8,7 @@ class FrozenLakeEnvConfig:
+     size: int = 4
+     p: float = 0.9
+     success_rate: float = 0.8
+-    is_slippery: bool = False
++    is_slippery: bool = True
+     map_seed: Optional[int] = None
+     render_mode: str = "text"
+     observation_format: str = "grid"
+diff --git a/scripts/runs/bandit_jobs.sh b/scripts/runs/bandit_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/frozenlake_jobs.sh b/scripts/runs/frozenlake_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/sokoban_jobs.sh b/scripts/runs/sokoban_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/webshop_jobs.sh b/scripts/runs/webshop_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/train_all.sh b/train_all.sh
+old mode 100755
+new mode 100644
+Submodule verl contains modified content
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh b/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh b/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/recipe/sppo/run_qwen2.5-7b_rm.sh b/verl/recipe/sppo/run_qwen2.5-7b_rm.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/generate_trainer_config.sh b/verl/scripts/generate_trainer_config.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/install_vllm_sglang_mcore.sh b/verl/scripts/install_vllm_sglang_mcore.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/generation/run_gen_qwen05.sh b/verl/tests/special_e2e/generation/run_gen_qwen05.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/run_one_step_off_policy.sh b/verl/tests/special_e2e/run_one_step_off_policy.sh
+old mode 100755
+new mode 100644

wandb/run-20260513_141834-qumom4e1/files/diff_b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0.patch

@@ -0,0 +1,536 @@
+diff --git a/config/_10_rubikscube.yaml b/config/_10_rubikscube.yaml
+index 277a8b1..a99b6a8 100644
+--- a/config/_10_rubikscube.yaml
++++ b/config/_10_rubikscube.yaml
+@@ -5,7 +5,7 @@ system:
+   CUDA_VISIBLE_DEVICES: "0,1,2,3"
+ 
+ trainer:
+-  experiment_name: 2048
++  experiment_name: rubikscube
+   n_gpus_per_node: 4
+ 
+ actor_rollout_ref:
+diff --git a/config/base.yaml b/config/base.yaml
+index 6029703..c10ab55 100644
+--- a/config/base.yaml
++++ b/config/base.yaml
+@@ -10,8 +10,8 @@ seed:
+   val: 123
+ 
+ micro_batch_size_per_gpu: 1
+-ppo_mini_batch_size: 32
+-model_path: 
++ppo_mini_batch_size: 16 #****
++model_path: /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ # /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ enable_response_mask: True # Enabling response mask could improve stability of rollout/old_log_prob, as P(st|history) are no longer calculated in loss here. See https://docs.google.com/document/d/1bg7obeiKTExuHHBl5uOiSpec5uLDZ2Tgvxy6li5pHX4/edit?usp=sharing for more details.
+ grpo_advantage_length_weight: False # if you do not enable this and critic/advantage_estimator is GRPO, and the critic/advantages/mean is too low, then you can try enabling this to encourage reasoning and forbid collapse
+@@ -48,11 +48,11 @@ actor_rollout_ref:
+     name: vllm
+     log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu} # following micro_batch_size_per_gpu
+     tensor_model_parallel_size: 1
+-    max_model_len: 16384 #3600 why** 14400
++    max_model_len: 16384 #3600 why** 14400 
+     prompt_length: 1 # useless. Just put it here
+-    response_length: 400 # single-turn response length
+-    gpu_memory_utilization: 0.7
+-    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true
++    response_length: 128 # single-turn response length 400 ****
++    gpu_memory_utilization: 0.6
++    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true 
+     temperature: 1
+     rollout_filter_ratio: 0.25
+     rollout_filter_type: largest # smallest or largest
+@@ -111,7 +111,7 @@ trainer:
+ 
+ agent_proxy:
+   max_context_window: -1 # set a value > 0 to enable context window for long trajectory
+-  max_turn: 25 #25 why** 700
++  max_turn: 15 #25 why** 700
+   action_sep: "||"
+   max_actions_per_turn: 1 # how many actions can be output at most in a single turn
+   use_turn_scores: False # important to GAE when applying token-level rewards to token-level advantages. If False, will take the sum of scores as the reward for the last turn.
+@@ -123,7 +123,7 @@ agent_proxy:
+ es_manager:
+   format_penalty: -0.1
+   train:
+-    env_groups: 8
++    env_groups: 8 
+     # under the same group, the env config and env seed are ensured to be equal
+     group_size: 16
+     env_configs:
+diff --git a/config/envs.yaml b/config/envs.yaml
+index d258d15..d7d687d 100644
+--- a/config/envs.yaml
++++ b/config/envs.yaml
+@@ -231,7 +231,7 @@ custom_envs:
+       Example: <answer>U</answer>
+     max_tokens: 96
+     env_config:
+-      scramble_depth: 3
++      scramble_depth: 5
+       max_steps: 20
+       render_mode: "text"
+   
+diff --git a/config/eval.yaml b/config/eval.yaml
+index 0802a0d..98d71dd 100644
+--- a/config/eval.yaml
++++ b/config/eval.yaml
+@@ -8,7 +8,7 @@ seed:
+   train: 10000
+   val: 123
+ 
+-model_path: /mnt/general/wanghy/RAGEN/saves/qwen3b_it_fromit_think_sudoku_sequence_multitask/global_step_200/qwen2.5_3b_actor_hf
++model_path: /mnt/general/wanghy/RAGEN/saves/qwen3B_it_think_rubikscube2_frommlpsave/global_step_50/qwen2.5_7B_actor_hf
+ # /mnt/general/share/model/tyzhu/SPA-frozenlake-qwen2.5-1.5b-instruct
+ 
+ lora:
+diff --git a/config/evaluate_api_llm.yaml b/config/evaluate_api_llm.yaml
+index bcbf206..9fe6f71 100644
+--- a/config/evaluate_api_llm.yaml
++++ b/config/evaluate_api_llm.yaml
+@@ -5,7 +5,7 @@ defaults:
+   - base # this is a symbolic link to the verl/verl/trainer/config/ppo_trainer.yaml file
+ 
+ model_config:
+-  model_name: TA/openai/gpt-oss-120b # should be registered in model_info
++  model_name: ark-deepseek-v3-250324 # should be registered in model_info
+   max_concurrency: 16
+ 
+ model_info:
+@@ -39,27 +39,21 @@ model_info:
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  ark-deepseek-v3-250324:
+-    provider_name: openai
+-    model_name: ark-deepseek-v3-250324
+-    generation_kwargs:
+-      temperature: 0
+-      max_completion_tokens: 512
+   deepseek-v3:
+     provider_name: deepseek
+     model_name: deepseek-chat
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  glm-4.6:
++  ark-deepseek-v3-250324:
+     provider_name: openai
+-    model_name: glm-4.6
++    model_name: ark-deepseek-v3-250324
+     generation_kwargs:
+       temperature: 0
+-      max_completion_tokens: 512
+-  TA/openai/gpt-oss-120b:
++      max_tokens: 8192
++  gemini-2.5-pro:
+     provider_name: openai
+-    model_name: TA/openai/gpt-oss-120b
++    model_name: gemini-2.5-pro
+     generation_kwargs:
+       temperature: 0
+       max_tokens: 8192
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+deleted file mode 120000
+index e1061c0..0000000
+--- a/config/ppo_trainer.yaml
++++ /dev/null
+@@ -1 +0,0 @@
+-../verl/verl/trainer/config/ppo_trainer.yaml
+
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+new file mode 100644
+index 0000000..c821483
+--- /dev/null
++++ b/config/ppo_trainer.yaml
+@@ -0,0 +1,308 @@
++# Format checks enforced on CI:
++# 1. Comments must appear above each field.
++# 2. There must be a blank line between each field.
++# 3. Inline comments (after a field on the same line) are not allowed.
++# 4. Indentation level is respected for nested fields.
++
++# specify the default per-component configs
++defaults:
++
++  # <folder_name>@<field_name>.<field_name>: <yaml_file_name>
++  # actor_rollout_ref.actor: trainer/config/actor/dp_actor.yaml
++  - actor@actor_rollout_ref.actor: dp_actor
++
++  # data: trainer/config/data/legacy_data.yaml
++  - data@data: legacy_data
++
++  # Reference model config.
++  # Reference model will be enabled when actor.use_kl_loss or/and algorithm.use_kl_in_reward is/are True.
++  - ref@actor_rollout_ref.ref: dp_ref
++
++  # Rollout model config.
++  - rollout@actor_rollout_ref.rollout: rollout
++
++  # Model config.
++  - model@actor_rollout_ref.model: hf_model
++
++  # Critic model config.
++  - critic@critic: dp_critic
++
++  # Reward model config.
++  - reward_model@reward_model: dp_reward_model
++
++  # load the reference default config, then apply the fields in the current yaml
++  # self config override anything above
++  - _self_
++
++# config for actor, rollout and reference model
++actor_rollout_ref:
++
++  # Whether it's a hybrid engine, currently only supports hybrid engine
++  hybrid_engine: true
++
++  # Timeout for operations executed against the process group
++  nccl_timeout: 600
++
++  # Rollout model config.
++  rollout:
++
++    # for huge model, layered summon can save memory (prevent OOM) but make it slower
++    layered_summon: False
++
++# custom reward function definition
++custom_reward_function:
++
++  # The path to the file containing your customized reward function.
++  # If not specified, pre-implemented reward functions will be used.
++  path: null
++
++  # The name of the reward function within the specified file. Default is 'compute_score'.
++  name: compute_score
++
++# config for the algorithm
++algorithm:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.trainer.config.AlgoConfig
++
++  # Discount factor for future rewards
++  gamma: 1.0
++
++  # Trade-off between bias and variance in the GAE estimator
++  lam: 1.0
++
++  # Advantage estimator type: "gae", "grpo", "reinforce_plus_plus", etc.
++  adv_estimator: gae
++
++  # Whether to normalize advantages by std (specific to GRPO)
++  norm_adv_by_std_in_grpo: True
++
++  # Whether to enable in-reward KL penalty
++  use_kl_in_reward: False
++
++  # How to estimate KL divergence: "kl", "abs", "mse", "low_var_kl", or "full"
++  kl_penalty: kl
++
++  # KL control configuration
++  kl_ctrl:
++
++    # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++    _target_: verl.trainer.config.KLControlConfig
++
++    # KL control type: "fixed" or "adaptive"
++    type: fixed
++
++    # Initial coefficient for KL penalty
++    kl_coef: 0.001
++
++    # Horizon value for adaptive controller (if enabled)
++    horizon: 10000
++
++    # Target KL divergence (used for adaptive controller)
++    target_kl: 0.1
++
++  # Whether to enable preference feedback PPO
++  use_pf_ppo: False
++
++  # Preference feedback PPO settings
++  pf_ppo:
++
++    # Method for reweighting samples: "pow", "max_min", or "max_random"
++    reweight_method: pow
++
++    # Power used for weight scaling in "pow" method
++    weight_pow: 2.0
++
++# config for the trainer
++trainer:
++
++  # Whether to balance batch sizes across distributed workers
++  balance_batch: True
++
++  # Number of epochs in training
++  total_epochs: 30
++
++  # Total training steps (can be set explicitly or derived from epochs)
++  total_training_steps: null
++
++  # Project name for experiment tracking (e.g., wandb)
++  project_name: verl_examples
++
++  # Experiment name for run identification in tracking tools
++  experiment_name: gsm8k
++
++  # Logging backends to use: "console", "wandb", etc.
++  logger: ["console", "wandb"]
++
++  # Number of generations to log during validation
++  log_val_generations: 0
++
++  # Directory for logging rollout data; no dump if null
++  rollout_data_dir: null
++
++  # Directory for logging validation data; no dump if null
++  validation_data_dir: null
++
++  # Number of nodes used in the training
++  nnodes: 1
++
++  # Number of GPUs per node
++  n_gpus_per_node: 8
++
++  # Save frequency (by iteration) for model checkpoints
++  save_freq: -1
++
++  # ESI refers to the elastic server instance used during training, similar to the training plan. For example,
++  # if you purchase 10 hours of computing power, the ESI will automatically shut down after 10 hours of training.
++  # To ensure a checkpoint is saved before ESI shuts down, the system will start saving a checkpoint in advance.
++  # The advance time is calculated as: Advance Time = Longest historical step duration + Checkpoint save duration + esi_redundant_time.
++  # Here, esi_redundant_time is a user-defined value that further extends the advance time for added safety.
++  esi_redundant_time: 0
++
++  # Resume mode: "auto", "disable", or "resume_path"
++  # "auto": resume from last checkpoint if available
++  # "disable": start from scratch
++  # "resume_path": resume from a user-defined path
++  resume_mode: auto
++
++  # Path to resume training from (only used when resume_mode is "resume_path")
++  resume_from_path: null
++
++  # Whether to run validation before training begins
++  val_before_train: True
++
++  # Whether to run validation only
++  val_only: False
++
++  # Validation frequency (in training iterations)
++  test_freq: -1
++
++  # Number of iterations to warm up the critic before updating policy
++  critic_warmup: 0
++
++  # Default path to distributed filesystem for saving checkpoints
++  default_hdfs_dir: null
++
++  # Whether to delete local checkpoints after loading
++  del_local_ckpt_after_load: False
++
++  # Default local directory for saving checkpoints
++  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
++
++  # Maximum number of actor checkpoints to keep
++  max_actor_ckpt_to_keep: null
++
++  # Maximum number of critic checkpoints to keep
++  max_critic_ckpt_to_keep: null
++
++  # Timeout (in seconds) for Ray worker to wait for registration
++  ray_wait_register_center_timeout: 300
++
++  # Device to run training on (e.g., "cuda", "cpu")
++  device: cuda
++
++  # whether to use legacy worker implementation
++  #  mode: "auto", "enable", or "disable"
++  use_legacy_worker_impl: auto
++
++# profiler configs
++global_profiler:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.utils.profiler.ProfilerConfig
++
++  # Profiling tool: choose between nsys, npu, torch, torch_memory
++  tool: null
++
++  # profile steps
++  steps: null
++
++  # Whether to combine continuous steps into one database.
++  ## If True, worker.profiler.discrete must be False, [1,2] in one, [5] in another.
++  ## If False, [1] in one, [2] in another, [5] in another.
++  profile_continuous_steps: False
++
++  # Path to save profiling contents
++  save_path: "outputs/profile"
++
++  # Specific tool configs, can use +profiler.tool_config.[tool].xxx to config
++  global_tool_config:
++
++    # nsys config
++    nsys:
++
++      # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++      _target_: verl.utils.profiler.config.NsightToolConfig
++
++      # True for each task has its own database, False for all tasks in one training step share one database.
++      discrete: False
++
++      # controller Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      ## reference https://docs.nvidia.com/nsight-systems/UserGuide/index.html
++      ## reference https://docs.ray.io/en/latest/ray-observability/user-guides/profiling.html
++      controller_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++      # worker Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      worker_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++        # Profiling only in a range of torch.cuda.profiler.start and stop. Do not change this config.
++        capture-range: "cudaProfilerApi"
++
++        # Specify the desired behavior when a capture range ends.
++        # In verl we need the torch.cuda.profiler.start/stop pair to repeats n times.
++        # valid values are "repeat-shutdown:n" or null.
++        # For normal whole step profiling, n = len(profile_steps);
++        # but for discrete profiling, n = len(profile_steps) * Number(subtasks).
++        # Or you can just leave it null and the program will use n = len(profile_steps) * 6;
++        capture-range-end: null
++
++        # Send signal to the target application's process group. We let the program to exit by itself.
++        kill: none
++
++    # enable memory visualization for debugging memory usage
++    torch_memory:
++
++      #  Maximum number of allocation entries to record
++      trace_alloc_max_entries: 100_000
++
++      # The depth of the call stack to capture for each allocation
++      stack_depth: 32
++
++      # 'alloc': records only allocation events || 'state': records memory state changes || 'all': records both.
++      context: "all"
++
++      # 'python': records Python stacks || 'cpp': records C++ stacks (available in some versions) || 'all': records both.
++      stacks: "all"
++
++      # devices, record_context etc.
++      kw_args: {}
++
++# configs related to ray
++ray_kwargs:
++
++  # configs related to ray initialization
++  ray_init:
++
++    # Number of CPUs for Ray. Use a fixed number instead of null when using SLURM.
++    num_cpus: null
++
++  # Path to save Ray timeline JSON for performance profiling
++  timeline_json_file: null
+Submodule external/kimina-lean-server contains modified content
+diff --git a/external/kimina-lean-server/setup.sh b/external/kimina-lean-server/setup.sh
+old mode 100755
+new mode 100644
+Submodule external/webshop-minimal contains modified content
+diff --git a/external/webshop-minimal/requirements.txt b/external/webshop-minimal/requirements.txt
+index 5a1b04f..238ed5a 100644
+--- a/external/webshop-minimal/requirements.txt
++++ b/external/webshop-minimal/requirements.txt
+@@ -4,7 +4,7 @@ flask
+ html2text
+ rank_bm25
+ pyserini
+-faiss-cpu
++faiss-gpu
+ thefuzz
+ gdown
+ spacy
+diff --git a/ragen/env/frozen_lake/config.py b/ragen/env/frozen_lake/config.py
+index 9950c34..de054f4 100644
+--- a/ragen/env/frozen_lake/config.py
++++ b/ragen/env/frozen_lake/config.py
+@@ -8,7 +8,7 @@ class FrozenLakeEnvConfig:
+     size: int = 4
+     p: float = 0.9
+     success_rate: float = 0.8
+-    is_slippery: bool = False
++    is_slippery: bool = True
+     map_seed: Optional[int] = None
+     render_mode: str = "text"
+     observation_format: str = "grid"
+diff --git a/scripts/runs/bandit_jobs.sh b/scripts/runs/bandit_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/frozenlake_jobs.sh b/scripts/runs/frozenlake_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/sokoban_jobs.sh b/scripts/runs/sokoban_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/webshop_jobs.sh b/scripts/runs/webshop_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/train_all.sh b/train_all.sh
+old mode 100755
+new mode 100644
+Submodule verl contains modified content
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh b/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh b/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/recipe/sppo/run_qwen2.5-7b_rm.sh b/verl/recipe/sppo/run_qwen2.5-7b_rm.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/generate_trainer_config.sh b/verl/scripts/generate_trainer_config.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/install_vllm_sglang_mcore.sh b/verl/scripts/install_vllm_sglang_mcore.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/generation/run_gen_qwen05.sh b/verl/tests/special_e2e/generation/run_gen_qwen05.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/run_one_step_off_policy.sh b/verl/tests/special_e2e/run_one_step_off_policy.sh
+old mode 100755
+new mode 100644

wandb/run-20260513_141834-qumom4e1/files/requirements.txt

@@ -0,0 +1,316 @@
+colorama==0.4.6
+psutil==7.2.2
+pyarrow==23.0.1
+math-verify==0.9.0
+pygame==2.6.1
+partial-json-parser==0.2.1.1.post7
+anyio==4.13.0
+wandb==0.25.1
+mathruler==0.1.0
+tzdata==2026.1
+gym-sokoban==0.0.6
+sniffio==1.3.1
+omegaconf==2.3.0
+httpcore==1.0.9
+scipy==1.15.3
+multidict==6.7.1
+nvidia-cusparse-cu12==12.3.1.170
+fonttools==4.62.1
+together==2.7.0
+antlr4-python3-runtime==4.9.3
+cupy-cuda12x==13.6.0
+av==17.0.0
+torch==2.6.0
+datasets==4.8.4
+pyparsing==3.3.2
+markdown-it-py==4.0.0
+accelerate==1.13.0
+lark==1.2.2
+sentencepiece==0.2.1
+Flask==3.1.3
+annotated-doc==0.0.4
+rignore==0.7.6
+ImageIO==2.37.3
+outlines_core==0.1.26
+gym==0.26.2
+depyf==0.18.0
+pydantic==2.12.5
+nvidia-cuda-nvrtc-cu12==12.4.127
+certifi==2026.2.25
+aiohttp==3.13.5
+flash_attn==2.7.4.post1
+msgspec==0.21.0
+matplotlib==3.10.8
+pandas==2.3.3
+openai==2.31.0
+sentry-sdk==2.57.0
+propcache==0.4.1
+nvidia-curand-cu12==10.3.5.147
+python-dateutil==2.9.0.post0
+itsdangerous==2.2.0
+cloudpickle==3.1.2
+ray==2.54.1
+cffi==2.0.0
+pyzmq==27.1.0
+Jinja2==3.1.6
+nest-asyncio==1.6.0
+orjson==3.11.8
+pydantic-extra-types==2.11.2
+nvidia-nccl-cu12==2.21.5
+gitdb==4.0.12
+Farama-Notifications==0.0.4
+async-timeout==5.0.1
+torchdata==0.11.0
+ninja==1.13.0
+hydra-core==1.3.2
+GitPython==3.1.46
+nvidia-cuda-runtime-cu12==12.4.127
+msgpack==1.1.2
+email-validator==2.3.0
+yarl==1.23.0
+numpy==1.26.4
+charset-normalizer==3.4.7
+pycountry==26.2.16
+annotated-types==0.7.0
+uvloop==0.22.1
+torchvision==0.21.0
+jsonschema-specifications==2025.9.1
+uvicorn==0.44.0
+nvidia-nvjitlink-cu12==12.4.127
+sympy==1.13.1
+latex2sympy2_extended==1.11.0
+triton==3.2.0
+tqdm==4.67.3
+diskcache==5.6.3
+kiwisolver==1.5.0
+llguidance==0.7.30
+prometheus_client==0.25.0
+types-PyYAML==6.0.12.20260408
+MarkupSafe==3.0.3
+fastapi-cloud-cli==0.16.1
+cachetools==7.0.5
+pillow==12.2.0
+airportsdata==20260315
+mpmath==1.3.0
+cycler==0.12.1
+qwen-vl-utils==0.0.14
+jsonschema==4.26.0
+safetensors==0.7.0
+gymnasium==1.2.3
+h11==0.16.0
+Pygments==2.20.0
+zipp==3.23.0
+outlines==0.1.11
+typing_extensions==4.15.0
+requests==2.33.1
+watchfiles==1.1.1
+shellingham==1.5.4
+xformers==0.0.29.post2
+blinker==1.9.0
+distro==1.9.0
+multiprocess==0.70.19
+regex==2026.4.4
+fastapi-cli==0.0.24
+tabulate==0.10.0
+referencing==0.37.0
+xxhash==3.6.0
+smmap==5.0.3
+six==1.17.0
+Werkzeug==3.1.8
+click==8.3.2
+py-cpuinfo==9.0.0
+aiosignal==1.4.0
+setuptools==69.1.0
+setuptools==82.0.1
+aiohappyeyeballs==2.6.1
+starlette==0.52.1
+gym-notices==0.1.0
+typing-inspection==0.4.2
+networkx==3.4.2
+pydantic_core==2.41.5
+pycparser==3.0
+contourpy==1.3.2
+codetiming==1.4.0
+python-dotenv==1.2.2
+rpds-py==0.30.0
+blake3==1.0.8
+python-multipart==0.0.24
+fastapi==0.135.3
+httpx==0.28.1
+attrs==26.1.0
+pytz==2026.1.post1
+platformdirs==4.9.6
+nvidia-cusolver-cu12==11.6.1.9
+hf-xet==1.4.3
+filelock==3.25.2
+types-requests==2.33.0.20260408
+idna==3.11
+fsspec==2026.2.0
+astor==0.8.1
+interegular==0.3.3
+nvidia-cudnn-cu12==9.1.0.70
+frozenlist==1.8.0
+pylatexenc==2.10
+nvidia-cublas-cu12==12.4.5.8
+httptools==0.7.1
+python-json-logger==4.1.0
+mdurl==0.1.2
+mistral_common==1.11.0
+vulkan==1.3.275.1
+nvidia-cuda-cupti-cu12==12.4.127
+pybind11==3.0.3
+PyYAML==6.0.3
+jiter==0.13.0
+fastrlock==0.8.3
+typeguard==4.5.1
+typer==0.24.1
+websockets==16.0
+nvidia-cufft-cu12==11.2.1.3
+nvidia-nvtx-cu12==12.4.127
+psutil==7.2.2
+tomli==2.4.1
+types-tqdm==4.67.3.20260408
+fastar==0.10.0
+einops==0.8.2
+lm-format-enforcer==0.10.12
+opencv-python-headless==4.11.0.86
+tiktoken==0.12.0
+rich-toolkit==0.19.7
+rich==14.3.3
+dnspython==2.8.0
+pydantic-settings==2.13.1
+types-tabulate==0.10.0.20260408
+torchaudio==2.6.0
+urllib3==2.6.3
+dill==0.4.1
+docstring_parser==0.18.0
+prometheus-fastapi-instrumentator==7.1.0
+peft==0.18.1
+exceptiongroup==1.3.1
+tyro==1.0.13
+nvidia-cusparselt-cu12==0.6.2
+packaging==26.0
+wheel==0.46.3
+pip==26.0.1
+pyjnius==1.7.0
+pure_eval==0.2.3
+ptyprocess==0.7.0
+flatbuffers==25.12.19
+faiss-gpu==1.7.2
+wrapt==2.1.2
+wcwidth==0.6.0
+wasabi==1.1.3
+traitlets==5.14.3
+threadpoolctl==3.6.0
+tenacity==9.1.4
+spacy-loggers==1.0.5
+spacy-legacy==3.0.12
+soupsieve==2.8.3
+RapidFuzz==3.14.5
+rank-bm25==0.2.2
+PySocks==1.7.1
+PyJWT==2.12.1
+parso==0.8.6
+protobuf==4.25.9
+pexpect==4.9.0
+opentelemetry-semantic-conventions-ai==0.4.13
+murmurhash==1.0.15
+loguru==0.7.3
+joblib==1.5.3
+humanfriendly==10.0
+httpx-sse==0.4.3
+html2text==2025.4.15
+grpcio==1.80.0
+executing==2.2.1
+decorator==5.2.1
+debugpy==1.8.20
+Cython==3.2.4
+cymem==2.0.13
+confection==1.3.3
+colorama==0.4.6
+cloudpathlib==0.23.0
+catalogue==2.0.10
+blis==1.3.3
+asttokens==3.0.1
+thefuzz==0.22.1
+stack-data==0.6.3
+srsly==2.5.3
+smart_open==7.6.0
+scikit-learn==1.7.2
+prompt_toolkit==3.0.52
+preshed==3.0.13
+opentelemetry-proto==1.26.0
+nltk==3.9.4
+matplotlib-inline==0.2.1
+jedi==0.19.2
+googleapis-common-protos==1.74.0
+Deprecated==1.3.1
+cryptography==46.0.7
+coloredlogs==15.0.1
+beautifulsoup4==4.14.3
+thinc==8.3.13
+opentelemetry-exporter-otlp-proto-common==1.26.0
+onnxruntime==1.23.2
+ipython==8.39.0
+gdown==6.0.0
+cleantext==1.1.4
+weasel==1.0.0
+tensordict==0.8.3
+sse-starlette==3.3.4
+mcp==1.27.0
+anthropic==0.96.0
+spacy==3.8.14
+opentelemetry-exporter-otlp-proto-http==1.26.0
+opentelemetry-exporter-otlp-proto-grpc==1.26.0
+kimina-client==0.2.1
+pyserini==1.2.0
+opentelemetry-exporter-otlp==1.26.0
+compressed-tensors==0.9.2
+vllm==0.8.2
+py-spy==0.4.1
+opencensus-context==0.1.3
+distlib==0.4.0
+colorful==0.5.8
+tensorboard-data-server==0.7.2
+python-discovery==1.2.2
+pyasn1==0.6.3
+proto-plus==1.27.2
+Markdown==3.10.2
+absl-py==2.4.0
+virtualenv==21.2.4
+tensorboard==2.20.0
+pyasn1_modules==0.4.2
+opentelemetry-api==1.24.0
+google-auth==2.49.2
+google-api-core==2.30.3
+aiohttp-cors==0.8.1
+opentelemetry-exporter-prometheus==0.62b0
+opencensus==0.11.4
+verl==0.5.0.dev0
+huggingface_hub==0.36.2
+opentelemetry-semantic-conventions==0.45b0
+opentelemetry-sdk==1.24.0
+llvmlite==0.43.0
+tokenizers==0.21.4
+gguf==0.10.0
+importlib-metadata==7.0.0
+hjson==3.1.0
+deepspeed==0.16.9
+transformers==4.51.1
+xgrammar==0.1.16
+ragen==0.1
+numba==0.60.0
+ragen==0.1
+verl==0.5.0.dev0
+autocommand==2.2.2
+backports.tarfile==1.2.0
+importlib_metadata==8.7.1
+jaraco.text==4.0.0
+jaraco.context==6.1.0
+jaraco.functools==4.4.0
+more-itertools==10.8.0
+packaging==26.0
+platformdirs==4.4.0
+tomli==2.4.0
+wheel==0.46.3
+zipp==3.23.0

wandb/run-20260513_141834-qumom4e1/files/wandb-metadata.json

@@ -0,0 +1,89 @@
+{
+  "os": "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python": "CPython 3.10.20",
+  "startedAt": "2026-05-13T06:18:34.898817Z",
+  "program": "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py",
+  "codePath": "cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py",
+  "codePathLocal": "cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py",
+  "git": {
+    "remote": "https://github.com/Harry-mic/SCOUT",
+    "commit": "b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0"
+  },
+  "email": "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root": "/mnt/general/wanghy/RAGEN",
+  "host": "pt-a7f17fedde804edca572f81ace5fcaf3-worker-0",
+  "executable": "/opt/conda/envs/ragen_new/bin/python",
+  "cpu_count": 64,
+  "cpu_count_logical": 128,
+  "gpu": "NVIDIA H100 80GB HBM3",
+  "gpu_count": 8,
+  "disk": {
+    "/": {
+      "total": "60129542144000",
+      "used": "67061088256"
+    }
+  },
+  "memory": {
+    "total": "2159579672576"
+  },
+  "gpu_nvidia": [
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-97b3b912-40cf-f573-ffce-8275a656891f"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-5e4acc7a-f7ab-1a15-312e-4e2a39c43b2c"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-b36695ed-370a-2556-79d8-b0a2c2659271"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-b3e13ca7-237c-931f-894b-798f9cfa5620"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-64647b1f-5d55-1b7e-bf3d-64fae3871140"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-fe8b9b7e-82a4-1238-4843-bbfd0269d746"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-4523d4e1-5745-8224-7bcd-44cf59b76bae"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-9262bcbd-a29f-d761-3330-ac2ce9f15e82"
+    }
+  ],
+  "cudaVersion": "12.4",
+  "writerId": "swzgj3glyzjumc8fct6a24j895q3ndhx"
+}

wandb/run-20260513_141834-qumom4e1/files/wandb-summary.json

@@ -0,0 +1 @@
+{"_step":151379,"_runtime":700.947858529,"_timestamp":1.7786538172727878e+09,"rollout/success":0,"perf/SPS":218,"rollout/episodic_length":100,"global_step":151379,"rollout/episodic_return":-9.99999999999998,"train/loss":0.0016797268763184547,"_wandb":{"runtime":700},"charts/epsilon":0.829703125,"rollout/success_rate_100":0.41}

wandb/run-20260513_141834-qumom4e1/run-qumom4e1.wandb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc3c5006ffd742733f032d110e4b73995f69b82a223cb42754224e283b818117
+size 17170432

wandb/run-20260513_143037-5nbglqlm/files/code/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()

wandb/run-20260513_143037-5nbglqlm/files/config.yaml

@@ -0,0 +1,193 @@
+_wandb:
+    value:
+        cli_version: 0.25.1
+        code_path: code/cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py
+        e:
+            xkjtt1054j25k2rxc53pvzqxyzin9js2:
+                codePath: cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py
+                codePathLocal: cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py
+                cpu_count: 64
+                cpu_count_logical: 128
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "60129542144000"
+                        used: "67078225920"
+                email: haoyu-wa22@mails.tsinghua.edu.cn
+                executable: /opt/conda/envs/ragen_new/bin/python
+                git:
+                    commit: b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0
+                    remote: https://github.com/Harry-mic/SCOUT
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-97b3b912-40cf-f573-ffce-8275a656891f
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-5e4acc7a-f7ab-1a15-312e-4e2a39c43b2c
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b36695ed-370a-2556-79d8-b0a2c2659271
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b3e13ca7-237c-931f-894b-798f9cfa5620
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-64647b1f-5d55-1b7e-bf3d-64fae3871140
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-fe8b9b7e-82a4-1238-4843-bbfd0269d746
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-4523d4e1-5745-8224-7bcd-44cf59b76bae
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-9262bcbd-a29f-d761-3330-ac2ce9f15e82
+                host: pt-a7f17fedde804edca572f81ace5fcaf3-worker-0
+                memory:
+                    total: "2159579672576"
+                os: Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35
+                program: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py
+                python: CPython 3.10.20
+                root: /mnt/general/wanghy/RAGEN
+                startedAt: "2026-05-13T06:30:37.049177Z"
+                writerId: xkjtt1054j25k2rxc53pvzqxyzin9js2
+        m:
+            - "1": global_step
+              "6":
+                - 3
+              "7": []
+            - "2": perf/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": train/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": rollout/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": eval/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": losses/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": charts/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+        python_version: 3.10.20
+        t:
+            "1":
+                - 1
+                - 11
+                - 30
+                - 49
+                - 50
+                - 51
+                - 105
+            "2":
+                - 1
+                - 11
+                - 30
+                - 49
+                - 50
+                - 51
+                - 105
+            "3":
+                - 7
+                - 13
+                - 16
+                - 61
+            "4": 3.10.20
+            "5": 0.25.1
+            "6": 4.51.1
+            "12": 0.25.1
+            "13": linux-x86_64
+batch_size:
+    value: 128
+buffer_size:
+    value: 200000
+capture_video:
+    value: false
+cuda:
+    value: true
+dueling:
+    value: true
+end_e:
+    value: 0.1
+env_id:
+    value: SokobanNoisyDQN
+eval_episodes:
+    value: 8000
+eval_splits:
+    value: 2
+exp_name:
+    value: noisy_dqn_sokoban
+exploration_fraction:
+    value: 0.8
+gamma:
+    value: 0.99
+grid_h:
+    value: 6
+grid_w:
+    value: 6
+learning_rate:
+    value: 0.00025
+learning_starts:
+    value: 20000
+max_steps_env:
+    value: 100
+num_boxes:
+    value: 2
+reward_clip_abs:
+    value: 1
+search_depth:
+    value: 300
+seed:
+    value: 1
+start_e:
+    value: 1
+target_network_frequency:
+    value: 8000
+torch_deterministic:
+    value: true
+total_timesteps:
+    value: 1000000
+track:
+    value: true
+train_frequency:
+    value: 4
+wandb_entity:
+    value: null
+wandb_project_name:
+    value: cleanRL

wandb/run-20260513_143037-5nbglqlm/files/diff.patch

@@ -0,0 +1,536 @@
+diff --git a/config/_10_rubikscube.yaml b/config/_10_rubikscube.yaml
+index 277a8b1..a99b6a8 100644
+--- a/config/_10_rubikscube.yaml
++++ b/config/_10_rubikscube.yaml
+@@ -5,7 +5,7 @@ system:
+   CUDA_VISIBLE_DEVICES: "0,1,2,3"
+ 
+ trainer:
+-  experiment_name: 2048
++  experiment_name: rubikscube
+   n_gpus_per_node: 4
+ 
+ actor_rollout_ref:
+diff --git a/config/base.yaml b/config/base.yaml
+index 6029703..c10ab55 100644
+--- a/config/base.yaml
++++ b/config/base.yaml
+@@ -10,8 +10,8 @@ seed:
+   val: 123
+ 
+ micro_batch_size_per_gpu: 1
+-ppo_mini_batch_size: 32
+-model_path: 
++ppo_mini_batch_size: 16 #****
++model_path: /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ # /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ enable_response_mask: True # Enabling response mask could improve stability of rollout/old_log_prob, as P(st|history) are no longer calculated in loss here. See https://docs.google.com/document/d/1bg7obeiKTExuHHBl5uOiSpec5uLDZ2Tgvxy6li5pHX4/edit?usp=sharing for more details.
+ grpo_advantage_length_weight: False # if you do not enable this and critic/advantage_estimator is GRPO, and the critic/advantages/mean is too low, then you can try enabling this to encourage reasoning and forbid collapse
+@@ -48,11 +48,11 @@ actor_rollout_ref:
+     name: vllm
+     log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu} # following micro_batch_size_per_gpu
+     tensor_model_parallel_size: 1
+-    max_model_len: 16384 #3600 why** 14400
++    max_model_len: 16384 #3600 why** 14400 
+     prompt_length: 1 # useless. Just put it here
+-    response_length: 400 # single-turn response length
+-    gpu_memory_utilization: 0.7
+-    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true
++    response_length: 128 # single-turn response length 400 ****
++    gpu_memory_utilization: 0.6
++    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true 
+     temperature: 1
+     rollout_filter_ratio: 0.25
+     rollout_filter_type: largest # smallest or largest
+@@ -111,7 +111,7 @@ trainer:
+ 
+ agent_proxy:
+   max_context_window: -1 # set a value > 0 to enable context window for long trajectory
+-  max_turn: 25 #25 why** 700
++  max_turn: 15 #25 why** 700
+   action_sep: "||"
+   max_actions_per_turn: 1 # how many actions can be output at most in a single turn
+   use_turn_scores: False # important to GAE when applying token-level rewards to token-level advantages. If False, will take the sum of scores as the reward for the last turn.
+@@ -123,7 +123,7 @@ agent_proxy:
+ es_manager:
+   format_penalty: -0.1
+   train:
+-    env_groups: 8
++    env_groups: 8 
+     # under the same group, the env config and env seed are ensured to be equal
+     group_size: 16
+     env_configs:
+diff --git a/config/envs.yaml b/config/envs.yaml
+index d258d15..d7d687d 100644
+--- a/config/envs.yaml
++++ b/config/envs.yaml
+@@ -231,7 +231,7 @@ custom_envs:
+       Example: <answer>U</answer>
+     max_tokens: 96
+     env_config:
+-      scramble_depth: 3
++      scramble_depth: 5
+       max_steps: 20
+       render_mode: "text"
+   
+diff --git a/config/eval.yaml b/config/eval.yaml
+index 0802a0d..98d71dd 100644
+--- a/config/eval.yaml
++++ b/config/eval.yaml
+@@ -8,7 +8,7 @@ seed:
+   train: 10000
+   val: 123
+ 
+-model_path: /mnt/general/wanghy/RAGEN/saves/qwen3b_it_fromit_think_sudoku_sequence_multitask/global_step_200/qwen2.5_3b_actor_hf
++model_path: /mnt/general/wanghy/RAGEN/saves/qwen3B_it_think_rubikscube2_frommlpsave/global_step_50/qwen2.5_7B_actor_hf
+ # /mnt/general/share/model/tyzhu/SPA-frozenlake-qwen2.5-1.5b-instruct
+ 
+ lora:
+diff --git a/config/evaluate_api_llm.yaml b/config/evaluate_api_llm.yaml
+index bcbf206..9fe6f71 100644
+--- a/config/evaluate_api_llm.yaml
++++ b/config/evaluate_api_llm.yaml
+@@ -5,7 +5,7 @@ defaults:
+   - base # this is a symbolic link to the verl/verl/trainer/config/ppo_trainer.yaml file
+ 
+ model_config:
+-  model_name: TA/openai/gpt-oss-120b # should be registered in model_info
++  model_name: ark-deepseek-v3-250324 # should be registered in model_info
+   max_concurrency: 16
+ 
+ model_info:
+@@ -39,27 +39,21 @@ model_info:
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  ark-deepseek-v3-250324:
+-    provider_name: openai
+-    model_name: ark-deepseek-v3-250324
+-    generation_kwargs:
+-      temperature: 0
+-      max_completion_tokens: 512
+   deepseek-v3:
+     provider_name: deepseek
+     model_name: deepseek-chat
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  glm-4.6:
++  ark-deepseek-v3-250324:
+     provider_name: openai
+-    model_name: glm-4.6
++    model_name: ark-deepseek-v3-250324
+     generation_kwargs:
+       temperature: 0
+-      max_completion_tokens: 512
+-  TA/openai/gpt-oss-120b:
++      max_tokens: 8192
++  gemini-2.5-pro:
+     provider_name: openai
+-    model_name: TA/openai/gpt-oss-120b
++    model_name: gemini-2.5-pro
+     generation_kwargs:
+       temperature: 0
+       max_tokens: 8192
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+deleted file mode 120000
+index e1061c0..0000000
+--- a/config/ppo_trainer.yaml
++++ /dev/null
+@@ -1 +0,0 @@
+-../verl/verl/trainer/config/ppo_trainer.yaml
+
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+new file mode 100644
+index 0000000..c821483
+--- /dev/null
++++ b/config/ppo_trainer.yaml
+@@ -0,0 +1,308 @@
++# Format checks enforced on CI:
++# 1. Comments must appear above each field.
++# 2. There must be a blank line between each field.
++# 3. Inline comments (after a field on the same line) are not allowed.
++# 4. Indentation level is respected for nested fields.
++
++# specify the default per-component configs
++defaults:
++
++  # <folder_name>@<field_name>.<field_name>: <yaml_file_name>
++  # actor_rollout_ref.actor: trainer/config/actor/dp_actor.yaml
++  - actor@actor_rollout_ref.actor: dp_actor
++
++  # data: trainer/config/data/legacy_data.yaml
++  - data@data: legacy_data
++
++  # Reference model config.
++  # Reference model will be enabled when actor.use_kl_loss or/and algorithm.use_kl_in_reward is/are True.
++  - ref@actor_rollout_ref.ref: dp_ref
++
++  # Rollout model config.
++  - rollout@actor_rollout_ref.rollout: rollout
++
++  # Model config.
++  - model@actor_rollout_ref.model: hf_model
++
++  # Critic model config.
++  - critic@critic: dp_critic
++
++  # Reward model config.
++  - reward_model@reward_model: dp_reward_model
++
++  # load the reference default config, then apply the fields in the current yaml
++  # self config override anything above
++  - _self_
++
++# config for actor, rollout and reference model
++actor_rollout_ref:
++
++  # Whether it's a hybrid engine, currently only supports hybrid engine
++  hybrid_engine: true
++
++  # Timeout for operations executed against the process group
++  nccl_timeout: 600
++
++  # Rollout model config.
++  rollout:
++
++    # for huge model, layered summon can save memory (prevent OOM) but make it slower
++    layered_summon: False
++
++# custom reward function definition
++custom_reward_function:
++
++  # The path to the file containing your customized reward function.
++  # If not specified, pre-implemented reward functions will be used.
++  path: null
++
++  # The name of the reward function within the specified file. Default is 'compute_score'.
++  name: compute_score
++
++# config for the algorithm
++algorithm:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.trainer.config.AlgoConfig
++
++  # Discount factor for future rewards
++  gamma: 1.0
++
++  # Trade-off between bias and variance in the GAE estimator
++  lam: 1.0
++
++  # Advantage estimator type: "gae", "grpo", "reinforce_plus_plus", etc.
++  adv_estimator: gae
++
++  # Whether to normalize advantages by std (specific to GRPO)
++  norm_adv_by_std_in_grpo: True
++
++  # Whether to enable in-reward KL penalty
++  use_kl_in_reward: False
++
++  # How to estimate KL divergence: "kl", "abs", "mse", "low_var_kl", or "full"
++  kl_penalty: kl
++
++  # KL control configuration
++  kl_ctrl:
++
++    # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++    _target_: verl.trainer.config.KLControlConfig
++
++    # KL control type: "fixed" or "adaptive"
++    type: fixed
++
++    # Initial coefficient for KL penalty
++    kl_coef: 0.001
++
++    # Horizon value for adaptive controller (if enabled)
++    horizon: 10000
++
++    # Target KL divergence (used for adaptive controller)
++    target_kl: 0.1
++
++  # Whether to enable preference feedback PPO
++  use_pf_ppo: False
++
++  # Preference feedback PPO settings
++  pf_ppo:
++
++    # Method for reweighting samples: "pow", "max_min", or "max_random"
++    reweight_method: pow
++
++    # Power used for weight scaling in "pow" method
++    weight_pow: 2.0
++
++# config for the trainer
++trainer:
++
++  # Whether to balance batch sizes across distributed workers
++  balance_batch: True
++
++  # Number of epochs in training
++  total_epochs: 30
++
++  # Total training steps (can be set explicitly or derived from epochs)
++  total_training_steps: null
++
++  # Project name for experiment tracking (e.g., wandb)
++  project_name: verl_examples
++
++  # Experiment name for run identification in tracking tools
++  experiment_name: gsm8k
++
++  # Logging backends to use: "console", "wandb", etc.
++  logger: ["console", "wandb"]
++
++  # Number of generations to log during validation
++  log_val_generations: 0
++
++  # Directory for logging rollout data; no dump if null
++  rollout_data_dir: null
++
++  # Directory for logging validation data; no dump if null
++  validation_data_dir: null
++
++  # Number of nodes used in the training
++  nnodes: 1
++
++  # Number of GPUs per node
++  n_gpus_per_node: 8
++
++  # Save frequency (by iteration) for model checkpoints
++  save_freq: -1
++
++  # ESI refers to the elastic server instance used during training, similar to the training plan. For example,
++  # if you purchase 10 hours of computing power, the ESI will automatically shut down after 10 hours of training.
++  # To ensure a checkpoint is saved before ESI shuts down, the system will start saving a checkpoint in advance.
++  # The advance time is calculated as: Advance Time = Longest historical step duration + Checkpoint save duration + esi_redundant_time.
++  # Here, esi_redundant_time is a user-defined value that further extends the advance time for added safety.
++  esi_redundant_time: 0
++
++  # Resume mode: "auto", "disable", or "resume_path"
++  # "auto": resume from last checkpoint if available
++  # "disable": start from scratch
++  # "resume_path": resume from a user-defined path
++  resume_mode: auto
++
++  # Path to resume training from (only used when resume_mode is "resume_path")
++  resume_from_path: null
++
++  # Whether to run validation before training begins
++  val_before_train: True
++
++  # Whether to run validation only
++  val_only: False
++
++  # Validation frequency (in training iterations)
++  test_freq: -1
++
++  # Number of iterations to warm up the critic before updating policy
++  critic_warmup: 0
++
++  # Default path to distributed filesystem for saving checkpoints
++  default_hdfs_dir: null
++
++  # Whether to delete local checkpoints after loading
++  del_local_ckpt_after_load: False
++
++  # Default local directory for saving checkpoints
++  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
++
++  # Maximum number of actor checkpoints to keep
++  max_actor_ckpt_to_keep: null
++
++  # Maximum number of critic checkpoints to keep
++  max_critic_ckpt_to_keep: null
++
++  # Timeout (in seconds) for Ray worker to wait for registration
++  ray_wait_register_center_timeout: 300
++
++  # Device to run training on (e.g., "cuda", "cpu")
++  device: cuda
++
++  # whether to use legacy worker implementation
++  #  mode: "auto", "enable", or "disable"
++  use_legacy_worker_impl: auto
++
++# profiler configs
++global_profiler:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.utils.profiler.ProfilerConfig
++
++  # Profiling tool: choose between nsys, npu, torch, torch_memory
++  tool: null
++
++  # profile steps
++  steps: null
++
++  # Whether to combine continuous steps into one database.
++  ## If True, worker.profiler.discrete must be False, [1,2] in one, [5] in another.
++  ## If False, [1] in one, [2] in another, [5] in another.
++  profile_continuous_steps: False
++
++  # Path to save profiling contents
++  save_path: "outputs/profile"
++
++  # Specific tool configs, can use +profiler.tool_config.[tool].xxx to config
++  global_tool_config:
++
++    # nsys config
++    nsys:
++
++      # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++      _target_: verl.utils.profiler.config.NsightToolConfig
++
++      # True for each task has its own database, False for all tasks in one training step share one database.
++      discrete: False
++
++      # controller Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      ## reference https://docs.nvidia.com/nsight-systems/UserGuide/index.html
++      ## reference https://docs.ray.io/en/latest/ray-observability/user-guides/profiling.html
++      controller_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++      # worker Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      worker_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++        # Profiling only in a range of torch.cuda.profiler.start and stop. Do not change this config.
++        capture-range: "cudaProfilerApi"
++
++        # Specify the desired behavior when a capture range ends.
++        # In verl we need the torch.cuda.profiler.start/stop pair to repeats n times.
++        # valid values are "repeat-shutdown:n" or null.
++        # For normal whole step profiling, n = len(profile_steps);
++        # but for discrete profiling, n = len(profile_steps) * Number(subtasks).
++        # Or you can just leave it null and the program will use n = len(profile_steps) * 6;
++        capture-range-end: null
++
++        # Send signal to the target application's process group. We let the program to exit by itself.
++        kill: none
++
++    # enable memory visualization for debugging memory usage
++    torch_memory:
++
++      #  Maximum number of allocation entries to record
++      trace_alloc_max_entries: 100_000
++
++      # The depth of the call stack to capture for each allocation
++      stack_depth: 32
++
++      # 'alloc': records only allocation events || 'state': records memory state changes || 'all': records both.
++      context: "all"
++
++      # 'python': records Python stacks || 'cpp': records C++ stacks (available in some versions) || 'all': records both.
++      stacks: "all"
++
++      # devices, record_context etc.
++      kw_args: {}
++
++# configs related to ray
++ray_kwargs:
++
++  # configs related to ray initialization
++  ray_init:
++
++    # Number of CPUs for Ray. Use a fixed number instead of null when using SLURM.
++    num_cpus: null
++
++  # Path to save Ray timeline JSON for performance profiling
++  timeline_json_file: null
+Submodule external/kimina-lean-server contains modified content
+diff --git a/external/kimina-lean-server/setup.sh b/external/kimina-lean-server/setup.sh
+old mode 100755
+new mode 100644
+Submodule external/webshop-minimal contains modified content
+diff --git a/external/webshop-minimal/requirements.txt b/external/webshop-minimal/requirements.txt
+index 5a1b04f..238ed5a 100644
+--- a/external/webshop-minimal/requirements.txt
++++ b/external/webshop-minimal/requirements.txt
+@@ -4,7 +4,7 @@ flask
+ html2text
+ rank_bm25
+ pyserini
+-faiss-cpu
++faiss-gpu
+ thefuzz
+ gdown
+ spacy
+diff --git a/ragen/env/frozen_lake/config.py b/ragen/env/frozen_lake/config.py
+index 9950c34..de054f4 100644
+--- a/ragen/env/frozen_lake/config.py
++++ b/ragen/env/frozen_lake/config.py
+@@ -8,7 +8,7 @@ class FrozenLakeEnvConfig:
+     size: int = 4
+     p: float = 0.9
+     success_rate: float = 0.8
+-    is_slippery: bool = False
++    is_slippery: bool = True
+     map_seed: Optional[int] = None
+     render_mode: str = "text"
+     observation_format: str = "grid"
+diff --git a/scripts/runs/bandit_jobs.sh b/scripts/runs/bandit_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/frozenlake_jobs.sh b/scripts/runs/frozenlake_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/sokoban_jobs.sh b/scripts/runs/sokoban_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/webshop_jobs.sh b/scripts/runs/webshop_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/train_all.sh b/train_all.sh
+old mode 100755
+new mode 100644
+Submodule verl contains modified content
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh b/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh b/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/recipe/sppo/run_qwen2.5-7b_rm.sh b/verl/recipe/sppo/run_qwen2.5-7b_rm.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/generate_trainer_config.sh b/verl/scripts/generate_trainer_config.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/install_vllm_sglang_mcore.sh b/verl/scripts/install_vllm_sglang_mcore.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/generation/run_gen_qwen05.sh b/verl/tests/special_e2e/generation/run_gen_qwen05.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/run_one_step_off_policy.sh b/verl/tests/special_e2e/run_one_step_off_policy.sh
+old mode 100755
+new mode 100644

wandb/run-20260513_143037-5nbglqlm/files/diff_b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0.patch

@@ -0,0 +1,536 @@
+diff --git a/config/_10_rubikscube.yaml b/config/_10_rubikscube.yaml
+index 277a8b1..a99b6a8 100644
+--- a/config/_10_rubikscube.yaml
++++ b/config/_10_rubikscube.yaml
+@@ -5,7 +5,7 @@ system:
+   CUDA_VISIBLE_DEVICES: "0,1,2,3"
+ 
+ trainer:
+-  experiment_name: 2048
++  experiment_name: rubikscube
+   n_gpus_per_node: 4
+ 
+ actor_rollout_ref:
+diff --git a/config/base.yaml b/config/base.yaml
+index 6029703..c10ab55 100644
+--- a/config/base.yaml
++++ b/config/base.yaml
+@@ -10,8 +10,8 @@ seed:
+   val: 123
+ 
+ micro_batch_size_per_gpu: 1
+-ppo_mini_batch_size: 32
+-model_path: 
++ppo_mini_batch_size: 16 #****
++model_path: /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ # /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ enable_response_mask: True # Enabling response mask could improve stability of rollout/old_log_prob, as P(st|history) are no longer calculated in loss here. See https://docs.google.com/document/d/1bg7obeiKTExuHHBl5uOiSpec5uLDZ2Tgvxy6li5pHX4/edit?usp=sharing for more details.
+ grpo_advantage_length_weight: False # if you do not enable this and critic/advantage_estimator is GRPO, and the critic/advantages/mean is too low, then you can try enabling this to encourage reasoning and forbid collapse
+@@ -48,11 +48,11 @@ actor_rollout_ref:
+     name: vllm
+     log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu} # following micro_batch_size_per_gpu
+     tensor_model_parallel_size: 1
+-    max_model_len: 16384 #3600 why** 14400
++    max_model_len: 16384 #3600 why** 14400 
+     prompt_length: 1 # useless. Just put it here
+-    response_length: 400 # single-turn response length
+-    gpu_memory_utilization: 0.7
+-    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true
++    response_length: 128 # single-turn response length 400 ****
++    gpu_memory_utilization: 0.6
++    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true 
+     temperature: 1
+     rollout_filter_ratio: 0.25
+     rollout_filter_type: largest # smallest or largest
+@@ -111,7 +111,7 @@ trainer:
+ 
+ agent_proxy:
+   max_context_window: -1 # set a value > 0 to enable context window for long trajectory
+-  max_turn: 25 #25 why** 700
++  max_turn: 15 #25 why** 700
+   action_sep: "||"
+   max_actions_per_turn: 1 # how many actions can be output at most in a single turn
+   use_turn_scores: False # important to GAE when applying token-level rewards to token-level advantages. If False, will take the sum of scores as the reward for the last turn.
+@@ -123,7 +123,7 @@ agent_proxy:
+ es_manager:
+   format_penalty: -0.1
+   train:
+-    env_groups: 8
++    env_groups: 8 
+     # under the same group, the env config and env seed are ensured to be equal
+     group_size: 16
+     env_configs:
+diff --git a/config/envs.yaml b/config/envs.yaml
+index d258d15..d7d687d 100644
+--- a/config/envs.yaml
++++ b/config/envs.yaml
+@@ -231,7 +231,7 @@ custom_envs:
+       Example: <answer>U</answer>
+     max_tokens: 96
+     env_config:
+-      scramble_depth: 3
++      scramble_depth: 5
+       max_steps: 20
+       render_mode: "text"
+   
+diff --git a/config/eval.yaml b/config/eval.yaml
+index 0802a0d..98d71dd 100644
+--- a/config/eval.yaml
++++ b/config/eval.yaml
+@@ -8,7 +8,7 @@ seed:
+   train: 10000
+   val: 123
+ 
+-model_path: /mnt/general/wanghy/RAGEN/saves/qwen3b_it_fromit_think_sudoku_sequence_multitask/global_step_200/qwen2.5_3b_actor_hf
++model_path: /mnt/general/wanghy/RAGEN/saves/qwen3B_it_think_rubikscube2_frommlpsave/global_step_50/qwen2.5_7B_actor_hf
+ # /mnt/general/share/model/tyzhu/SPA-frozenlake-qwen2.5-1.5b-instruct
+ 
+ lora:
+diff --git a/config/evaluate_api_llm.yaml b/config/evaluate_api_llm.yaml
+index bcbf206..9fe6f71 100644
+--- a/config/evaluate_api_llm.yaml
++++ b/config/evaluate_api_llm.yaml
+@@ -5,7 +5,7 @@ defaults:
+   - base # this is a symbolic link to the verl/verl/trainer/config/ppo_trainer.yaml file
+ 
+ model_config:
+-  model_name: TA/openai/gpt-oss-120b # should be registered in model_info
++  model_name: ark-deepseek-v3-250324 # should be registered in model_info
+   max_concurrency: 16
+ 
+ model_info:
+@@ -39,27 +39,21 @@ model_info:
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  ark-deepseek-v3-250324:
+-    provider_name: openai
+-    model_name: ark-deepseek-v3-250324
+-    generation_kwargs:
+-      temperature: 0
+-      max_completion_tokens: 512
+   deepseek-v3:
+     provider_name: deepseek
+     model_name: deepseek-chat
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  glm-4.6:
++  ark-deepseek-v3-250324:
+     provider_name: openai
+-    model_name: glm-4.6
++    model_name: ark-deepseek-v3-250324
+     generation_kwargs:
+       temperature: 0
+-      max_completion_tokens: 512
+-  TA/openai/gpt-oss-120b:
++      max_tokens: 8192
++  gemini-2.5-pro:
+     provider_name: openai
+-    model_name: TA/openai/gpt-oss-120b
++    model_name: gemini-2.5-pro
+     generation_kwargs:
+       temperature: 0
+       max_tokens: 8192
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+deleted file mode 120000
+index e1061c0..0000000
+--- a/config/ppo_trainer.yaml
++++ /dev/null
+@@ -1 +0,0 @@
+-../verl/verl/trainer/config/ppo_trainer.yaml
+
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+new file mode 100644
+index 0000000..c821483
+--- /dev/null
++++ b/config/ppo_trainer.yaml
+@@ -0,0 +1,308 @@
++# Format checks enforced on CI:
++# 1. Comments must appear above each field.
++# 2. There must be a blank line between each field.
++# 3. Inline comments (after a field on the same line) are not allowed.
++# 4. Indentation level is respected for nested fields.
++
++# specify the default per-component configs
++defaults:
++
++  # <folder_name>@<field_name>.<field_name>: <yaml_file_name>
++  # actor_rollout_ref.actor: trainer/config/actor/dp_actor.yaml
++  - actor@actor_rollout_ref.actor: dp_actor
++
++  # data: trainer/config/data/legacy_data.yaml
++  - data@data: legacy_data
++
++  # Reference model config.
++  # Reference model will be enabled when actor.use_kl_loss or/and algorithm.use_kl_in_reward is/are True.
++  - ref@actor_rollout_ref.ref: dp_ref
++
++  # Rollout model config.
++  - rollout@actor_rollout_ref.rollout: rollout
++
++  # Model config.
++  - model@actor_rollout_ref.model: hf_model
++
++  # Critic model config.
++  - critic@critic: dp_critic
++
++  # Reward model config.
++  - reward_model@reward_model: dp_reward_model
++
++  # load the reference default config, then apply the fields in the current yaml
++  # self config override anything above
++  - _self_
++
++# config for actor, rollout and reference model
++actor_rollout_ref:
++
++  # Whether it's a hybrid engine, currently only supports hybrid engine
++  hybrid_engine: true
++
++  # Timeout for operations executed against the process group
++  nccl_timeout: 600
++
++  # Rollout model config.
++  rollout:
++
++    # for huge model, layered summon can save memory (prevent OOM) but make it slower
++    layered_summon: False
++
++# custom reward function definition
++custom_reward_function:
++
++  # The path to the file containing your customized reward function.
++  # If not specified, pre-implemented reward functions will be used.
++  path: null
++
++  # The name of the reward function within the specified file. Default is 'compute_score'.
++  name: compute_score
++
++# config for the algorithm
++algorithm:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.trainer.config.AlgoConfig
++
++  # Discount factor for future rewards
++  gamma: 1.0
++
++  # Trade-off between bias and variance in the GAE estimator
++  lam: 1.0
++
++  # Advantage estimator type: "gae", "grpo", "reinforce_plus_plus", etc.
++  adv_estimator: gae
++
++  # Whether to normalize advantages by std (specific to GRPO)
++  norm_adv_by_std_in_grpo: True
++
++  # Whether to enable in-reward KL penalty
++  use_kl_in_reward: False
++
++  # How to estimate KL divergence: "kl", "abs", "mse", "low_var_kl", or "full"
++  kl_penalty: kl
++
++  # KL control configuration
++  kl_ctrl:
++
++    # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++    _target_: verl.trainer.config.KLControlConfig
++
++    # KL control type: "fixed" or "adaptive"
++    type: fixed
++
++    # Initial coefficient for KL penalty
++    kl_coef: 0.001
++
++    # Horizon value for adaptive controller (if enabled)
++    horizon: 10000
++
++    # Target KL divergence (used for adaptive controller)
++    target_kl: 0.1
++
++  # Whether to enable preference feedback PPO
++  use_pf_ppo: False
++
++  # Preference feedback PPO settings
++  pf_ppo:
++
++    # Method for reweighting samples: "pow", "max_min", or "max_random"
++    reweight_method: pow
++
++    # Power used for weight scaling in "pow" method
++    weight_pow: 2.0
++
++# config for the trainer
++trainer:
++
++  # Whether to balance batch sizes across distributed workers
++  balance_batch: True
++
++  # Number of epochs in training
++  total_epochs: 30
++
++  # Total training steps (can be set explicitly or derived from epochs)
++  total_training_steps: null
++
++  # Project name for experiment tracking (e.g., wandb)
++  project_name: verl_examples
++
++  # Experiment name for run identification in tracking tools
++  experiment_name: gsm8k
++
++  # Logging backends to use: "console", "wandb", etc.
++  logger: ["console", "wandb"]
++
++  # Number of generations to log during validation
++  log_val_generations: 0
++
++  # Directory for logging rollout data; no dump if null
++  rollout_data_dir: null
++
++  # Directory for logging validation data; no dump if null
++  validation_data_dir: null
++
++  # Number of nodes used in the training
++  nnodes: 1
++
++  # Number of GPUs per node
++  n_gpus_per_node: 8
++
++  # Save frequency (by iteration) for model checkpoints
++  save_freq: -1
++
++  # ESI refers to the elastic server instance used during training, similar to the training plan. For example,
++  # if you purchase 10 hours of computing power, the ESI will automatically shut down after 10 hours of training.
++  # To ensure a checkpoint is saved before ESI shuts down, the system will start saving a checkpoint in advance.
++  # The advance time is calculated as: Advance Time = Longest historical step duration + Checkpoint save duration + esi_redundant_time.
++  # Here, esi_redundant_time is a user-defined value that further extends the advance time for added safety.
++  esi_redundant_time: 0
++
++  # Resume mode: "auto", "disable", or "resume_path"
++  # "auto": resume from last checkpoint if available
++  # "disable": start from scratch
++  # "resume_path": resume from a user-defined path
++  resume_mode: auto
++
++  # Path to resume training from (only used when resume_mode is "resume_path")
++  resume_from_path: null
++
++  # Whether to run validation before training begins
++  val_before_train: True
++
++  # Whether to run validation only
++  val_only: False
++
++  # Validation frequency (in training iterations)
++  test_freq: -1
++
++  # Number of iterations to warm up the critic before updating policy
++  critic_warmup: 0
++
++  # Default path to distributed filesystem for saving checkpoints
++  default_hdfs_dir: null
++
++  # Whether to delete local checkpoints after loading
++  del_local_ckpt_after_load: False
++
++  # Default local directory for saving checkpoints
++  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
++
++  # Maximum number of actor checkpoints to keep
++  max_actor_ckpt_to_keep: null
++
++  # Maximum number of critic checkpoints to keep
++  max_critic_ckpt_to_keep: null
++
++  # Timeout (in seconds) for Ray worker to wait for registration
++  ray_wait_register_center_timeout: 300
++
++  # Device to run training on (e.g., "cuda", "cpu")
++  device: cuda
++
++  # whether to use legacy worker implementation
++  #  mode: "auto", "enable", or "disable"
++  use_legacy_worker_impl: auto
++
++# profiler configs
++global_profiler:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.utils.profiler.ProfilerConfig
++
++  # Profiling tool: choose between nsys, npu, torch, torch_memory
++  tool: null
++
++  # profile steps
++  steps: null
++
++  # Whether to combine continuous steps into one database.
++  ## If True, worker.profiler.discrete must be False, [1,2] in one, [5] in another.
++  ## If False, [1] in one, [2] in another, [5] in another.
++  profile_continuous_steps: False
++
++  # Path to save profiling contents
++  save_path: "outputs/profile"
++
++  # Specific tool configs, can use +profiler.tool_config.[tool].xxx to config
++  global_tool_config:
++
++    # nsys config
++    nsys:
++
++      # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++      _target_: verl.utils.profiler.config.NsightToolConfig
++
++      # True for each task has its own database, False for all tasks in one training step share one database.
++      discrete: False
++
++      # controller Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      ## reference https://docs.nvidia.com/nsight-systems/UserGuide/index.html
++      ## reference https://docs.ray.io/en/latest/ray-observability/user-guides/profiling.html
++      controller_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++      # worker Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      worker_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++        # Profiling only in a range of torch.cuda.profiler.start and stop. Do not change this config.
++        capture-range: "cudaProfilerApi"
++
++        # Specify the desired behavior when a capture range ends.
++        # In verl we need the torch.cuda.profiler.start/stop pair to repeats n times.
++        # valid values are "repeat-shutdown:n" or null.
++        # For normal whole step profiling, n = len(profile_steps);
++        # but for discrete profiling, n = len(profile_steps) * Number(subtasks).
++        # Or you can just leave it null and the program will use n = len(profile_steps) * 6;
++        capture-range-end: null
++
++        # Send signal to the target application's process group. We let the program to exit by itself.
++        kill: none
++
++    # enable memory visualization for debugging memory usage
++    torch_memory:
++
++      #  Maximum number of allocation entries to record
++      trace_alloc_max_entries: 100_000
++
++      # The depth of the call stack to capture for each allocation
++      stack_depth: 32
++
++      # 'alloc': records only allocation events || 'state': records memory state changes || 'all': records both.
++      context: "all"
++
++      # 'python': records Python stacks || 'cpp': records C++ stacks (available in some versions) || 'all': records both.
++      stacks: "all"
++
++      # devices, record_context etc.
++      kw_args: {}
++
++# configs related to ray
++ray_kwargs:
++
++  # configs related to ray initialization
++  ray_init:
++
++    # Number of CPUs for Ray. Use a fixed number instead of null when using SLURM.
++    num_cpus: null
++
++  # Path to save Ray timeline JSON for performance profiling
++  timeline_json_file: null
+Submodule external/kimina-lean-server contains modified content
+diff --git a/external/kimina-lean-server/setup.sh b/external/kimina-lean-server/setup.sh
+old mode 100755
+new mode 100644
+Submodule external/webshop-minimal contains modified content
+diff --git a/external/webshop-minimal/requirements.txt b/external/webshop-minimal/requirements.txt
+index 5a1b04f..238ed5a 100644
+--- a/external/webshop-minimal/requirements.txt
++++ b/external/webshop-minimal/requirements.txt
+@@ -4,7 +4,7 @@ flask
+ html2text
+ rank_bm25
+ pyserini
+-faiss-cpu
++faiss-gpu
+ thefuzz
+ gdown
+ spacy
+diff --git a/ragen/env/frozen_lake/config.py b/ragen/env/frozen_lake/config.py
+index 9950c34..de054f4 100644
+--- a/ragen/env/frozen_lake/config.py
++++ b/ragen/env/frozen_lake/config.py
+@@ -8,7 +8,7 @@ class FrozenLakeEnvConfig:
+     size: int = 4
+     p: float = 0.9
+     success_rate: float = 0.8
+-    is_slippery: bool = False
++    is_slippery: bool = True
+     map_seed: Optional[int] = None
+     render_mode: str = "text"
+     observation_format: str = "grid"
+diff --git a/scripts/runs/bandit_jobs.sh b/scripts/runs/bandit_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/frozenlake_jobs.sh b/scripts/runs/frozenlake_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/sokoban_jobs.sh b/scripts/runs/sokoban_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/webshop_jobs.sh b/scripts/runs/webshop_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/train_all.sh b/train_all.sh
+old mode 100755
+new mode 100644
+Submodule verl contains modified content
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh b/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh b/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/recipe/sppo/run_qwen2.5-7b_rm.sh b/verl/recipe/sppo/run_qwen2.5-7b_rm.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/generate_trainer_config.sh b/verl/scripts/generate_trainer_config.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/install_vllm_sglang_mcore.sh b/verl/scripts/install_vllm_sglang_mcore.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/generation/run_gen_qwen05.sh b/verl/tests/special_e2e/generation/run_gen_qwen05.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/run_one_step_off_policy.sh b/verl/tests/special_e2e/run_one_step_off_policy.sh
+old mode 100755
+new mode 100644

wandb/run-20260513_143037-5nbglqlm/files/requirements.txt

@@ -0,0 +1,316 @@
+colorama==0.4.6
+psutil==7.2.2
+pyarrow==23.0.1
+math-verify==0.9.0
+pygame==2.6.1
+partial-json-parser==0.2.1.1.post7
+anyio==4.13.0
+wandb==0.25.1
+mathruler==0.1.0
+tzdata==2026.1
+gym-sokoban==0.0.6
+sniffio==1.3.1
+omegaconf==2.3.0
+httpcore==1.0.9
+scipy==1.15.3
+multidict==6.7.1
+nvidia-cusparse-cu12==12.3.1.170
+fonttools==4.62.1
+together==2.7.0
+antlr4-python3-runtime==4.9.3
+cupy-cuda12x==13.6.0
+av==17.0.0
+torch==2.6.0
+datasets==4.8.4
+pyparsing==3.3.2
+markdown-it-py==4.0.0
+accelerate==1.13.0
+lark==1.2.2
+sentencepiece==0.2.1
+Flask==3.1.3
+annotated-doc==0.0.4
+rignore==0.7.6
+ImageIO==2.37.3
+outlines_core==0.1.26
+gym==0.26.2
+depyf==0.18.0
+pydantic==2.12.5
+nvidia-cuda-nvrtc-cu12==12.4.127
+certifi==2026.2.25
+aiohttp==3.13.5
+flash_attn==2.7.4.post1
+msgspec==0.21.0
+matplotlib==3.10.8
+pandas==2.3.3
+openai==2.31.0
+sentry-sdk==2.57.0
+propcache==0.4.1
+nvidia-curand-cu12==10.3.5.147
+python-dateutil==2.9.0.post0
+itsdangerous==2.2.0
+cloudpickle==3.1.2
+ray==2.54.1
+cffi==2.0.0
+pyzmq==27.1.0
+Jinja2==3.1.6
+nest-asyncio==1.6.0
+orjson==3.11.8
+pydantic-extra-types==2.11.2
+nvidia-nccl-cu12==2.21.5
+gitdb==4.0.12
+Farama-Notifications==0.0.4
+async-timeout==5.0.1
+torchdata==0.11.0
+ninja==1.13.0
+hydra-core==1.3.2
+GitPython==3.1.46
+nvidia-cuda-runtime-cu12==12.4.127
+msgpack==1.1.2
+email-validator==2.3.0
+yarl==1.23.0
+numpy==1.26.4
+charset-normalizer==3.4.7
+pycountry==26.2.16
+annotated-types==0.7.0
+uvloop==0.22.1
+torchvision==0.21.0
+jsonschema-specifications==2025.9.1
+uvicorn==0.44.0
+nvidia-nvjitlink-cu12==12.4.127
+sympy==1.13.1
+latex2sympy2_extended==1.11.0
+triton==3.2.0
+tqdm==4.67.3
+diskcache==5.6.3
+kiwisolver==1.5.0
+llguidance==0.7.30
+prometheus_client==0.25.0
+types-PyYAML==6.0.12.20260408
+MarkupSafe==3.0.3
+fastapi-cloud-cli==0.16.1
+cachetools==7.0.5
+pillow==12.2.0
+airportsdata==20260315
+mpmath==1.3.0
+cycler==0.12.1
+qwen-vl-utils==0.0.14
+jsonschema==4.26.0
+safetensors==0.7.0
+gymnasium==1.2.3
+h11==0.16.0
+Pygments==2.20.0
+zipp==3.23.0
+outlines==0.1.11
+typing_extensions==4.15.0
+requests==2.33.1
+watchfiles==1.1.1
+shellingham==1.5.4
+xformers==0.0.29.post2
+blinker==1.9.0
+distro==1.9.0
+multiprocess==0.70.19
+regex==2026.4.4
+fastapi-cli==0.0.24
+tabulate==0.10.0
+referencing==0.37.0
+xxhash==3.6.0
+smmap==5.0.3
+six==1.17.0
+Werkzeug==3.1.8
+click==8.3.2
+py-cpuinfo==9.0.0
+aiosignal==1.4.0
+setuptools==69.1.0
+setuptools==82.0.1
+aiohappyeyeballs==2.6.1
+starlette==0.52.1
+gym-notices==0.1.0
+typing-inspection==0.4.2
+networkx==3.4.2
+pydantic_core==2.41.5
+pycparser==3.0
+contourpy==1.3.2
+codetiming==1.4.0
+python-dotenv==1.2.2
+rpds-py==0.30.0
+blake3==1.0.8
+python-multipart==0.0.24
+fastapi==0.135.3
+httpx==0.28.1
+attrs==26.1.0
+pytz==2026.1.post1
+platformdirs==4.9.6
+nvidia-cusolver-cu12==11.6.1.9
+hf-xet==1.4.3
+filelock==3.25.2
+types-requests==2.33.0.20260408
+idna==3.11
+fsspec==2026.2.0
+astor==0.8.1
+interegular==0.3.3
+nvidia-cudnn-cu12==9.1.0.70
+frozenlist==1.8.0
+pylatexenc==2.10
+nvidia-cublas-cu12==12.4.5.8
+httptools==0.7.1
+python-json-logger==4.1.0
+mdurl==0.1.2
+mistral_common==1.11.0
+vulkan==1.3.275.1
+nvidia-cuda-cupti-cu12==12.4.127
+pybind11==3.0.3
+PyYAML==6.0.3
+jiter==0.13.0
+fastrlock==0.8.3
+typeguard==4.5.1
+typer==0.24.1
+websockets==16.0
+nvidia-cufft-cu12==11.2.1.3
+nvidia-nvtx-cu12==12.4.127
+psutil==7.2.2
+tomli==2.4.1
+types-tqdm==4.67.3.20260408
+fastar==0.10.0
+einops==0.8.2
+lm-format-enforcer==0.10.12
+opencv-python-headless==4.11.0.86
+tiktoken==0.12.0
+rich-toolkit==0.19.7
+rich==14.3.3
+dnspython==2.8.0
+pydantic-settings==2.13.1
+types-tabulate==0.10.0.20260408
+torchaudio==2.6.0
+urllib3==2.6.3
+dill==0.4.1
+docstring_parser==0.18.0
+prometheus-fastapi-instrumentator==7.1.0
+peft==0.18.1
+exceptiongroup==1.3.1
+tyro==1.0.13
+nvidia-cusparselt-cu12==0.6.2
+packaging==26.0
+wheel==0.46.3
+pip==26.0.1
+pyjnius==1.7.0
+pure_eval==0.2.3
+ptyprocess==0.7.0
+flatbuffers==25.12.19
+faiss-gpu==1.7.2
+wrapt==2.1.2
+wcwidth==0.6.0
+wasabi==1.1.3
+traitlets==5.14.3
+threadpoolctl==3.6.0
+tenacity==9.1.4
+spacy-loggers==1.0.5
+spacy-legacy==3.0.12
+soupsieve==2.8.3
+RapidFuzz==3.14.5
+rank-bm25==0.2.2
+PySocks==1.7.1
+PyJWT==2.12.1
+parso==0.8.6
+protobuf==4.25.9
+pexpect==4.9.0
+opentelemetry-semantic-conventions-ai==0.4.13
+murmurhash==1.0.15
+loguru==0.7.3
+joblib==1.5.3
+humanfriendly==10.0
+httpx-sse==0.4.3
+html2text==2025.4.15
+grpcio==1.80.0
+executing==2.2.1
+decorator==5.2.1
+debugpy==1.8.20
+Cython==3.2.4
+cymem==2.0.13
+confection==1.3.3
+colorama==0.4.6
+cloudpathlib==0.23.0
+catalogue==2.0.10
+blis==1.3.3
+asttokens==3.0.1
+thefuzz==0.22.1
+stack-data==0.6.3
+srsly==2.5.3
+smart_open==7.6.0
+scikit-learn==1.7.2
+prompt_toolkit==3.0.52
+preshed==3.0.13
+opentelemetry-proto==1.26.0
+nltk==3.9.4
+matplotlib-inline==0.2.1
+jedi==0.19.2
+googleapis-common-protos==1.74.0
+Deprecated==1.3.1
+cryptography==46.0.7
+coloredlogs==15.0.1
+beautifulsoup4==4.14.3
+thinc==8.3.13
+opentelemetry-exporter-otlp-proto-common==1.26.0
+onnxruntime==1.23.2
+ipython==8.39.0
+gdown==6.0.0
+cleantext==1.1.4
+weasel==1.0.0
+tensordict==0.8.3
+sse-starlette==3.3.4
+mcp==1.27.0
+anthropic==0.96.0
+spacy==3.8.14
+opentelemetry-exporter-otlp-proto-http==1.26.0
+opentelemetry-exporter-otlp-proto-grpc==1.26.0
+kimina-client==0.2.1
+pyserini==1.2.0
+opentelemetry-exporter-otlp==1.26.0
+compressed-tensors==0.9.2
+vllm==0.8.2
+py-spy==0.4.1
+opencensus-context==0.1.3
+distlib==0.4.0
+colorful==0.5.8
+tensorboard-data-server==0.7.2
+python-discovery==1.2.2
+pyasn1==0.6.3
+proto-plus==1.27.2
+Markdown==3.10.2
+absl-py==2.4.0
+virtualenv==21.2.4
+tensorboard==2.20.0
+pyasn1_modules==0.4.2
+opentelemetry-api==1.24.0
+google-auth==2.49.2
+google-api-core==2.30.3
+aiohttp-cors==0.8.1
+opentelemetry-exporter-prometheus==0.62b0
+opencensus==0.11.4
+verl==0.5.0.dev0
+huggingface_hub==0.36.2
+opentelemetry-semantic-conventions==0.45b0
+opentelemetry-sdk==1.24.0
+llvmlite==0.43.0
+tokenizers==0.21.4
+gguf==0.10.0
+importlib-metadata==7.0.0
+hjson==3.1.0
+deepspeed==0.16.9
+transformers==4.51.1
+xgrammar==0.1.16
+ragen==0.1
+numba==0.60.0
+ragen==0.1
+verl==0.5.0.dev0
+autocommand==2.2.2
+backports.tarfile==1.2.0
+importlib_metadata==8.7.1
+jaraco.text==4.0.0
+jaraco.context==6.1.0
+jaraco.functools==4.4.0
+more-itertools==10.8.0
+packaging==26.0
+platformdirs==4.4.0
+tomli==2.4.0
+wheel==0.46.3
+zipp==3.23.0

wandb/run-20260513_143037-5nbglqlm/files/wandb-metadata.json

@@ -0,0 +1,89 @@
+{
+  "os": "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python": "CPython 3.10.20",
+  "startedAt": "2026-05-13T06:30:37.049177Z",
+  "program": "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py",
+  "codePath": "cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py",
+  "codePathLocal": "cleanrl/cleanrl/scout_dqn/noisy_dqn_sokoban.py",
+  "git": {
+    "remote": "https://github.com/Harry-mic/SCOUT",
+    "commit": "b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0"
+  },
+  "email": "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root": "/mnt/general/wanghy/RAGEN",
+  "host": "pt-a7f17fedde804edca572f81ace5fcaf3-worker-0",
+  "executable": "/opt/conda/envs/ragen_new/bin/python",
+  "cpu_count": 64,
+  "cpu_count_logical": 128,
+  "gpu": "NVIDIA H100 80GB HBM3",
+  "gpu_count": 8,
+  "disk": {
+    "/": {
+      "total": "60129542144000",
+      "used": "67078225920"
+    }
+  },
+  "memory": {
+    "total": "2159579672576"
+  },
+  "gpu_nvidia": [
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-97b3b912-40cf-f573-ffce-8275a656891f"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-5e4acc7a-f7ab-1a15-312e-4e2a39c43b2c"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-b36695ed-370a-2556-79d8-b0a2c2659271"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-b3e13ca7-237c-931f-894b-798f9cfa5620"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-64647b1f-5d55-1b7e-bf3d-64fae3871140"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-fe8b9b7e-82a4-1238-4843-bbfd0269d746"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-4523d4e1-5745-8224-7bcd-44cf59b76bae"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-9262bcbd-a29f-d761-3330-ac2ce9f15e82"
+    }
+  ],
+  "cudaVersion": "12.4",
+  "writerId": "xkjtt1054j25k2rxc53pvzqxyzin9js2"
+}

wandb/run-20260513_143037-5nbglqlm/files/wandb-summary.json

@@ -0,0 +1 @@
+{"charts/epsilon":0.1,"_runtime":7428.111123057,"rollout/episodic_length":99,"train/loss":0.009805000387132168,"rollout/episodic_return":2.100000000000019,"eval/avg_return":3.706750000000006,"eval/episodes":400,"rollout/success_rate_100":0.79,"eval/std_return":10.118252291650956,"global_step":1000000,"_timestamp":1.7786612665129719e+09,"perf/SPS":161,"_wandb":{"runtime":7428},"rollout/success":1,"_step":1000000,"eval/success_rate":0.635}

wandb/run-20260513_143037-5nbglqlm/run-5nbglqlm.wandb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cbbacac8fa0e1cdcec1378a5d553895ec38a42107d3b15d57d34018daf9dc98
+size 133753019

wandb/run-20260515_161238-gu8o8dz5/files/code/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 = 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 = 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()

wandb/run-20260515_161238-gu8o8dz5/files/diff.patch

@@ -0,0 +1,536 @@
+diff --git a/config/_10_rubikscube.yaml b/config/_10_rubikscube.yaml
+index 277a8b1..a99b6a8 100644
+--- a/config/_10_rubikscube.yaml
++++ b/config/_10_rubikscube.yaml
+@@ -5,7 +5,7 @@ system:
+   CUDA_VISIBLE_DEVICES: "0,1,2,3"
+ 
+ trainer:
+-  experiment_name: 2048
++  experiment_name: rubikscube
+   n_gpus_per_node: 4
+ 
+ actor_rollout_ref:
+diff --git a/config/base.yaml b/config/base.yaml
+index 6029703..c10ab55 100644
+--- a/config/base.yaml
++++ b/config/base.yaml
+@@ -10,8 +10,8 @@ seed:
+   val: 123
+ 
+ micro_batch_size_per_gpu: 1
+-ppo_mini_batch_size: 32
+-model_path: 
++ppo_mini_batch_size: 16 #****
++model_path: /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ # /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ enable_response_mask: True # Enabling response mask could improve stability of rollout/old_log_prob, as P(st|history) are no longer calculated in loss here. See https://docs.google.com/document/d/1bg7obeiKTExuHHBl5uOiSpec5uLDZ2Tgvxy6li5pHX4/edit?usp=sharing for more details.
+ grpo_advantage_length_weight: False # if you do not enable this and critic/advantage_estimator is GRPO, and the critic/advantages/mean is too low, then you can try enabling this to encourage reasoning and forbid collapse
+@@ -48,11 +48,11 @@ actor_rollout_ref:
+     name: vllm
+     log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu} # following micro_batch_size_per_gpu
+     tensor_model_parallel_size: 1
+-    max_model_len: 16384 #3600 why** 14400
++    max_model_len: 16384 #3600 why** 14400 
+     prompt_length: 1 # useless. Just put it here
+-    response_length: 400 # single-turn response length
+-    gpu_memory_utilization: 0.7
+-    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true
++    response_length: 128 # single-turn response length 400 ****
++    gpu_memory_utilization: 0.6
++    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true 
+     temperature: 1
+     rollout_filter_ratio: 0.25
+     rollout_filter_type: largest # smallest or largest
+@@ -111,7 +111,7 @@ trainer:
+ 
+ agent_proxy:
+   max_context_window: -1 # set a value > 0 to enable context window for long trajectory
+-  max_turn: 25 #25 why** 700
++  max_turn: 15 #25 why** 700
+   action_sep: "||"
+   max_actions_per_turn: 1 # how many actions can be output at most in a single turn
+   use_turn_scores: False # important to GAE when applying token-level rewards to token-level advantages. If False, will take the sum of scores as the reward for the last turn.
+@@ -123,7 +123,7 @@ agent_proxy:
+ es_manager:
+   format_penalty: -0.1
+   train:
+-    env_groups: 8
++    env_groups: 8 
+     # under the same group, the env config and env seed are ensured to be equal
+     group_size: 16
+     env_configs:
+diff --git a/config/envs.yaml b/config/envs.yaml
+index d258d15..d7d687d 100644
+--- a/config/envs.yaml
++++ b/config/envs.yaml
+@@ -231,7 +231,7 @@ custom_envs:
+       Example: <answer>U</answer>
+     max_tokens: 96
+     env_config:
+-      scramble_depth: 3
++      scramble_depth: 5
+       max_steps: 20
+       render_mode: "text"
+   
+diff --git a/config/eval.yaml b/config/eval.yaml
+index 0802a0d..98d71dd 100644
+--- a/config/eval.yaml
++++ b/config/eval.yaml
+@@ -8,7 +8,7 @@ seed:
+   train: 10000
+   val: 123
+ 
+-model_path: /mnt/general/wanghy/RAGEN/saves/qwen3b_it_fromit_think_sudoku_sequence_multitask/global_step_200/qwen2.5_3b_actor_hf
++model_path: /mnt/general/wanghy/RAGEN/saves/qwen3B_it_think_rubikscube2_frommlpsave/global_step_50/qwen2.5_7B_actor_hf
+ # /mnt/general/share/model/tyzhu/SPA-frozenlake-qwen2.5-1.5b-instruct
+ 
+ lora:
+diff --git a/config/evaluate_api_llm.yaml b/config/evaluate_api_llm.yaml
+index bcbf206..9fe6f71 100644
+--- a/config/evaluate_api_llm.yaml
++++ b/config/evaluate_api_llm.yaml
+@@ -5,7 +5,7 @@ defaults:
+   - base # this is a symbolic link to the verl/verl/trainer/config/ppo_trainer.yaml file
+ 
+ model_config:
+-  model_name: TA/openai/gpt-oss-120b # should be registered in model_info
++  model_name: ark-deepseek-v3-250324 # should be registered in model_info
+   max_concurrency: 16
+ 
+ model_info:
+@@ -39,27 +39,21 @@ model_info:
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  ark-deepseek-v3-250324:
+-    provider_name: openai
+-    model_name: ark-deepseek-v3-250324
+-    generation_kwargs:
+-      temperature: 0
+-      max_completion_tokens: 512
+   deepseek-v3:
+     provider_name: deepseek
+     model_name: deepseek-chat
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  glm-4.6:
++  ark-deepseek-v3-250324:
+     provider_name: openai
+-    model_name: glm-4.6
++    model_name: ark-deepseek-v3-250324
+     generation_kwargs:
+       temperature: 0
+-      max_completion_tokens: 512
+-  TA/openai/gpt-oss-120b:
++      max_tokens: 8192
++  gemini-2.5-pro:
+     provider_name: openai
+-    model_name: TA/openai/gpt-oss-120b
++    model_name: gemini-2.5-pro
+     generation_kwargs:
+       temperature: 0
+       max_tokens: 8192
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+deleted file mode 120000
+index e1061c0..0000000
+--- a/config/ppo_trainer.yaml
++++ /dev/null
+@@ -1 +0,0 @@
+-../verl/verl/trainer/config/ppo_trainer.yaml
+
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+new file mode 100644
+index 0000000..c821483
+--- /dev/null
++++ b/config/ppo_trainer.yaml
+@@ -0,0 +1,308 @@
++# Format checks enforced on CI:
++# 1. Comments must appear above each field.
++# 2. There must be a blank line between each field.
++# 3. Inline comments (after a field on the same line) are not allowed.
++# 4. Indentation level is respected for nested fields.
++
++# specify the default per-component configs
++defaults:
++
++  # <folder_name>@<field_name>.<field_name>: <yaml_file_name>
++  # actor_rollout_ref.actor: trainer/config/actor/dp_actor.yaml
++  - actor@actor_rollout_ref.actor: dp_actor
++
++  # data: trainer/config/data/legacy_data.yaml
++  - data@data: legacy_data
++
++  # Reference model config.
++  # Reference model will be enabled when actor.use_kl_loss or/and algorithm.use_kl_in_reward is/are True.
++  - ref@actor_rollout_ref.ref: dp_ref
++
++  # Rollout model config.
++  - rollout@actor_rollout_ref.rollout: rollout
++
++  # Model config.
++  - model@actor_rollout_ref.model: hf_model
++
++  # Critic model config.
++  - critic@critic: dp_critic
++
++  # Reward model config.
++  - reward_model@reward_model: dp_reward_model
++
++  # load the reference default config, then apply the fields in the current yaml
++  # self config override anything above
++  - _self_
++
++# config for actor, rollout and reference model
++actor_rollout_ref:
++
++  # Whether it's a hybrid engine, currently only supports hybrid engine
++  hybrid_engine: true
++
++  # Timeout for operations executed against the process group
++  nccl_timeout: 600
++
++  # Rollout model config.
++  rollout:
++
++    # for huge model, layered summon can save memory (prevent OOM) but make it slower
++    layered_summon: False
++
++# custom reward function definition
++custom_reward_function:
++
++  # The path to the file containing your customized reward function.
++  # If not specified, pre-implemented reward functions will be used.
++  path: null
++
++  # The name of the reward function within the specified file. Default is 'compute_score'.
++  name: compute_score
++
++# config for the algorithm
++algorithm:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.trainer.config.AlgoConfig
++
++  # Discount factor for future rewards
++  gamma: 1.0
++
++  # Trade-off between bias and variance in the GAE estimator
++  lam: 1.0
++
++  # Advantage estimator type: "gae", "grpo", "reinforce_plus_plus", etc.
++  adv_estimator: gae
++
++  # Whether to normalize advantages by std (specific to GRPO)
++  norm_adv_by_std_in_grpo: True
++
++  # Whether to enable in-reward KL penalty
++  use_kl_in_reward: False
++
++  # How to estimate KL divergence: "kl", "abs", "mse", "low_var_kl", or "full"
++  kl_penalty: kl
++
++  # KL control configuration
++  kl_ctrl:
++
++    # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++    _target_: verl.trainer.config.KLControlConfig
++
++    # KL control type: "fixed" or "adaptive"
++    type: fixed
++
++    # Initial coefficient for KL penalty
++    kl_coef: 0.001
++
++    # Horizon value for adaptive controller (if enabled)
++    horizon: 10000
++
++    # Target KL divergence (used for adaptive controller)
++    target_kl: 0.1
++
++  # Whether to enable preference feedback PPO
++  use_pf_ppo: False
++
++  # Preference feedback PPO settings
++  pf_ppo:
++
++    # Method for reweighting samples: "pow", "max_min", or "max_random"
++    reweight_method: pow
++
++    # Power used for weight scaling in "pow" method
++    weight_pow: 2.0
++
++# config for the trainer
++trainer:
++
++  # Whether to balance batch sizes across distributed workers
++  balance_batch: True
++
++  # Number of epochs in training
++  total_epochs: 30
++
++  # Total training steps (can be set explicitly or derived from epochs)
++  total_training_steps: null
++
++  # Project name for experiment tracking (e.g., wandb)
++  project_name: verl_examples
++
++  # Experiment name for run identification in tracking tools
++  experiment_name: gsm8k
++
++  # Logging backends to use: "console", "wandb", etc.
++  logger: ["console", "wandb"]
++
++  # Number of generations to log during validation
++  log_val_generations: 0
++
++  # Directory for logging rollout data; no dump if null
++  rollout_data_dir: null
++
++  # Directory for logging validation data; no dump if null
++  validation_data_dir: null
++
++  # Number of nodes used in the training
++  nnodes: 1
++
++  # Number of GPUs per node
++  n_gpus_per_node: 8
++
++  # Save frequency (by iteration) for model checkpoints
++  save_freq: -1
++
++  # ESI refers to the elastic server instance used during training, similar to the training plan. For example,
++  # if you purchase 10 hours of computing power, the ESI will automatically shut down after 10 hours of training.
++  # To ensure a checkpoint is saved before ESI shuts down, the system will start saving a checkpoint in advance.
++  # The advance time is calculated as: Advance Time = Longest historical step duration + Checkpoint save duration + esi_redundant_time.
++  # Here, esi_redundant_time is a user-defined value that further extends the advance time for added safety.
++  esi_redundant_time: 0
++
++  # Resume mode: "auto", "disable", or "resume_path"
++  # "auto": resume from last checkpoint if available
++  # "disable": start from scratch
++  # "resume_path": resume from a user-defined path
++  resume_mode: auto
++
++  # Path to resume training from (only used when resume_mode is "resume_path")
++  resume_from_path: null
++
++  # Whether to run validation before training begins
++  val_before_train: True
++
++  # Whether to run validation only
++  val_only: False
++
++  # Validation frequency (in training iterations)
++  test_freq: -1
++
++  # Number of iterations to warm up the critic before updating policy
++  critic_warmup: 0
++
++  # Default path to distributed filesystem for saving checkpoints
++  default_hdfs_dir: null
++
++  # Whether to delete local checkpoints after loading
++  del_local_ckpt_after_load: False
++
++  # Default local directory for saving checkpoints
++  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
++
++  # Maximum number of actor checkpoints to keep
++  max_actor_ckpt_to_keep: null
++
++  # Maximum number of critic checkpoints to keep
++  max_critic_ckpt_to_keep: null
++
++  # Timeout (in seconds) for Ray worker to wait for registration
++  ray_wait_register_center_timeout: 300
++
++  # Device to run training on (e.g., "cuda", "cpu")
++  device: cuda
++
++  # whether to use legacy worker implementation
++  #  mode: "auto", "enable", or "disable"
++  use_legacy_worker_impl: auto
++
++# profiler configs
++global_profiler:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.utils.profiler.ProfilerConfig
++
++  # Profiling tool: choose between nsys, npu, torch, torch_memory
++  tool: null
++
++  # profile steps
++  steps: null
++
++  # Whether to combine continuous steps into one database.
++  ## If True, worker.profiler.discrete must be False, [1,2] in one, [5] in another.
++  ## If False, [1] in one, [2] in another, [5] in another.
++  profile_continuous_steps: False
++
++  # Path to save profiling contents
++  save_path: "outputs/profile"
++
++  # Specific tool configs, can use +profiler.tool_config.[tool].xxx to config
++  global_tool_config:
++
++    # nsys config
++    nsys:
++
++      # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++      _target_: verl.utils.profiler.config.NsightToolConfig
++
++      # True for each task has its own database, False for all tasks in one training step share one database.
++      discrete: False
++
++      # controller Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      ## reference https://docs.nvidia.com/nsight-systems/UserGuide/index.html
++      ## reference https://docs.ray.io/en/latest/ray-observability/user-guides/profiling.html
++      controller_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++      # worker Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      worker_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++        # Profiling only in a range of torch.cuda.profiler.start and stop. Do not change this config.
++        capture-range: "cudaProfilerApi"
++
++        # Specify the desired behavior when a capture range ends.
++        # In verl we need the torch.cuda.profiler.start/stop pair to repeats n times.
++        # valid values are "repeat-shutdown:n" or null.
++        # For normal whole step profiling, n = len(profile_steps);
++        # but for discrete profiling, n = len(profile_steps) * Number(subtasks).
++        # Or you can just leave it null and the program will use n = len(profile_steps) * 6;
++        capture-range-end: null
++
++        # Send signal to the target application's process group. We let the program to exit by itself.
++        kill: none
++
++    # enable memory visualization for debugging memory usage
++    torch_memory:
++
++      #  Maximum number of allocation entries to record
++      trace_alloc_max_entries: 100_000
++
++      # The depth of the call stack to capture for each allocation
++      stack_depth: 32
++
++      # 'alloc': records only allocation events || 'state': records memory state changes || 'all': records both.
++      context: "all"
++
++      # 'python': records Python stacks || 'cpp': records C++ stacks (available in some versions) || 'all': records both.
++      stacks: "all"
++
++      # devices, record_context etc.
++      kw_args: {}
++
++# configs related to ray
++ray_kwargs:
++
++  # configs related to ray initialization
++  ray_init:
++
++    # Number of CPUs for Ray. Use a fixed number instead of null when using SLURM.
++    num_cpus: null
++
++  # Path to save Ray timeline JSON for performance profiling
++  timeline_json_file: null
+Submodule external/kimina-lean-server contains modified content
+diff --git a/external/kimina-lean-server/setup.sh b/external/kimina-lean-server/setup.sh
+old mode 100755
+new mode 100644
+Submodule external/webshop-minimal contains modified content
+diff --git a/external/webshop-minimal/requirements.txt b/external/webshop-minimal/requirements.txt
+index 5a1b04f..238ed5a 100644
+--- a/external/webshop-minimal/requirements.txt
++++ b/external/webshop-minimal/requirements.txt
+@@ -4,7 +4,7 @@ flask
+ html2text
+ rank_bm25
+ pyserini
+-faiss-cpu
++faiss-gpu
+ thefuzz
+ gdown
+ spacy
+diff --git a/ragen/env/frozen_lake/config.py b/ragen/env/frozen_lake/config.py
+index 9950c34..de054f4 100644
+--- a/ragen/env/frozen_lake/config.py
++++ b/ragen/env/frozen_lake/config.py
+@@ -8,7 +8,7 @@ class FrozenLakeEnvConfig:
+     size: int = 4
+     p: float = 0.9
+     success_rate: float = 0.8
+-    is_slippery: bool = False
++    is_slippery: bool = True
+     map_seed: Optional[int] = None
+     render_mode: str = "text"
+     observation_format: str = "grid"
+diff --git a/scripts/runs/bandit_jobs.sh b/scripts/runs/bandit_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/frozenlake_jobs.sh b/scripts/runs/frozenlake_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/sokoban_jobs.sh b/scripts/runs/sokoban_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/webshop_jobs.sh b/scripts/runs/webshop_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/train_all.sh b/train_all.sh
+old mode 100755
+new mode 100644
+Submodule verl contains modified content
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh b/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh b/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/recipe/sppo/run_qwen2.5-7b_rm.sh b/verl/recipe/sppo/run_qwen2.5-7b_rm.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/generate_trainer_config.sh b/verl/scripts/generate_trainer_config.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/install_vllm_sglang_mcore.sh b/verl/scripts/install_vllm_sglang_mcore.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/generation/run_gen_qwen05.sh b/verl/tests/special_e2e/generation/run_gen_qwen05.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/run_one_step_off_policy.sh b/verl/tests/special_e2e/run_one_step_off_policy.sh
+old mode 100755
+new mode 100644

wandb/run-20260515_161238-gu8o8dz5/files/diff_b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0.patch

@@ -0,0 +1,536 @@
+diff --git a/config/_10_rubikscube.yaml b/config/_10_rubikscube.yaml
+index 277a8b1..a99b6a8 100644
+--- a/config/_10_rubikscube.yaml
++++ b/config/_10_rubikscube.yaml
+@@ -5,7 +5,7 @@ system:
+   CUDA_VISIBLE_DEVICES: "0,1,2,3"
+ 
+ trainer:
+-  experiment_name: 2048
++  experiment_name: rubikscube
+   n_gpus_per_node: 4
+ 
+ actor_rollout_ref:
+diff --git a/config/base.yaml b/config/base.yaml
+index 6029703..c10ab55 100644
+--- a/config/base.yaml
++++ b/config/base.yaml
+@@ -10,8 +10,8 @@ seed:
+   val: 123
+ 
+ micro_batch_size_per_gpu: 1
+-ppo_mini_batch_size: 32
+-model_path: 
++ppo_mini_batch_size: 16 #****
++model_path: /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ # /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ enable_response_mask: True # Enabling response mask could improve stability of rollout/old_log_prob, as P(st|history) are no longer calculated in loss here. See https://docs.google.com/document/d/1bg7obeiKTExuHHBl5uOiSpec5uLDZ2Tgvxy6li5pHX4/edit?usp=sharing for more details.
+ grpo_advantage_length_weight: False # if you do not enable this and critic/advantage_estimator is GRPO, and the critic/advantages/mean is too low, then you can try enabling this to encourage reasoning and forbid collapse
+@@ -48,11 +48,11 @@ actor_rollout_ref:
+     name: vllm
+     log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu} # following micro_batch_size_per_gpu
+     tensor_model_parallel_size: 1
+-    max_model_len: 16384 #3600 why** 14400
++    max_model_len: 16384 #3600 why** 14400 
+     prompt_length: 1 # useless. Just put it here
+-    response_length: 400 # single-turn response length
+-    gpu_memory_utilization: 0.7
+-    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true
++    response_length: 128 # single-turn response length 400 ****
++    gpu_memory_utilization: 0.6
++    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true 
+     temperature: 1
+     rollout_filter_ratio: 0.25
+     rollout_filter_type: largest # smallest or largest
+@@ -111,7 +111,7 @@ trainer:
+ 
+ agent_proxy:
+   max_context_window: -1 # set a value > 0 to enable context window for long trajectory
+-  max_turn: 25 #25 why** 700
++  max_turn: 15 #25 why** 700
+   action_sep: "||"
+   max_actions_per_turn: 1 # how many actions can be output at most in a single turn
+   use_turn_scores: False # important to GAE when applying token-level rewards to token-level advantages. If False, will take the sum of scores as the reward for the last turn.
+@@ -123,7 +123,7 @@ agent_proxy:
+ es_manager:
+   format_penalty: -0.1
+   train:
+-    env_groups: 8
++    env_groups: 8 
+     # under the same group, the env config and env seed are ensured to be equal
+     group_size: 16
+     env_configs:
+diff --git a/config/envs.yaml b/config/envs.yaml
+index d258d15..d7d687d 100644
+--- a/config/envs.yaml
++++ b/config/envs.yaml
+@@ -231,7 +231,7 @@ custom_envs:
+       Example: <answer>U</answer>
+     max_tokens: 96
+     env_config:
+-      scramble_depth: 3
++      scramble_depth: 5
+       max_steps: 20
+       render_mode: "text"
+   
+diff --git a/config/eval.yaml b/config/eval.yaml
+index 0802a0d..98d71dd 100644
+--- a/config/eval.yaml
++++ b/config/eval.yaml
+@@ -8,7 +8,7 @@ seed:
+   train: 10000
+   val: 123
+ 
+-model_path: /mnt/general/wanghy/RAGEN/saves/qwen3b_it_fromit_think_sudoku_sequence_multitask/global_step_200/qwen2.5_3b_actor_hf
++model_path: /mnt/general/wanghy/RAGEN/saves/qwen3B_it_think_rubikscube2_frommlpsave/global_step_50/qwen2.5_7B_actor_hf
+ # /mnt/general/share/model/tyzhu/SPA-frozenlake-qwen2.5-1.5b-instruct
+ 
+ lora:
+diff --git a/config/evaluate_api_llm.yaml b/config/evaluate_api_llm.yaml
+index bcbf206..9fe6f71 100644
+--- a/config/evaluate_api_llm.yaml
++++ b/config/evaluate_api_llm.yaml
+@@ -5,7 +5,7 @@ defaults:
+   - base # this is a symbolic link to the verl/verl/trainer/config/ppo_trainer.yaml file
+ 
+ model_config:
+-  model_name: TA/openai/gpt-oss-120b # should be registered in model_info
++  model_name: ark-deepseek-v3-250324 # should be registered in model_info
+   max_concurrency: 16
+ 
+ model_info:
+@@ -39,27 +39,21 @@ model_info:
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  ark-deepseek-v3-250324:
+-    provider_name: openai
+-    model_name: ark-deepseek-v3-250324
+-    generation_kwargs:
+-      temperature: 0
+-      max_completion_tokens: 512
+   deepseek-v3:
+     provider_name: deepseek
+     model_name: deepseek-chat
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  glm-4.6:
++  ark-deepseek-v3-250324:
+     provider_name: openai
+-    model_name: glm-4.6
++    model_name: ark-deepseek-v3-250324
+     generation_kwargs:
+       temperature: 0
+-      max_completion_tokens: 512
+-  TA/openai/gpt-oss-120b:
++      max_tokens: 8192
++  gemini-2.5-pro:
+     provider_name: openai
+-    model_name: TA/openai/gpt-oss-120b
++    model_name: gemini-2.5-pro
+     generation_kwargs:
+       temperature: 0
+       max_tokens: 8192
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+deleted file mode 120000
+index e1061c0..0000000
+--- a/config/ppo_trainer.yaml
++++ /dev/null
+@@ -1 +0,0 @@
+-../verl/verl/trainer/config/ppo_trainer.yaml
+
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+new file mode 100644
+index 0000000..c821483
+--- /dev/null
++++ b/config/ppo_trainer.yaml
+@@ -0,0 +1,308 @@
++# Format checks enforced on CI:
++# 1. Comments must appear above each field.
++# 2. There must be a blank line between each field.
++# 3. Inline comments (after a field on the same line) are not allowed.
++# 4. Indentation level is respected for nested fields.
++
++# specify the default per-component configs
++defaults:
++
++  # <folder_name>@<field_name>.<field_name>: <yaml_file_name>
++  # actor_rollout_ref.actor: trainer/config/actor/dp_actor.yaml
++  - actor@actor_rollout_ref.actor: dp_actor
++
++  # data: trainer/config/data/legacy_data.yaml
++  - data@data: legacy_data
++
++  # Reference model config.
++  # Reference model will be enabled when actor.use_kl_loss or/and algorithm.use_kl_in_reward is/are True.
++  - ref@actor_rollout_ref.ref: dp_ref
++
++  # Rollout model config.
++  - rollout@actor_rollout_ref.rollout: rollout
++
++  # Model config.
++  - model@actor_rollout_ref.model: hf_model
++
++  # Critic model config.
++  - critic@critic: dp_critic
++
++  # Reward model config.
++  - reward_model@reward_model: dp_reward_model
++
++  # load the reference default config, then apply the fields in the current yaml
++  # self config override anything above
++  - _self_
++
++# config for actor, rollout and reference model
++actor_rollout_ref:
++
++  # Whether it's a hybrid engine, currently only supports hybrid engine
++  hybrid_engine: true
++
++  # Timeout for operations executed against the process group
++  nccl_timeout: 600
++
++  # Rollout model config.
++  rollout:
++
++    # for huge model, layered summon can save memory (prevent OOM) but make it slower
++    layered_summon: False
++
++# custom reward function definition
++custom_reward_function:
++
++  # The path to the file containing your customized reward function.
++  # If not specified, pre-implemented reward functions will be used.
++  path: null
++
++  # The name of the reward function within the specified file. Default is 'compute_score'.
++  name: compute_score
++
++# config for the algorithm
++algorithm:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.trainer.config.AlgoConfig
++
++  # Discount factor for future rewards
++  gamma: 1.0
++
++  # Trade-off between bias and variance in the GAE estimator
++  lam: 1.0
++
++  # Advantage estimator type: "gae", "grpo", "reinforce_plus_plus", etc.
++  adv_estimator: gae
++
++  # Whether to normalize advantages by std (specific to GRPO)
++  norm_adv_by_std_in_grpo: True
++
++  # Whether to enable in-reward KL penalty
++  use_kl_in_reward: False
++
++  # How to estimate KL divergence: "kl", "abs", "mse", "low_var_kl", or "full"
++  kl_penalty: kl
++
++  # KL control configuration
++  kl_ctrl:
++
++    # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++    _target_: verl.trainer.config.KLControlConfig
++
++    # KL control type: "fixed" or "adaptive"
++    type: fixed
++
++    # Initial coefficient for KL penalty
++    kl_coef: 0.001
++
++    # Horizon value for adaptive controller (if enabled)
++    horizon: 10000
++
++    # Target KL divergence (used for adaptive controller)
++    target_kl: 0.1
++
++  # Whether to enable preference feedback PPO
++  use_pf_ppo: False
++
++  # Preference feedback PPO settings
++  pf_ppo:
++
++    # Method for reweighting samples: "pow", "max_min", or "max_random"
++    reweight_method: pow
++
++    # Power used for weight scaling in "pow" method
++    weight_pow: 2.0
++
++# config for the trainer
++trainer:
++
++  # Whether to balance batch sizes across distributed workers
++  balance_batch: True
++
++  # Number of epochs in training
++  total_epochs: 30
++
++  # Total training steps (can be set explicitly or derived from epochs)
++  total_training_steps: null
++
++  # Project name for experiment tracking (e.g., wandb)
++  project_name: verl_examples
++
++  # Experiment name for run identification in tracking tools
++  experiment_name: gsm8k
++
++  # Logging backends to use: "console", "wandb", etc.
++  logger: ["console", "wandb"]
++
++  # Number of generations to log during validation
++  log_val_generations: 0
++
++  # Directory for logging rollout data; no dump if null
++  rollout_data_dir: null
++
++  # Directory for logging validation data; no dump if null
++  validation_data_dir: null
++
++  # Number of nodes used in the training
++  nnodes: 1
++
++  # Number of GPUs per node
++  n_gpus_per_node: 8
++
++  # Save frequency (by iteration) for model checkpoints
++  save_freq: -1
++
++  # ESI refers to the elastic server instance used during training, similar to the training plan. For example,
++  # if you purchase 10 hours of computing power, the ESI will automatically shut down after 10 hours of training.
++  # To ensure a checkpoint is saved before ESI shuts down, the system will start saving a checkpoint in advance.
++  # The advance time is calculated as: Advance Time = Longest historical step duration + Checkpoint save duration + esi_redundant_time.
++  # Here, esi_redundant_time is a user-defined value that further extends the advance time for added safety.
++  esi_redundant_time: 0
++
++  # Resume mode: "auto", "disable", or "resume_path"
++  # "auto": resume from last checkpoint if available
++  # "disable": start from scratch
++  # "resume_path": resume from a user-defined path
++  resume_mode: auto
++
++  # Path to resume training from (only used when resume_mode is "resume_path")
++  resume_from_path: null
++
++  # Whether to run validation before training begins
++  val_before_train: True
++
++  # Whether to run validation only
++  val_only: False
++
++  # Validation frequency (in training iterations)
++  test_freq: -1
++
++  # Number of iterations to warm up the critic before updating policy
++  critic_warmup: 0
++
++  # Default path to distributed filesystem for saving checkpoints
++  default_hdfs_dir: null
++
++  # Whether to delete local checkpoints after loading
++  del_local_ckpt_after_load: False
++
++  # Default local directory for saving checkpoints
++  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
++
++  # Maximum number of actor checkpoints to keep
++  max_actor_ckpt_to_keep: null
++
++  # Maximum number of critic checkpoints to keep
++  max_critic_ckpt_to_keep: null
++
++  # Timeout (in seconds) for Ray worker to wait for registration
++  ray_wait_register_center_timeout: 300
++
++  # Device to run training on (e.g., "cuda", "cpu")
++  device: cuda
++
++  # whether to use legacy worker implementation
++  #  mode: "auto", "enable", or "disable"
++  use_legacy_worker_impl: auto
++
++# profiler configs
++global_profiler:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.utils.profiler.ProfilerConfig
++
++  # Profiling tool: choose between nsys, npu, torch, torch_memory
++  tool: null
++
++  # profile steps
++  steps: null
++
++  # Whether to combine continuous steps into one database.
++  ## If True, worker.profiler.discrete must be False, [1,2] in one, [5] in another.
++  ## If False, [1] in one, [2] in another, [5] in another.
++  profile_continuous_steps: False
++
++  # Path to save profiling contents
++  save_path: "outputs/profile"
++
++  # Specific tool configs, can use +profiler.tool_config.[tool].xxx to config
++  global_tool_config:
++
++    # nsys config
++    nsys:
++
++      # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++      _target_: verl.utils.profiler.config.NsightToolConfig
++
++      # True for each task has its own database, False for all tasks in one training step share one database.
++      discrete: False
++
++      # controller Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      ## reference https://docs.nvidia.com/nsight-systems/UserGuide/index.html
++      ## reference https://docs.ray.io/en/latest/ray-observability/user-guides/profiling.html
++      controller_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++      # worker Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      worker_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++        # Profiling only in a range of torch.cuda.profiler.start and stop. Do not change this config.
++        capture-range: "cudaProfilerApi"
++
++        # Specify the desired behavior when a capture range ends.
++        # In verl we need the torch.cuda.profiler.start/stop pair to repeats n times.
++        # valid values are "repeat-shutdown:n" or null.
++        # For normal whole step profiling, n = len(profile_steps);
++        # but for discrete profiling, n = len(profile_steps) * Number(subtasks).
++        # Or you can just leave it null and the program will use n = len(profile_steps) * 6;
++        capture-range-end: null
++
++        # Send signal to the target application's process group. We let the program to exit by itself.
++        kill: none
++
++    # enable memory visualization for debugging memory usage
++    torch_memory:
++
++      #  Maximum number of allocation entries to record
++      trace_alloc_max_entries: 100_000
++
++      # The depth of the call stack to capture for each allocation
++      stack_depth: 32
++
++      # 'alloc': records only allocation events || 'state': records memory state changes || 'all': records both.
++      context: "all"
++
++      # 'python': records Python stacks || 'cpp': records C++ stacks (available in some versions) || 'all': records both.
++      stacks: "all"
++
++      # devices, record_context etc.
++      kw_args: {}
++
++# configs related to ray
++ray_kwargs:
++
++  # configs related to ray initialization
++  ray_init:
++
++    # Number of CPUs for Ray. Use a fixed number instead of null when using SLURM.
++    num_cpus: null
++
++  # Path to save Ray timeline JSON for performance profiling
++  timeline_json_file: null
+Submodule external/kimina-lean-server contains modified content
+diff --git a/external/kimina-lean-server/setup.sh b/external/kimina-lean-server/setup.sh
+old mode 100755
+new mode 100644
+Submodule external/webshop-minimal contains modified content
+diff --git a/external/webshop-minimal/requirements.txt b/external/webshop-minimal/requirements.txt
+index 5a1b04f..238ed5a 100644
+--- a/external/webshop-minimal/requirements.txt
++++ b/external/webshop-minimal/requirements.txt
+@@ -4,7 +4,7 @@ flask
+ html2text
+ rank_bm25
+ pyserini
+-faiss-cpu
++faiss-gpu
+ thefuzz
+ gdown
+ spacy
+diff --git a/ragen/env/frozen_lake/config.py b/ragen/env/frozen_lake/config.py
+index 9950c34..de054f4 100644
+--- a/ragen/env/frozen_lake/config.py
++++ b/ragen/env/frozen_lake/config.py
+@@ -8,7 +8,7 @@ class FrozenLakeEnvConfig:
+     size: int = 4
+     p: float = 0.9
+     success_rate: float = 0.8
+-    is_slippery: bool = False
++    is_slippery: bool = True
+     map_seed: Optional[int] = None
+     render_mode: str = "text"
+     observation_format: str = "grid"
+diff --git a/scripts/runs/bandit_jobs.sh b/scripts/runs/bandit_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/frozenlake_jobs.sh b/scripts/runs/frozenlake_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/sokoban_jobs.sh b/scripts/runs/sokoban_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/webshop_jobs.sh b/scripts/runs/webshop_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/train_all.sh b/train_all.sh
+old mode 100755
+new mode 100644
+Submodule verl contains modified content
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh b/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh b/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/recipe/sppo/run_qwen2.5-7b_rm.sh b/verl/recipe/sppo/run_qwen2.5-7b_rm.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/generate_trainer_config.sh b/verl/scripts/generate_trainer_config.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/install_vllm_sglang_mcore.sh b/verl/scripts/install_vllm_sglang_mcore.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/generation/run_gen_qwen05.sh b/verl/tests/special_e2e/generation/run_gen_qwen05.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/run_one_step_off_policy.sh b/verl/tests/special_e2e/run_one_step_off_policy.sh
+old mode 100755
+new mode 100644

wandb/run-20260515_161238-gu8o8dz5/files/requirements.txt

@@ -0,0 +1,316 @@
+colorama==0.4.6
+psutil==7.2.2
+pyarrow==23.0.1
+math-verify==0.9.0
+pygame==2.6.1
+partial-json-parser==0.2.1.1.post7
+anyio==4.13.0
+wandb==0.25.1
+mathruler==0.1.0
+tzdata==2026.1
+gym-sokoban==0.0.6
+sniffio==1.3.1
+omegaconf==2.3.0
+httpcore==1.0.9
+scipy==1.15.3
+multidict==6.7.1
+nvidia-cusparse-cu12==12.3.1.170
+fonttools==4.62.1
+together==2.7.0
+antlr4-python3-runtime==4.9.3
+cupy-cuda12x==13.6.0
+av==17.0.0
+torch==2.6.0
+datasets==4.8.4
+pyparsing==3.3.2
+markdown-it-py==4.0.0
+accelerate==1.13.0
+lark==1.2.2
+sentencepiece==0.2.1
+Flask==3.1.3
+annotated-doc==0.0.4
+rignore==0.7.6
+ImageIO==2.37.3
+outlines_core==0.1.26
+gym==0.26.2
+depyf==0.18.0
+pydantic==2.12.5
+nvidia-cuda-nvrtc-cu12==12.4.127
+certifi==2026.2.25
+aiohttp==3.13.5
+flash_attn==2.7.4.post1
+msgspec==0.21.0
+matplotlib==3.10.8
+pandas==2.3.3
+openai==2.31.0
+sentry-sdk==2.57.0
+propcache==0.4.1
+nvidia-curand-cu12==10.3.5.147
+python-dateutil==2.9.0.post0
+itsdangerous==2.2.0
+cloudpickle==3.1.2
+ray==2.54.1
+cffi==2.0.0
+pyzmq==27.1.0
+Jinja2==3.1.6
+nest-asyncio==1.6.0
+orjson==3.11.8
+pydantic-extra-types==2.11.2
+nvidia-nccl-cu12==2.21.5
+gitdb==4.0.12
+Farama-Notifications==0.0.4
+async-timeout==5.0.1
+torchdata==0.11.0
+ninja==1.13.0
+hydra-core==1.3.2
+GitPython==3.1.46
+nvidia-cuda-runtime-cu12==12.4.127
+msgpack==1.1.2
+email-validator==2.3.0
+yarl==1.23.0
+numpy==1.26.4
+charset-normalizer==3.4.7
+pycountry==26.2.16
+annotated-types==0.7.0
+uvloop==0.22.1
+torchvision==0.21.0
+jsonschema-specifications==2025.9.1
+uvicorn==0.44.0
+nvidia-nvjitlink-cu12==12.4.127
+sympy==1.13.1
+latex2sympy2_extended==1.11.0
+triton==3.2.0
+tqdm==4.67.3
+diskcache==5.6.3
+kiwisolver==1.5.0
+llguidance==0.7.30
+prometheus_client==0.25.0
+types-PyYAML==6.0.12.20260408
+MarkupSafe==3.0.3
+fastapi-cloud-cli==0.16.1
+cachetools==7.0.5
+pillow==12.2.0
+airportsdata==20260315
+mpmath==1.3.0
+cycler==0.12.1
+qwen-vl-utils==0.0.14
+jsonschema==4.26.0
+safetensors==0.7.0
+gymnasium==1.2.3
+h11==0.16.0
+Pygments==2.20.0
+zipp==3.23.0
+outlines==0.1.11
+typing_extensions==4.15.0
+requests==2.33.1
+watchfiles==1.1.1
+shellingham==1.5.4
+xformers==0.0.29.post2
+blinker==1.9.0
+distro==1.9.0
+multiprocess==0.70.19
+regex==2026.4.4
+fastapi-cli==0.0.24
+tabulate==0.10.0
+referencing==0.37.0
+xxhash==3.6.0
+smmap==5.0.3
+six==1.17.0
+Werkzeug==3.1.8
+click==8.3.2
+py-cpuinfo==9.0.0
+aiosignal==1.4.0
+setuptools==69.1.0
+setuptools==82.0.1
+aiohappyeyeballs==2.6.1
+starlette==0.52.1
+gym-notices==0.1.0
+typing-inspection==0.4.2
+networkx==3.4.2
+pydantic_core==2.41.5
+pycparser==3.0
+contourpy==1.3.2
+codetiming==1.4.0
+python-dotenv==1.2.2
+rpds-py==0.30.0
+blake3==1.0.8
+python-multipart==0.0.24
+fastapi==0.135.3
+httpx==0.28.1
+attrs==26.1.0
+pytz==2026.1.post1
+platformdirs==4.9.6
+nvidia-cusolver-cu12==11.6.1.9
+hf-xet==1.4.3
+filelock==3.25.2
+types-requests==2.33.0.20260408
+idna==3.11
+fsspec==2026.2.0
+astor==0.8.1
+interegular==0.3.3
+nvidia-cudnn-cu12==9.1.0.70
+frozenlist==1.8.0
+pylatexenc==2.10
+nvidia-cublas-cu12==12.4.5.8
+httptools==0.7.1
+python-json-logger==4.1.0
+mdurl==0.1.2
+mistral_common==1.11.0
+vulkan==1.3.275.1
+nvidia-cuda-cupti-cu12==12.4.127
+pybind11==3.0.3
+PyYAML==6.0.3
+jiter==0.13.0
+fastrlock==0.8.3
+typeguard==4.5.1
+typer==0.24.1
+websockets==16.0
+nvidia-cufft-cu12==11.2.1.3
+nvidia-nvtx-cu12==12.4.127
+psutil==7.2.2
+tomli==2.4.1
+types-tqdm==4.67.3.20260408
+fastar==0.10.0
+einops==0.8.2
+lm-format-enforcer==0.10.12
+opencv-python-headless==4.11.0.86
+tiktoken==0.12.0
+rich-toolkit==0.19.7
+rich==14.3.3
+dnspython==2.8.0
+pydantic-settings==2.13.1
+types-tabulate==0.10.0.20260408
+torchaudio==2.6.0
+urllib3==2.6.3
+dill==0.4.1
+docstring_parser==0.18.0
+prometheus-fastapi-instrumentator==7.1.0
+peft==0.18.1
+exceptiongroup==1.3.1
+tyro==1.0.13
+nvidia-cusparselt-cu12==0.6.2
+packaging==26.0
+wheel==0.46.3
+pip==26.0.1
+pyjnius==1.7.0
+pure_eval==0.2.3
+ptyprocess==0.7.0
+flatbuffers==25.12.19
+faiss-gpu==1.7.2
+wrapt==2.1.2
+wcwidth==0.6.0
+wasabi==1.1.3
+traitlets==5.14.3
+threadpoolctl==3.6.0
+tenacity==9.1.4
+spacy-loggers==1.0.5
+spacy-legacy==3.0.12
+soupsieve==2.8.3
+RapidFuzz==3.14.5
+rank-bm25==0.2.2
+PySocks==1.7.1
+PyJWT==2.12.1
+parso==0.8.6
+protobuf==4.25.9
+pexpect==4.9.0
+opentelemetry-semantic-conventions-ai==0.4.13
+murmurhash==1.0.15
+loguru==0.7.3
+joblib==1.5.3
+humanfriendly==10.0
+httpx-sse==0.4.3
+html2text==2025.4.15
+grpcio==1.80.0
+executing==2.2.1
+decorator==5.2.1
+debugpy==1.8.20
+Cython==3.2.4
+cymem==2.0.13
+confection==1.3.3
+colorama==0.4.6
+cloudpathlib==0.23.0
+catalogue==2.0.10
+blis==1.3.3
+asttokens==3.0.1
+thefuzz==0.22.1
+stack-data==0.6.3
+srsly==2.5.3
+smart_open==7.6.0
+scikit-learn==1.7.2
+prompt_toolkit==3.0.52
+preshed==3.0.13
+opentelemetry-proto==1.26.0
+nltk==3.9.4
+matplotlib-inline==0.2.1
+jedi==0.19.2
+googleapis-common-protos==1.74.0
+Deprecated==1.3.1
+cryptography==46.0.7
+coloredlogs==15.0.1
+beautifulsoup4==4.14.3
+thinc==8.3.13
+opentelemetry-exporter-otlp-proto-common==1.26.0
+onnxruntime==1.23.2
+ipython==8.39.0
+gdown==6.0.0
+cleantext==1.1.4
+weasel==1.0.0
+tensordict==0.8.3
+sse-starlette==3.3.4
+mcp==1.27.0
+anthropic==0.96.0
+spacy==3.8.14
+opentelemetry-exporter-otlp-proto-http==1.26.0
+opentelemetry-exporter-otlp-proto-grpc==1.26.0
+kimina-client==0.2.1
+pyserini==1.2.0
+opentelemetry-exporter-otlp==1.26.0
+compressed-tensors==0.9.2
+vllm==0.8.2
+py-spy==0.4.1
+opencensus-context==0.1.3
+distlib==0.4.0
+colorful==0.5.8
+tensorboard-data-server==0.7.2
+python-discovery==1.2.2
+pyasn1==0.6.3
+proto-plus==1.27.2
+Markdown==3.10.2
+absl-py==2.4.0
+virtualenv==21.2.4
+tensorboard==2.20.0
+pyasn1_modules==0.4.2
+opentelemetry-api==1.24.0
+google-auth==2.49.2
+google-api-core==2.30.3
+aiohttp-cors==0.8.1
+opentelemetry-exporter-prometheus==0.62b0
+opencensus==0.11.4
+verl==0.5.0.dev0
+huggingface_hub==0.36.2
+opentelemetry-semantic-conventions==0.45b0
+opentelemetry-sdk==1.24.0
+llvmlite==0.43.0
+tokenizers==0.21.4
+gguf==0.10.0
+importlib-metadata==7.0.0
+hjson==3.1.0
+deepspeed==0.16.9
+transformers==4.51.1
+xgrammar==0.1.16
+ragen==0.1
+numba==0.60.0
+ragen==0.1
+verl==0.5.0.dev0
+autocommand==2.2.2
+backports.tarfile==1.2.0
+importlib_metadata==8.7.1
+jaraco.text==4.0.0
+jaraco.context==6.1.0
+jaraco.functools==4.4.0
+more-itertools==10.8.0
+packaging==26.0
+platformdirs==4.4.0
+tomli==2.4.0
+wheel==0.46.3
+zipp==3.23.0

wandb/run-20260515_161238-gu8o8dz5/files/wandb-metadata.json

@@ -0,0 +1,89 @@
+{
+  "os": "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python": "CPython 3.10.20",
+  "startedAt": "2026-05-15T08:12:38.521989Z",
+  "program": "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py",
+  "codePath": "cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py",
+  "codePathLocal": "cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py",
+  "git": {
+    "remote": "https://github.com/Harry-mic/SCOUT",
+    "commit": "b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0"
+  },
+  "email": "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root": "/mnt/general/wanghy/RAGEN",
+  "host": "pt-a7f17fedde804edca572f81ace5fcaf3-worker-0",
+  "executable": "/opt/conda/envs/ragen_new/bin/python",
+  "cpu_count": 64,
+  "cpu_count_logical": 128,
+  "gpu": "NVIDIA H100 80GB HBM3",
+  "gpu_count": 8,
+  "disk": {
+    "/": {
+      "total": "60129542144000",
+      "used": "72513884160"
+    }
+  },
+  "memory": {
+    "total": "2159579672576"
+  },
+  "gpu_nvidia": [
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-97b3b912-40cf-f573-ffce-8275a656891f"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-5e4acc7a-f7ab-1a15-312e-4e2a39c43b2c"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-b36695ed-370a-2556-79d8-b0a2c2659271"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-b3e13ca7-237c-931f-894b-798f9cfa5620"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-64647b1f-5d55-1b7e-bf3d-64fae3871140"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-fe8b9b7e-82a4-1238-4843-bbfd0269d746"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-4523d4e1-5745-8224-7bcd-44cf59b76bae"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-9262bcbd-a29f-d761-3330-ac2ce9f15e82"
+    }
+  ],
+  "cudaVersion": "12.4",
+  "writerId": "wivgvewa54gi2r1e37nw598ga9bd00ah"
+}

wandb/run-20260515_161238-gu8o8dz5/run-gu8o8dz5.wandb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1c5ae04b784bf6effe9fcd4f7c79d4d47a53eb92e0dd052f3421e245b1b76e5
+size 60424192

wandb/run-20260515_162634-oma8h4e9/files/code/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()

wandb/run-20260515_162634-oma8h4e9/files/config.yaml

@@ -0,0 +1,200 @@
+_wandb:
+    value:
+        cli_version: 0.25.1
+        code_path: code/cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py
+        e:
+            rpamc3wni7ysqe4ryq6pxzkkfppcrszf:
+                codePath: cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py
+                codePathLocal: cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py
+                cpu_count: 64
+                cpu_count_logical: 128
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "60129542144000"
+                        used: "72513892352"
+                email: haoyu-wa22@mails.tsinghua.edu.cn
+                executable: /opt/conda/envs/ragen_new/bin/python
+                git:
+                    commit: b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0
+                    remote: https://github.com/Harry-mic/SCOUT
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-97b3b912-40cf-f573-ffce-8275a656891f
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-5e4acc7a-f7ab-1a15-312e-4e2a39c43b2c
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b36695ed-370a-2556-79d8-b0a2c2659271
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b3e13ca7-237c-931f-894b-798f9cfa5620
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-64647b1f-5d55-1b7e-bf3d-64fae3871140
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-fe8b9b7e-82a4-1238-4843-bbfd0269d746
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-4523d4e1-5745-8224-7bcd-44cf59b76bae
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-9262bcbd-a29f-d761-3330-ac2ce9f15e82
+                host: pt-a7f17fedde804edca572f81ace5fcaf3-worker-0
+                memory:
+                    total: "2159579672576"
+                os: Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35
+                program: /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py
+                python: CPython 3.10.20
+                root: /mnt/general/wanghy/RAGEN
+                startedAt: "2026-05-15T08:26:34.223611Z"
+                writerId: rpamc3wni7ysqe4ryq6pxzkkfppcrszf
+        m:
+            - "1": global_step
+              "6":
+                - 3
+              "7": []
+            - "2": perf/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": train/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": rollout/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": eval/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": losses/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+            - "2": charts/*
+              "5": 1
+              "6":
+                - 1
+              "7": []
+        python_version: 3.10.20
+        t:
+            "1":
+                - 1
+                - 11
+                - 30
+                - 49
+                - 50
+                - 51
+                - 105
+            "2":
+                - 1
+                - 11
+                - 30
+                - 49
+                - 50
+                - 51
+                - 105
+            "3":
+                - 7
+                - 13
+                - 16
+                - 41
+                - 61
+            "4": 3.10.20
+            "5": 0.25.1
+            "6": 4.51.1
+            "12": 0.25.1
+            "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
+difficulty:
+    value: easy
+ent_coef:
+    value: 0.01
+env_id:
+    value: Sudoku
+eval_episodes:
+    value: 4000
+eval_splits:
+    value: 2
+exp_name:
+    value: ppo_sudoku_actionmask
+gae_lambda:
+    value: 0.95
+gamma:
+    value: 0.99
+grid_size:
+    value: 4
+learning_rate:
+    value: 0.0003
+max_grad_norm:
+    value: 0.5
+minibatch_size:
+    value: 256
+norm_adv:
+    value: true
+num_envs:
+    value: 8
+num_iterations:
+    value: 9765
+num_minibatches:
+    value: 4
+num_steps:
+    value: 128
+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: cleanRL

wandb/run-20260515_162634-oma8h4e9/files/diff.patch

@@ -0,0 +1,536 @@
+diff --git a/config/_10_rubikscube.yaml b/config/_10_rubikscube.yaml
+index 277a8b1..a99b6a8 100644
+--- a/config/_10_rubikscube.yaml
++++ b/config/_10_rubikscube.yaml
+@@ -5,7 +5,7 @@ system:
+   CUDA_VISIBLE_DEVICES: "0,1,2,3"
+ 
+ trainer:
+-  experiment_name: 2048
++  experiment_name: rubikscube
+   n_gpus_per_node: 4
+ 
+ actor_rollout_ref:
+diff --git a/config/base.yaml b/config/base.yaml
+index 6029703..c10ab55 100644
+--- a/config/base.yaml
++++ b/config/base.yaml
+@@ -10,8 +10,8 @@ seed:
+   val: 123
+ 
+ micro_batch_size_per_gpu: 1
+-ppo_mini_batch_size: 32
+-model_path: 
++ppo_mini_batch_size: 16 #****
++model_path: /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ # /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ enable_response_mask: True # Enabling response mask could improve stability of rollout/old_log_prob, as P(st|history) are no longer calculated in loss here. See https://docs.google.com/document/d/1bg7obeiKTExuHHBl5uOiSpec5uLDZ2Tgvxy6li5pHX4/edit?usp=sharing for more details.
+ grpo_advantage_length_weight: False # if you do not enable this and critic/advantage_estimator is GRPO, and the critic/advantages/mean is too low, then you can try enabling this to encourage reasoning and forbid collapse
+@@ -48,11 +48,11 @@ actor_rollout_ref:
+     name: vllm
+     log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu} # following micro_batch_size_per_gpu
+     tensor_model_parallel_size: 1
+-    max_model_len: 16384 #3600 why** 14400
++    max_model_len: 16384 #3600 why** 14400 
+     prompt_length: 1 # useless. Just put it here
+-    response_length: 400 # single-turn response length
+-    gpu_memory_utilization: 0.7
+-    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true
++    response_length: 128 # single-turn response length 400 ****
++    gpu_memory_utilization: 0.6
++    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true 
+     temperature: 1
+     rollout_filter_ratio: 0.25
+     rollout_filter_type: largest # smallest or largest
+@@ -111,7 +111,7 @@ trainer:
+ 
+ agent_proxy:
+   max_context_window: -1 # set a value > 0 to enable context window for long trajectory
+-  max_turn: 25 #25 why** 700
++  max_turn: 15 #25 why** 700
+   action_sep: "||"
+   max_actions_per_turn: 1 # how many actions can be output at most in a single turn
+   use_turn_scores: False # important to GAE when applying token-level rewards to token-level advantages. If False, will take the sum of scores as the reward for the last turn.
+@@ -123,7 +123,7 @@ agent_proxy:
+ es_manager:
+   format_penalty: -0.1
+   train:
+-    env_groups: 8
++    env_groups: 8 
+     # under the same group, the env config and env seed are ensured to be equal
+     group_size: 16
+     env_configs:
+diff --git a/config/envs.yaml b/config/envs.yaml
+index d258d15..d7d687d 100644
+--- a/config/envs.yaml
++++ b/config/envs.yaml
+@@ -231,7 +231,7 @@ custom_envs:
+       Example: <answer>U</answer>
+     max_tokens: 96
+     env_config:
+-      scramble_depth: 3
++      scramble_depth: 5
+       max_steps: 20
+       render_mode: "text"
+   
+diff --git a/config/eval.yaml b/config/eval.yaml
+index 0802a0d..98d71dd 100644
+--- a/config/eval.yaml
++++ b/config/eval.yaml
+@@ -8,7 +8,7 @@ seed:
+   train: 10000
+   val: 123
+ 
+-model_path: /mnt/general/wanghy/RAGEN/saves/qwen3b_it_fromit_think_sudoku_sequence_multitask/global_step_200/qwen2.5_3b_actor_hf
++model_path: /mnt/general/wanghy/RAGEN/saves/qwen3B_it_think_rubikscube2_frommlpsave/global_step_50/qwen2.5_7B_actor_hf
+ # /mnt/general/share/model/tyzhu/SPA-frozenlake-qwen2.5-1.5b-instruct
+ 
+ lora:
+diff --git a/config/evaluate_api_llm.yaml b/config/evaluate_api_llm.yaml
+index bcbf206..9fe6f71 100644
+--- a/config/evaluate_api_llm.yaml
++++ b/config/evaluate_api_llm.yaml
+@@ -5,7 +5,7 @@ defaults:
+   - base # this is a symbolic link to the verl/verl/trainer/config/ppo_trainer.yaml file
+ 
+ model_config:
+-  model_name: TA/openai/gpt-oss-120b # should be registered in model_info
++  model_name: ark-deepseek-v3-250324 # should be registered in model_info
+   max_concurrency: 16
+ 
+ model_info:
+@@ -39,27 +39,21 @@ model_info:
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  ark-deepseek-v3-250324:
+-    provider_name: openai
+-    model_name: ark-deepseek-v3-250324
+-    generation_kwargs:
+-      temperature: 0
+-      max_completion_tokens: 512
+   deepseek-v3:
+     provider_name: deepseek
+     model_name: deepseek-chat
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  glm-4.6:
++  ark-deepseek-v3-250324:
+     provider_name: openai
+-    model_name: glm-4.6
++    model_name: ark-deepseek-v3-250324
+     generation_kwargs:
+       temperature: 0
+-      max_completion_tokens: 512
+-  TA/openai/gpt-oss-120b:
++      max_tokens: 8192
++  gemini-2.5-pro:
+     provider_name: openai
+-    model_name: TA/openai/gpt-oss-120b
++    model_name: gemini-2.5-pro
+     generation_kwargs:
+       temperature: 0
+       max_tokens: 8192
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+deleted file mode 120000
+index e1061c0..0000000
+--- a/config/ppo_trainer.yaml
++++ /dev/null
+@@ -1 +0,0 @@
+-../verl/verl/trainer/config/ppo_trainer.yaml
+
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+new file mode 100644
+index 0000000..c821483
+--- /dev/null
++++ b/config/ppo_trainer.yaml
+@@ -0,0 +1,308 @@
++# Format checks enforced on CI:
++# 1. Comments must appear above each field.
++# 2. There must be a blank line between each field.
++# 3. Inline comments (after a field on the same line) are not allowed.
++# 4. Indentation level is respected for nested fields.
++
++# specify the default per-component configs
++defaults:
++
++  # <folder_name>@<field_name>.<field_name>: <yaml_file_name>
++  # actor_rollout_ref.actor: trainer/config/actor/dp_actor.yaml
++  - actor@actor_rollout_ref.actor: dp_actor
++
++  # data: trainer/config/data/legacy_data.yaml
++  - data@data: legacy_data
++
++  # Reference model config.
++  # Reference model will be enabled when actor.use_kl_loss or/and algorithm.use_kl_in_reward is/are True.
++  - ref@actor_rollout_ref.ref: dp_ref
++
++  # Rollout model config.
++  - rollout@actor_rollout_ref.rollout: rollout
++
++  # Model config.
++  - model@actor_rollout_ref.model: hf_model
++
++  # Critic model config.
++  - critic@critic: dp_critic
++
++  # Reward model config.
++  - reward_model@reward_model: dp_reward_model
++
++  # load the reference default config, then apply the fields in the current yaml
++  # self config override anything above
++  - _self_
++
++# config for actor, rollout and reference model
++actor_rollout_ref:
++
++  # Whether it's a hybrid engine, currently only supports hybrid engine
++  hybrid_engine: true
++
++  # Timeout for operations executed against the process group
++  nccl_timeout: 600
++
++  # Rollout model config.
++  rollout:
++
++    # for huge model, layered summon can save memory (prevent OOM) but make it slower
++    layered_summon: False
++
++# custom reward function definition
++custom_reward_function:
++
++  # The path to the file containing your customized reward function.
++  # If not specified, pre-implemented reward functions will be used.
++  path: null
++
++  # The name of the reward function within the specified file. Default is 'compute_score'.
++  name: compute_score
++
++# config for the algorithm
++algorithm:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.trainer.config.AlgoConfig
++
++  # Discount factor for future rewards
++  gamma: 1.0
++
++  # Trade-off between bias and variance in the GAE estimator
++  lam: 1.0
++
++  # Advantage estimator type: "gae", "grpo", "reinforce_plus_plus", etc.
++  adv_estimator: gae
++
++  # Whether to normalize advantages by std (specific to GRPO)
++  norm_adv_by_std_in_grpo: True
++
++  # Whether to enable in-reward KL penalty
++  use_kl_in_reward: False
++
++  # How to estimate KL divergence: "kl", "abs", "mse", "low_var_kl", or "full"
++  kl_penalty: kl
++
++  # KL control configuration
++  kl_ctrl:
++
++    # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++    _target_: verl.trainer.config.KLControlConfig
++
++    # KL control type: "fixed" or "adaptive"
++    type: fixed
++
++    # Initial coefficient for KL penalty
++    kl_coef: 0.001
++
++    # Horizon value for adaptive controller (if enabled)
++    horizon: 10000
++
++    # Target KL divergence (used for adaptive controller)
++    target_kl: 0.1
++
++  # Whether to enable preference feedback PPO
++  use_pf_ppo: False
++
++  # Preference feedback PPO settings
++  pf_ppo:
++
++    # Method for reweighting samples: "pow", "max_min", or "max_random"
++    reweight_method: pow
++
++    # Power used for weight scaling in "pow" method
++    weight_pow: 2.0
++
++# config for the trainer
++trainer:
++
++  # Whether to balance batch sizes across distributed workers
++  balance_batch: True
++
++  # Number of epochs in training
++  total_epochs: 30
++
++  # Total training steps (can be set explicitly or derived from epochs)
++  total_training_steps: null
++
++  # Project name for experiment tracking (e.g., wandb)
++  project_name: verl_examples
++
++  # Experiment name for run identification in tracking tools
++  experiment_name: gsm8k
++
++  # Logging backends to use: "console", "wandb", etc.
++  logger: ["console", "wandb"]
++
++  # Number of generations to log during validation
++  log_val_generations: 0
++
++  # Directory for logging rollout data; no dump if null
++  rollout_data_dir: null
++
++  # Directory for logging validation data; no dump if null
++  validation_data_dir: null
++
++  # Number of nodes used in the training
++  nnodes: 1
++
++  # Number of GPUs per node
++  n_gpus_per_node: 8
++
++  # Save frequency (by iteration) for model checkpoints
++  save_freq: -1
++
++  # ESI refers to the elastic server instance used during training, similar to the training plan. For example,
++  # if you purchase 10 hours of computing power, the ESI will automatically shut down after 10 hours of training.
++  # To ensure a checkpoint is saved before ESI shuts down, the system will start saving a checkpoint in advance.
++  # The advance time is calculated as: Advance Time = Longest historical step duration + Checkpoint save duration + esi_redundant_time.
++  # Here, esi_redundant_time is a user-defined value that further extends the advance time for added safety.
++  esi_redundant_time: 0
++
++  # Resume mode: "auto", "disable", or "resume_path"
++  # "auto": resume from last checkpoint if available
++  # "disable": start from scratch
++  # "resume_path": resume from a user-defined path
++  resume_mode: auto
++
++  # Path to resume training from (only used when resume_mode is "resume_path")
++  resume_from_path: null
++
++  # Whether to run validation before training begins
++  val_before_train: True
++
++  # Whether to run validation only
++  val_only: False
++
++  # Validation frequency (in training iterations)
++  test_freq: -1
++
++  # Number of iterations to warm up the critic before updating policy
++  critic_warmup: 0
++
++  # Default path to distributed filesystem for saving checkpoints
++  default_hdfs_dir: null
++
++  # Whether to delete local checkpoints after loading
++  del_local_ckpt_after_load: False
++
++  # Default local directory for saving checkpoints
++  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
++
++  # Maximum number of actor checkpoints to keep
++  max_actor_ckpt_to_keep: null
++
++  # Maximum number of critic checkpoints to keep
++  max_critic_ckpt_to_keep: null
++
++  # Timeout (in seconds) for Ray worker to wait for registration
++  ray_wait_register_center_timeout: 300
++
++  # Device to run training on (e.g., "cuda", "cpu")
++  device: cuda
++
++  # whether to use legacy worker implementation
++  #  mode: "auto", "enable", or "disable"
++  use_legacy_worker_impl: auto
++
++# profiler configs
++global_profiler:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.utils.profiler.ProfilerConfig
++
++  # Profiling tool: choose between nsys, npu, torch, torch_memory
++  tool: null
++
++  # profile steps
++  steps: null
++
++  # Whether to combine continuous steps into one database.
++  ## If True, worker.profiler.discrete must be False, [1,2] in one, [5] in another.
++  ## If False, [1] in one, [2] in another, [5] in another.
++  profile_continuous_steps: False
++
++  # Path to save profiling contents
++  save_path: "outputs/profile"
++
++  # Specific tool configs, can use +profiler.tool_config.[tool].xxx to config
++  global_tool_config:
++
++    # nsys config
++    nsys:
++
++      # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++      _target_: verl.utils.profiler.config.NsightToolConfig
++
++      # True for each task has its own database, False for all tasks in one training step share one database.
++      discrete: False
++
++      # controller Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      ## reference https://docs.nvidia.com/nsight-systems/UserGuide/index.html
++      ## reference https://docs.ray.io/en/latest/ray-observability/user-guides/profiling.html
++      controller_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++      # worker Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      worker_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++        # Profiling only in a range of torch.cuda.profiler.start and stop. Do not change this config.
++        capture-range: "cudaProfilerApi"
++
++        # Specify the desired behavior when a capture range ends.
++        # In verl we need the torch.cuda.profiler.start/stop pair to repeats n times.
++        # valid values are "repeat-shutdown:n" or null.
++        # For normal whole step profiling, n = len(profile_steps);
++        # but for discrete profiling, n = len(profile_steps) * Number(subtasks).
++        # Or you can just leave it null and the program will use n = len(profile_steps) * 6;
++        capture-range-end: null
++
++        # Send signal to the target application's process group. We let the program to exit by itself.
++        kill: none
++
++    # enable memory visualization for debugging memory usage
++    torch_memory:
++
++      #  Maximum number of allocation entries to record
++      trace_alloc_max_entries: 100_000
++
++      # The depth of the call stack to capture for each allocation
++      stack_depth: 32
++
++      # 'alloc': records only allocation events || 'state': records memory state changes || 'all': records both.
++      context: "all"
++
++      # 'python': records Python stacks || 'cpp': records C++ stacks (available in some versions) || 'all': records both.
++      stacks: "all"
++
++      # devices, record_context etc.
++      kw_args: {}
++
++# configs related to ray
++ray_kwargs:
++
++  # configs related to ray initialization
++  ray_init:
++
++    # Number of CPUs for Ray. Use a fixed number instead of null when using SLURM.
++    num_cpus: null
++
++  # Path to save Ray timeline JSON for performance profiling
++  timeline_json_file: null
+Submodule external/kimina-lean-server contains modified content
+diff --git a/external/kimina-lean-server/setup.sh b/external/kimina-lean-server/setup.sh
+old mode 100755
+new mode 100644
+Submodule external/webshop-minimal contains modified content
+diff --git a/external/webshop-minimal/requirements.txt b/external/webshop-minimal/requirements.txt
+index 5a1b04f..238ed5a 100644
+--- a/external/webshop-minimal/requirements.txt
++++ b/external/webshop-minimal/requirements.txt
+@@ -4,7 +4,7 @@ flask
+ html2text
+ rank_bm25
+ pyserini
+-faiss-cpu
++faiss-gpu
+ thefuzz
+ gdown
+ spacy
+diff --git a/ragen/env/frozen_lake/config.py b/ragen/env/frozen_lake/config.py
+index 9950c34..de054f4 100644
+--- a/ragen/env/frozen_lake/config.py
++++ b/ragen/env/frozen_lake/config.py
+@@ -8,7 +8,7 @@ class FrozenLakeEnvConfig:
+     size: int = 4
+     p: float = 0.9
+     success_rate: float = 0.8
+-    is_slippery: bool = False
++    is_slippery: bool = True
+     map_seed: Optional[int] = None
+     render_mode: str = "text"
+     observation_format: str = "grid"
+diff --git a/scripts/runs/bandit_jobs.sh b/scripts/runs/bandit_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/frozenlake_jobs.sh b/scripts/runs/frozenlake_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/sokoban_jobs.sh b/scripts/runs/sokoban_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/webshop_jobs.sh b/scripts/runs/webshop_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/train_all.sh b/train_all.sh
+old mode 100755
+new mode 100644
+Submodule verl contains modified content
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh b/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh b/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/recipe/sppo/run_qwen2.5-7b_rm.sh b/verl/recipe/sppo/run_qwen2.5-7b_rm.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/generate_trainer_config.sh b/verl/scripts/generate_trainer_config.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/install_vllm_sglang_mcore.sh b/verl/scripts/install_vllm_sglang_mcore.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/generation/run_gen_qwen05.sh b/verl/tests/special_e2e/generation/run_gen_qwen05.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/run_one_step_off_policy.sh b/verl/tests/special_e2e/run_one_step_off_policy.sh
+old mode 100755
+new mode 100644

wandb/run-20260515_162634-oma8h4e9/files/diff_b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0.patch

@@ -0,0 +1,536 @@
+diff --git a/config/_10_rubikscube.yaml b/config/_10_rubikscube.yaml
+index 277a8b1..a99b6a8 100644
+--- a/config/_10_rubikscube.yaml
++++ b/config/_10_rubikscube.yaml
+@@ -5,7 +5,7 @@ system:
+   CUDA_VISIBLE_DEVICES: "0,1,2,3"
+ 
+ trainer:
+-  experiment_name: 2048
++  experiment_name: rubikscube
+   n_gpus_per_node: 4
+ 
+ actor_rollout_ref:
+diff --git a/config/base.yaml b/config/base.yaml
+index 6029703..c10ab55 100644
+--- a/config/base.yaml
++++ b/config/base.yaml
+@@ -10,8 +10,8 @@ seed:
+   val: 123
+ 
+ micro_batch_size_per_gpu: 1
+-ppo_mini_batch_size: 32
+-model_path: 
++ppo_mini_batch_size: 16 #****
++model_path: /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ # /mnt/general/share/model/Qwen/Qwen2.5-0.5B-Instruct
+ enable_response_mask: True # Enabling response mask could improve stability of rollout/old_log_prob, as P(st|history) are no longer calculated in loss here. See https://docs.google.com/document/d/1bg7obeiKTExuHHBl5uOiSpec5uLDZ2Tgvxy6li5pHX4/edit?usp=sharing for more details.
+ grpo_advantage_length_weight: False # if you do not enable this and critic/advantage_estimator is GRPO, and the critic/advantages/mean is too low, then you can try enabling this to encourage reasoning and forbid collapse
+@@ -48,11 +48,11 @@ actor_rollout_ref:
+     name: vllm
+     log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu} # following micro_batch_size_per_gpu
+     tensor_model_parallel_size: 1
+-    max_model_len: 16384 #3600 why** 14400
++    max_model_len: 16384 #3600 why** 14400 
+     prompt_length: 1 # useless. Just put it here
+-    response_length: 400 # single-turn response length
+-    gpu_memory_utilization: 0.7
+-    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true
++    response_length: 128 # single-turn response length 400 ****
++    gpu_memory_utilization: 0.6
++    max_num_batched_tokens: 16384 # set only when enable_chunked_prefill is true 
+     temperature: 1
+     rollout_filter_ratio: 0.25
+     rollout_filter_type: largest # smallest or largest
+@@ -111,7 +111,7 @@ trainer:
+ 
+ agent_proxy:
+   max_context_window: -1 # set a value > 0 to enable context window for long trajectory
+-  max_turn: 25 #25 why** 700
++  max_turn: 15 #25 why** 700
+   action_sep: "||"
+   max_actions_per_turn: 1 # how many actions can be output at most in a single turn
+   use_turn_scores: False # important to GAE when applying token-level rewards to token-level advantages. If False, will take the sum of scores as the reward for the last turn.
+@@ -123,7 +123,7 @@ agent_proxy:
+ es_manager:
+   format_penalty: -0.1
+   train:
+-    env_groups: 8
++    env_groups: 8 
+     # under the same group, the env config and env seed are ensured to be equal
+     group_size: 16
+     env_configs:
+diff --git a/config/envs.yaml b/config/envs.yaml
+index d258d15..d7d687d 100644
+--- a/config/envs.yaml
++++ b/config/envs.yaml
+@@ -231,7 +231,7 @@ custom_envs:
+       Example: <answer>U</answer>
+     max_tokens: 96
+     env_config:
+-      scramble_depth: 3
++      scramble_depth: 5
+       max_steps: 20
+       render_mode: "text"
+   
+diff --git a/config/eval.yaml b/config/eval.yaml
+index 0802a0d..98d71dd 100644
+--- a/config/eval.yaml
++++ b/config/eval.yaml
+@@ -8,7 +8,7 @@ seed:
+   train: 10000
+   val: 123
+ 
+-model_path: /mnt/general/wanghy/RAGEN/saves/qwen3b_it_fromit_think_sudoku_sequence_multitask/global_step_200/qwen2.5_3b_actor_hf
++model_path: /mnt/general/wanghy/RAGEN/saves/qwen3B_it_think_rubikscube2_frommlpsave/global_step_50/qwen2.5_7B_actor_hf
+ # /mnt/general/share/model/tyzhu/SPA-frozenlake-qwen2.5-1.5b-instruct
+ 
+ lora:
+diff --git a/config/evaluate_api_llm.yaml b/config/evaluate_api_llm.yaml
+index bcbf206..9fe6f71 100644
+--- a/config/evaluate_api_llm.yaml
++++ b/config/evaluate_api_llm.yaml
+@@ -5,7 +5,7 @@ defaults:
+   - base # this is a symbolic link to the verl/verl/trainer/config/ppo_trainer.yaml file
+ 
+ model_config:
+-  model_name: TA/openai/gpt-oss-120b # should be registered in model_info
++  model_name: ark-deepseek-v3-250324 # should be registered in model_info
+   max_concurrency: 16
+ 
+ model_info:
+@@ -39,27 +39,21 @@ model_info:
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  ark-deepseek-v3-250324:
+-    provider_name: openai
+-    model_name: ark-deepseek-v3-250324
+-    generation_kwargs:
+-      temperature: 0
+-      max_completion_tokens: 512
+   deepseek-v3:
+     provider_name: deepseek
+     model_name: deepseek-chat
+     generation_kwargs:
+       temperature: 0
+       max_completion_tokens: 512
+-  glm-4.6:
++  ark-deepseek-v3-250324:
+     provider_name: openai
+-    model_name: glm-4.6
++    model_name: ark-deepseek-v3-250324
+     generation_kwargs:
+       temperature: 0
+-      max_completion_tokens: 512
+-  TA/openai/gpt-oss-120b:
++      max_tokens: 8192
++  gemini-2.5-pro:
+     provider_name: openai
+-    model_name: TA/openai/gpt-oss-120b
++    model_name: gemini-2.5-pro
+     generation_kwargs:
+       temperature: 0
+       max_tokens: 8192
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+deleted file mode 120000
+index e1061c0..0000000
+--- a/config/ppo_trainer.yaml
++++ /dev/null
+@@ -1 +0,0 @@
+-../verl/verl/trainer/config/ppo_trainer.yaml
+
+diff --git a/config/ppo_trainer.yaml b/config/ppo_trainer.yaml
+new file mode 100644
+index 0000000..c821483
+--- /dev/null
++++ b/config/ppo_trainer.yaml
+@@ -0,0 +1,308 @@
++# Format checks enforced on CI:
++# 1. Comments must appear above each field.
++# 2. There must be a blank line between each field.
++# 3. Inline comments (after a field on the same line) are not allowed.
++# 4. Indentation level is respected for nested fields.
++
++# specify the default per-component configs
++defaults:
++
++  # <folder_name>@<field_name>.<field_name>: <yaml_file_name>
++  # actor_rollout_ref.actor: trainer/config/actor/dp_actor.yaml
++  - actor@actor_rollout_ref.actor: dp_actor
++
++  # data: trainer/config/data/legacy_data.yaml
++  - data@data: legacy_data
++
++  # Reference model config.
++  # Reference model will be enabled when actor.use_kl_loss or/and algorithm.use_kl_in_reward is/are True.
++  - ref@actor_rollout_ref.ref: dp_ref
++
++  # Rollout model config.
++  - rollout@actor_rollout_ref.rollout: rollout
++
++  # Model config.
++  - model@actor_rollout_ref.model: hf_model
++
++  # Critic model config.
++  - critic@critic: dp_critic
++
++  # Reward model config.
++  - reward_model@reward_model: dp_reward_model
++
++  # load the reference default config, then apply the fields in the current yaml
++  # self config override anything above
++  - _self_
++
++# config for actor, rollout and reference model
++actor_rollout_ref:
++
++  # Whether it's a hybrid engine, currently only supports hybrid engine
++  hybrid_engine: true
++
++  # Timeout for operations executed against the process group
++  nccl_timeout: 600
++
++  # Rollout model config.
++  rollout:
++
++    # for huge model, layered summon can save memory (prevent OOM) but make it slower
++    layered_summon: False
++
++# custom reward function definition
++custom_reward_function:
++
++  # The path to the file containing your customized reward function.
++  # If not specified, pre-implemented reward functions will be used.
++  path: null
++
++  # The name of the reward function within the specified file. Default is 'compute_score'.
++  name: compute_score
++
++# config for the algorithm
++algorithm:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.trainer.config.AlgoConfig
++
++  # Discount factor for future rewards
++  gamma: 1.0
++
++  # Trade-off between bias and variance in the GAE estimator
++  lam: 1.0
++
++  # Advantage estimator type: "gae", "grpo", "reinforce_plus_plus", etc.
++  adv_estimator: gae
++
++  # Whether to normalize advantages by std (specific to GRPO)
++  norm_adv_by_std_in_grpo: True
++
++  # Whether to enable in-reward KL penalty
++  use_kl_in_reward: False
++
++  # How to estimate KL divergence: "kl", "abs", "mse", "low_var_kl", or "full"
++  kl_penalty: kl
++
++  # KL control configuration
++  kl_ctrl:
++
++    # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++    _target_: verl.trainer.config.KLControlConfig
++
++    # KL control type: "fixed" or "adaptive"
++    type: fixed
++
++    # Initial coefficient for KL penalty
++    kl_coef: 0.001
++
++    # Horizon value for adaptive controller (if enabled)
++    horizon: 10000
++
++    # Target KL divergence (used for adaptive controller)
++    target_kl: 0.1
++
++  # Whether to enable preference feedback PPO
++  use_pf_ppo: False
++
++  # Preference feedback PPO settings
++  pf_ppo:
++
++    # Method for reweighting samples: "pow", "max_min", or "max_random"
++    reweight_method: pow
++
++    # Power used for weight scaling in "pow" method
++    weight_pow: 2.0
++
++# config for the trainer
++trainer:
++
++  # Whether to balance batch sizes across distributed workers
++  balance_batch: True
++
++  # Number of epochs in training
++  total_epochs: 30
++
++  # Total training steps (can be set explicitly or derived from epochs)
++  total_training_steps: null
++
++  # Project name for experiment tracking (e.g., wandb)
++  project_name: verl_examples
++
++  # Experiment name for run identification in tracking tools
++  experiment_name: gsm8k
++
++  # Logging backends to use: "console", "wandb", etc.
++  logger: ["console", "wandb"]
++
++  # Number of generations to log during validation
++  log_val_generations: 0
++
++  # Directory for logging rollout data; no dump if null
++  rollout_data_dir: null
++
++  # Directory for logging validation data; no dump if null
++  validation_data_dir: null
++
++  # Number of nodes used in the training
++  nnodes: 1
++
++  # Number of GPUs per node
++  n_gpus_per_node: 8
++
++  # Save frequency (by iteration) for model checkpoints
++  save_freq: -1
++
++  # ESI refers to the elastic server instance used during training, similar to the training plan. For example,
++  # if you purchase 10 hours of computing power, the ESI will automatically shut down after 10 hours of training.
++  # To ensure a checkpoint is saved before ESI shuts down, the system will start saving a checkpoint in advance.
++  # The advance time is calculated as: Advance Time = Longest historical step duration + Checkpoint save duration + esi_redundant_time.
++  # Here, esi_redundant_time is a user-defined value that further extends the advance time for added safety.
++  esi_redundant_time: 0
++
++  # Resume mode: "auto", "disable", or "resume_path"
++  # "auto": resume from last checkpoint if available
++  # "disable": start from scratch
++  # "resume_path": resume from a user-defined path
++  resume_mode: auto
++
++  # Path to resume training from (only used when resume_mode is "resume_path")
++  resume_from_path: null
++
++  # Whether to run validation before training begins
++  val_before_train: True
++
++  # Whether to run validation only
++  val_only: False
++
++  # Validation frequency (in training iterations)
++  test_freq: -1
++
++  # Number of iterations to warm up the critic before updating policy
++  critic_warmup: 0
++
++  # Default path to distributed filesystem for saving checkpoints
++  default_hdfs_dir: null
++
++  # Whether to delete local checkpoints after loading
++  del_local_ckpt_after_load: False
++
++  # Default local directory for saving checkpoints
++  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
++
++  # Maximum number of actor checkpoints to keep
++  max_actor_ckpt_to_keep: null
++
++  # Maximum number of critic checkpoints to keep
++  max_critic_ckpt_to_keep: null
++
++  # Timeout (in seconds) for Ray worker to wait for registration
++  ray_wait_register_center_timeout: 300
++
++  # Device to run training on (e.g., "cuda", "cpu")
++  device: cuda
++
++  # whether to use legacy worker implementation
++  #  mode: "auto", "enable", or "disable"
++  use_legacy_worker_impl: auto
++
++# profiler configs
++global_profiler:
++
++  # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++  _target_: verl.utils.profiler.ProfilerConfig
++
++  # Profiling tool: choose between nsys, npu, torch, torch_memory
++  tool: null
++
++  # profile steps
++  steps: null
++
++  # Whether to combine continuous steps into one database.
++  ## If True, worker.profiler.discrete must be False, [1,2] in one, [5] in another.
++  ## If False, [1] in one, [2] in another, [5] in another.
++  profile_continuous_steps: False
++
++  # Path to save profiling contents
++  save_path: "outputs/profile"
++
++  # Specific tool configs, can use +profiler.tool_config.[tool].xxx to config
++  global_tool_config:
++
++    # nsys config
++    nsys:
++
++      # Required when using verl.utils.omega_conf_to_dataclass to instantiate dataclass configs
++      _target_: verl.utils.profiler.config.NsightToolConfig
++
++      # True for each task has its own database, False for all tasks in one training step share one database.
++      discrete: False
++
++      # controller Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      ## reference https://docs.nvidia.com/nsight-systems/UserGuide/index.html
++      ## reference https://docs.ray.io/en/latest/ray-observability/user-guides/profiling.html
++      controller_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++      # worker Nvidia Nsight Systems Options. Must set when profile_steps is not None.
++      worker_nsight_options:
++
++        # Select the API(s) to be traced.
++        trace: "cuda,nvtx,cublas,ucx"
++
++        # Track the GPU memory usage by CUDA kernels. Must be string type "true" or "false".
++        cuda-memory-usage: "true"
++
++        # CUDA graphs will be traced as a whole
++        cuda-graph-trace: "graph"
++
++        # Profiling only in a range of torch.cuda.profiler.start and stop. Do not change this config.
++        capture-range: "cudaProfilerApi"
++
++        # Specify the desired behavior when a capture range ends.
++        # In verl we need the torch.cuda.profiler.start/stop pair to repeats n times.
++        # valid values are "repeat-shutdown:n" or null.
++        # For normal whole step profiling, n = len(profile_steps);
++        # but for discrete profiling, n = len(profile_steps) * Number(subtasks).
++        # Or you can just leave it null and the program will use n = len(profile_steps) * 6;
++        capture-range-end: null
++
++        # Send signal to the target application's process group. We let the program to exit by itself.
++        kill: none
++
++    # enable memory visualization for debugging memory usage
++    torch_memory:
++
++      #  Maximum number of allocation entries to record
++      trace_alloc_max_entries: 100_000
++
++      # The depth of the call stack to capture for each allocation
++      stack_depth: 32
++
++      # 'alloc': records only allocation events || 'state': records memory state changes || 'all': records both.
++      context: "all"
++
++      # 'python': records Python stacks || 'cpp': records C++ stacks (available in some versions) || 'all': records both.
++      stacks: "all"
++
++      # devices, record_context etc.
++      kw_args: {}
++
++# configs related to ray
++ray_kwargs:
++
++  # configs related to ray initialization
++  ray_init:
++
++    # Number of CPUs for Ray. Use a fixed number instead of null when using SLURM.
++    num_cpus: null
++
++  # Path to save Ray timeline JSON for performance profiling
++  timeline_json_file: null
+Submodule external/kimina-lean-server contains modified content
+diff --git a/external/kimina-lean-server/setup.sh b/external/kimina-lean-server/setup.sh
+old mode 100755
+new mode 100644
+Submodule external/webshop-minimal contains modified content
+diff --git a/external/webshop-minimal/requirements.txt b/external/webshop-minimal/requirements.txt
+index 5a1b04f..238ed5a 100644
+--- a/external/webshop-minimal/requirements.txt
++++ b/external/webshop-minimal/requirements.txt
+@@ -4,7 +4,7 @@ flask
+ html2text
+ rank_bm25
+ pyserini
+-faiss-cpu
++faiss-gpu
+ thefuzz
+ gdown
+ spacy
+diff --git a/ragen/env/frozen_lake/config.py b/ragen/env/frozen_lake/config.py
+index 9950c34..de054f4 100644
+--- a/ragen/env/frozen_lake/config.py
++++ b/ragen/env/frozen_lake/config.py
+@@ -8,7 +8,7 @@ class FrozenLakeEnvConfig:
+     size: int = 4
+     p: float = 0.9
+     success_rate: float = 0.8
+-    is_slippery: bool = False
++    is_slippery: bool = True
+     map_seed: Optional[int] = None
+     render_mode: str = "text"
+     observation_format: str = "grid"
+diff --git a/scripts/runs/bandit_jobs.sh b/scripts/runs/bandit_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/frozenlake_jobs.sh b/scripts/runs/frozenlake_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/sokoban_jobs.sh b/scripts/runs/sokoban_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/scripts/runs/webshop_jobs.sh b/scripts/runs/webshop_jobs.sh
+old mode 100755
+new mode 100644
+diff --git a/train_all.sh b/train_all.sh
+old mode 100755
+new mode 100644
+Submodule verl contains modified content
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh b/verl/examples/gpg_trainer/run_qwen2-7b_math_megatron.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh b/verl/examples/sglang_multiturn/run_qwen0.5b_gsm8k_multiturn_curriculum.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_4xgpu_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh b/verl/examples/sglang_multiturn/run_qwen2.5-3b_gsm8k_multiturn_server.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh b/verl/examples/sglang_multiturn/run_qwen3-4b_gsm8k_multiturn.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/recipe/sppo/run_qwen2.5-7b_rm.sh b/verl/recipe/sppo/run_qwen2.5-7b_rm.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/generate_trainer_config.sh b/verl/scripts/generate_trainer_config.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/scripts/install_vllm_sglang_mcore.sh b/verl/scripts/install_vllm_sglang_mcore.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/generation/run_gen_qwen05.sh b/verl/tests/special_e2e/generation/run_gen_qwen05.sh
+old mode 100755
+new mode 100644
+diff --git a/verl/tests/special_e2e/run_one_step_off_policy.sh b/verl/tests/special_e2e/run_one_step_off_policy.sh
+old mode 100755
+new mode 100644

wandb/run-20260515_162634-oma8h4e9/files/requirements.txt

@@ -0,0 +1,316 @@
+colorama==0.4.6
+psutil==7.2.2
+pyarrow==23.0.1
+math-verify==0.9.0
+pygame==2.6.1
+partial-json-parser==0.2.1.1.post7
+anyio==4.13.0
+wandb==0.25.1
+mathruler==0.1.0
+tzdata==2026.1
+gym-sokoban==0.0.6
+sniffio==1.3.1
+omegaconf==2.3.0
+httpcore==1.0.9
+scipy==1.15.3
+multidict==6.7.1
+nvidia-cusparse-cu12==12.3.1.170
+fonttools==4.62.1
+together==2.7.0
+antlr4-python3-runtime==4.9.3
+cupy-cuda12x==13.6.0
+av==17.0.0
+torch==2.6.0
+datasets==4.8.4
+pyparsing==3.3.2
+markdown-it-py==4.0.0
+accelerate==1.13.0
+lark==1.2.2
+sentencepiece==0.2.1
+Flask==3.1.3
+annotated-doc==0.0.4
+rignore==0.7.6
+ImageIO==2.37.3
+outlines_core==0.1.26
+gym==0.26.2
+depyf==0.18.0
+pydantic==2.12.5
+nvidia-cuda-nvrtc-cu12==12.4.127
+certifi==2026.2.25
+aiohttp==3.13.5
+flash_attn==2.7.4.post1
+msgspec==0.21.0
+matplotlib==3.10.8
+pandas==2.3.3
+openai==2.31.0
+sentry-sdk==2.57.0
+propcache==0.4.1
+nvidia-curand-cu12==10.3.5.147
+python-dateutil==2.9.0.post0
+itsdangerous==2.2.0
+cloudpickle==3.1.2
+ray==2.54.1
+cffi==2.0.0
+pyzmq==27.1.0
+Jinja2==3.1.6
+nest-asyncio==1.6.0
+orjson==3.11.8
+pydantic-extra-types==2.11.2
+nvidia-nccl-cu12==2.21.5
+gitdb==4.0.12
+Farama-Notifications==0.0.4
+async-timeout==5.0.1
+torchdata==0.11.0
+ninja==1.13.0
+hydra-core==1.3.2
+GitPython==3.1.46
+nvidia-cuda-runtime-cu12==12.4.127
+msgpack==1.1.2
+email-validator==2.3.0
+yarl==1.23.0
+numpy==1.26.4
+charset-normalizer==3.4.7
+pycountry==26.2.16
+annotated-types==0.7.0
+uvloop==0.22.1
+torchvision==0.21.0
+jsonschema-specifications==2025.9.1
+uvicorn==0.44.0
+nvidia-nvjitlink-cu12==12.4.127
+sympy==1.13.1
+latex2sympy2_extended==1.11.0
+triton==3.2.0
+tqdm==4.67.3
+diskcache==5.6.3
+kiwisolver==1.5.0
+llguidance==0.7.30
+prometheus_client==0.25.0
+types-PyYAML==6.0.12.20260408
+MarkupSafe==3.0.3
+fastapi-cloud-cli==0.16.1
+cachetools==7.0.5
+pillow==12.2.0
+airportsdata==20260315
+mpmath==1.3.0
+cycler==0.12.1
+qwen-vl-utils==0.0.14
+jsonschema==4.26.0
+safetensors==0.7.0
+gymnasium==1.2.3
+h11==0.16.0
+Pygments==2.20.0
+zipp==3.23.0
+outlines==0.1.11
+typing_extensions==4.15.0
+requests==2.33.1
+watchfiles==1.1.1
+shellingham==1.5.4
+xformers==0.0.29.post2
+blinker==1.9.0
+distro==1.9.0
+multiprocess==0.70.19
+regex==2026.4.4
+fastapi-cli==0.0.24
+tabulate==0.10.0
+referencing==0.37.0
+xxhash==3.6.0
+smmap==5.0.3
+six==1.17.0
+Werkzeug==3.1.8
+click==8.3.2
+py-cpuinfo==9.0.0
+aiosignal==1.4.0
+setuptools==69.1.0
+setuptools==82.0.1
+aiohappyeyeballs==2.6.1
+starlette==0.52.1
+gym-notices==0.1.0
+typing-inspection==0.4.2
+networkx==3.4.2
+pydantic_core==2.41.5
+pycparser==3.0
+contourpy==1.3.2
+codetiming==1.4.0
+python-dotenv==1.2.2
+rpds-py==0.30.0
+blake3==1.0.8
+python-multipart==0.0.24
+fastapi==0.135.3
+httpx==0.28.1
+attrs==26.1.0
+pytz==2026.1.post1
+platformdirs==4.9.6
+nvidia-cusolver-cu12==11.6.1.9
+hf-xet==1.4.3
+filelock==3.25.2
+types-requests==2.33.0.20260408
+idna==3.11
+fsspec==2026.2.0
+astor==0.8.1
+interegular==0.3.3
+nvidia-cudnn-cu12==9.1.0.70
+frozenlist==1.8.0
+pylatexenc==2.10
+nvidia-cublas-cu12==12.4.5.8
+httptools==0.7.1
+python-json-logger==4.1.0
+mdurl==0.1.2
+mistral_common==1.11.0
+vulkan==1.3.275.1
+nvidia-cuda-cupti-cu12==12.4.127
+pybind11==3.0.3
+PyYAML==6.0.3
+jiter==0.13.0
+fastrlock==0.8.3
+typeguard==4.5.1
+typer==0.24.1
+websockets==16.0
+nvidia-cufft-cu12==11.2.1.3
+nvidia-nvtx-cu12==12.4.127
+psutil==7.2.2
+tomli==2.4.1
+types-tqdm==4.67.3.20260408
+fastar==0.10.0
+einops==0.8.2
+lm-format-enforcer==0.10.12
+opencv-python-headless==4.11.0.86
+tiktoken==0.12.0
+rich-toolkit==0.19.7
+rich==14.3.3
+dnspython==2.8.0
+pydantic-settings==2.13.1
+types-tabulate==0.10.0.20260408
+torchaudio==2.6.0
+urllib3==2.6.3
+dill==0.4.1
+docstring_parser==0.18.0
+prometheus-fastapi-instrumentator==7.1.0
+peft==0.18.1
+exceptiongroup==1.3.1
+tyro==1.0.13
+nvidia-cusparselt-cu12==0.6.2
+packaging==26.0
+wheel==0.46.3
+pip==26.0.1
+pyjnius==1.7.0
+pure_eval==0.2.3
+ptyprocess==0.7.0
+flatbuffers==25.12.19
+faiss-gpu==1.7.2
+wrapt==2.1.2
+wcwidth==0.6.0
+wasabi==1.1.3
+traitlets==5.14.3
+threadpoolctl==3.6.0
+tenacity==9.1.4
+spacy-loggers==1.0.5
+spacy-legacy==3.0.12
+soupsieve==2.8.3
+RapidFuzz==3.14.5
+rank-bm25==0.2.2
+PySocks==1.7.1
+PyJWT==2.12.1
+parso==0.8.6
+protobuf==4.25.9
+pexpect==4.9.0
+opentelemetry-semantic-conventions-ai==0.4.13
+murmurhash==1.0.15
+loguru==0.7.3
+joblib==1.5.3
+humanfriendly==10.0
+httpx-sse==0.4.3
+html2text==2025.4.15
+grpcio==1.80.0
+executing==2.2.1
+decorator==5.2.1
+debugpy==1.8.20
+Cython==3.2.4
+cymem==2.0.13
+confection==1.3.3
+colorama==0.4.6
+cloudpathlib==0.23.0
+catalogue==2.0.10
+blis==1.3.3
+asttokens==3.0.1
+thefuzz==0.22.1
+stack-data==0.6.3
+srsly==2.5.3
+smart_open==7.6.0
+scikit-learn==1.7.2
+prompt_toolkit==3.0.52
+preshed==3.0.13
+opentelemetry-proto==1.26.0
+nltk==3.9.4
+matplotlib-inline==0.2.1
+jedi==0.19.2
+googleapis-common-protos==1.74.0
+Deprecated==1.3.1
+cryptography==46.0.7
+coloredlogs==15.0.1
+beautifulsoup4==4.14.3
+thinc==8.3.13
+opentelemetry-exporter-otlp-proto-common==1.26.0
+onnxruntime==1.23.2
+ipython==8.39.0
+gdown==6.0.0
+cleantext==1.1.4
+weasel==1.0.0
+tensordict==0.8.3
+sse-starlette==3.3.4
+mcp==1.27.0
+anthropic==0.96.0
+spacy==3.8.14
+opentelemetry-exporter-otlp-proto-http==1.26.0
+opentelemetry-exporter-otlp-proto-grpc==1.26.0
+kimina-client==0.2.1
+pyserini==1.2.0
+opentelemetry-exporter-otlp==1.26.0
+compressed-tensors==0.9.2
+vllm==0.8.2
+py-spy==0.4.1
+opencensus-context==0.1.3
+distlib==0.4.0
+colorful==0.5.8
+tensorboard-data-server==0.7.2
+python-discovery==1.2.2
+pyasn1==0.6.3
+proto-plus==1.27.2
+Markdown==3.10.2
+absl-py==2.4.0
+virtualenv==21.2.4
+tensorboard==2.20.0
+pyasn1_modules==0.4.2
+opentelemetry-api==1.24.0
+google-auth==2.49.2
+google-api-core==2.30.3
+aiohttp-cors==0.8.1
+opentelemetry-exporter-prometheus==0.62b0
+opencensus==0.11.4
+verl==0.5.0.dev0
+huggingface_hub==0.36.2
+opentelemetry-semantic-conventions==0.45b0
+opentelemetry-sdk==1.24.0
+llvmlite==0.43.0
+tokenizers==0.21.4
+gguf==0.10.0
+importlib-metadata==7.0.0
+hjson==3.1.0
+deepspeed==0.16.9
+transformers==4.51.1
+xgrammar==0.1.16
+ragen==0.1
+numba==0.60.0
+ragen==0.1
+verl==0.5.0.dev0
+autocommand==2.2.2
+backports.tarfile==1.2.0
+importlib_metadata==8.7.1
+jaraco.text==4.0.0
+jaraco.context==6.1.0
+jaraco.functools==4.4.0
+more-itertools==10.8.0
+packaging==26.0
+platformdirs==4.4.0
+tomli==2.4.0
+wheel==0.46.3
+zipp==3.23.0

wandb/run-20260515_162634-oma8h4e9/files/wandb-metadata.json

@@ -0,0 +1,89 @@
+{
+  "os": "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python": "CPython 3.10.20",
+  "startedAt": "2026-05-15T08:26:34.223611Z",
+  "program": "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py",
+  "codePath": "cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py",
+  "codePathLocal": "cleanrl/cleanrl/scout_ppo/ppo_sudoku_actionmask.py",
+  "git": {
+    "remote": "https://github.com/Harry-mic/SCOUT",
+    "commit": "b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0"
+  },
+  "email": "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root": "/mnt/general/wanghy/RAGEN",
+  "host": "pt-a7f17fedde804edca572f81ace5fcaf3-worker-0",
+  "executable": "/opt/conda/envs/ragen_new/bin/python",
+  "cpu_count": 64,
+  "cpu_count_logical": 128,
+  "gpu": "NVIDIA H100 80GB HBM3",
+  "gpu_count": 8,
+  "disk": {
+    "/": {
+      "total": "60129542144000",
+      "used": "72513892352"
+    }
+  },
+  "memory": {
+    "total": "2159579672576"
+  },
+  "gpu_nvidia": [
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-97b3b912-40cf-f573-ffce-8275a656891f"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-5e4acc7a-f7ab-1a15-312e-4e2a39c43b2c"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-b36695ed-370a-2556-79d8-b0a2c2659271"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-b3e13ca7-237c-931f-894b-798f9cfa5620"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-64647b1f-5d55-1b7e-bf3d-64fae3871140"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-fe8b9b7e-82a4-1238-4843-bbfd0269d746"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-4523d4e1-5745-8224-7bcd-44cf59b76bae"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-9262bcbd-a29f-d761-3330-ac2ce9f15e82"
+    }
+  ],
+  "cudaVersion": "12.4",
+  "writerId": "rpamc3wni7ysqe4ryq6pxzkkfppcrszf"
+}

wandb/run-20260515_162634-oma8h4e9/files/wandb-summary.json

@@ -0,0 +1 @@
+{"_runtime":3111.936040208,"train/old_approx_kl":8.741393685340881e-06,"charts/avg_reward":1.521484375,"eval/success_rate":0.9855,"_wandb":{"runtime":3111},"eval/episodes":4000,"_step":9999360,"rollout/ep_rew_mean":16,"eval/std_return":2.42313727105482,"rollout/success_rate":1,"_timestamp":1.7788367075641153e+09,"perf/SPS":3216,"global_step":9999360,"train/entropy":0.6433544158935547,"train/learning_rate":3.072196620584888e-08,"eval/avg_return":15.642875,"train/episodic_length":6,"losses/explained_variance":0.827873170375824,"charts/avg_value":10.706439971923828,"train/approx_kl":5.820766091346741e-09,"train/success":1,"train/policy_loss":-5.54695725440979e-06,"train/episodic_return":16,"train/success_rate_100":0.96,"train/value_loss":2.485055923461914,"rollout/ep_len_mean":6}

wandb/run-20260515_162634-oma8h4e9/run-oma8h4e9.wandb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c393b069802d31064ee7b3c235e0f77cb817e9a6a5a4ad02ff2aca8bd898a64d
+size 495368288

wandb/run-20260602_163908-h5c4lnf8/files/config.yaml

@@ -0,0 +1,962 @@
+_wandb:
+    value:
+        cli_version: 0.23.0
+        e:
+            xujgpyta9fobjr0dv9c8irk09puw6cyf:
+                args:
+                    - --node-ip-address=10.119.99.71
+                    - --node-manager-port=40857
+                    - --object-store-name=/tmp/ray/session_2026-06-02_16-37-20_802181_63/sockets/plasma_store
+                    - --raylet-name=/tmp/ray/session_2026-06-02_16-37-20_802181_63/sockets/raylet
+                    - --redis-address=None
+                    - --metrics-agent-port=61011
+                    - --logging-rotate-bytes=536870912
+                    - --logging-rotate-backup-count=5
+                    - --runtime-env-agent-port=64336
+                    - --gcs-address=10.119.99.71:58508
+                    - --session-name=session_2026-06-02_16-37-20_802181_63
+                    - --temp-dir=/tmp/ray
+                    - --webui=127.0.0.1:8265
+                    - --cluster-id=84bd6fc9f3347ae38148ba1fc34ddb17acef60e63f043d1f96cdb6a1
+                    - --startup-token=112
+                    - --worker-launch-time-ms=1780389444445
+                    - --node-id=b414ad5d57488276b4be7a2e773fdd2e0d34dafbb1c67008822cb310
+                    - --runtime-env-hash=-839022692
+                cpu_count: 64
+                cpu_count_logical: 128
+                cudaVersion: "12.4"
+                disk:
+                    /:
+                        total: "60129542144000"
+                        used: "3272704"
+                email: haoyu-wa22@mails.tsinghua.edu.cn
+                executable: /root/local/miniconda3/envs/ragen/bin/python
+                git:
+                    commit: b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0
+                    remote: https://github.com/Harry-mic/SCOUT
+                gpu: NVIDIA H100 80GB HBM3
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-089f171c-391c-dbe6-9732-e9dcab584b2a
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-dd51e744-372c-c614-a72c-669a2e06a129
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-b90b5f70-0fa3-34a8-3493-47d296746407
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-c0dd667b-31c0-dafb-d08e-1ad2118cb424
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-2d1ce5d0-61a8-a6bc-0add-5cbd5c318090
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-54dd1f4c-02ad-838f-3539-9944b7e06aef
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-ac5dd66a-cc74-66d9-e1c1-07dfad209fcc
+                    - architecture: Hopper
+                      cudaCores: 16896
+                      memoryTotal: "85520809984"
+                      name: NVIDIA H100 80GB HBM3
+                      uuid: GPU-26a4af72-9a63-2169-5525-ca7c5848b780
+                host: pt-8d304999aaac4ce1bdbc8c16dc65a596-worker-0
+                memory:
+                    total: "2159611842560"
+                os: Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35
+                program: /root/local/miniconda3/envs/ragen/lib/python3.10/site-packages/ray/_private/workers/default_worker.py
+                python: CPython 3.10.19
+                root: /mnt/general/wanghy/RAGEN
+                startedAt: "2026-06-02T08:39:08.900060Z"
+                writerId: xujgpyta9fobjr0dv9c8irk09puw6cyf
+        m: []
+        python_version: 3.10.19
+        t:
+            "1":
+                - 1
+                - 5
+                - 11
+                - 30
+                - 41
+                - 49
+                - 50
+                - 51
+                - 53
+                - 71
+                - 95
+                - 97
+                - 98
+                - 105
+            "2":
+                - 1
+                - 5
+                - 11
+                - 30
+                - 41
+                - 49
+                - 50
+                - 51
+                - 53
+                - 71
+                - 95
+                - 97
+                - 98
+                - 105
+            "3":
+                - 2
+                - 13
+                - 16
+                - 61
+            "4": 3.10.19
+            "5": 0.23.0
+            "6": 4.57.3
+            "12": 0.23.0
+            "13": linux-x86_64
+actor_rollout_ref:
+    value:
+        actor:
+            _target_: verl.workers.config.FSDPActorConfig
+            checkpoint:
+                _target_: verl.trainer.config.CheckpointConfig
+                async_save: false
+                load_contents:
+                    - model
+                    - optimizer
+                    - extra
+                save_contents:
+                    - model
+                    - optimizer
+                    - extra
+            clip_ratio: 0.2
+            clip_ratio_c: 3
+            clip_ratio_high: 0.2
+            clip_ratio_low: 0.2
+            entropy_checkpointing: false
+            entropy_coeff: 0.001
+            entropy_from_logits_with_chunking: false
+            freeze_vision_tower: false
+            fsdp_config:
+                _target_: verl.workers.config.FSDPEngineConfig
+                entropy_checkpointing: false
+                entropy_from_logits_with_chunking: false
+                forward_only: false
+                forward_prefetch: false
+                fsdp_size: -1
+                model_dtype: fp32
+                offload_policy: false
+                optimizer_offload: false
+                param_offload: false
+                reshard_after_forward: true
+                strategy: fsdp
+                ulysses_sequence_parallel_size: 1
+                use_orig_params: false
+                use_torch_compile: true
+                wrap_policy:
+                    min_num_params: 0
+            grad_clip: 1
+            grpo_advantage_length_weight: false
+            kl_loss_coef: 0.001
+            kl_loss_type: kl
+            loss_agg_mode: token-mean
+            optim:
+                _target_: verl.workers.config.FSDPOptimizerConfig
+                betas:
+                    - 0.9
+                    - 0.999
+                clip_grad: 1
+                lr: 1e-06
+                lr_warmup_steps: -1
+                lr_warmup_steps_ratio: 0
+                min_lr_ratio: 0
+                num_cycles: 0.5
+                total_training_steps: 200
+                warmup_style: constant
+                weight_decay: 0.01
+            policy_loss:
+                _target_: verl.workers.config.PolicyLossConfig
+                clip_cov_lb: 1
+                clip_cov_ratio: 0.0002
+                clip_cov_ub: 5
+                kl_cov_ratio: 0.0002
+                loss_mode: vanilla
+                ppo_kl_coef: 0.1
+            ppo_epochs: 1
+            ppo_max_token_len_per_gpu: 16384
+            ppo_micro_batch_size: null
+            ppo_micro_batch_size_per_gpu: 1
+            ppo_mini_batch_size: 16
+            profiler:
+                _target_: verl.utils.profiler.ProfilerConfig
+                all_ranks: false
+                enable: false
+                ranks: []
+                save_path: outputs/profile
+                tool: null
+                tool_config:
+                    npu:
+                        _target_: verl.utils.profiler.config.NPUToolConfig
+                        analysis: true
+                        contents: []
+                        discrete: false
+                        level: level1
+                    nsys:
+                        _target_: verl.utils.profiler.config.NsightToolConfig
+                        discrete: false
+                    torch:
+                        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+                        step_end: null
+                        step_start: 0
+                    torch_memory:
+                        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+                        stack_depth: 32
+                        trace_alloc_max_entries: 100000
+            shuffle: false
+            strategy: fsdp
+            tis_imp_ratio_cap: -1
+            ulysses_sequence_parallel_size: 1
+            use_dynamic_bsz: false
+            use_fused_kernels: false
+            use_kl_loss: false
+            use_ref: true
+            use_remove_padding: false
+            use_torch_compile: true
+        hybrid_engine: true
+        model:
+            _target_: verl.workers.config.HFModelConfig
+            custom_chat_template: null
+            enable_activation_offload: false
+            enable_gradient_checkpointing: true
+            exclude_modules: null
+            external_lib: null
+            fused_kernel_options:
+                impl_backend: torch
+            hf_config_path: null
+            lora_alpha: 16
+            lora_rank: 0
+            path: /mnt/general/share/model/Qwen/Qwen2.5-3B-Instruct
+            target_modules: all-linear
+            tokenizer_path: null
+            torch_dtype: bfloat16
+            trust_remote_code: false
+            use_fused_kernels: false
+            use_liger: false
+            use_remove_padding: false
+            use_shm: false
+        nccl_timeout: 600
+        ref:
+            entropy_checkpointing: false
+            entropy_from_logits_with_chunking: false
+            fsdp_config:
+                _target_: verl.workers.config.FSDPEngineConfig
+                entropy_checkpointing: false
+                entropy_from_logits_with_chunking: false
+                forward_only: false
+                forward_prefetch: false
+                fsdp_size: -1
+                model_dtype: fp32
+                offload_policy: false
+                optimizer_offload: false
+                param_offload: false
+                reshard_after_forward: true
+                strategy: fsdp
+                ulysses_sequence_parallel_size: 1
+                use_orig_params: false
+                use_torch_compile: true
+                wrap_policy:
+                    min_num_params: 0
+            log_prob_max_token_len_per_gpu: 16384
+            log_prob_micro_batch_size: null
+            log_prob_micro_batch_size_per_gpu: 1
+            log_prob_use_dynamic_bsz: false
+            model: null
+            profiler:
+                _target_: verl.utils.profiler.ProfilerConfig
+                all_ranks: false
+                enable: false
+                ranks: []
+                save_path: outputs/profile
+                tool: null
+                tool_config:
+                    npu:
+                        _target_: verl.utils.profiler.config.NPUToolConfig
+                        analysis: true
+                        contents: []
+                        discrete: false
+                        level: level1
+                    nsys:
+                        _target_: verl.utils.profiler.config.NsightToolConfig
+                        discrete: false
+                    torch:
+                        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+                        step_end: null
+                        step_start: 0
+                    torch_memory:
+                        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+                        stack_depth: 32
+                        trace_alloc_max_entries: 100000
+            strategy: fsdp
+            ulysses_sequence_parallel_size: 1
+            use_torch_compile: true
+        rollout:
+            _target_: verl.workers.config.RolloutConfig
+            agent:
+                _target_: verl.workers.config.AgentLoopConfig
+                agent_loop_config_path: null
+                custom_async_server:
+                    _target_: verl.workers.config.CustomAsyncServerConfig
+                    name: null
+                    path: null
+                num_workers: 8
+            calculate_log_probs: false
+            cudagraph_capture_sizes: null
+            data_parallel_size: 1
+            disable_log_stats: true
+            do_sample: true
+            dtype: bfloat16
+            enable_chunked_prefill: true
+            enable_prefix_caching: true
+            enforce_eager: true
+            expert_parallel_size: 1
+            free_cache_engine: true
+            gpu_memory_utilization: 0.6
+            ignore_eos: false
+            layered_summon: false
+            load_format: dummy
+            log_prob_max_token_len_per_gpu: 16384
+            log_prob_micro_batch_size: null
+            log_prob_micro_batch_size_per_gpu: 1
+            log_prob_use_dynamic_bsz: false
+            max_model_len: 16384
+            max_num_batched_tokens: 16384
+            max_num_seqs: 1024
+            mode: sync
+            multi_stage_wake_up: false
+            multi_turn:
+                _target_: verl.workers.config.MultiTurnConfig
+                enable: false
+                format: hermes
+                interaction_config_path: null
+                max_assistant_turns: null
+                max_parallel_calls: 1
+                max_tool_response_length: 256
+                max_user_turns: null
+                num_repeat_rollouts: null
+                tokenization_sanity_check_mode: strict
+                tool_config_path: null
+                tool_response_truncate_side: middle
+                use_inference_chat_template: false
+            "n": 1
+            name: vllm
+            over_sample_rate: 0
+            profiler:
+                _target_: verl.utils.profiler.ProfilerConfig
+                all_ranks: false
+                enable: false
+                ranks: []
+                save_path: outputs/profile
+                tool: null
+                tool_config:
+                    npu:
+                        _target_: verl.utils.profiler.config.NPUToolConfig
+                        analysis: true
+                        contents: []
+                        discrete: false
+                        level: level1
+                    nsys:
+                        _target_: verl.utils.profiler.config.NsightToolConfig
+                        discrete: false
+                    torch:
+                        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+                        step_end: null
+                        step_start: 0
+                    torch_memory:
+                        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+                        stack_depth: 32
+                        trace_alloc_max_entries: 100000
+            prompt_length: 1
+            response_length: 500
+            rollout_filter_metric: reward_variance
+            rollout_filter_ratio: 1
+            rollout_filter_type: largest
+            skip_dump_dir: /tmp/rollout_dump
+            skip_rollout: false
+            skip_tokenizer_init: true
+            temperature: 1
+            tensor_model_parallel_size: 1
+            top_k: -1
+            top_p: 1
+            trace:
+                _target_: verl.workers.config.TraceConfig
+                backend: null
+                token2text: false
+            update_weights_bucket_megabytes: 512
+            val_kwargs:
+                _target_: verl.workers.config.SamplingConfig
+                do_sample: true
+                "n": 1
+                temperature: 0.5
+                top_k: -1
+                top_p: 1
+agent_proxy:
+    value:
+        action_sep: '||'
+        enable_think: true
+        max_actions_per_turn: 1
+        max_context_window: -1
+        max_turn: 15
+        reward_normalization:
+            grouping: state
+            method: identity
+        use_turn_scores: false
+algorithm:
+    value:
+        _target_: verl.trainer.config.AlgoConfig
+        adv_estimator: gae
+        bi_level_gae: false
+        gamma: 1
+        high_level_gamma: 0.95
+        kl_ctrl:
+            _target_: verl.trainer.config.KLControlConfig
+            horizon: 10000
+            kl_coef: 0.001
+            target_kl: 0.1
+            type: fixed
+        kl_penalty: kl
+        lam: 1
+        norm_adv_by_std_in_grpo: true
+        pf_ppo:
+            reweight_method: pow
+            weight_pow: 2
+        use_kl_in_reward: false
+        use_pf_ppo: false
+critic:
+    value:
+        _target_: verl.workers.config.FSDPCriticConfig
+        checkpoint:
+            _target_: verl.trainer.config.CheckpointConfig
+            async_save: false
+            load_contents:
+                - model
+                - optimizer
+                - extra
+            save_contents:
+                - model
+                - optimizer
+                - extra
+        cliprange_value: 0.5
+        enable: null
+        forward_max_token_len_per_gpu: 32768
+        forward_micro_batch_size: null
+        forward_micro_batch_size_per_gpu: 1
+        grad_clip: 1
+        loss_agg_mode: token-mean
+        model:
+            _target_: verl.workers.config.FSDPCriticModelCfg
+            enable_activation_offload: false
+            enable_gradient_checkpointing: true
+            external_lib: null
+            fsdp_config:
+                _target_: verl.workers.config.FSDPEngineConfig
+                entropy_checkpointing: false
+                entropy_from_logits_with_chunking: false
+                forward_only: false
+                forward_prefetch: false
+                fsdp_size: -1
+                model_dtype: fp32
+                offload_policy: false
+                optimizer_offload: false
+                param_offload: false
+                reshard_after_forward: true
+                strategy: fsdp
+                ulysses_sequence_parallel_size: 1
+                use_orig_params: false
+                use_torch_compile: true
+                wrap_policy:
+                    min_num_params: 0
+            lora_alpha: 16
+            lora_rank: 0
+            path: /mnt/general/share/model/Qwen/Qwen2.5-3B-Instruct
+            target_modules: all-linear
+            tokenizer_path: /mnt/general/share/model/Qwen/Qwen2.5-3B-Instruct
+            trust_remote_code: false
+            use_remove_padding: false
+            use_shm: false
+        optim:
+            _target_: verl.workers.config.FSDPOptimizerConfig
+            betas:
+                - 0.9
+                - 0.999
+            clip_grad: 1
+            lr: 1e-05
+            lr_warmup_steps: -1
+            lr_warmup_steps_ratio: 0
+            min_lr_ratio: 0
+            num_cycles: 0.5
+            total_training_steps: 200
+            warmup_style: constant
+            weight_decay: 0.01
+        ppo_epochs: 1
+        ppo_max_token_len_per_gpu: 32768
+        ppo_micro_batch_size: null
+        ppo_micro_batch_size_per_gpu: 1
+        ppo_mini_batch_size: 16
+        profiler:
+            _target_: verl.utils.profiler.ProfilerConfig
+            all_ranks: false
+            enable: false
+            ranks: []
+            save_path: outputs/profile
+            tool: null
+            tool_config:
+                npu:
+                    _target_: verl.utils.profiler.config.NPUToolConfig
+                    analysis: true
+                    contents: []
+                    discrete: false
+                    level: level1
+                nsys:
+                    _target_: verl.utils.profiler.config.NsightToolConfig
+                    discrete: false
+                torch:
+                    _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+                    step_end: null
+                    step_start: 0
+                torch_memory:
+                    _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+                    stack_depth: 32
+                    trace_alloc_max_entries: 100000
+        rollout_n: 1
+        shuffle: false
+        strategy: fsdp
+        ulysses_sequence_parallel_size: 1
+        use_dynamic_bsz: false
+ctx_manager:
+    value:
+        generation:
+            gen_config:
+                kwargs: null
+                response_length: 500
+                temperature: 1
+                top_k: -1
+                top_p: 1
+custom_envs:
+    value:
+        Bandit:
+            env_config:
+                split: train
+            env_instruction: ""
+            env_type: bandit
+            max_actions_per_traj: 1
+            max_tokens: 100
+        BanditTest:
+            env_config:
+                split: test
+            env_instruction: ""
+            env_type: bandit
+            max_actions_per_traj: 1
+            max_tokens: 100
+        CoordFrozenLake:
+            env_config:
+                observation_format: grid_coord
+            env_instruction: |
+                You are solving the FrozenLake puzzle. The observation includes both a symbol grid and zero-indexed coordinates for the start, goal, player, and any holes.
+                Coordinates range from the top-left corner (0, 0) to the bottom-right corner (5, 5).
+                Beware that the ice is slippery, so the agent might slide and end up in an unintended tile.
+                Respond with a sequence of actions such as <answer>Left || Up || Up</answer>.
+            env_type: frozen_lake
+            max_actions_per_traj: 25
+            max_tokens: 120
+        CoordSokoban:
+            env_config:
+                dim_x: 6
+                dim_y: 6
+                max_steps: 100
+                num_boxes: 2
+                observation_format: grid_coord
+            env_instruction: "You are solving the Sokoban puzzle. You are the player and you need to push all boxes to targets.\nYou are provided with a symbol grid and the zero-indexed coordinates of the player, each box, and each target. \nCoordinates range from the top-left corner (0, 0) to the bottom-right corner (5, 5). \nWhen you are exactly next to a box, you can push it by moving in the same direction. \nYou cannot push a box through a wall, and you cannot pull a box.\nThe answer should be a sequence of actions, like <answer>Right || Right || Up</answer>.\n"
+            env_type: sokoban
+            max_actions_per_traj: 10
+            max_tokens: 120
+        Countdown:
+            env_config: null
+            env_instruction: 'You are solving the Countdown puzzle. You should use the num list to create an equation that equals the target. Example answer format: <think> To find an equation using [3, 5, 2] to get 4. Let''s check 2 + 5 = 7, 7 - 3 = 4. So the answer is 2 + 5 - 3 = 4. </think><answer>2 + 5 - 3</answer>'
+            env_type: countdown
+            max_actions_per_traj: 1
+            max_tokens: 100
+        FrozenLake:
+            env_config: null
+            env_instruction: 'You are solving the FrozenLake puzzle. Forbid the whole and go to the target. You may move to the unintended direction due to the slippery ice. Example answer format: <think>To forbid the hole and go to the target, I should go left then go up.</think><answer>Left || Up</answer>'
+            env_type: frozen_lake
+            max_actions_per_traj: 25
+            max_tokens: 100
+        LargerSokoban:
+            env_config:
+                dim_x: 8
+                dim_y: 8
+                max_steps: 100
+                num_boxes: 2
+                search_depth: 10
+            env_instruction: "You are solving the Sokoban puzzle. \nYou are the player and you need to push all boxes to targets. \nWhen you are right next to a box, you can push it by moving in the same direction. \nYou cannot push a box through a wall, and you cannot pull a box. \nThe answer should be a sequence of actions, like <answer>Right || Right || Up</answer>\n"
+            env_type: sokoban
+            max_actions_per_traj: 10
+            max_tokens: 100
+        Lean:
+            env_config: null
+            env_instruction: You are a Lean theorem prover. Given a Lean theorem statement, propose a sequence of tactics that completes the proof. Think step by step about which tactics to apply next. Provide tactics separated by '||', for example <answer>intro || simp || rfl</answer>.
+            env_type: lean
+            max_actions_per_traj: 30
+            max_tokens: 512
+        MediumSudoku:
+            env_config:
+                difficulty: medium
+                grid_size: 9
+                max_steps: 81
+                render_format: with_feedback
+                show_conflicts: true
+                show_valid_numbers: true
+            env_instruction: |
+                You are solving a Sudoku puzzle. Fill in the grid so that every row, column, and 3x3 box contains the numbers 1-9 without repetition.
+                Initial cells are shown in [brackets] and cannot be modified. Empty cells are shown as dots (.).
+                Place numbers one at a time using the format: <answer>place 5 at row 2 col 3</answer> or <answer>2,3,5</answer>
+                The environment will provide feedback on valid/invalid moves and show conflicts if any occur.
+            env_type: sudoku
+            max_actions_per_traj: 30
+            max_tokens: 150
+            max_workers: 32
+            parallel_friendly: false
+        MetamathQA:
+            env_config: null
+            env_instruction: 'You are solving Math problems. '
+            env_type: metamathqa
+            max_actions_per_traj: 1
+            max_tokens: 100
+        SimpleSokoban:
+            env_config:
+                dim_x: 6
+                dim_y: 6
+                max_steps: 100
+                num_boxes: 2
+            env_instruction: "You are solving the Sokoban puzzle. \nYou are the player and you need to push all boxes to targets. \nWhen you are right next to a box, you can push it by moving in the same direction. \nYou cannot push a box through a wall, and you cannot pull a box. \nThe answer should be a sequence of actions, like <answer>Right || Right || Up</answer>\n"
+            env_type: sokoban
+            max_actions_per_traj: 10
+            max_tokens: 100
+        SimpleSudoku:
+            env_config:
+                difficulty: easy
+                grid_size: 4
+                max_steps: 20
+                render_format: with_feedback
+                show_conflicts: false
+                show_valid_numbers: false
+            env_instruction: |
+                You are solving a Sudoku puzzle. Fill in the grid so that every row, column, and 2x2 box contains the numbers 1-4 without repetition.
+                Initial cells are shown in [brackets] and cannot be modified. Empty cells are shown as dots (.).
+                Place numbers one at a time using the format, for example: <answer>place 1 at row 2 col 3</answer> or <answer>1,2,3</answer>
+                The environment will provide feedback on valid/invalid moves and show conflicts if any occur.
+            env_type: sudoku
+            max_actions_per_traj: 20
+            max_tokens: 150
+            max_workers: 32
+            parallel_friendly: false
+        SokobanDifferentGridVocab:
+            env_config:
+                dim_x: 6
+                dim_y: 6
+                grid_lookup:
+                    "0": W
+                    "1": .
+                    "2": G
+                    "3": C
+                    "4": B
+                    "5": A
+                    "6": '@'
+                grid_vocab:
+                    .: empty
+                    '@': player on target
+                    A: player
+                    B: box
+                    C: box on target
+                    G: target
+                    W: wall
+                max_steps: 100
+                num_boxes: 1
+                search_depth: 30
+            env_instruction: "You are solving the Sokoban puzzle. \nYou are the player and you need to push all boxes to targets. \nWhen you are right next to a box, you can push it by moving in the same direction. \nYou cannot push a box through a wall, and you cannot pull a box. \nThe answer should be a sequence of actions, like <answer>Right || Right || Up</answer>\n"
+            env_type: sokoban
+            max_actions_per_traj: 10
+            max_tokens: 100
+        VisualSimpleSokoban:
+            env_config:
+                dim_x: 6
+                dim_y: 6
+                max_steps: 100
+                num_boxes: 1
+                render_mode: rgb_array
+            env_instruction: You are solving the Sokoban puzzle. You are the player and you need to push all boxes to targets. When you are right next to a box, you can push it by moving in the same direction. You cannot push a box through a wall, and you cannot pull a box. The answer should be a sequence of actions, like <answer>Right || Right || Up</answer>
+            env_type: sokoban
+            max_actions_per_traj: 10
+            max_tokens: 100
+        WebShop:
+            env_config:
+                dataset: small
+            env_instruction: 'You are browsing an online shop. Based on the instruction, buy a product that close to the production description. You need to search, read the search results, pick a product, choose the size and color and buy. You should only choose action from the available actions list provided later.  Example process: I need a gingko light and 20x20 pillow cover that is hand painted. First search[gingko light 20x20 pillow cover hand painted], answer format: <answer>search[blanket with fleece throw]</answer>. Valid answer is search[<keywords>] or click[<clickable>].'
+            env_type: webshop
+            max_actions_per_traj: 9
+            max_tokens: 200
+        blackjack:
+            env_config: null
+            env_instruction: |
+                You are playing Blackjack against a dealer. The dealer must hit on 16 or less and stand on 17 or more.
+                Choose either Stick or Hit. Respond with a single action.
+                Example: <answer>Hit</answer>
+            env_type: blackjack
+            max_actions_per_traj: 10
+            max_tokens: 64
+        game_2048:
+            env_config: null
+            env_instruction: |
+                You are playing the 2048 game on a 4x4 grid. Merge equal tiles by sliding Up, Right, Down, or Left.
+                If a move is invalid (no tiles move), a small penalty is applied. Respond with a single action.
+                Example: <answer>Up</answer>
+            env_type: game_2048
+            max_actions_per_traj: 700
+            max_tokens: 8192
+        rubikscube:
+            env_config:
+                max_steps: 20
+                render_mode: text
+                scramble_depth: 5
+            env_instruction: |
+                You are solving a 2x2 Rubik's Cube (Pocket Cube). The goal is to restore the cube so that each of the faces consists of a single, unique color.
+                Available actions use standard Singmaster notation for face rotations: U, U', D, D', L, L', R, R', F, F', B, B'.
+                - Faces: U (Up), D (Down), L (Left), R (Right), F (Front), B (Back).
+                - Modifiers: A letter alone means 90° clockwise (e.g., 'R'). A letter with prime (') means 90° counter-clockwise (e.g., "R'").
+                Respond with a sequence of actions separated by "||".
+                Example: <answer>U</answer>
+            env_type: rubikscube
+            max_actions_per_traj: 20
+            max_tokens: 96
+custom_reward_function:
+    value:
+        name: compute_score
+        path: null
+data:
+    value:
+        custom_cls:
+            name: null
+            path: null
+        datagen:
+            name: null
+            path: null
+        dataloader_num_workers: 8
+        filter_overlong_prompts: false
+        filter_overlong_prompts_workers: 1
+        image_key: images
+        max_prompt_length: null
+        max_response_length: null
+        prompt_key: prompt
+        return_full_prompt: false
+        return_multi_modal_inputs: true
+        return_raw_chat: false
+        return_raw_input_ids: false
+        reward_fn_key: data_source
+        sampler:
+            class_name: null
+            class_path: null
+        shuffle: true
+        tokenizer: null
+        train_batch_size: 128
+        train_files: ~/data/rlhf/gsm8k/train.parquet
+        truncation: error
+        trust_remote_code: false
+        use_shm: false
+        val_batch_size: null
+        val_files: ~/data/rlhf/gsm8k/test.parquet
+        validation_shuffle: false
+        video_key: videos
+enable_response_mask:
+    value: true
+es_manager:
+    value:
+        format_penalty: -0.1
+        train:
+            env_configs:
+                n_groups:
+                    - 8
+                tags:
+                    - SimpleSudoku
+            env_groups: 8
+            group_size: 16
+        val:
+            env_configs:
+                n_groups:
+                    - 32
+                tags:
+                    - SimpleSudoku
+            env_groups: 32
+            group_size: 16
+global_profiler:
+    value:
+        _target_: verl.utils.profiler.ProfilerConfig
+        global_tool_config:
+            nsys:
+                _target_: verl.utils.profiler.config.NsightToolConfig
+                controller_nsight_options:
+                    cuda-graph-trace: graph
+                    cuda-memory-usage: "true"
+                    trace: cuda,nvtx,cublas,ucx
+                discrete: false
+                worker_nsight_options:
+                    capture-range: cudaProfilerApi
+                    capture-range-end: null
+                    cuda-graph-trace: graph
+                    cuda-memory-usage: "true"
+                    kill: none
+                    trace: cuda,nvtx,cublas,ucx
+            torch_memory:
+                context: all
+                stack_depth: 32
+                stacks: all
+                trace_alloc_max_entries: 100000
+        profile_continuous_steps: false
+        save_path: outputs/profile
+        steps: null
+        tool: null
+grpo_advantage_length_weight:
+    value: false
+lora:
+    value:
+        alpha: 16
+        rank: 0
+        target_modules: all-linear
+micro_batch_size_per_gpu:
+    value: 1
+model_path:
+    value: /mnt/general/share/model/Qwen/Qwen2.5-3B-Instruct
+ppo_mini_batch_size:
+    value: 16
+ray_kwargs:
+    value:
+        ray_init:
+            num_cpus: null
+        timeline_json_file: null
+reward_model:
+    value:
+        enable: false
+        enable_resource_pool: false
+        forward_max_token_len_per_gpu: 32768
+        launch_reward_fn_async: false
+        max_length: null
+        micro_batch_size: null
+        micro_batch_size_per_gpu: null
+        model:
+            external_lib: null
+            fsdp_config:
+                _target_: verl.workers.config.FSDPEngineConfig
+                forward_prefetch: false
+                fsdp_size: -1
+                param_offload: false
+                reshard_after_forward: true
+                wrap_policy:
+                    min_num_params: 0
+            input_tokenizer: /mnt/general/share/model/Qwen/Qwen2.5-3B-Instruct
+            path: ~/models/FsfairX-LLaMA3-RM-v0.1
+            trust_remote_code: false
+            use_fused_kernels: false
+            use_remove_padding: false
+            use_shm: false
+        n_gpus_per_node: 0
+        nnodes: 0
+        profiler:
+            _target_: verl.utils.profiler.ProfilerConfig
+            all_ranks: false
+            enable: false
+            ranks: []
+            save_path: outputs/profile
+            tool: null
+            tool_config:
+                npu:
+                    _target_: verl.utils.profiler.config.NPUToolConfig
+                    analysis: true
+                    contents: []
+                    discrete: false
+                    level: level1
+                nsys:
+                    _target_: verl.utils.profiler.config.NsightToolConfig
+                    discrete: false
+                torch:
+                    _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+                    step_end: null
+                    step_start: 0
+                torch_memory:
+                    _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+                    stack_depth: 32
+                    trace_alloc_max_entries: 100000
+        reward_manager: naive
+        sandbox_fusion:
+            max_concurrent: 64
+            memory_limit_mb: 1024
+            url: null
+        strategy: fsdp
+        ulysses_sequence_parallel_size: 1
+        use_dynamic_bsz: false
+seed:
+    value:
+        train: 10000
+        val: 123
+system:
+    value:
+        CUDA_VISIBLE_DEVICES: 0,1,2,3,4,5,6,7
+trainer:
+    value:
+        balance_batch: true
+        critic_warmup: 0
+        default_hdfs_dir: null
+        default_local_dir: /mnt/general/wanghy/RAGEN/saves/
+        del_local_ckpt_after_load: false
+        device: cuda
+        esi_redundant_time: 0
+        experiment_name: sudoku-4x4-nohint-action1
+        generations_to_log_to_wandb:
+            train: 128
+            val: 20
+        local_log_dir: results/
+        log_val_generations: 0
+        logger:
+            - console
+            - wandb
+        max_actor_ckpt_to_keep: 1
+        max_critic_ckpt_to_keep: 1
+        n_gpus_per_node: 8
+        nnodes: 1
+        project_name: ragen_latest_qwen_25_3b_it
+        ray_wait_register_center_timeout: 300
+        resume_from_path: null
+        resume_mode: auto
+        rollout_data_dir: null
+        save_freq: -1
+        test_freq: 10
+        total_epochs: 30
+        total_training_steps: 200
+        use_legacy_worker_impl: auto
+        val_before_train: true
+        val_only: false
+        validation_data_dir: null
+        validation_steps: 1

wandb/run-20260602_163908-h5c4lnf8/files/requirements.txt

@@ -0,0 +1,313 @@
+ragen==0.1
+ragen==0.1
+colorama==0.4.6
+psutil==7.1.3
+Farama-Notifications==0.0.4
+MarkupSafe==2.1.5
+PyJWT==2.10.1
+PySocks==1.7.1
+absl-py==2.3.1
+accelerate==1.12.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.2
+aiohttp-cors==0.8.1
+aiosignal==1.4.0
+airportsdata==20250909
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anthropic==0.75.0
+antlr4-python3-runtime==4.9.3
+anyio==4.12.0
+astor==0.8.1
+asttokens==3.0.1
+async-timeout==5.0.1
+attrs==25.4.0
+beautifulsoup4==4.14.3
+black==25.11.0
+blake3==1.0.8
+blinker==1.9.0
+blis==1.3.3
+cachetools==6.2.2
+catalogue==2.0.10
+certifi==2025.11.12
+cffi==2.0.0
+charset-normalizer==3.4.4
+cleantext==1.1.4
+click==8.2.1
+cloudpathlib==0.23.0
+cloudpickle==3.1.2
+codetiming==1.4.0
+colorama==0.4.6
+coloredlogs==15.0.1
+colorful==0.5.8
+compressed-tensors==0.9.3
+confection==0.1.5
+contourpy==1.3.2
+cryptography==46.0.3
+cupy-cuda12x==13.6.0
+cycler==0.12.1
+cymem==2.0.13
+Cython==3.2.2
+datasets==4.4.1
+debugpy==1.8.17
+decorator==5.2.1
+Deprecated==1.3.1
+depyf==0.18.0
+dill==0.4.0
+diskcache==5.6.3
+distlib==0.4.0
+distro==1.9.0
+dnspython==2.8.0
+docstring_parser==0.17.0
+einops==0.8.1
+email-validator==2.3.0
+eval_type_backport==0.2.2
+exceptiongroup==1.3.1
+executing==2.2.1
+faiss-gpu==1.7.2
+fastapi==0.123.1
+fastapi-cli==0.0.16
+fastapi-cloud-cli==0.5.2
+fastar==0.8.0
+fastrlock==0.8.3
+filelock==3.19.1
+flash_attn==2.8.3
+Flask==3.1.2
+flatbuffers==25.9.23
+fonttools==4.61.0
+frozenlist==1.8.0
+fsspec==2025.9.0
+gdown==5.2.0
+gguf==0.17.1
+gitdb==4.0.12
+GitPython==3.1.45
+google-api-core==2.28.1
+google-auth==2.43.0
+googleapis-common-protos==1.72.0
+grpcio==1.76.0
+gym==0.26.2
+gym-notices==0.1.0
+gym-sokoban==0.0.6
+gymnasium==1.2.2
+h11==0.16.0
+hf-xet==1.2.0
+html2text==2025.4.15
+httpcore==1.0.9
+httptools==0.7.1
+httpx==0.28.1
+httpx-sse==0.4.3
+huggingface-hub==0.36.0
+humanfriendly==10.0
+hydra-core==1.3.2
+idna==3.11
+ImageIO==2.37.2
+importlib_metadata==8.0.0
+interegular==0.3.3
+ipython==8.37.0
+itsdangerous==2.2.0
+jedi==0.19.2
+Jinja2==3.1.6
+jiter==0.12.0
+joblib==1.5.2
+jsonschema==4.25.1
+jsonschema-specifications==2025.9.1
+kimina-client==0.2.1
+kiwisolver==1.4.9
+lark==1.2.2
+llguidance==0.7.30
+llvmlite==0.44.0
+lm-format-enforcer==0.10.12
+loguru==0.7.3
+Markdown==3.10
+markdown-it-py==4.0.0
+matplotlib==3.10.7
+matplotlib-inline==0.2.1
+mcp==1.22.0
+mdurl==0.1.2
+mistral_common==1.8.6
+mpmath==1.3.0
+msgpack==1.1.2
+msgspec==0.20.0
+multidict==6.7.0
+multiprocess==0.70.18
+murmurhash==1.0.15
+mypy_extensions==1.1.0
+nest-asyncio==1.6.0
+networkx==3.3
+ninja==1.13.0
+nltk==3.9.2
+numba==0.61.2
+numpy==1.26.4
+nvidia-cublas-cu12==12.4.5.8
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cudnn-cu12==9.1.0.70
+nvidia-cufft-cu12==11.2.1.3
+nvidia-curand-cu12==10.3.5.147
+nvidia-cusolver-cu12==11.6.1.9
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-cusparselt-cu12==0.6.2
+nvidia-nccl-cu12==2.21.5
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvtx-cu12==12.4.127
+omegaconf==2.3.0
+onnxruntime==1.23.2
+openai==2.8.1
+opencensus==0.11.4
+opencensus-context==0.1.3
+opencv-python-headless==4.12.0.88
+opentelemetry-api==1.38.0
+opentelemetry-exporter-otlp==1.26.0
+opentelemetry-exporter-otlp-proto-common==1.26.0
+opentelemetry-exporter-otlp-proto-grpc==1.26.0
+opentelemetry-exporter-otlp-proto-http==1.26.0
+opentelemetry-exporter-prometheus==0.59b0
+opentelemetry-proto==1.26.0
+opentelemetry-sdk==1.38.0
+opentelemetry-semantic-conventions==0.59b0
+opentelemetry-semantic-conventions-ai==0.4.13
+orjson==3.11.4
+outlines==0.1.11
+outlines_core==0.1.26
+packaging==25.0
+pandas==2.3.3
+parso==0.8.5
+partial-json-parser==0.2.1.1.post7
+pathspec==0.12.1
+peft==0.18.0
+pexpect==4.9.0
+pillow==11.3.0
+pip==25.3
+platformdirs==4.5.0
+preshed==3.0.12
+prometheus_client==0.23.1
+prometheus-fastapi-instrumentator==7.1.0
+prompt_toolkit==3.0.52
+propcache==0.4.1
+proto-plus==1.26.1
+protobuf==4.25.8
+psutil==7.1.3
+ptyprocess==0.7.0
+pure_eval==0.2.3
+py-cpuinfo==9.0.0
+py-spy==0.4.1
+pyarrow==22.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pybind11==3.0.1
+pycountry==24.6.1
+pycparser==2.23
+pydantic==2.12.5
+pydantic_core==2.41.5
+pydantic-extra-types==2.10.6
+pydantic-settings==2.12.0
+pygame==2.6.1
+Pygments==2.19.2
+pyjnius==1.7.0
+pylatexenc==2.10
+pyparsing==3.2.5
+pyserini==1.2.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.1
+python-json-logger==4.0.0
+python-multipart==0.0.20
+pytokens==0.3.0
+pytz==2025.2
+PyYAML==6.0.3
+pyzmq==27.1.0
+ragen==0.1
+rank-bm25==0.2.2
+RapidFuzz==3.14.3
+ray==2.52.1
+referencing==0.37.0
+regex==2025.11.3
+requests==2.32.5
+rich==14.2.0
+rich-toolkit==0.17.0
+rignore==0.7.6
+rpds-py==0.30.0
+rsa==4.9.1
+safetensors==0.7.0
+scikit-learn==1.7.2
+scipy==1.15.3
+sentencepiece==0.2.1
+sentry-sdk==2.46.0
+setuptools==80.9.0
+shellingham==1.5.4
+six==1.17.0
+smart_open==7.5.0
+smmap==5.0.2
+sniffio==1.3.1
+soupsieve==2.8
+spacy==3.8.11
+spacy-legacy==3.0.12
+spacy-loggers==1.0.5
+srsly==2.5.2
+sse-starlette==3.0.3
+stack-data==0.6.3
+starlette==0.50.0
+sympy==1.13.1
+tabulate==0.9.0
+tenacity==9.1.2
+tensorboard==2.20.0
+tensorboard-data-server==0.7.2
+tensordict==0.8.3
+thefuzz==0.22.1
+thinc==8.3.10
+threadpoolctl==3.6.0
+tiktoken==0.12.0
+together==1.5.31
+tokenizers==0.22.1
+tomli==2.3.0
+torch==2.6.0+cu124
+torchaudio==2.6.0
+torchdata==0.11.0
+torchvision==0.21.0
+tqdm==4.67.1
+traitlets==5.14.3
+transformers==4.57.3
+triton==3.2.0
+typer==0.19.2
+typer-slim==0.20.0
+typing_extensions==4.15.0
+typing-inspection==0.4.2
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.38.0
+uvloop==0.22.1
+verl==0.5.0.dev0
+virtualenv==20.35.4
+vllm==0.8.5
+wandb==0.23.0
+wasabi==1.1.3
+watchfiles==1.1.1
+wcwidth==0.2.14
+weasel==0.4.3
+websockets==15.0.1
+Werkzeug==3.1.4
+wheel==0.45.1
+wrapt==2.0.1
+xformers==0.0.29.post2
+xgrammar==0.1.18
+xxhash==3.6.0
+yarl==1.22.0
+zipp==3.23.0
+ragen==0.1
+verl==0.5.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

wandb/run-20260602_163908-h5c4lnf8/files/wandb-metadata.json

@@ -0,0 +1,107 @@
+{
+  "os": "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python": "CPython 3.10.19",
+  "startedAt": "2026-06-02T08:39:08.900060Z",
+  "args": [
+    "--node-ip-address=10.119.99.71",
+    "--node-manager-port=40857",
+    "--object-store-name=/tmp/ray/session_2026-06-02_16-37-20_802181_63/sockets/plasma_store",
+    "--raylet-name=/tmp/ray/session_2026-06-02_16-37-20_802181_63/sockets/raylet",
+    "--redis-address=None",
+    "--metrics-agent-port=61011",
+    "--logging-rotate-bytes=536870912",
+    "--logging-rotate-backup-count=5",
+    "--runtime-env-agent-port=64336",
+    "--gcs-address=10.119.99.71:58508",
+    "--session-name=session_2026-06-02_16-37-20_802181_63",
+    "--temp-dir=/tmp/ray",
+    "--webui=127.0.0.1:8265",
+    "--cluster-id=84bd6fc9f3347ae38148ba1fc34ddb17acef60e63f043d1f96cdb6a1",
+    "--startup-token=112",
+    "--worker-launch-time-ms=1780389444445",
+    "--node-id=b414ad5d57488276b4be7a2e773fdd2e0d34dafbb1c67008822cb310",
+    "--runtime-env-hash=-839022692"
+  ],
+  "program": "/root/local/miniconda3/envs/ragen/lib/python3.10/site-packages/ray/_private/workers/default_worker.py",
+  "git": {
+    "remote": "https://github.com/Harry-mic/SCOUT",
+    "commit": "b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0"
+  },
+  "email": "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root": "/mnt/general/wanghy/RAGEN",
+  "host": "pt-8d304999aaac4ce1bdbc8c16dc65a596-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": "60129542144000",
+      "used": "3272704"
+    }
+  },
+  "memory": {
+    "total": "2159611842560"
+  },
+  "gpu_nvidia": [
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-089f171c-391c-dbe6-9732-e9dcab584b2a"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-dd51e744-372c-c614-a72c-669a2e06a129"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-b90b5f70-0fa3-34a8-3493-47d296746407"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-c0dd667b-31c0-dafb-d08e-1ad2118cb424"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-2d1ce5d0-61a8-a6bc-0add-5cbd5c318090"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-54dd1f4c-02ad-838f-3539-9944b7e06aef"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-ac5dd66a-cc74-66d9-e1c1-07dfad209fcc"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-26a4af72-9a63-2169-5525-ca7c5848b780"
+    }
+  ],
+  "cudaVersion": "12.4",
+  "writerId": "xujgpyta9fobjr0dv9c8irk09puw6cyf"
+}

wandb/run-20260602_163908-h5c4lnf8/files/wandb-summary.json

@@ -0,0 +1 @@
+{"rollout/chosen_in_group_reward_mean":-1.5,"timing_s/values":1.2375335600227118,"global_seqlen/min":47115,"response_length/clip_ratio":0.0078125,"val-env/SimpleSudoku/steps_remaining":0.2350260416666666,"global_seqlen/max":47904,"_runtime":15051.57103574,"critic/rewards/max":-1.5,"rollout/chosen_in_group_reward_std":0,"val-aux/unknown/reward/best@16/mean":-1.5,"critic/score/mean":-1.5,"val-aux/unknown/reward/worst@32/std":0,"val-aux/unknown/reward/best@128/mean":-1.5,"train/SimpleSudoku/episodic_return":0,"perf/throughput":612.8385968510593,"val-aux/unknown/reward/worst@256/mean":-1.5,"val-env/SimpleSudoku/success":0,"val-env/SimpleSudoku/non-zero/cells_filled":0.7333333333333334,"val-env/SimpleSudoku/non-zero/pass@16":1,"train/SimpleSudoku/pass@16":0,"train/SimpleSudoku/valid_numbers":0,"train/SimpleSudoku/steps_remaining":0.14843749999999994,"train/SimpleSudoku/non-zero/success":1,"global_seqlen/minmax_diff":789,"global_seqlen/balanced_min":47475,"perf/cpu_memory_used_gb":145.84748458862305,"val-aux/unknown/reward/best@8/mean":-1.5,"critic/vf_loss":1.804428694640592e-05,"train/SimpleSudoku/success":0,"response_length_non_aborted/clip_ratio":0.0078125,"global_seqlen/mean":47479.5,"timing_s/gen":16.51886278297752,"critic/score/max":-1.5,"val-aux/unknown/reward/best@32/std":0,"train/charts/avg_episode_return":0,"val-aux/unknown/reward/best@64/std":0,"val-aux/unknown/reward/std@512":0,"train/SimpleSudoku/error":0,"actor/pg_clipfrac":0.1909701218828559,"train/SimpleSudoku/action_is_effective":0.0078125,"val-aux/unknown/reward/best@256/mean":-1.5,"train/SimpleSudoku/non-zero/cells_remaining":0.33333333333333326,"val-aux/unknown/reward/worst@256/std":0,"train/SimpleSudoku/correct_placement":0.007812499999999999,"rollout/in_group_max":-1.5,"train/SimpleSudoku/cells_filled":0.08593749999999997,"critic/advantages/min":-22.47217559814453,"perf/total_num_tokens":379836,"timing_s/testing":44.64179565664381,"rollout/in_group_std":0,"critic/rewards/min":-1.5,"val-env/SimpleSudoku/non-zero/steps_remaining":1.2666666666666664,"val-env/SimpleSudoku/non-zero/cells_remaining":0.33333333333333326,"timing_per_token_ms/update_critic":0.014127838562066414,"val-env/SimpleSudoku/correct_placement":0.01028645833333333,"val-env/SimpleSudoku/cells_remaining":0.06184895833333332,"val-env/response_length":261.642578125,"response_length/mean":2967.4609375,"train/SimpleSudoku/non-zero/action_is_effective":0.06666666666666667,"train/SimpleSudoku/non-zero/correct_placement":0.06666666666666667,"val-env/SimpleSudoku/raw_reward":0,"val-aux/unknown/reward/best@4/mean":-1.5,"rollout/ref_log_prob":-2.0205864906311035,"prompt_length/clip_ratio":0.0078125,"val-aux/unknown/reward/best@8/std":0,"response_length_non_aborted/mean":2967.4609375,"response_length_non_aborted/min":2909,"val-env/charts/avg_episode_return":0,"val-aux/unknown/reward/best@32/mean":-1.5,"val-aux/unknown/reward/worst@64/mean":-1.5,"val-env/SimpleSudoku/action_is_valid":0.012369791666666668,"val/generations":{"sha256":"dd443c58fa2c693fedfbf789ef478f1ee25a49c0f970b7bc47ad234c6020194d","ncols":61,"log_mode":"IMMUTABLE","path":"media/table/val/generations_199_dd443c58fa2c693fedfb.table.json","artifact_path":"wandb-client-artifact://61fu3yfy3g4rm11un0fxwpk552zc734xbs2q1wp769zalezifcxa0owsv9mqo28oxbiprzway8rjselmnj2qhonkyltlb7zk37a76ngwp6h1ktfjshvuknsjtkiwymut/val/generations.table.json","size":5240215,"_latest_artifact_path":"wandb-client-artifact://8rposlbagcy12m9e3jac5z79e1xe1sa1064b55ijja2x0qhfpp3xqv1lizcleylgte58krt90gd61dgwhurookkml4jmdm4a7pg5ykt1snj47wp9upcsfujzqjdpcrb9:latest/val/generations.table.json","nrows":21,"_type":"table-file"},"val-aux/unknown/reward/best@2/std":0,"val-aux/unknown/reward/worst@16/std":0,"val-aux/unknown/reward/worst@512/std":0,"rollout/chosen_in_group_reward_max":-1.5,"perf/max_memory_allocated_gb":85.0548768043518,"timing_s/adv":0.1450896319001913,"timing_per_token_ms/update_actor":0.016082790392032507,"critic/returns/max":-1.5,"val-aux/unknown/reward/worst@64/std":0,"timing_per_token_ms/gen":0.04348957516547322,"val-env/SimpleSudoku/non-zero/num_actions":1,"val-aux/unknown/reward/best@256/std":0,"val-env/SimpleSudoku/episodic_return":0,"val-env/SimpleSudoku/non-zero/correct_placement":0.06666666666666664,"timing_per_token_ms/ref":0.004577696253015235,"val-aux/unknown/reward/worst@128/mean":-1.5,"val-env/SimpleSudoku/error":0,"critic/rewards/mean":-1.5,"critic/returns/min":-1.5,"train/SimpleSudoku/non-zero/num_actions":1,"response_length_non_aborted/max":3143,"val-aux/unknown/reward/worst@16/mean":-1.5,"perf/time_per_step":77.47472212743014,"timing_per_token_ms/values":0.003258073379097062,"critic/advantages/mean":5.963733951119821e-09,"prompt_length/max":1,"val-env/SimpleSudoku/action_is_effective":0.012369791666666668,"val-aux/unknown/reward/best@2/mean":-1.5,"train/SimpleSudoku/cells_remaining":0.03906249999999999,"train/SimpleSudoku/non-zero/cells_filled":0.7333333333333331,"critic/grad_norm":0.13168655754998326,"timing_s/step":77.47472212743014,"critic/lr":1e-05,"val-core/unknown/reward/best@512/std":0,"critic/values/min":-1.6484375,"val-env/SimpleSudoku/non-zero/success":1,"rollout/in_group_mean":-1.5,"_step":200,"critic/returns/mean":-1.5,"critic/vpred_mean":-1.4995767399668694,"val-aux/unknown/reward/best@64/mean":-1.5,"val-aux/unknown/reward/worst@32/mean":-1.5,"train/SimpleSudoku/non-zero/steps_remaining":1.2666666666666662,"_timestamp":1.7804046017678175e+09,"response/aborted_ratio":0,"perf/mfu/critic":0.20693354739183392,"val-aux/unknown/reward/worst@512/mean":-1.5,"response_length/max":3143,"response_length/min":2909,"critic/score/min":-1.5,"prompt_length/min":0,"rollout/chosen_in_group_std":0,"timing_s/total":14922.658925771713,"train/SimpleSudoku/action_is_valid":0.0078125,"val-aux/unknown/reward/best@4/std":0,"val-env/SimpleSudoku/valid_numbers":0,"timing_s/update_actor":6.108822771348059,"actor/lr":1e-06,"train/SimpleSudoku/num_actions":0,"val-core/unknown/reward/best@512/mean":-1.5,"val-aux/unknown/reward/worst@2/std":0,"rollout/in_group_reward_mean":-1.5,"val-aux/unknown/reward/best@128/std":0,"train/response_length":284.84375,"val-env/SimpleSudoku/pass@16":0,"val-aux/unknown/reward/worst@4/std":0,"timing_per_token_ms/adv":0.00038197967517610574,"val-aux/unknown/reward/worst@128/std":0,"critic/vf_clipfrac":0,"val-aux/unknown/reward/worst@8/mean":-1.5,"timing_s/update_critic":5.3662616880610585,"critic/advantages/max":16.816442489624023,"timing_s/old_log_prob":1.7121353344991803,"actor/entropy":0.059398408979177475,"actor/ppo_kl":0.25673066452145576,"val-aux/unknown/reward/best@16/std":0,"perf/max_memory_reserved_gb":95.701171875,"timing_s/ref":1.7387738339602947,"val-core/unknown/reward/mean@512":-1.5,"val-env/SimpleSudoku/non-zero/action_is_valid":0.06666666666666664,"critic/vf_explained_var":-6.65411901473999,"train/SimpleSudoku/raw_reward":0,"val-env/SimpleSudoku/num_actions":0,"rollout/in_group_reward_max":-1.5,"val-env/SimpleSudoku/cells_filled":0.13606770833333334,"val-aux/unknown/reward/worst@2/mean":-1.5,"_wandb":{"runtime":15051},"val-aux/unknown/reward/worst@8/std":0,"rollout/in_group_reward_std":0,"critic/values/mean":-1.5013045072555542,"actor/pg_loss":0.03950008543324657,"rollout/chosen_in_group_mean":-1.5,"rollout/chosen_in_group_max":-1.5,"train/SimpleSudoku/non-zero/action_is_valid":0.06666666666666667,"global_seqlen/balanced_max":47507,"perf/mfu/actor":0.18168074867067482,"val-env/SimpleSudoku/non-zero/action_is_effective":0.06666666666666664,"actor/pg_clipfrac_lower":0.018831426088581793,"actor/grad_norm":31.330472588539124,"val-aux/unknown/reward/worst@4/mean":-1.5,"prompt_length/mean":0.0078125,"critic/values/max":-1.3046875,"train/SimpleSudoku/non-zero/pass@16":1}

wandb/run-20260602_163908-h5c4lnf8/run-h5c4lnf8.wandb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34f7d0a9597f8faa8c4608f71242603dca084d186fbe07b985060ea460fb8b72
+size 6617712

wandb/run-20260602_211333-zvukmwu2/files/wandb-metadata.json

@@ -0,0 +1,107 @@
+{
+  "os": "Linux-5.14.0-284.25.1.el9_2.x86_64-x86_64-with-glibc2.35",
+  "python": "CPython 3.10.19",
+  "startedAt": "2026-06-02T13:13:33.724901Z",
+  "args": [
+    "--node-ip-address=10.119.96.124",
+    "--node-manager-port=35733",
+    "--object-store-name=/tmp/ray/session_2026-06-02_21-11-54_431321_63/sockets/plasma_store",
+    "--raylet-name=/tmp/ray/session_2026-06-02_21-11-54_431321_63/sockets/raylet",
+    "--redis-address=None",
+    "--metrics-agent-port=62363",
+    "--logging-rotate-bytes=536870912",
+    "--logging-rotate-backup-count=5",
+    "--runtime-env-agent-port=54255",
+    "--gcs-address=10.119.96.124:51608",
+    "--session-name=session_2026-06-02_21-11-54_431321_63",
+    "--temp-dir=/tmp/ray",
+    "--webui=127.0.0.1:8265",
+    "--cluster-id=c6183f59462744eca1a6543543b0e4c99bbde7f8ade67682111b7ab9",
+    "--startup-token=112",
+    "--worker-launch-time-ms=1780405917770",
+    "--node-id=11ba2a93c7bcc50c0f55b4204da5cff04050cbc6b6a9c7be39a5550f",
+    "--runtime-env-hash=-839022692"
+  ],
+  "program": "/root/local/miniconda3/envs/ragen/lib/python3.10/site-packages/ray/_private/workers/default_worker.py",
+  "git": {
+    "remote": "https://github.com/Harry-mic/SCOUT",
+    "commit": "b365f5022f55c02c8a7077c3fcd7d0af6abdc5f0"
+  },
+  "email": "haoyu-wa22@mails.tsinghua.edu.cn",
+  "root": "/mnt/general/wanghy/RAGEN",
+  "host": "pt-c065f0fd87d04b4a91e5f0c014d981ec-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": "60129542144000",
+      "used": "3268608"
+    }
+  },
+  "memory": {
+    "total": "2159579938816"
+  },
+  "gpu_nvidia": [
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-e7eef8e0-be1e-0495-4dfa-3249b800ed7e"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-0d364614-ae2e-9a5e-89af-fc4d4ebb1587"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-96317307-9273-75d9-69f8-e96dcd2de164"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-ded0782b-667b-19b0-8394-a812a841980e"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-f3eb01ef-538d-33ef-b591-50d93e046cfe"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-961d5026-538d-c41b-d5c3-16146c87ac32"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-deaa8300-97f0-d013-b595-43bd8f825d0e"
+    },
+    {
+      "name": "NVIDIA H100 80GB HBM3",
+      "memoryTotal": "85520809984",
+      "cudaCores": 16896,
+      "architecture": "Hopper",
+      "uuid": "GPU-b2bd9595-a04d-610c-e532-bf97c99afd61"
+    }
+  ],
+  "cudaVersion": "12.4",
+  "writerId": "64uxfxiycfatedh1bs7sc8pav6cd1wdm"
+}

wandb/run-20260602_211333-zvukmwu2/run-zvukmwu2.wandb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64b748a1e6c6b30bb4bde2ced021b2d0a3cb96454a0e05054d7ba2f38a6a1ffe
+size 6774443

wandb/run-20260603_105223-opxt7tw0/run-opxt7tw0.wandb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a1c89f017d27223923c3cec08481a92b3fab45474468464701a31183eed3c5c
+size 7026915