Add files using upload-large-folder tool

config/_10_rubikscube.yaml

@@ -0,0 +1,25 @@
+defaults:
+  - base
+
+trainer:
+  experiment_name: rubikscube
+
+actor_rollout_ref:
+  rollout:
+    response_length: 500
+    val_kwargs:
+      do_sample: True
+      temperature: 0.5 
+ 
+agent_proxy:
+  max_turn: 10
+  max_actions_per_turn: 4
+  max_context_window: 5
+
+es_manager:
+  train:
+    env_configs:
+      tags: ["rubikscube"]
+  val:
+    env_configs:
+      tags: ["rubikscube"]

config/_1_bandit.yaml

@@ -0,0 +1,30 @@
+defaults:
+  - base
+
+hydra:
+  searchpath:
+    - pkg://verl.trainer.config
+
+actor_rollout_ref:
+  rollout:
+    response_length: 500
+    val_kwargs:
+      do_sample: True
+      temperature: 0.5 # enabling randomness in evaluation 
+ 
+trainer:
+  experiment_name: bandit-base
+
+agent_proxy:
+  max_turn: 1
+  max_actions_per_turn: 1 # how many actions can be output at most in a single turn
+
+es_manager:
+  train:
+    env_configs:
+      tags: ["Bandit"] # BanditGeneralizationNoThink
+  val:
+    env_groups: 512
+    env_configs:
+      tags: ["Bandit", "BanditTest"]
+      n_groups: [256, 256]

config/_3_frozen_lake.yaml

@@ -0,0 +1,24 @@
+defaults:
+  - base
+
+hydra:
+  searchpath:
+    - pkg://verl.trainer.config
+
+trainer:
+  experiment_name: frozenlake-main
+
+
+es_manager:
+  train:
+    env_configs:
+      tags: ["CoordFrozenLake"]
+  val:
+    env_configs:
+      tags: ["CoordFrozenLake"]
+
+custom_envs:
+  CoordFrozenLake:
+    env_config:
+      success_rate: 1 # Probability of moving in the intended direction
+      observation_format: "grid_coord"

config/_5_metamathqa.yaml

@@ -0,0 +1,14 @@
+defaults:
+  - base
+
+hydra:
+  searchpath:
+    - pkg://verl.trainer.config
+    
+es_manager:
+  train:
+    env_configs:
+      tags: ["MetamathQA"]
+  val:
+    env_configs:
+      tags: ["MetamathQA"]

config/_9_2048.yaml

@@ -0,0 +1,23 @@
+defaults:
+  - base
+
+trainer:
+  experiment_name: 2048
+
+agent_proxy:
+  max_turn: 800
+  max_actions_per_turn: 1
+  max_context_window: 5
+
+actor_rollout_ref:
+  rollout:
+    max_model_len: 8192
+    response_length: 256
+
+es_manager:
+  train:
+    env_configs:
+      tags: ["game_2048"]
+  val:
+    env_configs:
+      tags: ["game_2048"]

config/_9_search.yaml

@@ -0,0 +1,38 @@
+defaults:
+  - base
+
+hydra:
+  searchpath:
+    - pkg://verl.trainer.config
+
+# NOTE: Before training, start the retrieval server:
+#   bash scripts/retrieval/launch_server.sh ./search_data/prebuilt_indices 8000
+
+micro_batch_size_per_gpu: 4
+ppo_mini_batch_size: 32
+model_path: Qwen/Qwen2.5-3B-Instruct
+
+trainer:
+  experiment_name: search-qa
+
+agent_proxy:
+  max_turn: 5              # allow up to 5 search rounds before final answer
+  max_actions_per_turn: 1  # one action per LLM response (search or finish)
+
+actor_rollout_ref:
+  rollout:
+    max_model_len: 5000
+    max_num_batched_tokens: 5000
+
+es_manager:
+  train:
+    env_groups: 16
+    group_size: 8
+    env_configs:
+      tags: ["SearchQA"]
+      n_groups: [16]
+  val:
+    env_groups: 256
+    env_configs:
+      tags: ["SearchQA"]
+      n_groups: [256]

config/envs.yaml

@@ -0,0 +1,426 @@
+custom_envs:
+  SimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 20 # used in environment state manager to control the actual max actions executed per trajectory
+    env_instruction: |
+      You are a careful Sokoban solver. Use these reusable abstractions when reasoning:
+      1. First compare the box position with the target position; the useful push directions are usually the directions that reduce their row/column distance.
+      2. Before pushing, move the player to the square opposite the intended push direction. A move that only repositions the player can be useful if it sets up the next push.
+      3. Never push a box into a wall, corner, or narrow dead end unless that square is the target or clearly on the only path to the target.
+      4. Prefer short plans that move the single box steadily toward the target; avoid wandering moves that do not improve player position or box position.
+      5. If the box and target are aligned in the same row or column, try to keep the box on that line and push along it.
+      6. If they are not aligned, first push to fix one coordinate, then reposition and push to fix the other coordinate.
+      7. Check that after each push, the player can still reach the next required pushing side of the box.
+      8. Output only the required XML-like format and choose valid Sokoban actions.
+
+      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>
+    max_tokens: 100 # used to curate llm prompt "max words", not used for rollout
+    parallel_friendly: false
+    max_workers: 32
+    env_config: # keys should be a subset of SokobanConfig
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 2
+      max_steps: 100
+
+  LargerSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 8
+      dim_y: 8
+      num_boxes: 2
+      max_steps: 100
+      search_depth: 10
+  
+  SokobanDifferentGridVocab:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: # keys should be a subset of SokobanConfig
+      search_depth: 30
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      grid_lookup: {0: "W", 1: ".", 2: "G", 3: "C", 4: "B", 5: "A", 6: "@"}
+      grid_vocab: {"W": "wall", ".": "empty", "G": "target", "C": "box on target", "B": "box", "A": "player", "@": "player on target"}
+
+  CoordSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 20
+    env_instruction: |
+      You are solving the Sokoban puzzle. You are the player and you need to push all boxes to targets.
+      You are provided with a symbol grid and the zero-indexed coordinates of the player, each box, and each target. 
+      Coordinates range from the top-left corner (0, 0) to the bottom-right corner (5, 5). 
+      When you are exactly 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>.
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config: # keys should be a subset of SokobanConfig
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      observation_format: "grid_coord"
+
+  VisualSimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: # keys should be a subset of SokobanConfig
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      render_mode: "rgb_array"
+
+  Alfworld:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: |
+      You are an expert agent in the ALFRED Embodied Environment.
+      Complete household tasks by navigating and interacting with objects.
+
+      You should first reason step-by-step about the current situation. This reasoning process MUST be enclosed within <think> </think> tags.
+      Once you've finished your reasoning, you should choose an admissible action for current step and present it within <answer>...</answer> tags.
+
+    max_tokens: 512
+    env_config:
+      eval_dataset: "eval_in_distribution"
+
+  AlfworldOOD:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: |
+      You are an expert agent in the ALFRED Embodied Environment.
+      Complete household tasks by navigating and interacting with objects.
+
+      You should first reason step-by-step about the current situation. This reasoning process MUST be enclosed within <think> </think> tags.
+      Once you've finished your reasoning, you should choose an admissible action for current step and present it within <answer>...</answer> tags.
+
+    max_tokens: 512
+    env_config:
+      eval_dataset: "eval_out_of_distribution"
+
+  Countdown:
+    env_type: countdown
+    max_actions_per_traj: 1
+    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>"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: null
+
+  Bandit:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ""
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: 
+      split: "train"
+
+  BanditTest:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ""
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: 
+      split: "test"
+      
+  DeepCoder:
+    env_type: deepcoder
+    max_actions_per_traj: 1
+    env_instruction: "You are solving a coding task. Provide a complete Python function solution only. Format: <answer>...</answer>"
+    max_tokens: 8000
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 1
+
+  FrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      success_rate: 0.8
+
+  CoordFrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>.
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      observation_format: "grid_coord"
+      success_rate: 0.8
+
+  MetamathQA:
+    env_type: metamathqa
+    max_actions_per_traj: 1
+    env_instruction: "You are solving Math problems. "
+    max_tokens: 100
+    env_config: null
+
+  WebShopFull:
+    env_type: webshop
+    max_actions_per_traj: 15
+    env_instruction: "You are an expert autonomous agent operating in the WebShop e‑commerce environment."
+    max_tokens: 200
+    env_config: 
+      dataset: full # choose from small or full
+
+  WebShop:
+    env_type: webshop
+    max_actions_per_traj: 9
+    # env_instruction: "You are browsing an online shop. Based on the instruction, find the product that close to the production description. You need to read the website and decide what action to take next until buying a product. Available actions depends on the page: in the search page you can search keywords, in the search result page you can click an item url or click[next >] to navigate to next page, in the product page you can click[description] or click[features] to see the details, click[blue] or click[x-large] to choose size and colors, click[buy now] when you decided to buy the product, click[back to search] to return to search page. You should only choose action from the available actions list.  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_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_instruction: >
+    #   You are browsing an online shop. Based on the instruction, find a product
+    #   that closely matches the production description. You need to iteratively take
+    #   actions(search or click) in the browser and buy the chosen product.
+    #   Example:
+    #   WebShop [SEP] Instruction: [SEP] Find me machine wash men's dress shirts with cotton spandex, classic fit, short sleeve with color: deep atlantic, and size: large tall, and price lower than 60.00 dollars [SEP] Search
+    #   Available actions: ['search[<content>]']
+    #   <think>Search for the item: men's dress shirts with cotton spandex, classic fit, short sleeve. Do not search for color, size or price, because they will be on the search result or product page</think><answer>search[men's dress shirts with cotton spandex, classic fit, short sleeve]</answer>
+    #   Instruction: [SEP] Find me machine wash men's dress shirts with cotton spandex, classic fit, short sleeve with color: deep atlantic, and size: large tall, and price lower than 60.00 dollars [SEP] Back to Search [SEP] Page 1 (Total results: 1) [SEP] Next > [SEP] B09M63B87V [SEP] YALFJV Women Long Sleeve Crew Neck Side Button T Shirts Tunic Dress Loose Asymmetric Hem Tunic Pullover to Wear with Leggings [SEP] $10.71 to $18.34
+    #   <think>The product on this page is for women. None of the products are close to the description. Click next page to see more products.</think><answer>click[next >]</answer>
+    #   Instruction: [SEP] Find me machine wash men's dress shirts with cotton spandex, classic fit, short sleeve with color: deep atlantic, and size: large tall, and price lower than 60.00 dollars [SEP] Back to Search [SEP] Page 2 (Total results: 2) [SEP] B07HRFSNL4 [SEP] Nautica Men's Solid Crew Neck Short-Sleeve Pocket T-Shirt [SEP] $16.05 to $40.98 [SEP] B07N7TDKXQ [SEP] SOCKS'NBULK Mens Cotton Crew Neck Short Sleeve T-Shirts Mix Colors Bulk [SEP] $80.79 to $172.8
+    #   Available actions: ['click[back to search]', 'click[< prev]', 'click[next >]', 'click[b07hrfsnl4]', 'click[b07n7tdkxq]']
+    #   <think>The B07HRFSNL4 products seems close to the description, and with the price range. Click it.</think><answer>click[b07hrfsnl4]</answer>
+    #   Instruction: [SEP] Find me machine wash men's dress shirts with cotton spandex, classic fit, short sleeve with color: deep atlantic, and size: large tall, and price lower than 60.00 dollars [SEP] Back to Search [SEP] < Prev [SEP] size [SEP] x-small [SEP] small [SEP] large tall [SEP] color [SEP] navy [SEP] deep atlantic [SEP] deep atlantic
+    #   Available actions: ['click[back to search]', 'click[< prev]', 'click[description]', 'click[features]', 'click[reviews]', 'click[buy now]', 'click[x-small]', 'click[small]', 'click[large tall]', 'click[navy]', 'click[deep atlantic]']
+    #   <think>I need to choose the right size. Click large tall</think><answer>click[large tall]</answer>
+    #   Instruction: [SEP] Find me machine wash men's dress shirts with cotton spandex, classic fit, short sleeve with color: deep atlantic, and size: large tall, and price lower than 60.00 dollars [SEP] Back to Search [SEP] < Prev [SEP] size [SEP] x-small [SEP] small [SEP] large tall [SEP] color [SEP] navy [SEP] deep atlantic [SEP] deep atlantic
+    #   Available actions: ['click[back to search]', 'click[< prev]', 'click[description]', 'click[features]', 'click[reviews]', 'click[buy now]', 'click[x-small]', 'click[small]', 'click[large tall]', 'click[navy]', 'click[deep atlantic]']
+    #   <think>Now I need to choose the right color. Click deep atlantic</think><answer>click[deep atlantic]</answer>
+    #   Instruction: [SEP] Find me machine wash men's dress shirts with cotton spandex, classic fit, short sleeve with color: deep atlantic, and size: large tall, and price lower than 60.00 dollars [SEP] Back to Search [SEP] < Prev [SEP] size [SEP] x-small [SEP] small [SEP] large tall [SEP] color [SEP] navy [SEP] deep atlantic [SEP] deep atlantic
+    #   Available actions: ['click[back to search]', 'click[< prev]', 'click[description]', 'click[features]', 'click[reviews]', 'click[buy now]', 'click[x-small]', 'click[small]', 'click[large tall]', 'click[navy]', 'click[deep atlantic]']
+    #   <think>Having selected the size and color, I am ready to buy. Click buy now.</think><answer>click[buy now]</answer>
+
+    # You are browsing an online shop. Based on the instruction, find the product 
+    # that best matches the production description. You need to iteratively take 
+    # actions(search or click) in the browser and buy the chosen product. Example 
+    # process: 
+    # Instruction: Find me machine wash men's t-shirts with long sleeve with color: black, and size: xx-large big tall, and price lower than 50.00 dollars
+    # WebShop [SEP] Instruction: [SEP] Find me machine wash men's t-shirts with long sleeve with color: black, and size: xx-large big tall, and price lower than 50.00 dollars [SEP] Search
+    # Available actions: ['search[<content>]']
+    # <think>First search for the big catagory: machine wash men's t-shirts with long sleeve. Do not search for color, size or price, because they will be on the search result or product page</think><answer>search[machine wash men's t-shirts with long sleeve]</answer>
+    # Instruction: [SEP] Find me machine wash men's t-shirts with long sleeve with color: black, and size: xx-large big tall, and price lower than 50.00 dollars [SEP] Back to Search [SEP] Page 1 (Total results: 50) [SEP] Next > [SEP] B09QQP3356 [SEP] HAUKLIE Men's Sports Waffle Ribbed Polo Shirts Summer Short Sleeve Cotton Muscle Quarter-Zip Henley T-Shirt Tunics Tops [SEP] $10.99 [SEP] B09Q8RD8YN [SEP] Bungo Stray Anime Dogs Anime Character, Long Sleeve, Sweatshirt, Hoodie, T shirt [SEP] $19.99 [SEP] B09QGK5XHZ [SEP] WENKOMG1 Men's Long Sleeve Undershirt with Mask Turtleneck Hooded T-Shirt Solid Color Workout Tops Zipper Side Slit Shirts Slim Fit Sweatshirt Spring/Summer Tee Shirts(Gray,) [SEP] $8.39 [SEP] B09QQJJ3KM [SEP] One Lucky Teacher St Patrick Day Shamrock Tee Teachers Custom Personalized Unisex T-Shirts Long Sleeve Hoodie Sweatshirt Gifts [SEP] $100.0 [SEP] B09S3BN15C [SEP] Mens Linen Shirt,Men's Striped Shirts Casual Short Sleeve Button Down Shirts Regular Fit Hawaiian Shirts Beach Tees Tops [SEP] $3.78 to $11.38 [SEP] B09ND9DP7J [SEP] InterestPrint Gold Horse Pattern Men's 2-Piece Sleepwear Set, Long Sleeve Shirt with Pants Loungewear [SEP] $43.59 [SEP] B09T756KQ5 [SEP] WENKOMG1 Men's Crewneck Goth Tee Shirts Skull Print Tops Spring/Summer Long Sleeve Sports T-Shirt Baggy Y2K Soft Streetwear [SEP] $4.09 to $8.09 [SEP] B09Q67H373 [SEP] JSPOYOU 2022 Newly T-Shirt for Mens Funny 3D Graphics Pattern Crewneck Short Sleeve Tees Big and Tall Summer Casual Comfy Top [SEP] $1.99 to $8.99 [SEP] B09R9YCM6R [SEP] XXBR Summer T-shirts for Mens, Soldier Short Sleeve 3D Street Vintage Printed Shirt Slim Fit Muscle Casual Tee Tops [SEP] $8.98 to $11.99 [SEP] B09KLQLLT2 [SEP] Long Sleeve Superhero T Shirt Tank Top Mens Compression Shirt Men Workout Fitness Gym Shirt [SEP] $19.99
+    # Available actions: ['click[back to search]', 'click[next >]', 'click[b09qqp3356]', 'click[b09q8rd8yn]', 'click[b09qgk5xhz]', 'click[b09qqjj3km]', 'click[b09s3bn15c]', 'click[b09nd9dp7j]', 'click[b09t756kq5]', 'click[b09q67h373]', 'click[b09r9ycm6r]', 'click[b09klqllt2]']
+    # <think>Product b09klqllt2 is a Men's Long Sleeve Superhero T Shirt priced 19.99$, which satisfies my need</think><answer>click[b09klqllt2]</answer>
+    # Instruction: [SEP] Find me machine wash men's t-shirts with long sleeve with color: black, and size: xx-large big tall, and price lower than 50.00 dollars [SEP] Back to Search [SEP] < Prev [SEP] color [SEP] black | blue [SEP] blue [SEP] blue | red [SEP] bronze [SEP] brown [SEP] gold [SEP] green [SEP] red [SEP] red | blue [SEP] yellow [SEP] grey | red [SEP] size [SEP] small [SEP] medium [SEP] large [SEP] x-large [SEP] xx-large [SEP] Long Sleeve Superhero T Shirt Tank Top Mens Compression Shirt Men Workout Fitness Gym Shirt [SEP] Price: $19.99 [SEP] Rating: N.A. [SEP] Description [SEP] Features [SEP] Reviews [SEP] Buy Now
+    # Available actions: ['click[back to search]', 'click[< prev]', 'click[description]', 'click[features]', 'click[reviews]', 'click[buy now]', 'click[black | blue]', 'click[blue]', 'click[blue | red]', 'click[bronze]', 'click[brown]', 'click[gold]', 'click[green]', 'click[red]', 'click[red | blue]', 'click[yellow]', 'click[grey | red]', 'click[small]', 'click[medium]', 'click[large]', 'click[x-large]', 'click[xx-large]']
+    # <think>Produce description and price looks good, now select the right color</think><answer>click[black | blue]</answer>
+    # Instruction: [SEP] Find me machine wash men's t-shirts with long sleeve with color: black, and size: xx-large big tall, and price lower than 50.00 dollars [SEP] Back to Search [SEP] < Prev [SEP] color [SEP] black | blue [SEP] blue [SEP] blue | red [SEP] bronze [SEP] brown [SEP] gold [SEP] green [SEP] red [SEP] red | blue [SEP] yellow [SEP] grey | red [SEP] size [SEP] small [SEP] medium [SEP] large [SEP] x-large [SEP] xx-large [SEP] Long Sleeve Superhero T Shirt Tank Top Mens Compression Shirt Men Workout Fitness Gym Shirt [SEP] Price: $19.99 [SEP] Rating: N.A. [SEP] Description [SEP] Features [SEP] Reviews [SEP] Buy Now
+    # Available actions: ['click[back to search]', 'click[< prev]', 'click[description]', 'click[features]', 'click[reviews]', 'click[buy now]', 'click[black | blue]', 'click[blue]', 'click[blue | red]', 'click[bronze]', 'click[brown]', 'click[gold]', 'click[green]', 'click[red]', 'click[red | blue]', 'click[yellow]', 'click[grey | red]', 'click[small]', 'click[medium]', 'click[large]', 'click[x-large]', 'click[xx-large]']
+    # <think>I already selected color, now click size xx-large</think><answer>click[xx-large]</answer>
+    # Instruction: [SEP] Find me machine wash men's t-shirts with long sleeve with color: black, and size: xx-large big tall, and price lower than 50.00 dollars [SEP] Back to Search [SEP] < Prev [SEP] color [SEP] black | blue [SEP] blue [SEP] blue | red [SEP] bronze [SEP] brown [SEP] gold [SEP] green [SEP] red [SEP] red | blue [SEP] yellow [SEP] grey | red [SEP] size [SEP] small [SEP] medium [SEP] large [SEP] x-large [SEP] xx-large [SEP] Long Sleeve Superhero T Shirt Tank Top Mens Compression Shirt Men Workout Fitness Gym Shirt [SEP] Price: $19.99 [SEP] Rating: N.A. [SEP] Description [SEP] Features [SEP] Reviews [SEP] Buy Now
+    # Available actions: ['click[back to search]', 'click[< prev]', 'click[description]', 'click[features]', 'click[reviews]', 'click[buy now]', 'click[black | blue]', 'click[blue]', 'click[blue | red]', 'click[bronze]', 'click[brown]', 'click[gold]', 'click[green]', 'click[red]', 'click[red | blue]', 'click[yellow]', 'click[grey | red]', 'click[small]', 'click[medium]', 'click[large]', 'click[x-large]', 'click[xx-large]']
+    # <think>I already selected color and size, now click buy now</think><answer>click[buy now]</answer>
+    max_tokens: 200
+    # env_config: null
+    env_config: 
+      dataset: small # choose from small or full
+    #   data_path: /RAGEN-Dev/external/webshop-minimal/webshop_minimal
+    #   file_path: /RAGEN-Dev/external/webshop-minimal/webshop_minimal/data/items_shuffle.json
+
+  Lean:
+    env_type: lean
+    max_actions_per_traj: 30
+    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>."
+    max_tokens: 512
+    parallel_friendly: true
+    max_workers: 32
+    env_config: null # Please refer to ragen/env/lean/config.py for a full list of parameters.
+
+  SimpleSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 20
+    env_instruction: |
+      You are a careful 4x4 Sudoku solver. Use these reusable abstractions when reasoning:
+      1. In <think>, explain the constraint logic behind the move, not just the final placement. Mention which row, column, or 2x2 box makes the move safe or forced.
+      2. Treat each move as a constraint-preserving placement: place a number only if it does not already appear in the same row, column, or 2x2 box.
+      3. First look for highly forced cells. If an empty cell has only one legal candidate after checking its row, column, and box, fill it immediately and explain why other numbers are excluded.
+      4. If no cell is obviously forced, scan each row, column, and 2x2 box for missing numbers. If a missing number can go in only one empty position within that unit, place it there and state that unit-level reason.
+      5. Prefer moves that reduce uncertainty and create new forced cells for the next turn. A good move should make the remaining puzzle more constrained, not more ambiguous.
+      6. Solve incrementally: choose exactly one placement, explain it briefly in <think>, then output that one move in <answer>.
+      7. Never modify bracketed initial cells or already-filled cells. Only place numbers into dots.
+      8. Avoid exploratory guesses when a forced move exists. In this environment, reliable progress usually comes from constraint propagation rather than trial-and-error.
+      9. If a previous move was invalid or the board did not change, do not repeat the same placement. Recompute legal candidates and explain the corrected constraint-consistent choice.
+      10. Use row, column, and box agreement as confidence: the strongest placements are those supported by multiple constraints at once.
+      11. Keep <think> concise but meaningful: identify the target cell, list or compare its legal candidates, and give the decisive constraint.
+      12. Output only the required XML-like format and choose valid Sudoku placements.
+
+      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: <answer>place 1 at row 2 col 3</answer>
+      Always output: <think> [brief constraint-based reasoning] </think> <answer> [one placement] </answer>
+      The environment will provide feedback on valid/invalid moves and show conflicts if any occur.
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 4
+      difficulty: "easy"
+      render_format: "with_feedback"
+      show_conflicts: false
+      show_valid_numbers: false
+      max_steps: 20
+
+  MediumSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 30
+    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.
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: "medium"
+      render_format: "with_feedback"
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+
+  # --- Search QA (HotpotQA) ---
+  # Requires: retrieval server running (see scripts/retrieval/launch_server.sh)
+  SearchQA:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: |
+      You are a search agent answering questions by searching for information.
+      Use search[your query] to find relevant documents, and finish[your answer] to submit your final answer.
+
+      You should first reason step-by-step about the current situation. This reasoning process MUST be enclosed within <think> </think> tags.
+      Then provide your action within <answer>...</answer> tags.
+
+      Examples:
+        <think>I need to find information about Ben Platt's father.</think><answer>search[Ben Platt father parent]</answer>
+        <think>Based on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry Platt]</answer>
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+
+  SearchQAMock:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: |
+      You are a search agent answering questions by searching for information.
+      Use search[your query] to find relevant documents, and finish[your answer] to submit your final answer.
+
+      You should first reason step-by-step about the current situation. This reasoning process MUST be enclosed within <think> </think> tags.
+      Then provide your action within <answer>...</answer> tags.
+
+      Examples:
+        <think>I need to find information about Ben Platt's father.</think><answer>search[Ben Platt father parent]</answer>
+        <think>Based on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry Platt]</answer>
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+      mock_mode: true
+  game_2048:
+    env_type: game_2048
+    max_actions_per_traj: 700
+    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>
+    max_tokens: 8192
+    env_config: null
+
+  rubikscube:
+    env_type: rubikscube
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 96
+    env_config:
+      scramble_depth: 1
+      max_steps: 7
+      render_mode: "text"
+
+
+      # You are a careful 4x4 Sudoku solver. Use these reusable abstractions when reasoning:
+      # 1. In <think>, explain the constraint logic behind the move, not just the final placement. Mention which row, column, or 2x2 box makes the move safe or forced.
+      # 2. Treat each move as a constraint-preserving placement: place a number only if it does not already appear in the same row, column, or 2x2 box.
+      # 3. First look for highly forced cells. If an empty cell has only one legal candidate after checking its row, column, and box, fill it immediately and explain why other numbers are excluded.
+      # 4. If no cell is obviously forced, scan each row, column, and 2x2 box for missing numbers. If a missing number can go in only one empty position within that unit, place it there and state that unit-level reason.
+      # 5. Prefer moves that reduce uncertainty and create new forced cells for the next turn. A good move should make the remaining puzzle more constrained, not more ambiguous.
+      # 6. Solve incrementally: choose exactly one placement, explain it briefly in <think>, then output that one move in <answer>.
+      # 7. Never modify bracketed initial cells or already-filled cells. Only place numbers into dots.
+      # 8. Avoid exploratory guesses when a forced move exists. In this environment, reliable progress usually comes from constraint propagation rather than trial-and-error.
+      # 9. If a previous move was invalid or the board did not change, do not repeat the same placement. Recompute legal candidates and explain the corrected constraint-consistent choice.
+      # 10. Use row, column, and box agreement as confidence: the strongest placements are those supported by multiple constraints at once.
+      # 11. Keep <think> concise but meaningful: identify the target cell, list or compare its legal candidates, and give the decisive constraint.
+      # 12. Output only the required XML-like format and choose valid Sudoku placements.
+
+      # 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: <answer>place 1 at row 2 col 3</answer>
+      # Always output: <think> [brief constraint-based reasoning] </think> <answer> [one placement] </answer>
+      # The environment will provide feedback on valid/invalid moves and show conflicts if any occur.
+
+
+
+
+      # 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.

config/eval.yaml

@@ -0,0 +1,96 @@
+defaults:
+  - envs
+  - base
+
+hydra:
+  searchpath:
+    - pkg://verl.trainer.config
+
+system:
+  CUDA_VISIBLE_DEVICES: "0"
+
+seed:
+  train: 10000
+  val: 123
+
+model_path: Qwen/Qwen2.5-3B-Instruct
+enable_response_mask: True
+
+lora:
+  rank: 0
+  alpha: 64
+  target_modules: all-linear
+
+actor_rollout_ref:
+  model:
+    path: ${model_path}
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+  rollout:
+    name: vllm
+    log_prob_micro_batch_size_per_gpu: 64
+    tensor_model_parallel_size: 1
+    dtype: bfloat16
+    max_model_len: 3600
+    prompt_length: 1
+    response_length: 400
+    gpu_memory_utilization: 0.9
+    max_num_batched_tokens: 8192
+    enforce_eager: True
+    free_cache_engine: True
+    enable_chunked_prefill: False
+    disable_log_stats: False
+    val_kwargs:
+      do_sample: True
+      temperature: 0.5
+      top_p: 1.0
+      top_k: -1
+      logprobs: 20 # return top20 logprobs
+
+agent_proxy:
+  context_window_mode: "full"  # "full" | "limited_multi_turn" | "single_turn"
+  max_context_window: -1
+  max_turn: 5
+  action_sep: "||"
+  max_actions_per_turn: 2
+  use_turn_scores: False
+  enable_think: True
+  reward_normalization:
+    grouping: "state"
+    method: "identity"
+
+es_manager:
+  format_penalty: -0.1
+  train:
+    env_groups: 8
+    group_size: 16
+    env_configs:
+      tags: ["CoordSokoban"]
+      n_groups: [8]
+  val:
+    env_groups: 32
+    group_size: 16
+    env_configs:
+      tags: ["CoordSokoban"]
+      n_groups: [32]
+
+ctx_manager:
+  generation:
+    gen_config:
+      response_length: ${actor_rollout_ref.rollout.response_length}
+      temperature: ${actor_rollout_ref.rollout.temperature}
+      top_p: ${actor_rollout_ref.rollout.top_p}
+      top_k: ${actor_rollout_ref.rollout.top_k}
+      kwargs: null
+
+output:
+  dir: results/eval
+  filename: val_rollouts.pkl
+  format: pkl  # pkl | jsonl
+  append_timestamp: true
+  save_jsonl_backup: false  # Save JSONL backup when format=pkl
+  save_pkl_backup: false    # Save PKL backup when format=jsonl
+  keep_batch_keys: null
+  keep_non_tensor_keys: null
+  keep_meta_info: true

config/eval_webshop.yaml

@@ -0,0 +1,35 @@
+defaults:
+  - base  # inherit the base training/eval config
+
+hydra:
+  searchpath:
+    - pkg://verl.trainer.config
+
+system:
+  CUDA_VISIBLE_DEVICES: "0,1,2,3"        # change to your GPU layout
+
+trainer:
+  # Evaluation-only run (no training)
+  val_only: true
+  val_before_train: false
+  total_training_steps: 0
+  validation_steps: 1                     # e.g., each step may launch a fixed number of rollouts
+  test_freq: 0
+  logger: [console]                       # turn off W&B
+  save_freq: -1                           # no checkpoints
+  experiment_name: webshop_10turns_eval   # ASCII only; keep concise
+
+  # Resume a pre-trained checkpoint to evaluate
+  resume_mode: resume_path
+  resume_from_path: /ABSOLUTE/PATH/TO/checkpoints/webshop_12turns_200steps_grpo/global_step_200  # <- set this
+
+use_critic: false                         # no critic during eval
+
+# Rollout / decoding behavior
+actor_rollout_ref:
+  rollout:
+    do_sample: false                      # deterministic (greedy). For a stochastic pass, flip to true and set temperature/top_p elsewhere
+
+# Evaluation horizon
+agent_proxy:
+  max_turn: 10                            # align with experiment_name; change to 12/18 if you want longer horizons

config/evaluate_api_llm.yaml

@@ -0,0 +1,59 @@
+defaults:
+  - base # this is a symbolic link to the verl/verl/trainer/config/ppo_trainer.yaml file
+
+hydra:
+  searchpath:
+    - pkg://verl.trainer.config
+
+model_config:
+  model_name: gpt-4o # should be registered in model_info
+  max_concurrency: 16
+
+model_info:
+  Qwen2.5-7B-Instruct:
+    provider_name: together
+    model_name: Qwen/Qwen2.5-7B-Instruct-Turbo
+    generation_kwargs:
+      temperature: 0
+      max_tokens: 512
+  Qwen2.5-72B-Instruct:
+    provider_name: together
+    model_name: Qwen/Qwen2.5-72B-Instruct-Turbo
+    generation_kwargs:
+      temperature: 0
+      max_tokens: 512
+  claude-3.7:
+    provider_name: anthropic
+    model_name: claude-3-7-sonnet-20250219
+    generation_kwargs:
+      temperature: 0
+      max_tokens: 512 # max_completion_tokens if o1-mini
+  gpt-4o:
+    provider_name: openai
+    model_name: gpt-4o
+    generation_kwargs:
+      temperature: 0
+      max_tokens: 512 # max_completion_tokens if o1-mini
+  deepseek-r1:
+    provider_name: deepseek
+    model_name: deepseek-reasoner
+    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
+
+
+
+es_manager:
+  val:
+    env_groups: 256
+    group_size: 1 # should be set to 1 because val temperature is set to 0 and same prompt leads to same output
+    env_configs:
+      tags: ["CoordSokoban"]
+      n_groups: [256] # If not set, all env names divide nums equally. Under the same group, the env config and env seed (prompt) are equal in each generation
+

docs/eval.md

@@ -0,0 +1,265 @@
+# RAGEN Evaluation Guide
+
+This guide explains how to evaluate trained RAGEN models and configure output formats.
+
+## Quick Start
+
+Evaluate a model using the default configuration:
+
+```bash
+python -m ragen.llm_agent.agent_proxy --config-name eval
+```
+
+Or use a specific config:
+
+```bash
+python -m ragen.llm_agent.agent_proxy --config-name _2_sokoban
+```
+
+## Configuration File
+
+Evaluation settings are configured in `config/eval.yaml`. Key sections:
+
+### Model Configuration
+
+```yaml
+model_path: Qwen/Qwen2.5-3B-Instruct
+
+lora:
+  rank: 0        # Set to 0 to disable LoRA; set to > 0 for LoRA-finetuned models
+  alpha: 64
+  target_modules: all-linear
+```
+
+### Rollout Settings
+
+```yaml
+actor_rollout_ref:
+  rollout:
+    max_model_len: 3600        # Max context length
+    response_length: 400       # Max tokens per response
+    val_kwargs:
+      do_sample: True          # Enable sampling
+      temperature: 0.5         # Sampling temperature
+      top_p: 1.0              # Nucleus sampling
+      top_k: -1               # Top-k sampling (-1 = disabled)
+```
+
+### Agent Proxy Settings
+
+```yaml
+agent_proxy:
+  context_window_mode: "full"  # "full" | "limited_multi_turn" | "single_turn"
+  max_context_window: -1       # Number of previous turns to retain (-1 = unlimited)
+  max_turn: 5                  # Maximum interaction turns
+  enable_think: True           # Enable <think>...</think> reasoning
+```
+
+**Context Window Modes:**
+- `full`: Keep all previous turns in context
+- `limited_multi_turn`: Keep only the last `max_context_window` turns
+- `single_turn`: Only current state, no history
+
+### Environment Settings
+
+```yaml
+es_manager:
+  val:
+    env_groups: 32           # Number of environment groups
+    group_size: 16           # Environments per group (total = groups × size)
+    env_configs:
+      tags: ["CoordSokoban"]  # Environment type(s)
+      n_groups: [32]          # Groups per environment type
+```
+
+**Available environment tags** are defined in `config/envs.yaml` under `custom_envs`.
+
+### Output Configuration
+
+```yaml
+output:
+  dir: results/eval              # Output directory
+  filename: val_rollouts.pkl     # Output filename
+  format: pkl                    # pkl | jsonl
+  append_timestamp: true         # Add timestamp to filename
+  save_jsonl_backup: false       # Save JSONL backup when format=pkl
+  save_pkl_backup: false         # Save PKL backup when format=jsonl
+  keep_batch_keys: null          # Filter batch keys (null = keep all)
+  keep_non_tensor_keys: null     # Filter non-tensor keys (null = keep all)
+  keep_meta_info: true           # Include metadata
+```
+
+## Output Formats
+
+### PKL Format (Default)
+
+Binary format containing the full `DataProto` object with tensors, metadata, and trajectories.
+
+```yaml
+output:
+  format: pkl
+  filename: val_rollouts.pkl
+```
+
+**Visualization:**
+```bash
+python scripts/visualize.py --rollout_path results/eval/
+```
+
+### JSONL Format (OpenAI-Compatible)
+
+Human-readable JSONL where each line is a trajectory in OpenAI message format.
+
+```yaml
+output:
+  format: jsonl
+  filename: trajectories.jsonl
+```
+
+**JSONL structure:**
+```json
+{
+  "custom_id": "traj_0",
+  "messages": [
+    {"role": "user", "content": "Initial state..."},
+    {"role": "assistant", "content": "<think>...</think><ans>action</ans>"},
+    {"role": "user", "content": "Next state... (reward: 1.0)"},
+    ...
+  ],
+  "metadata": {
+    "env_id": 0,
+    "group_id": 0,
+    "success": true,
+    "total_reward": 5.0,
+    "num_turns": 3,
+    "entropy": 2.45,
+    "n_tokens": 128
+  }
+}
+```
+
+### Dual Output
+
+Save both formats simultaneously:
+
+```yaml
+output:
+  format: pkl
+  save_jsonl_backup: true  # Also save JSONL
+```
+
+Or:
+
+```yaml
+output:
+  format: jsonl
+  save_pkl_backup: true    # Also save PKL
+```
+
+## Converting Existing PKL Files
+
+Convert existing PKL rollouts to JSONL:
+
+```bash
+python scripts/convert_to_jsonl.py \
+  --input results/eval/val_rollouts_20260413_123456.pkl \
+  --output trajectories.jsonl
+```
+
+Auto-generate output filename:
+
+```bash
+python scripts/convert_to_jsonl.py --input results/eval/val_rollouts_*.pkl
+# Creates: val_rollouts_*.jsonl in the same directory
+```
+
+## Advanced Usage
+
+### Override Config from Command Line
+
+```bash
+python -m ragen.llm_agent.agent_proxy --config-name eval \
+  model_path=path/to/checkpoint \
+  actor_rollout_ref.rollout.temperature=0.7 \
+  output.format=jsonl \
+  es_manager.val.env_groups=64
+```
+
+### Custom Evaluation Seeds
+
+Control randomness for reproducibility:
+
+```yaml
+seed:
+  val: 123  # Validation seed
+```
+
+### GPU Configuration
+
+```yaml
+system:
+  CUDA_VISIBLE_DEVICES: "0"  # GPU device(s)
+
+actor_rollout_ref:
+  rollout:
+    tensor_model_parallel_size: 1  # Number of GPUs for tensor parallelism
+    gpu_memory_utilization: 0.9    # Max GPU memory fraction
+```
+
+### Filtering Output Data
+
+Reduce file size by filtering keys:
+
+```yaml
+output:
+  keep_batch_keys: ["rm_scores", "responses"]  # Only keep these tensor keys
+  keep_non_tensor_keys: ["history", "metrics"] # Only keep these non-tensor keys
+```
+
+Set to `null` to keep all keys.
+
+## Metrics
+
+After evaluation, metrics are displayed in the terminal:
+
+```
+rollout rewards: 0.85
+metrics:
+  CoordSokoban/success: 0.78
+  CoordSokoban/num_actions: 4.2
+  CoordSokoban/pass@16: 0.92
+```
+
+**Common metrics:**
+- `{env}/success`: Success rate (0-1)
+- `{env}/num_actions`: Average actions per trajectory
+- `{env}/pass@k`: At least one success in group of k rollouts
+- `episodic_return`: Cumulative reward
+
+## Troubleshooting
+
+**Out of memory:**
+```yaml
+actor_rollout_ref:
+  rollout:
+    max_model_len: 2048          # Reduce context length
+    response_length: 128         # Reduce response length
+    gpu_memory_utilization: 0.7  # Lower memory usage
+```
+
+**Evaluation too slow:**
+- Reduce `es_manager.val.env_groups` or `group_size`
+- Use `temperature: 0` for greedy decoding (faster)
+- Enable `enforce_eager: False` for compiled mode (if compatible)
+
+**JSONL parsing errors:**
+- Ensure `history` data is serializable
+- Check for special characters in state/response strings
+- Use `save_pkl_backup: true` to preserve original data
+
+## Related Documentation
+
+- [Main README](../README.md) - General RAGEN overview
+- [Rollout Filtering Guide](guide_rollout_filtering.md) - Training-time filtering
+- [V1 README](readme_v1.md) - Legacy evaluation instructions
+- [WebShop Evaluation](experiment_webshop_release.md) - WebShop-specific setup

docs/experiment_frozen_lake_slipper_sweep.md

@@ -0,0 +1,103 @@
+# FrozenLake Slipper Sweep Runs
+
+This doc covers the experiment script for the FrozenLake slipper-rate sweep.
+
+## Scripts Overview
+
+| Script | Purpose | Variables |
+|--------|---------|-----------|
+| `run_frozen_lake_slipper_rate_sweep.sh` | Sweep FrozenLake stochasticity while comparing `filter` vs `nofilter` | `slipper_rate` (`100,50,20,10,5,2,0` by default), `filter`/`nofilter` |
+
+The script runs FrozenLake with `Qwen2.5-3B`, `GAE`.
+
+---
+
+## 1. FrozenLake Slipper Sweep (`run_frozen_lake_slipper_rate_sweep.sh`)
+
+Tracks how `filter` and `nofilter` success rates change as FrozenLake stochasticity varies via `slipper_rate`, using project `ragen_release_frozenlake_slipper_rate_sweep`.
+
+Goal:
+- Test whether RV-style filtering remains helpful as FrozenLake transition randomness changes
+
+Key Details:
+- `slipper_rate` is normalized to a ratio in `[0, 1]`, and the environment is configured with `success_rate = 1 - slipper_rate`
+- Default comparison modes are both `filter` and `nofilter`
+- This script explicitly fixes `rollout_filter_top_p_prob_mode=softmax`
+- Mode mapping:
+  - `filter`: `top_p=0.9` by default and `rollout_filter_include_zero=False`
+  - `nofilter`: `top_p=1.0` by default and `rollout_filter_include_zero=True`
+
+```bash
+bash scripts/runs/run_frozen_lake_slipper_rate_sweep.sh
+```
+
+Options:
+- `--steps` (default: `400`)
+- `--slipper-rate` (comma list; accepts `100,50,20,10,5,2,0`, `1.0,0.5,...`, or `%`-suffixed values)
+- `--filter-modes` (comma list; `filter`, `nofilter`, or both; default: both)
+- `--filter-top-p` (default: `0.9`)
+- `--nofilter-top-p` (default: `1.0`)
+- `--gpus` (comma list; auto-detect if omitted)
+- `--gpus-per-exp` (default: `1`)
+- `--ray-num-cpus` (default: `16`)
+- `--cooldown` (default: `30`)
+- `--gpu-memory-utilization` (default: `0.5`)
+- `--save-freq` (default: `-1`)
+
+Examples:
+```bash
+# Run the full default sweep
+bash scripts/runs/run_frozen_lake_slipper_rate_sweep.sh
+
+# Run only `nofilter` on a custom subset of slipper rates
+bash scripts/runs/run_frozen_lake_slipper_rate_sweep.sh --slipper-rate 50,20,5 --filter-modes nofilter --gpus 0 --cooldown 30 --ray-num-cpus 8
+
+# Run one `filter` and one `nofilter` 50%-slipper experiment on 4xH100 each
+bash scripts/runs/run_frozen_lake_slipper_rate_sweep.sh --slipper-rate 50 --gpus-per-exp 4 --gpus 0,1,2,3,4,5,6,7
+```
+
+Outputs:
+- Per-run logs: `logs/frozenlake_slipper_rate_sweep_Qwen2.5-3B/<mode>/slip<label>/`
+- Summary log: `logs/frozenlake_slipper_rate_sweep_Qwen2.5-3B.log`
+
+---
+
+## Common Notes
+
+- Shared setup:
+  - Config: `_3_frozen_lake`
+  - Model: `Qwen/Qwen2.5-3B`
+  - `algorithm.adv_estimator=gae`
+  - `trainer.total_training_steps=400`
+  - `trainer.save_freq=-1`
+  - `trainer.logger=['console','wandb']`
+  - `trainer.val_before_train=True`
+  - `actor_rollout_ref.actor.loss_agg_mode=token-mean`
+  - `actor_rollout_ref.actor.use_kl_loss=False`
+  - `actor_rollout_ref.actor.kl_loss_type=low-var-kl`
+  - `actor_rollout_ref.actor.kl_loss_coef=0`
+  - `actor_rollout_ref.actor.entropy_coeff=0`
+  - `actor_rollout_ref.actor.entropy_from_logits_with_chunking=True`
+  - `actor_rollout_ref.actor.filter_loss_scaling=none`
+  - `actor_rollout_ref.actor.ppo_mini_batch_size=32`
+  - `actor_rollout_ref.actor.ppo_micro_batch_size_per_gpu=4`
+  - `critic.ppo_mini_batch_size=32`
+  - `critic.ppo_micro_batch_size_per_gpu=4`
+  - `actor_rollout_ref.ref.log_prob_micro_batch_size_per_gpu=8`
+  - `actor_rollout_ref.rollout.log_prob_micro_batch_size_per_gpu=8`
+  - `actor_rollout_ref.rollout.rollout_filter_strategy=top_p`
+  - `actor_rollout_ref.rollout.rollout_filter_top_p_prob_mode=softmax`
+  - `actor_rollout_ref.rollout.rollout_filter_type=largest`
+  - `actor_rollout_ref.rollout.rollout_filter_metric=reward_variance`
+  - `actor_rollout_ref.rollout.gpu_memory_utilization=0.5`
+  - `actor_rollout_ref.actor.checkpoint.save_contents=[model]`
+  - `critic.checkpoint.save_contents=[model]`
+- Input and naming conventions:
+  - `slipper_rate` accepts `50`, `0.5`, and `50%` as equivalent inputs
+  - Experiment labels use `slip<label>` with compact decimal formatting
+  - Examples: `50% -> slip0p5`, `2% -> slip0p02`
+- Comparison protocol:
+  - Each slipper rate is run under both `filter` and `nofilter` unless `--filter-modes` restricts the set
+  - With `--gpus-per-exp 4`, a 4-GPU list runs one experiment at a time; an 8-GPU list can run one `filter` and one `nofilter` experiment in parallel
+- Base-config inheritance:
+  - `algorithm.kl_ctrl.kl_coef` is not overridden in this script

docs/experiment_intervention_sweep.md

@@ -0,0 +1,171 @@
+# Intervention Sweep Runs
+
+This doc covers the experiment scripts for the intervention sweep experiments.
+
+## Scripts Overview
+
+| Script | Purpose | Variables |
+|--------|---------|-----------|
+| `run_top_p_sweep.sh` | Sweep RV-filter strength | `rollout_filter_value` (`1.0,0.98,0.95,0.9,0.8,0.6,0.4,nofilter`) |
+| `run_kl_sweep.sh` | Sweep KL regularization | `kl_loss_coef` (`0,0.001,0.003,0.01,0.03,0.1`) |
+| `run_entropy_sweep.sh` | Sweep entropy regularization | `entropy_coeff` (`0,0.001,0.003,0.01,0.03,0.1`) |
+
+All three scripts run Sokoban with `Qwen2.5-3B`, `GAE`.
+
+---
+
+## 1. Top-p Sweep (`run_top_p_sweep.sh`)
+
+Scans `actor_rollout_ref.rollout.rollout_filter_value` on Sokoban.
+
+Goal:
+- Isolate the effect of RV-filter strength while keeping KL and entropy lightly enabled at `0.001`
+
+Key Details:
+- Reward-variance filtering scores each env group by the standard deviation of rollout rewards within the group
+- Selection uses `top_p`, `largest`, `reward_variance`, and explicitly fixes `rollout_filter_top_p_prob_mode=softmax`
+- Filtered groups are dropped as whole groups, and this sweep keeps `filter_loss_scaling=none`
+- `1.0` and `nofilter` are different conditions: `1.0` still uses `include_zero=False`, while `nofilter` sets `include_zero=True`
+
+Options:
+- `--steps` (default: `400`)
+- `--rollout_filter_value` (comma list; default: `1.0,0.98,0.95,0.9,0.8,0.6,0.4,nofilter`)
+- `--gpus` (comma list; auto-detect if omitted)
+- `--gpus-per-exp` (default: `1`)
+- `--ray-num-cpus` (default: `16`)
+- `--gpu-memory-utilization` (default: `0.5`)
+- `--save-freq` (default: `-1`)
+
+Examples:
+```bash
+# Run the full default sweep
+bash scripts/runs/run_top_p_sweep.sh
+
+# Run one `0.9` point and one `nofilter` point on 4xH100 each
+bash scripts/runs/run_top_p_sweep.sh --rollout_filter_value 0.9,nofilter --gpus-per-exp 4 --gpus 0,1,2,3,4,5,6,7
+```
+
+Outputs:
+- Per-value logs: `logs/top_p_sweep_Qwen2.5-3B/<value_label>/`
+- Summary log: `logs/top_p_sweep_Qwen2.5-3B.log`
+
+---
+
+## 2. KL Sweep (`run_kl_sweep.sh`)
+
+Scans `actor_rollout_ref.actor.kl_loss_coef` on Sokoban.
+
+Goal:
+- Isolate the effect of KL regularization while fixing entropy to `0` and keeping RV-filter effectively off with `rollout_filter_value=1`
+
+Key Details:
+- KL is computed token-wise between the current policy and a frozen reference policy worker
+- This sweep uses the actor KL loss, not reward-level KL shaping
+- When `kl_loss_coef=0`, the script also sets `use_kl_loss=False`, so the ref-policy forward pass is skipped
+- Increasing `kl_loss_coef` penalizes drift from the reference policy more strongly
+
+Options:
+- `--steps` (default: `400`)
+- `--kl-values` (comma list; default: `0,0.001,0.003,0.01,0.03,0.1`)
+- `--rollout_filter_include_zero` (bool; default: `True`)
+- `--gpus` (comma list; auto-detect if omitted)
+- `--gpus-per-exp` (default: `1`)
+- `--ray-num-cpus` (default: `16`)
+- `--gpu-memory-utilization` (default: `0.5`)
+- `--save-freq` (default: `-1`)
+
+Examples:
+```bash
+# Run the full default sweep
+bash scripts/runs/run_kl_sweep.sh
+
+# Run two KL points on 4xH100 each, with zero-variance groups excluded
+bash scripts/runs/run_kl_sweep.sh --kl-values 0,0.01 --rollout_filter_include_zero False --gpus-per-exp 4 --gpus 0,1,2,3,4,5,6,7
+```
+
+Outputs:
+- Per-value logs: `logs/kl_sweep_Qwen2.5-3B/<filter_tag>/<value_label>/`
+- Summary log: `logs/kl_sweep_Qwen2.5-3B.log`
+
+---
+
+## 3. Entropy Sweep (`run_entropy_sweep.sh`)
+
+Scans `actor_rollout_ref.actor.entropy_coeff` on Sokoban.
+
+Goal:
+- Isolate the effect of entropy regularization while fixing KL to `0` and keeping RV-filter effectively off with `rollout_filter_value=1`
+
+Key Details:
+- Entropy is computed token-wise over the full vocabulary on response tokens
+- Aggregation is `token-mean`, so the sweep compares average token-level exploration pressure
+- The entropy term enters the actor loss with a negative sign, so larger `entropy_coeff` encourages more exploration
+- The script keeps `entropy_from_logits_with_chunking=True`, so large-vocabulary entropy is computed in a memory-friendly way
+
+```bash
+bash scripts/runs/run_entropy_sweep.sh
+```
+
+Options:
+- `--steps` (default: `400`)
+- `--entropy-values` (comma list; default: `0,0.001,0.003,0.01,0.03,0.1`)
+- `--rollout_filter_include_zero` (bool; default: `True`)
+- `--gpus` (comma list; auto-detect if omitted)
+- `--gpus-per-exp` (default: `1`)
+- `--ray-num-cpus` (default: `16`)
+- `--gpu-memory-utilization` (default: `0.5`)
+- `--save-freq` (default: `-1`)
+
+Examples:
+```bash
+# Run the full default sweep
+bash scripts/runs/run_entropy_sweep.sh
+
+# Run two entropy points on 4xH100 each, with zero-variance groups excluded
+bash scripts/runs/run_entropy_sweep.sh --entropy-values 0,0.01 --rollout_filter_include_zero False --gpus-per-exp 4 --gpus 0,1,2,3,4,5,6,7
+```
+
+Outputs:
+- Per-value logs: `logs/entropy_sweep_Qwen2.5-3B/<filter_tag>/<value_label>/`
+- Summary log: `logs/entropy_sweep_Qwen2.5-3B.log`
+
+---
+
+## Common Notes
+
+- Comparability protocol:
+  - The three Sokoban sweeps change only one intervention axis at a time
+  - Top-p sweep scans RV-filter while fixing `use_kl_loss=True`, `kl_loss_coef=0.001`, and `entropy_coeff=0.001`
+  - KL sweep scans `kl_loss_coef` while keeping entropy off and filtering off
+  - Entropy sweep scans `entropy_coeff` while keeping KL off and filtering off
+- Training budget and early stopping:
+  - Each condition runs for at most `400` PPO steps with `8` train env groups and `16` rollouts per group
+  - Runs may stop early if reward variance collapses for long enough or if validation success stays below the failure threshold for repeated validations
+  - Early stopping is part of the comparison protocol: if a setting stops early, that run is treated as a failed training regime rather than a fully budgeted run
+- Shared setup across all three sweeps:
+  - Config: `_2_sokoban`
+  - Model: `Qwen/Qwen2.5-3B`
+  - `algorithm.adv_estimator=gae`
+  - `trainer.total_training_steps=400`
+  - `trainer.save_freq=-1`
+  - `trainer.logger=['console','wandb']`
+  - `trainer.val_before_train=True`
+  - `actor_rollout_ref.actor.filter_loss_scaling=none`
+  - `actor_rollout_ref.actor.ppo_mini_batch_size=32`
+  - `actor_rollout_ref.actor.ppo_micro_batch_size_per_gpu=4`
+  - `critic.ppo_mini_batch_size=32`
+  - `critic.ppo_micro_batch_size_per_gpu=4`
+  - `actor_rollout_ref.ref.log_prob_micro_batch_size_per_gpu=8`
+  - `actor_rollout_ref.rollout.log_prob_micro_batch_size_per_gpu=8`
+  - `es_manager.train.env_groups=8`, `es_manager.train.group_size=16`
+  - `es_manager.val.env_groups=512`, `es_manager.val.group_size=1`
+- Rollout filter settings used by these sweeps:
+  - `rollout_filter_strategy=top_p`
+  - `rollout_filter_top_p_prob_mode=softmax`
+  - `rollout_filter_type=largest`
+  - `rollout_filter_metric=reward_variance`
+- Top-p sweep uses two distinct `top_p=1.0` conditions:
+  - `1.0`: `rollout_filter_value=1.0`, `rollout_filter_include_zero=False`
+  - `nofilter`: `rollout_filter_value=1.0`, `rollout_filter_include_zero=True`
+- KL sweep and Entropy sweep default to `rollout_filter_include_zero=True`; if you pass `--rollout_filter_include_zero False`, logs are written under `filter_zero/` instead of `nofilter/`
+- You can run a single sweep point on `4xH100` by setting `--gpus-per-exp 4` and passing a 4-GPU list, or run two sweep points in parallel by passing an 8-GPU list

docs/experiment_sokoban_gradient_analysis.md

@@ -0,0 +1,154 @@
+# Sokoban Gradient Analysis Runs
+
+This doc covers the helper scripts for the Sokoban top-p=0.9 gradient-analysis experiments.
+
+For the internal execution order, metric definitions, and plotting workflow, see [guide_gradient_analysis.md](guide_gradient_analysis.md).
+
+## Scripts Overview
+
+| Script | Purpose | When to use |
+|--------|---------|-------------|
+| `run_sokoban_ppo_filter_grad_analysis.sh` | Train Sokoban with periodic gradient-analysis passes | Run this first to produce training logs and checkpoints |
+| `run_sokoban_ppo_filter_grad_analysis_probe_ckpt.sh` | Resume a saved checkpoint and run one analysis-only probe | Run this after the training script when you want to inspect a specific checkpoint |
+
+Both scripts run Sokoban with `Qwen2.5-3B`, reward-variance top-p filtering at `0.9`, and a separate gradient-analysis batch of `128x16`.
+
+---
+
+## Recommended Workflow
+
+1. Start with `run_sokoban_ppo_filter_grad_analysis.sh`.
+- This is the script that actually trains the policy, runs periodic gradient analysis, and writes the checkpoint layout that the probe script expects by default.
+
+2. Choose a saved `global_step_*` checkpoint.
+- The probe helper defaults to `global_step_101` under the checkpoint directory layout produced by the training script.
+- If your run saved a different step, pass `--checkpoint-step` or `--resume-from-path`.
+
+3. Run `run_sokoban_ppo_filter_grad_analysis_probe_ckpt.sh`.
+- This reloads the checkpoint, runs one gradient-analysis pass, optionally performs a validation first, and then exits.
+
+---
+
+## 1. Periodic Training + Analysis (`run_sokoban_ppo_filter_grad_analysis.sh`)
+
+Trains Sokoban and inserts gradient-analysis passes during training.
+
+Goal:
+- Follow the filtered Sokoban setup while logging gradient-analysis metrics at a fixed cadence on a larger analysis batch.
+
+Key Details:
+- Validation runs once before training and then every `10` steps.
+- Gradient analysis runs every `50` steps. With the default `101` steps, the trigger points are `1`, `51`, and `101`.
+- The normal training batch is `8` env groups x `16` samples.
+- Gradient analysis uses a separate batch of `128` env groups x `16` samples.
+- The run continues after analysis because `trainer.exit_after_gradient_analysis=False`.
+- This script uses `top_p=0.9`, `rollout_filter_top_p_prob_mode=linear`, `rollout_filter_type=largest`, `rollout_filter_metric=reward_variance`, and `rollout_filter_include_zero=False`.
+- `--algo PPO` selects `algorithm.adv_estimator=gae` and `actor_rollout_ref.actor.loss_agg_mode=token-mean`.
+- `--algo GRPO` selects `algorithm.adv_estimator=grpo`, `algorithm.norm_adv_by_std_in_grpo=True`, and `actor_rollout_ref.actor.loss_agg_mode=seq-mean-token-mean`.
+- The training helper keeps `actor_rollout_ref.actor.use_kl_loss=False`, so it is meant for filtered training with periodic analysis rather than a KL-regularized sweep.
+
+Examples:
+```bash
+# Default PPO run
+bash scripts/runs/run_sokoban_ppo_filter_grad_analysis.sh
+
+# GRPO run on four GPUs
+bash scripts/runs/run_sokoban_ppo_filter_grad_analysis.sh --algo GRPO --gpus 0,1,2,3
+
+# Short smoke test
+bash scripts/runs/run_sokoban_ppo_filter_grad_analysis.sh --steps 5 --gpus 0,1,2,3
+```
+
+Options:
+- `--algo NAME` (`PPO` or `GRPO`; default: `PPO`)
+- `--steps` (default: `101`)
+- `--gpus` (comma list; auto-detect if omitted)
+- `--gpu-memory-utilization` (default: `0.3`)
+- `--ray-num-cpus` (default: `16`)
+- `--ppo-micro-batch-size-per-gpu` (default: `4`)
+- `--log-prob-micro-batch-size-per-gpu` (default: `4`)
+- `--save-freq` (default: `100`)
+
+Outputs:
+- Per-run log: `logs/gradient_analysis_sokoban_Qwen2.5-3B/<exp_name>.log`
+- Checkpoints: `model_saving/gradient_analysis/sokoban/<ALGO>/filter/<exp_name>/`
+- W&B project: `ragen_gradient_analysis`
+
+---
+
+## 2. Checkpoint Probe (`run_sokoban_ppo_filter_grad_analysis_probe_ckpt.sh`)
+
+Resumes a saved checkpoint and runs one gradient-analysis-only probe.
+
+Goal:
+- Inspect one checkpoint without continuing the normal training run.
+
+Key Details:
+- The script resumes from an existing `global_step_*` directory with `trainer.resume_mode=resume_path`.
+- It runs in probe mode with `trainer.gradient_analysis_only=True`.
+- It exits after the analysis pass because `trainer.exit_after_gradient_analysis=True`.
+- By default it does not run validation first; add `--with-val` if you want a pre-probe validation.
+- It uses the same Sokoban task, model, filter setup, and analysis batch shape as the training helper.
+- Unlike the training helper, this probe sets `actor_rollout_ref.actor.use_kl_loss=True` together with `kl_loss_coef=0.001` and `entropy_coeff=0.001`, so the checkpoint probe explicitly logs KL and entropy gradient components.
+- If `--resume-from-path` is given, that exact checkpoint directory is used. Otherwise the script resolves `<checkpoint-root>/global_step_<checkpoint-step>`.
+
+Examples:
+```bash
+# Probe the default checkpoint layout produced by the training helper
+bash scripts/runs/run_sokoban_ppo_filter_grad_analysis_probe_ckpt.sh
+
+# Probe a specific saved step with validation
+bash scripts/runs/run_sokoban_ppo_filter_grad_analysis_probe_ckpt.sh \
+  --checkpoint-step 51 \
+  --with-val \
+  --gpus 0,1,2,3
+
+# Probe an exact checkpoint path
+bash scripts/runs/run_sokoban_ppo_filter_grad_analysis_probe_ckpt.sh \
+  --resume-from-path model_saving/gradient_analysis/sokoban/PPO/filter/<exp_name>/global_step_101 \
+  --gpus 0,1,2,3
+```
+
+Options:
+- `--algo NAME` (`PPO` or `GRPO`; default: `PPO`)
+- `--checkpoint-step` (default: `101`)
+- `--checkpoint-root DIR` (default: derived from the training helper's checkpoint layout)
+- `--resume-from-path DIR` (exact `global_step_*` directory; overrides root + step resolution)
+- `--with-val` (flag; default: off)
+- `--gpus` (comma list; auto-detect if omitted)
+- `--gpu-memory-utilization` (default: `0.3`)
+- `--ray-num-cpus` (default: `16`)
+- `--ppo-micro-batch-size-per-gpu` (default: `4`)
+- `--log-prob-micro-batch-size-per-gpu` (default: `4`)
+
+Outputs:
+- Per-run log: `logs/gradient_analysis_probe_sokoban_Qwen2.5-3B/<exp_name>.log`
+- Probe output dir: `model_saving/gradient_analysis_probe/sokoban/<ALGO>/filter/<exp_name>/`
+- W&B project: `ragen_gradient_analysis_probe`
+
+---
+
+## Common Notes
+
+- Shared fixed setup:
+  - config: `_2_sokoban`
+  - model: `Qwen/Qwen2.5-3B`
+  - training batch: `es_manager.train.env_groups=8`, `es_manager.train.group_size=16`
+  - analysis batch: `trainer.gradient_analysis_env_groups=128`, `trainer.gradient_analysis_group_size=16`
+  - `trainer.gradient_analysis_log_prefilter=True`
+  - `actor_rollout_ref.rollout.gradient_analysis_num_buckets=6`
+  - `actor_rollout_ref.rollout.gradient_analysis_bucket_mode=quantile`
+- Shared rollout filter setup:
+  - `actor_rollout_ref.rollout.rollout_filter_value=0.9`
+  - `actor_rollout_ref.rollout.rollout_filter_strategy=top_p`
+  - `actor_rollout_ref.rollout.rollout_filter_top_p_prob_mode=linear`
+  - `actor_rollout_ref.rollout.rollout_filter_type=largest`
+  - `actor_rollout_ref.rollout.rollout_filter_metric=reward_variance`
+  - `actor_rollout_ref.rollout.rollout_filter_include_zero=False`
+- GPU behavior:
+  - if `--gpus` is omitted, the scripts try to auto-detect GPUs with `nvidia-smi`
+  - if auto-detection fails, they fall back to `0,1,2,3,4,5,6,7`
+- Directory relationship:
+  - the training helper writes checkpoints under `model_saving/gradient_analysis/...`
+  - the probe helper reads from that layout by default and writes its own outputs under `model_saving/gradient_analysis_probe/...`
+- If you need the meaning of bucket metrics, prefilter logging, or the plotting commands after the run finishes, use [guide_gradient_analysis.md](guide_gradient_analysis.md).

docs/experiment_webshop_release.md

@@ -0,0 +1,136 @@
+# WebShop Release Runs
+
+This doc covers the current WebShop release runner.
+
+## Overview
+
+Use [`scripts/runs/run_webshop_release_combos.sh`](../scripts/runs/run_webshop_release_combos.sh) for the main WebShop release experiments.
+
+Fixed setup:
+- **Task**: WebShop
+- **Config**: `_6_webshop`
+- **Model**: `Qwen/Qwen2.5-3B-Instruct`
+- **Algorithm**: `GRPO`
+- **Train batch**: `16` env groups x `8` samples
+- **Validation batch**: `256` env groups x `1` sample
+- **W&B project**: `main_webshop`
+
+The runner compares four filter modes while keeping the rest of the setup fixed:
+
+| Filter | Strategy | Value | Prob Mode | Description |
+|--------|----------|-------|-----------|-------------|
+| `topk25` | `top_k` | `0.25` | `linear` | Keep top 25% of groups by reward variance |
+| `topp09` | `top_p` | `0.9` | `linear` | Keep groups covering 90% cumulative reward variance |
+| `topp095` | `top_p` | `0.95` | `linear` | Keep groups covering 95% cumulative reward variance |
+| `nofilter` | `top_p` | `1.0` | `linear` | Keep all groups |
+
+All four modes use:
+- `rollout_filter_type=largest`
+- `rollout_filter_metric=reward_variance`
+- `rollout_filter_include_zero=True`
+
+## Setup
+
+For WebShop, use the original base setup path:
+
+```bash
+bash scripts/setup_ragen_old.sh
+bash scripts/setup_webshop.sh
+```
+
+Do not use `setup_ragen.sh` as the primary WebShop setup path.
+
+Notes:
+- `setup_webshop.sh` now treats the Google Drive full-data download as best-effort. A failure there does not mean the Python environment setup failed.
+- The runner already pins `micro_batch_size_per_gpu=1` and `log_prob_micro_batch_size_per_gpu=1` to reduce WebShop rollout/log-prob memory pressure.
+
+## Main Commands
+
+### 4 GPUs
+
+Run one experiment on 4 GPUs:
+
+```bash
+bash scripts/runs/run_webshop_release_combos.sh \
+  --steps 400 \
+  --gpus 0,1,2,3 \
+  --gpus-per-exp 4 \
+  --filters nofilter
+```
+
+Other filter modes:
+
+```bash
+bash scripts/runs/run_webshop_release_combos.sh \
+  --steps 400 \
+  --gpus 0,1,2,3 \
+  --gpus-per-exp 4 \
+  --filters topk25
+```
+
+```bash
+bash scripts/runs/run_webshop_release_combos.sh \
+  --steps 400 \
+  --gpus 0,1,2,3 \
+  --gpus-per-exp 4 \
+  --filters topp09
+```
+
+```bash
+bash scripts/runs/run_webshop_release_combos.sh \
+  --steps 400 \
+  --gpus 0,1,2,3 \
+  --gpus-per-exp 4 \
+  --filters topp095
+```
+
+### 8 GPUs
+
+Run one experiment on 8 GPUs:
+
+```bash
+bash scripts/runs/run_webshop_release_combos.sh \
+  --steps 400 \
+  --gpus 0,1,2,3,4,5,6,7 \
+  --gpus-per-exp 8 \
+  --filters nofilter
+```
+
+You can swap `nofilter` for `topk25`, `topp09`, or `topp095`.
+
+## Key Flags
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--steps N` | `100` | Total training steps |
+| `--gpus LIST` | auto-detect | Comma-separated GPU IDs |
+| `--gpus-per-exp N` | `1` | GPUs assigned to one experiment |
+| `--save-freq N` | `100` | Checkpoint save frequency |
+| `--gpu-memory-utilization V` | `0.3` | vLLM rollout memory fraction |
+| `--filters LIST` | `all` | `topk25`, `topp09`, `topp095`, `nofilter`, or `all` |
+| `--cooldown N` | `30` | Delay before reusing the same GPU slot |
+
+## Outputs
+
+- Logs: `logs/webshop_release_combos/<exp_name>.log`
+- Per-run summaries: `logs/webshop_release_combos/<exp_name>.result`
+- Checkpoints: `model_saving/webshop_release_combos/<model>/<algo>/<filter>/<exp_name>/`
+- W&B project: `main_webshop`
+
+Experiment names follow:
+
+```text
+webshop-release-GRPO-<filter-suffix>-Qwen2.5-3B-Instruct-16x8
+```
+
+Examples:
+- `webshop-release-GRPO-topk25-Qwen2.5-3B-Instruct-16x8`
+- `webshop-release-GRPO-topp09-linear-Qwen2.5-3B-Instruct-16x8`
+- `webshop-release-GRPO-topp095-linear-Qwen2.5-3B-Instruct-16x8`
+- `webshop-release-GRPO-nofilter-Qwen2.5-3B-Instruct-16x8`
+
+## Related Files
+
+- [`scripts/runs/run_webshop_release_combos.sh`](../scripts/runs/run_webshop_release_combos.sh)
+- [`scripts/runs/run_webshop_small_combos.sh`](../scripts/runs/run_webshop_small_combos.sh)
+- [`scripts/runs/README_webshop_small_combos.md`](../scripts/runs/README_webshop_small_combos.md)

docs/guide_gradient_analysis.md

@@ -0,0 +1,491 @@
+# Gradient Analysis Walkthrough
+
+This document explains how gradient analysis works in the current RAGEN codebase, which arguments control it, which W&B metrics it writes, how to run it from scratch or from a checkpoint, and how to turn a finished W&B run into local plots.
+
+Normal training now enables gradient analysis by default:
+- `trainer.gradient_analysis_mode=True`
+- `trainer.gradient_analysis_every=50`
+- by default it reuses the training batch unless separate analysis batch overrides are set
+
+## Quickstart
+
+### Run a periodic analysis job from scratch
+
+```bash
+bash scripts/runs/run_sokoban_ppo_filter_grad_analysis.sh \
+  --gpus 0,1,2,3,4,5,6,7
+```
+
+That helper script:
+- trains for `101` steps
+- runs validation before training and then every `10` steps
+- runs gradient analysis on steps `1`, `51`, and `101`
+- uses the main-table training batch (`8x16`) but a separate analysis batch (`128x16`)
+
+### Run one analysis-only job
+
+```bash
+bash scripts/runs/run_sokoban_ppo_filter_grad_analysis.sh \
+  --steps 1 \
+  --gpus 0,1,2,3,4,5,6,7
+```
+
+Then set:
+- `trainer.gradient_analysis_every=1`
+- `trainer.exit_after_gradient_analysis=True`
+
+### Plot the finished run
+
+```bash
+python gradient_analysis/plot_gradient_analysis.py \
+  --wandb-path deimos-xing/ragen_gradient_analysis/<run_id> \
+  --step 1
+```
+
+Default output directory:
+
+```text
+gradient_analysis_outputs/<run_name>_<run_id>/
+```
+
+## What It Does
+
+Gradient analysis is a reporting path that probes the actor on reward-variance buckets without taking an optimizer step.
+
+The current execution order inside [agent_trainer.py](../ragen/trainer/agent_trainer.py) is:
+
+1. generate rollouts
+2. apply rollout filtering
+3. compute rewards and advantages
+4. update critic if enabled
+5. if the current step matches the gradient-analysis cadence:
+   - split the batch into reward-variance buckets
+   - run actor backward passes for task / entropy / KL on each bucket
+   - log gradient-analysis metrics
+6. if `trainer.exit_after_gradient_analysis=True`, exit here
+7. otherwise continue to the normal actor update
+
+So the important boundary is:
+- gradient analysis runs after rollout, filtering, reward computation, and critic update
+- it runs before the normal actor update
+- with `exit_after_gradient_analysis=True`, the run exits before actor update, checkpoint save, and post-step validation
+
+When `trainer.gradient_analysis_env_groups` or `trainer.gradient_analysis_group_size` is set:
+- training still uses the normal training batch
+- the analysis step generates a second, separate rollout batch just for gradient analysis
+- that separate batch is filtered, scored, bucketed, and probed without affecting the training update batch
+
+## How Bucketing Works
+
+Bucketing is implemented in [rollout_filter.py](../ragen/trainer/rollout_filter.py).
+
+### Source Signal
+
+- The rollout filter computes in-group reward standard deviation
+- It broadcasts that value to each sample as `batch.batch["reward_std"]`
+- Gradient analysis then splits the filtered batch using this `reward_std`
+
+This means the buckets are built from the same reward-variance signal used by rollout filtering, not from a separate offline computation.
+
+### Bucket Modes
+
+Two bucket modes are supported:
+
+1. `quantile` (default)
+- Controlled by `gradient_analysis_num_buckets`
+- Groups are sorted by group-level `reward_std`
+- They are split into equal-percentage buckets
+- If the filtered batch contains fewer groups than the requested bucket count, the effective bucket count is reduced so each bucket still contains at least one group
+- Bucket names are `bucket_1` to `bucket_N`
+- `bucket_1` is lowest reward variance, `bucket_N` is highest reward variance
+
+2. `fixed_rv`
+- Uses fixed reward-variance intervals:
+  - `bucket_1`: `[0, 1)`
+  - `bucket_2`: `[1, 2)`
+  - `bucket_3`: `[2, 3)`
+  - `bucket_4`: `[3, 4)`
+  - `bucket_5`: `[4, 5)`
+  - `bucket_6`: `[5, +inf)`
+
+### Special `all` Bucket
+
+Gradient analysis always includes an `all` bucket in addition to the real variance buckets.
+
+`all` means:
+- the whole filtered batch
+- no bucket subsetting
+
+This is the bridge between the bucketed metrics and the top-level actor metrics.
+
+### DP Safety
+
+If a bucket size is not divisible by `trainer.n_gpus_per_node`, the reporter drops the remainder before calling actor update. If a bucket would become empty after that adjustment, it is skipped.
+
+## How The Analysis Is Computed
+
+The reporting loop is in [gradient_reporter.py](../ragen/trainer/gradient_reporter.py).
+
+For each bucket:
+
+1. create a sub-batch
+2. set two meta flags:
+   - `skip_optimizer_step=True`
+   - `grad_component_analysis=True`
+3. call `trainer.actor_rollout_wg.update_actor(sub_batch)`
+4. inside the actor, run three backward passes:
+   - task policy loss
+   - entropy term
+   - KL term
+5. record gradient norms and losses
+6. zero gradients and move to the next bucket
+
+The component-wise backward path is implemented in [dp_actor.py](../ragen/workers/actor/dp_actor.py).
+
+Important detail:
+- this path does not call `optimizer.step()`
+- it is analysis-only probing of the current actor state
+
+## Arguments
+
+### New Hydra Args
+
+These are the gradient-analysis-specific trainer overrides:
+
+1. `trainer.gradient_analysis_mode=True`
+- enables the feature
+- default behavior in `config/base.yaml`: enabled
+- set `trainer.gradient_analysis_mode=False` to disable it
+
+2. `trainer.gradient_analysis_every=<N>`
+- run analysis every `N` training steps
+- trigger condition is:
+  - `(global_steps - 1) % gradient_analysis_every == 0`
+- default behavior in `config/base.yaml`: `50`
+- so `gradient_analysis_every=1` means every step
+- `gradient_analysis_every=50` means steps `1, 51, 101, ...`
+
+3. `trainer.exit_after_gradient_analysis=True`
+- analysis-only mode
+- after the selected analysis step finishes, log metrics and exit immediately
+- exit happens before:
+  - actor update
+  - checkpoint save
+  - post-step validation
+- default behavior in `config/base.yaml`: `False`
+- it does not suppress `val_before_train`
+
+4. `trainer.gradient_analysis_env_groups=<N>`
+- optional
+- if set, gradient analysis uses a separate rollout batch with this many groups
+- training keeps using `es_manager.train.env_groups`
+- default behavior in `config/base.yaml`: `null` (reuse training batch)
+
+5. `trainer.gradient_analysis_group_size=<N>`
+- optional
+- if set, gradient analysis uses a separate rollout batch with this group size
+- training keeps using `es_manager.train.group_size`
+- default behavior in `config/base.yaml`: `null` (reuse training batch)
+
+6. `actor_rollout_ref.rollout.gradient_analysis_num_buckets=<N>`
+- number of quantile buckets
+- default is `6`
+
+7. `actor_rollout_ref.rollout.gradient_analysis_bucket_mode=quantile|fixed_rv`
+- chooses the bucketing rule
+- default is `quantile`
+
+### Existing Training Args That Matter
+
+These are not new, but they materially affect the analysis:
+
+- `es_manager.train.env_groups`
+  - number of prompt groups
+  - more groups gives a finer reward-variance ranking
+
+- `es_manager.train.group_size`
+  - number of rollouts per group
+  - affects how stable each group reward-variance estimate is
+
+- `trainer.n_gpus_per_node`
+  - affects DP-safe bucket trimming
+
+- rollout filter args such as:
+  - `actor_rollout_ref.rollout.rollout_filter_value`
+  - `actor_rollout_ref.rollout.rollout_filter_strategy`
+  - `actor_rollout_ref.rollout.rollout_filter_metric`
+  - `actor_rollout_ref.rollout.rollout_filter_top_p_prob_mode`
+  - `actor_rollout_ref.rollout.rollout_filter_include_zero`
+
+The current Sokoban PPO helper runner uses:
+- training batch: `env_groups=8`, `group_size=16`
+- analysis batch: `gradient_analysis_env_groups=128`, `gradient_analysis_group_size=16`
+- `rollout_filter_strategy=top_p`
+- `rollout_filter_value=0.9`
+- `rollout_filter_metric=reward_variance`
+- `rollout_filter_top_p_prob_mode=softmax`
+
+## W&B Metrics
+
+There are two layers of metrics:
+
+1. bucket-prefixed analysis metrics
+2. top-level actor metrics copied from the `all` bucket
+
+### Bucket-Prefixed Metrics
+
+These are written under:
+- `grad_norm/all/...`
+- `grad_norm/bucket_1/...`
+- `grad_norm/bucket_2/...`
+- ...
+
+#### Bucket Size / Coverage
+
+- `grad_norm/<bucket>/sample_count`
+- `grad_norm/<bucket>/sample_pct`
+
+#### Reward-Variance Stats
+
+- `grad_norm/<bucket>/reward_std_mean`
+- `grad_norm/<bucket>/reward_std_min`
+- `grad_norm/<bucket>/reward_std_max`
+- `grad_norm/<bucket>/group_rv_count`
+- `grad_norm/<bucket>/group_rv_table`
+
+`group_rv_table` is a `wandb.Table` with columns:
+- `bucket`
+- `group_id`
+- `reward_std`
+
+#### Gradient Norms
+
+- `grad_norm/<bucket>/task`
+- `grad_norm/<bucket>/entropy`
+- `grad_norm/<bucket>/kl`
+
+#### Normalized Gradient Norms
+
+- `grad_norm/<bucket>/per_sample/task`
+- `grad_norm/<bucket>/per_sample/entropy`
+- `grad_norm/<bucket>/per_sample/kl`
+- `grad_norm/<bucket>/per_token/task`
+- `grad_norm/<bucket>/per_token/entropy`
+- `grad_norm/<bucket>/per_token/kl`
+
+#### Losses
+
+- `grad_norm/<bucket>/loss/policy`
+- `grad_norm/<bucket>/loss/entropy`
+- `grad_norm/<bucket>/loss/kl`
+- `grad_norm/<bucket>/loss/total`
+
+### Top-Level Metrics Copied From `all`
+
+When the bucket name is `all`, the reporter also writes the actor metrics back to top level:
+
+- `actor/loss/policy`
+- `actor/loss/entropy`
+- `actor/loss/kl`
+- `actor/loss/total`
+- `actor/grad_norm/task`
+- `actor/grad_norm/entropy`
+- `actor/grad_norm/kl`
+
+If `exit_after_gradient_analysis=True`, the trainer also logs:
+
+- `trainer/exited_after_gradient_analysis = 1.0`
+
+## Commands
+
+### 1. From Scratch With The Helper Script
+
+The helper runner is:
+- [run_sokoban_ppo_filter_grad_analysis.sh](../scripts/runs/run_sokoban_ppo_filter_grad_analysis.sh)
+
+It is fixed to:
+- task: `sokoban`
+- algo: `PPO`
+- filter: `top_p=0.9`
+- model: `Qwen2.5-3B`
+- env_groups: `32`
+- group_size: `16`
+- gradient analysis: once on step 1
+- `exit_after_gradient_analysis=True`
+- one initial validation before training
+- no periodic validation afterwards
+
+Example on 8 GPUs:
+
+```bash
+bash scripts/runs/run_sokoban_ppo_filter_grad_analysis.sh \
+  --steps 1 \
+  --gpus 0,1,2,3,4,5,6,7
+```
+
+Key defaults inside that script:
+- `trainer.project_name=ragen_gradient_analysis`
+- `env_groups=32`
+- `group_size=16`
+- `trainer.gradient_analysis_every=1`
+- `trainer.exit_after_gradient_analysis=True`
+- `actor_rollout_ref.rollout.gradient_analysis_num_buckets=6`
+- `actor_rollout_ref.rollout.gradient_analysis_bucket_mode=quantile`
+
+### 2. Direct `train.py` Usage
+
+Minimal pattern when you want to override the global defaults:
+
+```bash
+python train.py ... \
+  trainer.gradient_analysis_mode=True \
+  trainer.gradient_analysis_every=1 \
+  trainer.exit_after_gradient_analysis=True \
+  actor_rollout_ref.rollout.gradient_analysis_num_buckets=6 \
+  actor_rollout_ref.rollout.gradient_analysis_bucket_mode=quantile
+```
+
+### 3. Resume From A Checkpoint And Probe It Once
+
+Checkpoint resume should point to the `global_step_<N>` directory, not the nested `actor/` directory.
+
+Example:
+
+```bash
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 python train.py --config-name _2_sokoban \
+  model_path=Qwen/Qwen2.5-3B \
+  trainer.project_name=ragen_gradient_analysis \
+  trainer.experiment_name=sokoban-PPO-filter-topp09-grad-from-ckpt100 \
+  trainer.default_local_dir=model_saving/gradient_analysis/sokoban/PPO/filter/sokoban-PPO-filter-topp09-grad-from-ckpt100 \
+  trainer.resume_mode=resume_path \
+  trainer.resume_from_path=/ABS/PATH/TO/your_run/global_step_100 \
+  trainer.total_training_steps=101 \
+  trainer.save_freq=-1 \
+  trainer.val_before_train=False \
+  trainer.test_freq=-1 \
+  trainer.n_gpus_per_node=8 \
+  ray_kwargs.ray_init.num_cpus=16 \
+  system.CUDA_VISIBLE_DEVICES="'0,1,2,3,4,5,6,7'" \
+  es_manager.train.env_groups=32 \
+  es_manager.train.group_size=16 \
+  es_manager.train.env_configs.n_groups="[32]" \
+  actor_rollout_ref.actor.use_kl_loss=False \
+  actor_rollout_ref.actor.kl_loss_type=low-var-kl \
+  actor_rollout_ref.actor.kl_loss_coef=0.001 \
+  actor_rollout_ref.actor.entropy_coeff=0.001 \
+  actor_rollout_ref.actor.entropy_from_logits_with_chunking=True \
+  actor_rollout_ref.actor.filter_loss_scaling=none \
+  actor_rollout_ref.actor.loss_agg_mode=token-mean \
+  actor_rollout_ref.rollout.gpu_memory_utilization=0.3 \
+  actor_rollout_ref.rollout.rollout_filter_value=0.9 \
+  actor_rollout_ref.rollout.rollout_filter_strategy=top_p \
+  actor_rollout_ref.rollout.rollout_filter_top_p_prob_mode=softmax \
+  actor_rollout_ref.rollout.rollout_filter_type=largest \
+  actor_rollout_ref.rollout.rollout_filter_metric=reward_variance \
+  actor_rollout_ref.rollout.rollout_filter_include_zero=True \
+  algorithm.adv_estimator=gae \
+  trainer.gradient_analysis_mode=True \
+  trainer.gradient_analysis_every=1 \
+  trainer.exit_after_gradient_analysis=True \
+  actor_rollout_ref.rollout.gradient_analysis_num_buckets=6 \
+  actor_rollout_ref.rollout.gradient_analysis_bucket_mode=quantile
+```
+
+Why `total_training_steps=101` for a `global_step_100` checkpoint:
+- the trainer resumes at step 100
+- one more training iteration is enough to trigger one analysis pass
+- `exit_after_gradient_analysis=True` then exits before actor update
+
+## Practical Notes
+
+- `exit_after_gradient_analysis=True` is not a full “no training code at all” mode.
+  - rollout generation, filtering, reward computation, and critic update still happen before the analysis point
+  - what it prevents is the normal actor update and everything after it
+
+- If you want the cleanest checkpoint inspection, keep the resumed run aligned with the original training geometry:
+  - same `env_groups`
+  - same `group_size`
+  - same rollout filter settings
+
+- The analysis buckets are built on the filtered batch, not on the raw unfiltered rollout batch.
+
+## Plotting After The Run
+
+The plotting entry point is:
+- [plot_gradient_analysis.py](../gradient_analysis/plot_gradient_analysis.py)
+
+### List Available Analysis Steps
+
+Before plotting, you can ask the script which steps in the run actually contain bucket metrics:
+
+```bash
+python gradient_analysis/plot_gradient_analysis.py \
+  --wandb-path deimos-xing/ragen_gradient_analysis/<run_id> \
+  --list-steps
+```
+
+### Plot All Available Analysis Steps
+
+```bash
+python gradient_analysis/plot_gradient_analysis.py \
+  --wandb-path deimos-xing/ragen_gradient_analysis/<run_id>
+```
+
+### Plot A Specific Step
+
+```bash
+python gradient_analysis/plot_gradient_analysis.py \
+  --wandb-path deimos-xing/ragen_gradient_analysis/<run_id> \
+  --step 1
+```
+
+You can also request multiple steps:
+
+```bash
+python gradient_analysis/plot_gradient_analysis.py \
+  --wandb-path deimos-xing/ragen_gradient_analysis/<run_id> \
+  --step 1 11 21
+```
+
+### Choose An Output Directory
+
+```bash
+python gradient_analysis/plot_gradient_analysis.py \
+  --wandb-path deimos-xing/ragen_gradient_analysis/<run_id> \
+  --step 1 \
+  --output-dir gradient_analysis_outputs/my_run_step1
+```
+
+### Files The Plot Script Produces
+
+For each selected step, it writes:
+
+- `gradient_analysis_summary_step_<N>.png`
+- `gradient_analysis_plots_step_<N>.png`
+- `gradient_analysis_loss_plots_step_<N>.png`
+- `gradient_analysis_reward_std_step_<N>.png`
+- `gradient_analysis_normed_grads_step_<N>.png`
+- `gradient_analysis_metrics_step_<N>.json`
+- `gradient_analysis_bucket_rv_table_step_<N>.csv`
+
+Recommended reading order:
+
+1. `gradient_analysis_summary_step_<N>.png`
+2. `gradient_analysis_plots_step_<N>.png`
+3. `gradient_analysis_metrics_step_<N>.json`
+
+### Paper-Style Multi-Step Figure
+
+If you already exported per-step `metrics.json` files and want the fixed 3-step comparison figure, use:
+
+```bash
+python gradient_analysis/plot_icml_steps.py \
+  --mode ppo \
+  --step0-dir /path/to/step0 \
+  --step20-dir /path/to/step20 \
+  --step40-dir /path/to/step40 \
+  --out gradient_analysis_outputs/ppo_step0_20_40.png
+```
+
+The plotting-only README is here:
+- [gradient_analysis/README.md](../gradient_analysis/README.md)

docs/guide_rollout_filtering.md

@@ -0,0 +1,130 @@
+# Rollout Filtering Guide
+
+## What is Rollout Filtering?
+
+In RAGEN, each training step generates multiple rollouts per prompt (a **group**). The within-group **reward variance (RV)** measures how much the model's responses differ in quality for that prompt:
+
+- **High RV** — the model sometimes succeeds and sometimes fails → strong learning signal
+- **Low RV** — all responses receive similar rewards → noisy gradient (low SNR)
+
+**SNR-Adaptive Filtering** discards low-variance groups before the policy gradient update, keeping only prompts that provide meaningful signal. This reduces gradient noise and mitigates reasoning collapse during training.
+
+<p align="center"><img src="../public/top_p.png" width="800px" alt="SNR-Adaptive Filtering (Top-p) pipeline" /></p>
+<p align="center"><em>Top-p filtering pipeline: (1) sample rollouts and compute rewards, (2) compute within-prompt reward variance, (3) rank by RV and apply Top-p threshold — low-variance prompts are discarded.</em></p>
+
+All config keys live under `actor_rollout_ref.rollout` in [config/base.yaml](../config/base.yaml).
+
+## Quick Recommendation
+
+| Goal | Config |
+|---|---|
+| No filtering (default) | `rollout_filter_value=1.0`, `rollout_filter_include_zero=True` |
+| **Top-p Linear (recommended)** | `rollout_filter_value=0.9`, `rollout_filter_top_p_prob_mode=linear`, `rollout_filter_include_zero=False`, `rollout_filter_selection_eps=0.01` |
+| Top-p Softmax | `rollout_filter_value=0.9`, `rollout_filter_top_p_prob_mode=softmax`, `rollout_filter_include_zero=False` |
+| Top-k Fractional | `rollout_filter_strategy=top_k`, `rollout_filter_value=0.25`, `rollout_filter_type=largest`, `rollout_filter_include_zero=True` |
+
+## Config Parameters
+
+| Parameter | Description |
+|---|---|
+| `rollout_filter_strategy` | Selection strategy: `top_p`, `top_k`, `top_k_abs`, `min_p` |
+| `rollout_filter_value` | Threshold value — meaning depends on strategy (see below) |
+| `rollout_filter_type` | `largest` (keep high-RV groups) or `smallest` (keep low-RV groups) |
+| `rollout_filter_include_zero` | Whether to keep groups with zero reward variance |
+| `rollout_filter_top_p_prob_mode` | Top-p score aggregation: `linear` (score-sum rule) or `softmax` (probability mass) |
+| `rollout_filter_selection_eps` | Epsilon for the linear top-p threshold (default `0.01`) |
+| `rollout_filter_metric` | What to compute per group: `reward_variance` (default), `reward`, `reward_sum`, `entropy`, `entropy_variance`, `length` |
+| `rollout_filter_empty_stop_steps` | Early-stop after this many consecutive steps with 0 kept samples (default `5`) |
+
+## Filtering Strategies
+
+### 1. No Filter
+
+Keep all groups. Use this as a baseline.
+
+```yaml
+actor_rollout_ref:
+  rollout:
+    rollout_filter_strategy: top_p
+    rollout_filter_value: 1.0
+    rollout_filter_include_zero: True
+```
+
+With `value=1.0` and `include_zero=True`, the filter is effectively disabled — all groups pass through.
+
+### 2. Top-p Linear (Recommended)
+
+Keep the highest-RV groups whose cumulative score reaches a fraction of the total score.
+
+```yaml
+actor_rollout_ref:
+  rollout:
+    rollout_filter_strategy: top_p
+    rollout_filter_value: 0.9
+    rollout_filter_top_p_prob_mode: linear
+    rollout_filter_include_zero: False
+    rollout_filter_selection_eps: 0.01
+```
+
+How it works:
+1. Remove zero-RV groups (`include_zero=False`)
+2. Sort remaining groups by score (descending)
+3. Compute threshold: `top_p * sum(scores) - eps`
+4. Accumulate scores from the top until the threshold is reached
+5. If the threshold cannot be reached, the step is skipped (`empty_after_filter`)
+
+Tuning:
+- `value=0.9`: recommended default
+- Lower `value` → more aggressive filtering (fewer groups kept)
+- `eps=0.01`: recommended default; larger eps rejects near-zero-RV batches more easily
+
+### 3. Top-p Softmax
+
+Nucleus-style selection based on softmax probability mass over group scores.
+
+```yaml
+actor_rollout_ref:
+  rollout:
+    rollout_filter_strategy: top_p
+    rollout_filter_value: 0.9
+    rollout_filter_top_p_prob_mode: softmax
+    rollout_filter_include_zero: False
+```
+
+How it works:
+1. Remove zero-RV groups (`include_zero=False`)
+2. Convert scores to probabilities: `probs = softmax(scores)`
+3. Sort by probability (descending) and accumulate until cumulative mass reaches `top_p`
+
+Tuning:
+- `value=0.9`: recommended default
+- `0.95–0.98`: mild filtering
+- `0.6–0.8`: aggressive filtering
+
+### 4. Top-k Fractional
+
+Keep a fixed fraction of groups ranked by score.
+
+```yaml
+actor_rollout_ref:
+  rollout:
+    rollout_filter_strategy: top_k
+    rollout_filter_value: 0.25
+    rollout_filter_type: largest
+    rollout_filter_include_zero: True
+```
+
+How it works:
+1. Compute `k = int(value * num_groups)` (at least 1)
+2. Keep the top-k groups by score
+3. With `include_zero=True`, zero-RV groups remain as candidates
+
+`value=0.25` means "keep about 25% of groups". Example: with 8 groups, keeps `int(0.25 * 8) = 2` groups.
+
+For a fixed absolute count instead of a fraction, use `strategy=top_k_abs`.
+
+## Code References
+
+- Filter logic: [ragen/trainer/rollout_filter.py](../ragen/trainer/rollout_filter.py)
+- Trainer integration: [ragen/trainer/agent_trainer.py](../ragen/trainer/agent_trainer.py)
+- Experiment scripts: [scripts/runs/run_filtering_final.sh](../scripts/runs/run_filtering_final.sh)

docs/readme_v1.md

@@ -0,0 +1,397 @@
+<h1 align="center"> RAGEN: Training Agents by Reinforcing Reasoning </h1>
+
+
+<p align="center"><img src="public/ragen_logo.jpeg" width="300px" alt="RAGEN icon" /></p>
+
+
+
+<p align="center" style="font-size: 18px;">
+  <strong>RAGEN</strong> (<b>R</b>easoning <b>AGEN</b>t, pronounced like "region") leverages reinforcement learning (RL) to train <br>
+  <strong>LLM reasoning agents</strong> in interactive, stochastic environments.<br>
+  <em>We strongly believe in the future of RL + LLM + Agents. The release is a minimally viable leap forward.</em>
+</p>
+
+
+<p align="center">
+  <a href="https://ragen-ai.github.io/"><img src="https://img.shields.io/badge/📝_HomePage-FF5722?style=for-the-badge&logoColor=white" alt="Blog"></a>
+  <a href="https://arxiv.org/abs/2504.20073"><img src="https://img.shields.io/badge/📄_Paper-EA4335?style=for-the-badge&logoColor=white" alt="Paper"></a>
+  <a href="https://ragen-doc.readthedocs.io/"><img src="https://img.shields.io/badge/📚_Documentation-4285F4?style=for-the-badge&logoColor=white" alt="Documentation"></a>
+  <a href="https://x.com/wzihanw/status/1915052871474712858"><img src="https://img.shields.io/badge/🔍_Post-34A853?style=for-the-badge&logoColor=white" alt="Post"></a>
+  <a href="https://api.wandb.ai/links/zihanwang-ai-northwestern-university/a8er8l7b"><img src="https://img.shields.io/badge/🧪_Experiment_Log-AB47BC?style=for-the-badge&logoColor=white" alt="Experiment Log"></a>
+
+</p>
+
+**2025.5.8 Update:**
+We now release the official [Documentation](https://ragen-doc.readthedocs.io/) for RAGEN. The documentation will be continuously updated and improved to provide a comprehensive and up-to-date guidance.
+
+**2025.5.2 Update:**
+We now release a [tracking document](https://docs.google.com/document/d/1bg7obeiKTExuHHBl5uOiSpec5uLDZ2Tgvxy6li5pHX4/edit?usp=sharing) to log minor updates in the RAGEN codebase. 
+
+
+**2025.4.20 Update:**
+
+Our RAGEN [paper](https://arxiv.org/abs/2504.20073) is out!
+
+We've further streamlined the RAGEN codebase (v0423) to improve development.
+1. Architecture: Restructured veRL as a submodule for better co-development
+2. Modularity: Divided RAGEN into three components—Environment Manager, Context Manager, and Agent Proxy, making it significantly simpler to add new environments (details below), track environmental dynamics, and run multiple experiments
+
+
+**2025.4.16 Update:**
+
+We recently noticed that a [third-party website](https://ragen-ai.com) has been created using our project's name and content. While we appreciate the interest in the project, we'd like to clarify that this GitHub repository is the official and primary source for all code, updates, and documentation.
+If we launch an official website in the future, it will be explicitly linked here.
+
+Thank you for your support and understanding!
+
+
+**2025.3.13 Update:**
+
+
+We are recently refactoring RAGEN code to help you better develop your own idea on the codebase. Please checkout our [developing branch](https://github.com/ZihanWang314/RAGEN/tree/main-new). The first version decomposes RAGEN and veRL for better co-development, taking the latter as a submodule rather than a static directory.
+
+**2025.3.8 Update:**
+
+1. In previous veRL implementation, there is a [KL term issue](https://github.com/volcengine/verl/pull/179/files), which has been fixed in recent versions.
+2. We find evidence from multiple sources that PPO could be more stable than GRPO training in [Open-Reasoner-Zero](https://x.com/rosstaylor90/status/1892664646890312125), [TinyZero](https://github.com/Jiayi-Pan/TinyZero), and [Zhihu](https://www.zhihu.com/search?type=content&q=%E6%97%A0%E5%81%8FGRPO). We have changed the default advantage estimator to GAE (using PPO) and aim to find more stable while efficient RL optimization methods in later versions.
+
+**2025.1.27:**
+
+We are thrilled to release RAGEN! Check out our post [here](https://x.com/wzihanw/status/1884092805598826609).
+
+
+## Overview
+
+<!--
+Reinforcement Learning (RL) with rule-based rewards has shown promise in enhancing reasoning capabilities of large language models (LLMs). However, existing approaches have primarily focused on static, single-turn tasks like math reasoning and coding. Extending these methods to agent scenarios introduces two fundamental challenges:
+
+1. **Multi-turn Interactions**: Agents must perform sequential decision-making and react to environment feedback
+2. **Stochastic Environments**: Uncertainty where identical actions can lead to different outcomes
+
+RAGEN addresses these challenges through:
+- A Markov Decision Process (MDP) formulation for agent tasks
+- State-Thinking-Actions-Reward Policy Optimization (StarPO) algorithm that optimizes entire trajectory distributions
+- Progressive reward normalization strategies to handle diverse, complex environments
+-->
+
+Reinforcement Learning (RL) with rule-based rewards has shown promise in enhancing reasoning capabilities of large language models (LLMs). However, existing approaches have primarily focused on static, single-turn tasks like math reasoning and coding. Extending these methods to agent scenarios introduces two fundamental challenges:
+
+1. **Multi-turn Interactions**: Agents must perform sequential decision-making and react to environment feedback
+2. **Stochastic Environments**: Uncertainty where identical actions can lead to different outcomes
+
+To address these challenges, we propose a general RL framework: **StarPO** (**S**tate-**T**hinking-**A**ctions-**R**eward **P**olicy **O**ptimization), a comprehensive RL framework that provides a unified approach for training multi-turn, trajectory-level agents with flexible control over reasoning processes, reward assignment mechanisms, and prompt-rollout structures. 
+Building upon StarPO, we introduce **RAGEN**, a modular agent training and evaluation system that implements the complete training loop, including rollout generation, reward calculation, and trajectory optimization. RAGEN serves as a robust research infrastructure for systematically analyzing LLM agent training dynamics in multi-turn and stochastic environments.
+
+## Algorithm
+
+RAGEN introduces a reinforcement learning framework to train reasoning-capable LLM agents that can operate in interactive, stochastic environments. 
+
+<p align="center"><img src="public/starpo_logo.png" width="800px" alt="StarPO Framework" /></p>
+<p align="center" style="font-size: 16px; max-width: 800px; margin: 0 auto;">
+The StarPO (State-Thinking-Action-Reward Policy Optimization) framework with two interleaved stages: <b>rollout stage</b> and <b>update stage</b>. LLM iteratively generates reasoning-guided actions to interact with the environment to obtain trajectory-level rewards for LLM update to jointly   optimize reasoning and action strategies.
+</p>
+
+The framework consists of two key components:
+
+### > MDP Formulation 
+We formulate agent-environment interactions as Markov Decision Processes (MDPs) where states and actions are token sequences, allowing LLMs to reason over environment dynamics. At time t, state $s_t$ transitions to the next state through action $a_t$ following a transition function. The policy generates actions given the trajectory history. The objective is to maximize expected cumulative rewards across multiple interaction turns.
+
+### > StarPO: Reinforcing Reasoning via Trajectory-Level Optimization
+StarPO is a general RL framework for optimizing entire multi-turn interaction trajectories for LLM agents.
+The algorithm alternates between two phases:
+
+#### Rollout Stage: Reasoning-Interaction Trajectories
+Given an initial state, the LLM generates multiple trajectories. At each step, the model receives the trajectory history and generates a reasoning-guided action: `<think>...</think><ans> action </ans>`. The environment receives the action and returns feedback (reward and next state).
+
+#### Update Stage: Multi-turn Trajectory Optimization 
+After generating trajectories, we train LLMs to optimize expected rewards. Instead of step-by-step optimization, StarPO optimizes entire trajectories using importance sampling. This approach enables long-horizon reasoning while maintaining computational efficiency. 
+StarPO supports multiple optimization strategies: 
+- PPO: We estimate token-level advantages using a value function over trajectories
+- GRPO: We assign normalized reward to the full trajectory
+
+Rollout and update stages interleave in StarPO, enabling both online and offline learning.
+
+<!--
+### > Reward Normalization Strategies 
+We implement three progressive normalization strategies to stabilize training: 
+1. **ARPO**: Preserves raw rewards directly 
+2. **BRPO**: Normalizes rewards across each training batch using batch statistics
+3. **GRPO**: Normalizes within prompt groups to balance learning across varying task difficulties
+-->
+
+## Environment Setup
+For detailed setup instructions, please check our [documentation](https://ragen-doc.readthedocs.io/). Here's a quick start guide:
+
+```bash
+# Setup environment for RAGEN
+bash scripts/setup_ragen.sh
+```
+
+If this fails, you can follow the manual setup instructions in `scripts/setup_ragen.md`.
+
+### Optional Dependencies
+
+RAGEN supports optional environment-specific dependencies. You can install only the components you need:
+
+```bash
+pip install -e . # Base installation (core functionality only)
+pip install -e ".[webshop]" # Include WebShop environment dependencies
+pip install -e ".[lean]" # Include Lean environment dependencies
+pip install -e ".[all]" # Install all optional dependencies
+pip install -e ".[webshop,lean]" # Or combine multiple extras
+```
+
+## Training Models
+Here's how to train models with RAGEN:
+
+### Export variables and train
+We provide default configuration in `config/base.yaml`. This file includes symbolic links to:
+- `config/ppo_trainer.yaml` 
+- `config/envs.yaml`
+
+The base configuration automatically inherits all contents from these two config files, creating a unified configuration system.
+
+To train:
+
+```bash
+python train.py --config-name base
+```
+
+
+### Parameter efficient training with LoRA
+
+### Saving compute
+By default our code is runnable on A100 80GB machines. If you are using machine with lower memory (e.g. RTX 4090), please consider adapting below parameters, like follows (performance might change due to smaller batch size and shorter context length):
+```bash
+python train.py \
+  micro_batch_size_per_gpu=1 \ 
+  ppo_mini_batch_size=8 \ 
+  actor_rollout_ref.rollout.max_model_len=2048 \ 
+  actor_rollout_ref.rollout.response_length=128 
+```
+
+#### Parameter efficient training with LoRA
+We provide a default configuration with LoRA enabled in `config/base-lora.yaml`. To customize the LoRA settings, see the the `lora` section at the top of the configuration file. The current settings are:
+
+```yaml
+lora rank: 64
+lora alpha: 64
+actor learning rate: 1e-5
+critic learning rate: 1e-4
+```
+
+<!--
+## Supervised Finetuning (Optional)
+For supervised finetuning with LoRA:
+
+1. Create supervised finetuning data:
+```bash
+bash sft/generate_data.sh <env_type>
+```
+
+2. Finetune the model:
+```bash
+bash sft/finetune_lora.sh <env_type> <num_gpus> <save_path>
+```
+
+3. Merge LoRA weights with the base model:
+```bash
+python sft/utils/merge_lora.py \
+    --base_model_name <base_model_name> \
+    --lora_model_path <lora_model_path> \
+    --output_path <output_path>
+```
+-->
+
+## Visualization
+Please check the `val/generations` metric in your wandb dashboard to see the trajectories generated by the model throughout training. Check this [relevant issue](https://github.com/RAGEN-AI/RAGEN/issues/84) for more information. 
+
+
+## Performance
+
+We evaluate RAGEN across multiple environments. Below are results Qwen-2.5-0.5B-Instruct on Sokoban, Frozenlake, Bandit, and Spatial. 
+- No KL loss or KL penalty was applied during training
+- We selectively retained only the top 25% of trajectories that successfully completed their respective tasks
+
+<p align="center" style="display: flex; justify-content: center; align-items: center; flex-direction: column; gap: 20px; max-width: 500px; margin: 0 auto;">
+    <img src="public/exp1.png" width="250px" alt="Bandit" />
+    <img src="public/exp2.png" width="250px"  alt="Simple Sokoban" />
+    <img src="public/exp3.png" width="250px"  alt="Frozen lake" />
+</p>
+
+We demonstrate RAGEN's robust generalization ability by training on simple Sokoban environments (6×6 with 1 box) and successfully evaluating performance on:
+- Larger Sokoban environments (8×8 with 2 boxes)
+- Simple Sokoban with alternative grid vocabulary representations
+- FrozenLake environments
+
+<p align="center" style="display: flex; justify-content: center; align-items: center; flex-direction: column; gap: 20px; max-width: 500px; margin: 0 auto;">
+    <img src="public/exp4.png" width="250px" alt="Larger Sokoban" />
+    <img src="public/exp5.png" width="250px"  alt="Sokoban with Different Grid Vocabulary" />
+    <img src="public/exp6.png" width="250px"  alt="Frozen lake" />
+</p>
+
+Key observations:
+- By using no KL and filtering out failed trajectories, we can achieve better and stable performance
+- Generalization results highlight RAGEN's capacity to transfer learned policies across varying environment complexities, representations, and domains.
+
+## Evaluation
+RAGEN provides a easy way to evaluate a model:
+```bash
+python -m ragen.llm_agent.agent_proxy --config-name <eval_config>
+```
+The proxy now loads `config/eval.yaml` by default, which only keeps the rollout-specific knobs required for evaluation. You can still point to any other file via `--config-name`. Each evaluation config supports an `output` block so you can control where rollouts are stored and which fields are persisted:
+
+```yaml
+output:
+  dir: results/eval
+  filename: val_rollouts.pkl
+  append_timestamp: true   # include run timestamp in the file name
+  keep_batch_keys: ["rm_scores", "responses"]   # set to null to keep everything
+  keep_non_tensor_keys: null
+  keep_meta_info: true
+```
+
+With this configuration the proxy filters the `DataProto` before saving (handy if you want to drop large tensors such as log-probs) and places the artifact directly under `results/eval`.  
+You only need to set model and environment to evaluate in `config/<eval_config>.yaml`.  
+To limit how many previous turns the model sees during evaluation, you can set `agent_proxy.max_context_window` in your config file.
+
+
+<!--
+## Example Trajectories
+
+Visualization of agent reasoning on the Sokoban task:
+
+<p align="center" style="display: flex; justify-content: center; gap: 10px;">
+    <img src="./public/step_1.png" width="200px" alt="Step 1" />
+    <img src="./public/step_2.png" width="200px" alt="Step 2" />
+</p>
+
+The visualizations show how the agent reasons through sequential steps to solve the puzzle.
+
+## Case Studies
+We provide several case studies showing the model's behavior:
+- [Reward hacking](https://github.com/ZihanWang314/agent-r1/blob/main/cases/reward_hacking.txt)
+- [Challenging moments](https://github.com/ZihanWang314/agent-r1/blob/main/cases/suck_moment.txt)
+
+More case studies will be added to showcase both successful reasoning patterns and failure modes.
+-->
+
+## Modular System Design of RAGEN
+
+We implement RAGEN as a modular system: there are three main modules: **Environment State Manager** (`ragen/llm_agent/es_manager.py`), **Context Manager** (`ragen/llm_agent/ctx_manager.py`), and **Agent Proxy** (`ragen/llm_agent/agent_proxy.py`).
+
+- Environment State Manager (**es_manager**):
+  - Supports multiple environments (different environments, same environment different seeds, same environment same seed)
+  - Training seeds are controlled via `seed.train` in the config. The manager increments this seed each reset so runs are deterministic.
+  - Records states of each environment during rollout
+  - Processes actions from **ctx_manager**, executes step, and returns action results (observations) to **ctx_manager** in a batch-wise manner
+- Context Manager (**ctx_manager**):
+  - Parses raw agent tokens into structured actions for the **es_manager**
+  - Formats observation from **es_manager**, parses and formulates them for following rollout of agent.
+  - Supports a `max_context_window` hyperparameter, which limits how many previous turns of interaction history are retained in the model’s input. 
+  - Gathers final rollout trajectories and compiles them into tokens, attention masks, reward scores, and loss masks for llm updating.
+- Agent Proxy (**agent_proxy**): Serves as the interface for executing single or multi-round rollouts
+
+## Adding Custom Environments
+
+To add a new environment to our framework:
+
+1. Implement an OpenAI Gym-compatible environment in `ragen/env/new_env/env.py` with these required methods:
+   - `step(action)`: Process actions and return next state
+   - `reset(seed)`: Initialize environment with new seed
+   - `render()`: Return current state observation
+   - `close()`: Clean up resources
+
+2. Define environment configuration in `ragen/env/new_env/config.py`
+
+3. Register your environment in `config/envs.yaml`:
+   ```yaml
+   custom_envs:
+     - NewEnvironment # Tag
+       - env_type: new_env  # Must match environment class name
+       - max_actions_per_traj: 50  # Example value
+       - env_instruction: "Your environment instructions here"
+       - parallel_friendly: false # Set to true if your environment supports parallel execution.
+       - max_workers: 128 # If parallel_friendly=True, max_workers threads will be used.
+       - env_config: {}  # Configuration options from config.py
+   ```
+   (Hint: Due to the extra time cost associated with using a thread pool, there is a trade-off between the pool's overhead and the speed of the environment itself. It is recommended to enable the parallelism only for complex environments. Meanwhile, running the RNG-dependent environments inside shared thread pools means multiple workers touch Python’s global random state concurrently, so even with the same seed, interleaving differs per run when setting `parallel_friendly=True`.)
+
+4. Add the environment tag to the `es_manager` section in `config/base.yaml`
+
+## Using RAGEN with dstack
+
+[dstackai/dstack](https://github.com/dstackai/dstack) is an open-source container orchestrator that simplifies distributed training across cloud providers and on-premises environments
+without the need to use K8S or Slurm.
+
+### 1. Create fleet
+
+Before submitting distributed training jobs, create a `dstack` [fleet](https://dstack.ai/docs/concepts/fleets).
+
+### 2. Run a Ray cluster task
+
+Once the fleet is created, define and apply a Ray cluster task:
+
+```shell
+$ dstack apply -f examples/distributed-training/ray-ragen/.dstack.yml
+```
+
+You can find the task configuration example at [`examples/distributed-training/ray-ragen/.dstack.yml`](https://github.com/dstackai/dstack/blob/master/examples/distributed-training/ray-ragen/.dstack.yml).
+
+The `dstack apply` command will provision the Ray cluster with all dependencies and forward the Ray dashboard port to `localhost:8265`.
+
+
+### 3. Submit a training job
+
+Now you can submit a training job locally to the Ray cluster:
+
+```shell
+$ RAY_ADDRESS=http://localhost:8265
+$ ray job submit \
+    ...
+```
+
+See the full [RAGEN+Ray example](https://dstack.ai/examples/distributed-training/ray-ragen/).
+
+For more details on how `dstack` can be used for distributed training, check out the [Clusters](https://dstack.ai/docs/guides/clusters/) guide.
+
+## Feedback
+We welcome all forms of feedback! Please raise an issue for bugs, questions, or suggestions. This helps our team address common problems efficiently and builds a more productive community.
+
+## Awesome work powered or inspired by RAGEN
+ - [ROLL](https://github.com/alibaba/ROLL): An Efficient and User-Friendly Scaling Library for Reinforcement Learning with Large Language Models
+ - [VAGEN](https://github.com/RAGEN-AI/VAGEN): Training Visual Agents with multi-turn reinforcement learning
+ - [Search-R1](https://github.com/PeterGriffinJin/Search-R1): Train your LLMs to reason and call a search engine with reinforcement learning
+ - [ZeroSearch](https://github.com/Alibaba-nlp/ZeroSearch): Incentivize the Search Capability of LLMs without Searching
+ - [Agent-R1](https://github.com/0russwest0/Agent-R1): Training Powerful LLM Agents with End-to-End Reinforcement Learning
+ - [OpenManus-RL](https://github.com/OpenManus/OpenManus-RL): A live stream development of RL tunning for LLM agents
+ - [MetaSpatial](https://github.com/PzySeere/MetaSpatial): Reinforcing 3D Spatial Reasoning in VLMs for the Metaverse
+ - [s3](https://github.com/pat-jj/s3): Efficient Yet Effective Search Agent Training via Reinforcement Learning
+
+
+## Contributors
+
+[**Zihan Wang**\*](https://zihanwang314.github.io/), [**Kangrui Wang**\*](https://jameskrw.github.io/), [**Qineng Wang**\*](https://qinengwang-aiden.github.io/), [**Pingyue Zhang**\*](https://williamzhangsjtu.github.io/), [**Linjie Li**\*](https://scholar.google.com/citations?user=WR875gYAAAAJ&hl=en), [**Zhengyuan Yang**](https://zyang-ur.github.io/), [**Xing Jin**](https://openreview.net/profile?id=~Xing_Jin3), [**Kefan Yu**](https://www.linkedin.com/in/kefan-yu-22723a25b/en/), [**Minh Nhat Nguyen**](https://www.linkedin.com/in/menhguin/?originalSubdomain=sg), [**Licheng Liu**](https://x.com/liulicheng10), [**Eli Gottlieb**](https://www.linkedin.com/in/eli-gottlieb1/), [**Yiping Lu**](https://2prime.github.io), [**Kyunghyun Cho**](https://kyunghyuncho.me/), [**Jiajun Wu**](https://jiajunwu.com/), [**Li Fei-Fei**](https://profiles.stanford.edu/fei-fei-li), [**Lijuan Wang**](https://www.microsoft.com/en-us/research/people/lijuanw/), [**Yejin Choi**](https://homes.cs.washington.edu/~yejin/), [**Manling Li**](https://limanling.github.io/)
+
+*:Equal Contribution.
+
+## Acknowledgements
+We thank the [DeepSeek](https://github.com/deepseek-ai/DeepSeek-R1) team for providing the DeepSeek-R1 model and early conceptual inspirations. We are grateful to the [veRL](https://github.com/volcengine/verl) team for their infrastructure support. We thank the [TinyZero](https://github.com/Jiayi-Pan/TinyZero) team for their discoveries that informed our initial exploration. We would like to appreciate insightful discussions with Han Liu, Xinyu Xing, Li Erran Li, John Schulman, Akari Asai, Eiso Kant, Lu Lu, Runxin Xu, Huajian Xin, Zijun Liu, Weiyi Liu, Weimin Wu, Yibo Wen, Jiarui Liu, Lorenzo Xiao, Ishan Mukherjee, Anabella Isaro, Haosen Sun, How-Yeh Wan, Lester Xue, Matthew Khoriaty, Haoxiang Sun, Jiajun Liu.
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=ragen-ai/ragen&type=Date)](https://www.star-history.com/#ragen-ai/ragen&Date)
+
+## Citation
+If you find RAGEN useful, we would appreciate it if you consider citing our work:
+```md
+@misc{ragen,
+      title={RAGEN: Understanding Self-Evolution in LLM Agents via Multi-Turn Reinforcement Learning}, 
+      author={Zihan Wang and Kangrui Wang and Qineng Wang and Pingyue Zhang and Linjie Li and Zhengyuan Yang and Xing Jin and Kefan Yu and Minh Nhat Nguyen and Licheng Liu and Eli Gottlieb and Yiping Lu and Kyunghyun Cho and Jiajun Wu and Li Fei-Fei and Lijuan Wang and Yejin Choi and Manling Li},
+      year={2025},
+      eprint={2504.20073},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2504.20073}, 
+}
+```

docs/reference_mutual_information_metrics.md

@@ -0,0 +1,490 @@
+# Mutual Information Metrics for Collapse Detection
+
+This document provides a comprehensive explanation of the mutual information (MI) based metrics used in RAGEN for detecting training collapse phenomena.
+
+## 1. Overview: Two Core Metrics
+
+We focus on two diagnostic quantities:
+
+| Quantity | Meaning | Diagnostic Metric |
+|--------------|------------|-------------------|
+| **Within-input variability** | How much reasoning varies under the same input | $H(Z \mid X)$ |
+| **Across-input dependence** | How much reasoning still depends on the input | $I(X; Z)$ |
+
+**Key Insight**: We compute MI under the batch's empirical input distribution (uniform over prompts), not the true $p(x)$. This is exactly what's needed for diagnosing whether reasoning remains input-dependent inside a training batch.
+
+---
+
+## 2. Design Decision: Partitioning $X$ and $Z$
+
+The choice of how to partition the sequence into conditioning context $X$ and reasoning $Z$ is crucial for meaningful collapse detection. The partition answers: **"Which segment of generation depends on which segment of input context?"**
+
+### 2.1 Design Goal
+
+We want to measure whether the reasoning content becomes increasingly input-independent (i.e., ignoring the environment state and producing generic outputs), while also tracking how much variability remains under the same input.
+
+### 2.2 Recommended Partition
+
+For a typical agent turn with structure:
+```
+[System Prompt] [User: State] [Assistant:] <think> reasoning content </think> <answer> action </answer>
+```
+
+We define:
+
+| Variable | Content | Rationale |
+|----------|---------|-----------|
+| **$X$** | System prompt + User turn (state) + Assistant prefix + `<think>` tag | Everything the model sees *before* generating reasoning content |
+| **$Z$** | Reasoning content tokens (between `<think>` and `</think>`, **excluding both tags**) | The actual reasoning we want to measure dependency for |
+
+### 2.3 Why Include `<think>` in $X$?
+
+The `<think>` tag should be part of $X$ (conditioning context), not $Z$ (reasoning):
+
+1. **Semantic role**: `<think>` is a control token meaning "start generating reasoning" — it's a boundary marker, not reasoning content itself.
+
+2. **Near-constant token**: `<think>` appears identically in every sample, so including it in $Z$ would:
+   - Add no discriminative information between prompts
+   - Dilute entropy/MI statistics with high-probability constant tokens
+
+3. **Clean separation**: With `<think>` in $X$, the partition becomes: "everything before reasoning starts" vs "reasoning content itself"
+
+### 2.4 Why Exclude `</think>` from $Z$?
+
+The `</think>` closing tag should also be excluded from $Z$:
+
+1. **Structural boundary**: Like `<think>`, it's a format token, not reasoning content.
+
+2. **Format stability signal**: If `</think>` is included in $Z$, MI/entropy metrics would conflate:
+   - Reasoning content dependency (what we want)
+   - Format stability (whether the model reliably closes tags)
+
+3. **Cleaner interpretation**: Excluding both tags means $Z$ purely measures "does the reasoning *content* depend on the input state?"
+
+### 2.5 Implementation Mapping
+
+In the codebase, this corresponds to:
+
+| Field | Content |
+|-------|---------|
+| `first_turn_prompt_ids` | Tokens up to and including `<think>` |
+| `first_turn_reasoning_ids` | Reasoning content tokens only (no `<think>`, no `</think>`) |
+
+---
+
+## 3. Notation and Definitions
+
+### 3.1 Random Variables
+
+| Symbol | Description |
+|--------|-------------|
+| $X$ | Input context: system prompt + user turn + assistant prefix + `<think>` |
+| $Z$ | Reasoning content tokens (between `<think>` and `</think>`, excluding tags) |
+| $x_j$ | The $j$-th unique prompt in the batch, $j \in \{1, \ldots, N\}$ |
+| $z_{i,k}$ | The $k$-th reasoning sample for trajectory $i$ |
+| $N$ | Number of unique prompts in the batch |
+| $K$ | Number of reasoning samples per prompt (group size) |
+
+### 3.2 Probability Distributions
+
+| Symbol | Definition | Description |
+|--------|------------|-------------|
+| $p(z \mid x)$ | $\prod_{t=1}^{T} p_\theta(z_t \mid x, z_{1:t-1})$ | Conditional probability of reasoning $z$ given prompt $x$ under policy $\pi_\theta$ |
+| $p_{\text{mix}}(z)$ | $\frac{1}{N} \sum_{j=1}^{N} p(z \mid x_j)$ | Marginal probability under uniform prompt mixture |
+| $\hat{p}(x)$ | $\frac{1}{N}$ | Empirical (uniform) distribution over batch prompts |
+
+---
+
+## 4. Core Information-Theoretic Quantities
+
+### 4.1 Conditional Entropy $H(Z \mid X)$
+
+**Definition**: The expected uncertainty in the reasoning $Z$ given the prompt $X$.
+
+$$H(Z \mid X) = -\mathbb{E}_{x \sim \hat{p}(x)} \mathbb{E}_{z \sim p(z|x)} \left[ \log p(z \mid x) \right]$$
+
+**Estimation**: Using sampled (prompt, reasoning) pairs:
+
+$$\hat{H}(Z \mid X) = -\frac{1}{NK} \sum_{i,k} \log p(z_{i,k} \mid x_i)$$
+
+**Interpretation**:
+- **High $H(Z \mid X)$**: Model generates diverse responses for each prompt (stochastic policy)
+- **Low $H(Z \mid X)$**: Model generates deterministic/repetitive responses for each prompt
+
+**Code Reference** (`collapse_metrics.py:675-700`):
+```python
+conditional_entropy = -matched.mean().item()  # H(Z|X) estimate
+```
+
+### 4.2 Marginal Entropy $H(Z)$
+
+**Definition**: The total entropy of reasoning under the marginal distribution.
+
+$$H(Z) = -\mathbb{E}_{z \sim p_{\text{mix}}(z)} \left[ \log p_{\text{mix}}(z) \right]$$
+
+**Estimation**: Using the mixture distribution:
+
+$$\hat{H}(Z) = -\frac{1}{NK} \sum_{i,k} \log p_{\text{mix}}(z_{i,k})$$
+
+where:
+
+$$p_{\text{mix}}(z) = \frac{1}{N} \sum_{j=1}^{N} p(z \mid x_j)$$
+
+**Code Reference** (`collapse_metrics.py:675-700`):
+```python
+reasoning_entropy = -marginal.mean().item()  # H(Z) estimate
+```
+
+### 4.3 Mutual Information $I(X; Z)$
+
+**Definition**: The amount of information that the reasoning $Z$ contains about the prompt $X$.
+
+$$I(X; Z) = H(Z) - H(Z \mid X)$$
+
+Equivalently:
+
+$$I(X; Z) = \mathbb{E}_{x, z} \left[ \log \frac{p(z \mid x)}{p_{\text{mix}}(z)} \right]$$
+
+**Estimation**:
+
+$$\hat{I}(X; Z) = \frac{1}{NK} \sum_{i,k} \left[ \log p(z_{i,k} \mid x_i) - \log p_{\text{mix}}(z_{i,k}) \right]$$
+
+**Interpretation**:
+- **High $I(X; Z)$**: Reasoning is input-dependent (healthy)
+- **Low $I(X; Z)$**: Reasoning has weak input dependence
+- **Upper Bound**: $I(X; Z) \leq H(X) = \log N$ (when $X$ is uniform)
+
+**Practical Note on Negative Values**:
+- The true mutual information satisfies $I(X; Z) \geq 0$.
+- Our logged `mi_estimate` and `mi_seq_estimate` are finite-sample Monte Carlo estimates, not exact MI.
+- Because they average noisy sample terms of the form $\log p(z \mid x) - \log p_{\text{mix}}(z)$, they can temporarily dip below zero when the true MI is near zero or the sampled batch is noisy.
+- In practice, a small negative value should usually be read as "approximately zero input dependence within estimation noise," not as a violation of information theory.
+
+**Code Reference** (`collapse_metrics.py:563-590`):
+```python
+def _compute_mi_estimate(self, matched, marginal, N_prompts):
+    mi = matched.mean().item() - marginal.mean().item()
+    return {
+        "collapse/mi_estimate": mi,
+        "collapse/mi_upper_bound": math.log(N_prompts),
+    }
+```
+
+---
+
+## 5. Computation Pipeline
+
+### 5.1 Cross Log-Probability Matrix
+
+For each reasoning $z_{i,k}$ and each prompt $x_j$, we compute the cross log-probability:
+
+$$\ell_j(z_{i,k}) = \log p(z_{i,k} \mid x_j) = \sum_{t=1}^{T} \log p_\theta(z_{i,k,t} \mid x_j, z_{i,k,1:t-1})$$
+
+This forms a matrix $\mathbf{L} \in \mathbb{R}^{NK \times N}$ where:
+- Rows index (trajectory, sample) pairs
+- Columns index unique prompts
+
+**Code Reference** (`collapse_metrics.py:452-546`):
+```python
+def _compute_cross_log_probs(self, ...):
+    """
+    For each reasoning z_{i,k} and each prompt x_j:
+    1. Construct sequence [x_j | z_{i,k}]
+    2. Compute teacher-forcing log prob
+    3. Sum over reasoning tokens → ℓ_j(z_{i,k})
+    """
+    cross_log_probs = torch.zeros(NK, N, device=device)      # per-token mean
+    cross_log_probs_sum = torch.zeros(NK, N, device=device)  # per-sequence sum
+```
+
+### 5.2 Matched vs Marginal Log-Probabilities
+
+**Matched**: Log-probability of reasoning under its true prompt:
+$$\text{matched}_{i,k} = \ell_i(z_{i,k}) = \log p(z_{i,k} \mid x_i)$$
+
+**Marginal**: Log-probability under uniform prompt mixture:
+$$\text{marginal}_{i,k} = \log p_{\text{mix}}(z_{i,k}) = \log \left( \frac{1}{N} \sum_{j=1}^{N} \exp(\ell_j(z_{i,k})) \right)$$
+
+Using log-sum-exp for numerical stability:
+$$\text{marginal}_{i,k} = \text{logsumexp}_j(\ell_j(z_{i,k})) - \log N$$
+
+**Code Reference** (`collapse_metrics.py:548-561`):
+```python
+def _compute_log_prob_stats(self, cross_log_probs, col_ids):
+    NK, N = cross_log_probs.shape
+    matched = cross_log_probs[torch.arange(NK), col_ids]  # diagonal elements
+    marginal = torch.logsumexp(cross_log_probs, dim=1) - math.log(N)
+    return matched, marginal
+```
+
+---
+
+## 6. Per-Token vs Per-Sequence Metrics
+
+We compute two variants of each metric:
+
+| Variant | Normalization | Use Case |
+|---------|--------------|----------|
+| **Per-token** (`_est`) | Divide by sequence length | Length-invariant comparison |
+| **Per-sequence** (`_seq_est`) | Sum over tokens | Total information content |
+
+### 6.1 Per-Token (Length-Normalized)
+
+$$\bar{\ell}_j(z) = \frac{1}{T} \sum_{t=1}^{T} \log p(z_t \mid x_j, z_{1:t-1})$$
+
+This reduces length bias when comparing reasoning of different lengths.
+
+### 6.2 Per-Sequence (Sum)
+
+$$\ell_j(z) = \sum_{t=1}^{T} \log p(z_t \mid x_j, z_{1:t-1})$$
+
+This captures total log-probability without normalization.
+
+**Base Metric Suffixes**:
+- `collapse/mi_estimate` — Per-token MI
+- `collapse/mi_seq_estimate` — Per-sequence MI
+- `collapse/conditional_entropy_est` — Per-token $H(Z|X)$
+- `collapse/conditional_entropy_seq_est` — Per-sequence $H(Z|X)$
+- `collapse/reasoning_entropy_est` — Per-token $H(Z)$
+- `collapse/reasoning_entropy_seq_est` — Per-sequence $H(Z)$
+
+These are the raw suffixes produced inside `_compute_metrics_for_pairs`. In logged outputs, they are usually namespaced as `collapse_first_turn_sample/<suffix>` or `collapse_trajectory_sample/<suffix>`.
+
+---
+
+## 7. Additional Diagnostic Metrics
+
+### 7.1 Retrieval Accuracy
+
+**Definition**: Fraction of samples where the highest cross-log-probability matches the true prompt.
+If multiple prompts are identical (same tokenized prompt text), they are treated as equivalent columns, and any of those columns counts as correct for retrieval accuracy and chance.
+
+$$\text{Acc} = \frac{1}{NK} \sum_{i,k} \mathbf{1}\left[ \arg\max_j \ell_j(z_{i,k}) = i \right]$$
+
+**Interpretation**:
+- **High Accuracy** ($\approx 1$): Reasoning is highly prompt-specific
+- **Chance Level** ($\approx 1/N$): Reasoning is prompt-independent
+
+**Code Reference** (`collapse_metrics.py:592-673`):
+```python
+def _compute_retrieval_accuracy(self, cross_log_probs, col_ids, N_prompts):
+    predicted_cols = torch.argmax(cross_log_probs, dim=1)
+    correct = (predicted_cols == col_ids).float()
+    accuracy = correct.mean().item()
+    chance_level = 1.0 / N_prompts
+```
+
+**Base Metric Suffixes**:
+- `collapse/retrieval_accuracy` — Top-1 accuracy
+- `collapse/retrieval_accuracy@k` — Top-k accuracy (k ∈ {2, 4, 8})
+- `collapse/retrieval_chance_level` — Expected accuracy under random guessing
+- `collapse/retrieval_above_chance` — Accuracy improvement over chance
+- `collapse/retrieval_chance_level@k` — Expected top-k accuracy under random guessing
+- `collapse/retrieval_above_chance@k` — Top-k accuracy improvement over chance
+
+### 7.2 MI Z-Score
+
+**Definition**: Standardized MI using the marginal log-probability standard deviation.
+
+$$\text{MI-ZScore} = \frac{\text{matched} - \text{marginal}}{\sigma_{\text{marginal}} + \epsilon}$$
+
+where $\sigma_{\text{marginal}} = \text{std}(\text{marginal}_{i,k})$ and $\epsilon = 10^{-3}$ for stability.
+
+**Interpretation**: Measures how many standard deviations the matched log-prob is above the marginal. More robust to scale changes during training.
+
+**Practical Note on Extreme Negative Z-Scores**:
+- Negative `mi_zscore*` values are normal; they simply mean the matched log-prob is below the marginal baseline on that batch.
+- Very large-magnitude values, especially for `mi_zscore_seq`, often happen when `marginal_std` or `marginal_std_seq` becomes very small, so the normalization denominator is close to `std_eps`.
+- When this happens, interpret `mi_zscore*` together with `marginal_std*` and `mi_estimate` rather than in isolation.
+
+**Code Reference** (`collapse_metrics.py:302-320`):
+```python
+marginal_std = marginal.std(unbiased=False)
+metrics["collapse/mi_zscore"] = ((matched - marginal) / (marginal_std + self.std_eps)).mean().item()
+```
+
+### 7.3 EMA-Normalized MI Z-Score
+
+To handle variance drift during training, we track an exponential moving average of the marginal standard deviation:
+
+$$\sigma_{\text{EMA}}^{(t)} = \alpha \cdot \sigma_{\text{EMA}}^{(t-1)} + (1 - \alpha) \cdot \sigma_{\text{marginal}}^{(t)}$$
+
+where $\alpha = 0.9$ (default decay rate).
+
+**Base Metric Suffixes**:
+- `collapse/marginal_std` — Current batch marginal std
+- `collapse/marginal_std_seq` — Current batch marginal std (per-sequence)
+- `collapse/marginal_std_ema` — EMA of marginal std
+- `collapse/mi_zscore_ema` — MI Z-score normalized by EMA std
+- `collapse/marginal_std_ema_seq` — EMA of marginal std (per-sequence)
+- `collapse/mi_zscore_seq` — MI Z-score (per-sequence)
+- `collapse/mi_zscore_ema_seq` — MI Z-score normalized by EMA std (per-sequence)
+
+---
+
+## 8. Multi-Turn Sampling Strategies
+
+For multi-turn trajectories, we support two sampling strategies:
+
+### 8.1 Trajectory-Uniform Sampling
+
+**Probability**: $\Pr(m, t) = \frac{1}{M} \cdot \frac{1}{T_m}$
+
+- First sample trajectory $m$ uniformly
+- Then sample turn $t$ uniformly within trajectory
+- Each trajectory has equal weight regardless of length
+
+**Code Reference** (`collapse_metrics.py:780-813`):
+```python
+def _sample_trajectory_uniform(self, ...):
+    """Each trajectory has equal weight regardless of length."""
+    for _ in range(num_to_sample):
+        m = np.random.randint(M)  # uniform over trajectories
+        t = np.random.randint(turn_counts[m])  # uniform over turns
+```
+
+### 8.2 Turn-Uniform Sampling (Disabled by Default)
+
+**Probability**: $\Pr(m, t) = \frac{1}{\sum_m T_m}$
+
+- Uniform over all (trajectory, turn) pairs
+- Longer trajectories contribute more samples
+
+---
+
+## 9. Summary of All Logged Metrics
+
+The code logs metrics in two layers:
+
+1. **Sample-scoped diagnostic metrics**: computed on sampled $(x, z)$ pairs, then namespaced by sampling strategy.
+2. **Global coverage / timing metrics**: logged directly without an additional sample prefix.
+
+### 9.1 W&B Namespace Patterns
+
+| Logged Key Pattern | When It Appears | Meaning |
+|--------------------|-----------------|---------|
+| `collapse_first_turn_sample/<suffix>` | `first_turn_enabled=True` and first-turn data exists | Diagnostics computed on first-turn $(x, z)$ pairs |
+| `collapse_trajectory_sample/<suffix>` | `multi_turn_enabled=True` and multi-turn data exists | Diagnostics computed on trajectory-uniform multi-turn samples |
+| `collapse_turn_sample/<suffix>` | Code path exists, but currently disabled by default | Diagnostics computed on turn-uniform multi-turn samples |
+| `collapse/valid_thinking_rate` | `turn_counts_total` and `turn_counts` are available | Fraction of valid reasoning turns among all turns |
+| `collapse/first_turn_num_total` | First-turn metrics enabled and data exists | Number of first-turn candidates before filtering empty reasoning |
+| `collapse/first_turn_num_valid` | First-turn metrics enabled and data exists | Number of first-turn samples with non-empty reasoning |
+| `collapse/first_turn_valid_rate` | First-turn metrics enabled and data exists | Valid first-turn fraction |
+| `timing_s/collapse_multi_turn_step` | `multi_turn_enabled=True` | Wall-clock time for the multi-turn collapse pass |
+| `timing_s/collapse_first_turn_step` | `first_turn_enabled=True` | Wall-clock time for the first-turn collapse pass |
+
+The suffix tables below describe the metric families that can appear under `collapse_first_turn_sample/`, `collapse_trajectory_sample/`, and, if re-enabled, `collapse_turn_sample/`.
+
+### 9.2 Core Information Metrics
+
+| Suffix | Formula / Definition | Typical Reading |
+|--------|----------------------|-----------------|
+| `mi_estimate` | $\mathbb{E}[\log p(z \mid x) - \log p_{\text{mix}}(z)]$ | Higher means stronger input dependence |
+| `mi_seq_estimate` | Sequence-sum version of MI | Same as above, but not length-normalized |
+| `mi_upper_bound` | $\log N$ | Theoretical ceiling given $N$ unique prompts |
+| `conditional_entropy_est` | $-\mathbb{E}[\log p(z \mid x)]$ | Higher means more within-input variability |
+| `conditional_entropy_seq_est` | Sequence-sum version of $H(Z \mid X)$ | Total within-input uncertainty per sequence |
+| `reasoning_entropy_est` | $-\mathbb{E}[\log p_{\text{mix}}(z)]$ | Total marginal diversity across prompts |
+| `reasoning_entropy_seq_est` | Sequence-sum version of $H(Z)$ | Total marginal uncertainty per sequence |
+| `matched_log_prob_mean` | $\mathbb{E}[\log p(z \mid x)]$ | Less negative is better fit to the true prompt |
+| `marginal_log_prob_mean` | $\mathbb{E}[\log p_{\text{mix}}(z)]$ | Less negative means the response is broadly likely under the prompt mixture |
+
+Example W&B keys:
+- `collapse_first_turn_sample/mi_estimate`
+- `collapse_trajectory_sample/conditional_entropy_est`
+- `collapse_first_turn_sample/reasoning_entropy_seq_est`
+
+### 9.3 Retrieval Metrics
+
+| Suffix | Definition | Typical Reading |
+|--------|------------|-----------------|
+| `retrieval_accuracy` | Top-1 prompt retrieval accuracy from cross log-probs | Higher means reasoning is more prompt-specific |
+| `retrieval_accuracy@2`, `@4`, `@8` | Top-k retrieval accuracy | Higher means prompt identity is easier to recover |
+| `retrieval_chance_level` | Expected top-1 accuracy under random guessing | Baseline for comparison |
+| `retrieval_chance_level@2`, `@4`, `@8` | Expected top-k accuracy under random guessing | Top-k baseline |
+| `retrieval_above_chance` | `retrieval_accuracy - retrieval_chance_level` | Positive margin over chance |
+| `retrieval_above_chance@2`, `@4`, `@8` | Top-k accuracy minus top-k chance | Positive margin over chance |
+
+Example W&B keys:
+- `collapse_first_turn_sample/retrieval_accuracy`
+- `collapse_trajectory_sample/retrieval_accuracy@4`
+- `collapse_first_turn_sample/retrieval_above_chance@8`
+
+### 9.4 Variance-Normalized Metrics
+
+| Suffix | Definition | Typical Reading |
+|--------|------------|-----------------|
+| `marginal_std` | $\text{std}(\text{marginal})$ | Current-batch spread of marginal log-probs |
+| `marginal_std_seq` | Sequence-sum version of `marginal_std` | Current-batch spread on total log-prob scale |
+| `marginal_std_ema` | EMA of `marginal_std` | Smoothed normalization scale |
+| `marginal_std_ema_seq` | EMA of `marginal_std_seq` | Smoothed sequence-scale normalization |
+| `mi_zscore` | $(\text{matched} - \text{marginal}) / (\text{marginal\_std} + \epsilon)$ | Standardized MI, batch-normalized |
+| `mi_zscore_seq` | Sequence-sum version of `mi_zscore` | Standardized sequence-scale MI |
+| `mi_zscore_ema` | MI normalized by `marginal_std_ema` | More stable across training drift |
+| `mi_zscore_ema_seq` | Sequence-sum version of `mi_zscore_ema` | Stable sequence-scale normalization |
+
+### 9.5 Directly Logged Coverage and Timing Metrics
+
+| Logged Key | Meaning |
+|------------|---------|
+| `collapse/valid_thinking_rate` | Share of valid reasoning turns among all recorded turns |
+| `collapse/first_turn_num_total` | Count of first-turn entries before removing empty reasoning |
+| `collapse/first_turn_num_valid` | Count of first-turn entries with non-empty reasoning |
+| `collapse/first_turn_valid_rate` | `first_turn_num_valid / first_turn_num_total` |
+| `timing_s/collapse_multi_turn_step` | Time spent computing multi-turn collapse metrics on this step |
+| `timing_s/collapse_first_turn_step` | Time spent computing first-turn collapse metrics on this step |
+
+---
+
+## 10. Configuration Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `compute_freq` | 5 | Compute metrics every N steps |
+| `micro_batch_size` | 128 | Batch size for cross-scoring |
+| `first_turn_enabled` | True | Compute first-turn metrics |
+| `multi_turn_enabled` | True | Enable multi-turn sampling |
+| `num_samples` | 64 | Number of $(x, z)$ pairs to sample |
+| `std_eps` | 1e-3 | Stability constant for std normalization |
+| `ema_decay` | 0.9 | EMA decay for cross-time std tracking |
+
+**Configuration in `base.yaml`** (`base.yaml:135-139`):
+```yaml
+collapse_detection:
+  compute_freq: 5
+  micro_batch_size: 128
+  first_turn_enabled: true
+  multi_turn_enabled: true
+  num_samples: 64
+```
+
+---
+
+## 11. Mathematical Derivations
+
+### 11.1 MI Estimation via Importance Sampling
+
+The mutual information is:
+
+$$I(X; Z) = \mathbb{E}_{p(x,z)} \left[ \log \frac{p(z \mid x)}{p(z)} \right]$$
+
+Under the empirical distribution $\hat{p}(x) = 1/N$ (uniform over batch prompts):
+
+$$I(X; Z) = \mathbb{E}_{x \sim \hat{p}(x)} \mathbb{E}_{z \sim p(z|x)} \left[ \log \frac{p(z \mid x)}{p_{\text{mix}}(z)} \right]$$
+
+where $p_{\text{mix}}(z) = \sum_j \hat{p}(x_j) p(z \mid x_j) = \frac{1}{N} \sum_j p(z \mid x_j)$.
+
+Monte Carlo estimate with $K$ samples per prompt:
+
+$$\hat{I}(X; Z) = \frac{1}{NK} \sum_{i=1}^{N} \sum_{k=1}^{K} \left[ \log p(z_{i,k} \mid x_i) - \log p_{\text{mix}}(z_{i,k}) \right]$$
+
+### 11.2 Information-Theoretic Identity
+
+The fundamental identity relating our metrics:
+
+$$I(X; Z) = H(Z) - H(Z \mid X)$$
+
+This means:
+- If $H(Z|X)$ drops but $H(Z)$ stays constant → MI increases (good)
+- If both $H(Z)$ and $H(Z|X)$ drop equally → MI stays constant
+- If $H(Z) \to H(Z|X)$ → MI → 0 (input dependence vanishes)

gradient_analysis/README.md

@@ -0,0 +1,128 @@
+# Gradient Analysis Plotting
+
+This folder contains the plotting utilities for the gradient-analysis workflow.
+
+There are two plotting entry points:
+
+1. [plot_gradient_analysis.py](./plot_gradient_analysis.py)
+- pulls one W&B run directly
+- exports local `json` / `csv`
+- writes per-step PNG plots
+
+2. [plot_icml_steps.py](./plot_icml_steps.py)
+- builds a fixed 3-step comparison figure from already-exported `metrics.json` files
+- intended for paper-style summary figures
+
+For the training-side workflow and arguments, see:
+- [docs/guide_gradient_analysis.md](../docs/guide_gradient_analysis.md)
+
+Current default training behavior from [config/base.yaml](../config/base.yaml):
+- `trainer.gradient_analysis_mode=True`
+- `trainer.gradient_analysis_every=50`
+- `trainer.gradient_analysis_env_groups=null`
+- `trainer.gradient_analysis_group_size=null`
+- `trainer.exit_after_gradient_analysis=False`
+
+## Typical Workflow
+
+### 1. Run one analysis job
+
+Example helper runner:
+
+```bash
+bash scripts/runs/run_sokoban_ppo_filter_grad_analysis.sh \
+  --gpus 0,1,2,3,4,5,6,7
+```
+
+That job:
+- trains for `101` steps
+- validates before training and every `10` steps
+- runs gradient analysis at steps `1`, `51`, and `101`
+- uses a training batch of `8x16`
+- uses a separate gradient-analysis batch of `128x16`
+
+### 2. List available analysis steps in W&B
+
+```bash
+python gradient_analysis/plot_gradient_analysis.py \
+  --wandb-path deimos-xing/ragen_gradient_analysis/<run_id> \
+  --list-steps
+```
+
+### 3. Plot all analysis steps from that run
+
+```bash
+python gradient_analysis/plot_gradient_analysis.py \
+  --wandb-path deimos-xing/ragen_gradient_analysis/<run_id>
+```
+
+Default output directory:
+
+```text
+gradient_analysis_outputs/<run_name>_<run_id>/
+```
+
+### 4. Plot only one step
+
+```bash
+python gradient_analysis/plot_gradient_analysis.py \
+  --wandb-path deimos-xing/ragen_gradient_analysis/<run_id> \
+  --step 1
+```
+
+### 5. Choose your own output directory
+
+```bash
+python gradient_analysis/plot_gradient_analysis.py \
+  --wandb-path deimos-xing/ragen_gradient_analysis/<run_id> \
+  --step 1 \
+  --output-dir gradient_analysis_outputs/my_custom_dir
+```
+
+## Files Produced By `gradient_analysis/plot_gradient_analysis.py`
+
+For each selected step, the script writes:
+
+- `gradient_analysis_summary_step_<N>.png`
+- `gradient_analysis_plots_step_<N>.png`
+- `gradient_analysis_loss_plots_step_<N>.png`
+- `gradient_analysis_reward_std_step_<N>.png`
+- `gradient_analysis_normed_grads_step_<N>.png`
+- `gradient_analysis_metrics_step_<N>.json`
+- `gradient_analysis_bucket_rv_table_step_<N>.csv`
+
+The `metrics.json` export is the bridge to the paper-style plotting script.
+
+## Building A 3-Step Comparison Figure
+
+If you have three exported step directories and want the fixed grid figure:
+
+```bash
+python gradient_analysis/plot_icml_steps.py \
+  --mode ppo \
+  --step0-dir /path/to/step0 \
+  --step20-dir /path/to/step20 \
+  --step40-dir /path/to/step40 \
+  --out gradient_analysis_outputs/ppo_step0_20_40.png
+```
+
+Each step directory must contain:
+
+```text
+metrics.json
+```
+
+If your exported file is named `gradient_analysis_metrics_step_<N>.json`, copy or rename it to `metrics.json` inside each step directory before calling `plot_icml_steps.py`.
+
+## What To Inspect First
+
+For a new run, start with:
+
+1. `gradient_analysis_summary_step_<N>.png`
+2. `gradient_analysis_plots_step_<N>.png`
+3. `gradient_analysis_metrics_step_<N>.json`
+
+Those three are usually enough to tell:
+- how many buckets were populated
+- whether task gradients dominate regularizer gradients
+- whether gradient magnitude is monotonic or non-monotonic in reward variance

gradient_analysis/plot_gradient_analysis.py

@@ -0,0 +1,438 @@
+import argparse
+import csv
+import json
+import os
+
+import matplotlib.pyplot as plt
+import wandb
+
+DEFAULT_BUCKETS = [
+    "bucket_1",
+    "bucket_2",
+    "bucket_3",
+    "bucket_4",
+    "bucket_5",
+    "bucket_6",
+]
+COMPONENTS = ["kl", "entropy", "task"]
+LOSS_COMPONENTS = ["policy", "entropy", "kl", "total"]
+
+def _sanitize_dir_name(name: str) -> str:
+    return "".join(c if c.isalnum() or c in ("-", "_") else "_" for c in name)
+
+def _bucket_sort_key(bucket_name: str):
+    if bucket_name.startswith("bucket_"):
+        suffix = bucket_name.split("_", 1)[1]
+        if suffix.isdigit():
+            return (0, int(suffix))
+    return (1, bucket_name)
+
+def _extract_buckets(metric_source: dict) -> list[str]:
+    buckets = set()
+    for key in metric_source.keys():
+        if not key.startswith("grad_norm/bucket_"):
+            continue
+        parts = key.split("/")
+        if len(parts) >= 2:
+            buckets.add(parts[1])
+    if not buckets:
+        return DEFAULT_BUCKETS
+    return sorted(buckets, key=_bucket_sort_key)
+
+def get_bucket_label(bucket_name):
+    """Formats bucket names for the plot axis."""
+    if bucket_name.startswith("bucket_"):
+        return bucket_name.replace("_", " ")
+    return bucket_name
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Plot gradient-analysis metrics from a W&B run.",
+        epilog=(
+            "Examples:\n"
+            "  python gradient_analysis/plot_gradient_analysis.py --wandb-path entity/project/run_id\n"
+            "  python gradient_analysis/plot_gradient_analysis.py --wandb-path entity/project/run_id --step 1\n"
+            "  python gradient_analysis/plot_gradient_analysis.py --wandb-path entity/project/run_id "
+            "--output-dir gradient_analysis_outputs/my_run\n"
+            "  python gradient_analysis/plot_gradient_analysis.py --wandb-path entity/project/run_id --list-steps"
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument(
+        "--wandb-path",
+        required=True,
+        help="W&B run path like entity/project/run_id",
+    )
+    parser.add_argument(
+        "--output-dir",
+        default=None,
+        help=(
+            "Directory for generated plots and exported metrics. "
+            "Defaults to gradient_analysis_outputs/<run_name>_<run_id>."
+        ),
+    )
+    parser.add_argument(
+        "--step",
+        dest="steps",
+        type=int,
+        nargs="+",
+        default=None,
+        help="One or more training steps to plot. Default: all available gradient-analysis steps.",
+    )
+    parser.add_argument(
+        "--list-steps",
+        action="store_true",
+        help="List available gradient-analysis steps in the run and exit.",
+    )
+    args = parser.parse_args()
+
+    print(f"Connecting to WandB run: {args.wandb_path}...")
+    api = wandb.Api()
+    try:
+        run = api.run(args.wandb_path)
+    except Exception as e:
+        print(f"Error accessing run: {e}")
+        return
+
+    summary = run.summary
+    step_metrics = {}
+    available_steps = set()
+    for row in run.scan_history():
+        bucket_items = [(k, v) for k, v in row.items() if k.startswith("grad_norm/bucket_")]
+        has_bucket_metrics = any(v is not None for _, v in bucket_items)
+        has_nonzero_bucket_metrics = any((v is not None and v != 0) for _, v in bucket_items)
+        if not has_bucket_metrics or not has_nonzero_bucket_metrics:
+            continue
+        step = row.get("_step")
+        if step is None:
+            continue
+        available_steps.add(step)
+        if step not in step_metrics:
+            step_metrics[step] = {}
+        for k, v in row.items():
+            if v is None:
+                continue
+            step_metrics[step][k] = v
+
+    if available_steps:
+        print(f"Found grad_norm bucket metrics at steps: {sorted(available_steps)}")
+    else:
+        print("Warning: no grad_norm metrics found in history; falling back to run summary.")
+        step_metrics = {"summary": summary}
+
+    if args.list_steps:
+        if available_steps:
+            print("Available gradient-analysis steps:")
+            for step in sorted(available_steps):
+                print(step)
+        else:
+            print("No gradient-analysis steps found.")
+        return
+
+    default_dir = os.path.join(
+        "gradient_analysis_outputs",
+        f"{_sanitize_dir_name(run.name)}_{run.id}",
+    )
+    output_dir = args.output_dir or default_dir
+    os.makedirs(output_dir, exist_ok=True)
+    titles = {
+        "kl": "KL Gradient Norm",
+        "entropy": "Entropy Gradient Norm",
+        "task": "Task (Policy) Gradient Norm"
+    }
+    
+    colors = ["#3498db", "#2ecc71", "#e74c3c"] # Blue, Green, Red
+    loss_titles = {
+        "policy": "Policy (Task) Loss",
+        "entropy": "Entropy Loss",
+        "kl": "KL Loss",
+        "total": "Total Loss",
+    }
+    loss_colors = ["#8e44ad", "#27ae60", "#2980b9", "#c0392b"]  # Purple, Green, Blue, Red
+    norm_titles = {
+        "kl": "KL Grad Norm (Per Sample vs Per Token)",
+        "entropy": "Entropy Grad Norm (Per Sample vs Per Token)",
+        "task": "Task Grad Norm (Per Sample vs Per Token)",
+    }
+
+    steps_to_plot = sorted(step_metrics.keys(), key=lambda x: (isinstance(x, str), x))
+    if args.steps is not None:
+        requested_steps = set(args.steps)
+        steps_to_plot = [s for s in steps_to_plot if s in requested_steps]
+        if not steps_to_plot:
+            print(f"Error: none of the requested steps {sorted(requested_steps)} were found.")
+            return
+
+    for step_key in steps_to_plot:
+        metric_source = step_metrics[step_key]
+        buckets = _extract_buckets(metric_source)
+        x_labels = [get_bucket_label(b) for b in buckets]
+        step_tag = f"step_{step_key}"
+        output_file = os.path.join(output_dir, f"gradient_analysis_plots_{step_tag}.png")
+        output_file_loss = os.path.join(output_dir, f"gradient_analysis_loss_plots_{step_tag}.png")
+        output_file_rv = os.path.join(output_dir, f"gradient_analysis_reward_std_{step_tag}.png")
+        output_file_normed = os.path.join(output_dir, f"gradient_analysis_normed_grads_{step_tag}.png")
+        output_file_summary = os.path.join(output_dir, f"gradient_analysis_summary_{step_tag}.png")
+        output_metrics_json = os.path.join(output_dir, f"gradient_analysis_metrics_{step_tag}.json")
+        output_rv_table = os.path.join(output_dir, f"gradient_analysis_bucket_rv_table_{step_tag}.csv")
+
+        # Create subplots for gradient norms
+        fig, axes = plt.subplots(1, 3, figsize=(20, 6))
+        plt.subplots_adjust(wspace=0.3, top=0.62, bottom=0.12)
+
+        bucket_rv = {
+            b: {
+                "mean": metric_source.get(f"grad_norm/{b}/reward_std_mean", 0),
+                "min": metric_source.get(f"grad_norm/{b}/reward_std_min", 0),
+                "max": metric_source.get(f"grad_norm/{b}/reward_std_max", 0),
+            }
+            for b in buckets
+        }
+        bucket_rv_values = {b: [] for b in buckets}
+        table_keys = [f"grad_norm/{b}/group_rv_table" for b in buckets]
+        for row in run.scan_history(keys=["_step", *table_keys]):
+            if row.get("_step") != step_key:
+                continue
+            for b in buckets:
+                key = f"grad_norm/{b}/group_rv_table"
+                table_meta = row.get(key)
+                if not isinstance(table_meta, dict) or "path" not in table_meta:
+                    continue
+                table_path = table_meta["path"]
+                try:
+                    file_ref = run.file(table_path)
+                    local_path = file_ref.download(replace=True).name
+                    with open(local_path, "r") as f:
+                        table_json = json.load(f)
+                    # table_json has keys: columns, data
+                    data_rows = table_json.get("data", [])
+                    # columns: bucket, group_id, reward_std
+                    for row_vals in data_rows:
+                        if len(row_vals) >= 3:
+                            bucket_rv_values[b].append(float(row_vals[2]))
+                except Exception:
+                    continue
+        # Save raw metric snapshot and RV table values for this step
+        try:
+            with open(output_metrics_json, "w") as f:
+                json.dump(metric_source, f, indent=2, sort_keys=True)
+        except Exception as e:
+            print(f"Warning: failed to write metrics json: {e}")
+
+        try:
+            with open(output_rv_table, "w", newline="") as f:
+                writer = csv.writer(f)
+                writer.writerow(["bucket", "reward_std"])
+                for b in buckets:
+                    for rv in bucket_rv_values[b]:
+                        writer.writerow([b, rv])
+        except Exception as e:
+            print(f"Warning: failed to write rv table csv: {e}")
+        legend_lines = []
+        for label, bucket in zip(x_labels, buckets):
+            rv = bucket_rv.get(bucket, {})
+            legend_lines.append(
+                f"{label}: mean={rv.get('mean', 0):.3f} min={rv.get('min', 0):.3f} max={rv.get('max', 0):.3f}"
+            )
+        for ax, comp, color in zip(axes, COMPONENTS, colors):
+            y_values = []
+            for bucket in buckets:
+                key = f"grad_norm/{bucket}/{comp}"
+                val = metric_source.get(key, 0)
+                y_values.append(val)
+
+            bars = ax.bar(x_labels, y_values, color=color, alpha=0.8, edgecolor='black', linewidth=1)
+            ax.set_title(titles[comp], fontsize=16, fontweight='bold', pad=15)
+            ax.set_ylabel("Grad Norm Magnitude", fontsize=12)
+            ax.set_xlabel("Reward Variance Bucket", fontsize=12)
+            ax.grid(axis='y', linestyle='--', alpha=0.6)
+
+            for bar in bars:
+                height = bar.get_height()
+                ax.text(bar.get_x() + bar.get_width()/2., height + (max(y_values)*0.01 if y_values else 0.01),
+                        f'{height:.4f}', ha='center', va='bottom', fontsize=10, fontweight='bold')
+
+        fig.suptitle(f"Gradient Norms - Run: {run.name} (Step {step_key})", fontsize=20, y=0.98)
+        fig.text(0.5, 0.88, "\n".join(legend_lines), ha="center", va="top", fontsize=8)
+        plt.savefig(output_file, bbox_inches='tight', dpi=300)
+        print(f"\nSuccess! Results visualization saved to: {os.path.abspath(output_file)}")
+        plt.close(fig)
+
+        # Create subplots for per-component losses
+        fig2, axes2 = plt.subplots(2, 2, figsize=(16, 10))
+        plt.subplots_adjust(hspace=0.35, wspace=0.25)
+
+        for ax, comp, color in zip(axes2.flatten(), LOSS_COMPONENTS, loss_colors):
+            y_values = []
+            for bucket in buckets:
+                key = f"grad_norm/{bucket}/loss/{comp}"
+                val = metric_source.get(key, 0)
+                y_values.append(val)
+
+            bars = ax.bar(x_labels, y_values, color=color, alpha=0.8, edgecolor="black", linewidth=1)
+            ax.set_title(loss_titles[comp], fontsize=14, fontweight="bold", pad=10)
+            ax.set_ylabel("Loss", fontsize=11)
+            ax.set_xlabel("Reward Variance Bucket", fontsize=11)
+            ax.grid(axis="y", linestyle="--", alpha=0.6)
+
+            for bar in bars:
+                height = bar.get_height()
+                ax.text(
+                    bar.get_x() + bar.get_width() / 2.0,
+                    height + (max(y_values) * 0.01 if y_values else 0.01),
+                    f"{height:.4f}",
+                    ha="center",
+                    va="bottom",
+                    fontsize=9,
+                    fontweight="bold",
+                )
+
+        fig2.suptitle(f"Per-Component Losses - Run: {run.name} (Step {step_key})", fontsize=18, y=1.02)
+        plt.tight_layout()
+        plt.savefig(output_file_loss, bbox_inches="tight", dpi=300)
+        print(f"Success! Loss visualization saved to: {os.path.abspath(output_file_loss)}")
+        plt.close(fig2)
+
+    # Create plot for per-bucket mean reward variance (std)
+        rv_values = []
+        for bucket in buckets:
+            rv_values.append(metric_source.get(f"grad_norm/{bucket}/reward_std_mean", 0))
+        if any(v != 0 for v in rv_values):
+            fig3, ax3 = plt.subplots(1, 1, figsize=(10, 5))
+            bars = ax3.bar(x_labels, rv_values, color="#f39c12", alpha=0.85, edgecolor="black", linewidth=1)
+            ax3.set_title(f"Reward Std Mean by Bucket - Run: {run.name} (Step {step_key})", fontsize=14, fontweight="bold", pad=10)
+            ax3.set_ylabel("Reward Std (Mean)", fontsize=11)
+            ax3.set_xlabel("Reward Variance Bucket", fontsize=11)
+            ax3.grid(axis="y", linestyle="--", alpha=0.6)
+            for bar in bars:
+                height = bar.get_height()
+                ax3.text(
+                    bar.get_x() + bar.get_width() / 2.0,
+                    height + (max(rv_values) * 0.01 if rv_values else 0.01),
+                    f"{height:.4f}",
+                    ha="center",
+                    va="bottom",
+                    fontsize=9,
+                    fontweight="bold",
+                )
+            plt.tight_layout()
+            plt.savefig(output_file_rv, bbox_inches="tight", dpi=300)
+            print(f"Success! Reward std visualization saved to: {os.path.abspath(output_file_rv)}")
+            plt.close(fig3)
+        else:
+            print(f"Warning: No reward std mean metrics found at step {step_key}; skipping reward std plot.")
+
+        # Create plots for per-sample and per-token grad norms (combined per component)
+        fig4, axes4 = plt.subplots(1, 3, figsize=(20, 6))
+        plt.subplots_adjust(wspace=0.3)
+        for ax, comp in zip(axes4, COMPONENTS):
+            per_sample = []
+            per_token = []
+            for bucket in buckets:
+                per_sample.append(metric_source.get(f"grad_norm/{bucket}/per_sample/{comp}", 0))
+                per_token.append(metric_source.get(f"grad_norm/{bucket}/per_token/{comp}", 0))
+
+            x = range(len(x_labels))
+            width = 0.38
+            bars1 = ax.bar([i - width / 2 for i in x], per_sample, width=width, label="per_sample", color="#16a085", alpha=0.85)
+            bars2 = ax.bar([i + width / 2 for i in x], per_token, width=width, label="per_token", color="#f39c12", alpha=0.85)
+            ax.set_xticks(list(x))
+            ax.set_xticklabels(x_labels)
+            ax.set_title(norm_titles[comp], fontsize=14, fontweight="bold", pad=10)
+            ax.set_ylabel("Grad Norm", fontsize=11)
+            ax.set_xlabel("Reward Variance Bucket", fontsize=11)
+            ax.grid(axis="y", linestyle="--", alpha=0.6)
+            ax.legend(frameon=False, fontsize=9)
+
+            for bar in list(bars1) + list(bars2):
+                height = bar.get_height()
+                ax.text(
+                    bar.get_x() + bar.get_width() / 2.0,
+                    height + (max(per_sample + per_token) * 0.01 if (per_sample + per_token) else 0.01),
+                    f"{height:.4f}",
+                    ha="center",
+                    va="bottom",
+                    fontsize=8,
+                )
+
+        fig4.suptitle(f"Normalized Grad Norms - Run: {run.name} (Step {step_key})", fontsize=18, y=1.03)
+        plt.tight_layout()
+        plt.savefig(output_file_normed, bbox_inches="tight", dpi=300)
+        print(f"Success! Normalized grad visualization saved to: {os.path.abspath(output_file_normed)}")
+        plt.close(fig4)
+
+        # Summary 3-panel plot with available aggregates
+        rv_means = [bucket_rv[b]["mean"] for b in buckets]
+        rv_mins = [bucket_rv[b]["min"] for b in buckets]
+        rv_maxs = [bucket_rv[b]["max"] for b in buckets]
+        task_grads = [metric_source.get(f"grad_norm/{b}/task", 0) for b in buckets]
+        kl_grads = [metric_source.get(f"grad_norm/{b}/kl", 0) for b in buckets]
+        ent_grads = [metric_source.get(f"grad_norm/{b}/entropy", 0) for b in buckets]
+        reg_grads = [k + e for k, e in zip(kl_grads, ent_grads)]
+
+        fig5, axes5 = plt.subplots(1, 3, figsize=(20, 6))
+        plt.subplots_adjust(wspace=0.35, top=0.80, bottom=0.15)
+
+        # Left: RV mean with min/max error bars per bucket
+        ax = axes5[0]
+        use_boxplot = any(bucket_rv_values[b] for b in buckets)
+        if use_boxplot:
+            data = [bucket_rv_values[b] for b in buckets]
+            data_mins = [min(v) if v else 0 for v in data]
+            data_maxs = [max(v) if v else 0 for v in data]
+            # sanity check: compare against logged min/max (per-sample)
+            mismatch = any(
+                abs(dm - rm) > 1e-3 or abs(dx - rx) > 1e-3
+                for dm, rm, dx, rx in zip(data_mins, rv_mins, data_maxs, rv_maxs)
+            )
+            if mismatch:
+                print(f"Warning: bucket RV table min/max mismatch at step {step_key}; falling back to error bars.")
+                use_boxplot = False
+        if use_boxplot:
+            ax.boxplot(data, tick_labels=x_labels, showfliers=False)
+            ax.set_title("RV by Bucket (Boxplot)", fontsize=13, fontweight="bold")
+        else:
+            # Guard against negative error bars from inconsistent min/max logging.
+            yerr = [
+                [max(0.0, m - lo) for m, lo in zip(rv_means, rv_mins)],
+                [max(0.0, hi - m) for m, hi in zip(rv_means, rv_maxs)],
+            ]
+            ax.errorbar(x_labels, rv_means, yerr=yerr, fmt="o-", color="#6c5ce7", ecolor="#2d3436", capsize=4)
+            ax.set_title("RV by Bucket (Mean ± Min/Max)", fontsize=13, fontweight="bold")
+        ax.set_xlabel("Bucket")
+        ax.set_ylabel("Reward Variance (Std)")
+        ax.grid(axis="y", linestyle="--", alpha=0.5)
+
+        # Middle: task grad norm vs mean RV
+        ax = axes5[1]
+        ax.plot(rv_means, task_grads, "o-", color="#e67e22")
+        for i, (xv, yv) in enumerate(zip(rv_means, task_grads), start=1):
+            ax.text(xv, yv, f"Q{i}", fontsize=8, ha="left", va="bottom")
+        ax.set_title("Task Grad Norm vs RV Mean", fontsize=13, fontweight="bold")
+        ax.set_xlabel("RV Mean")
+        ax.set_ylabel("Task Grad Norm")
+        ax.grid(axis="y", linestyle="--", alpha=0.5)
+        mid_ylim = ax.get_ylim()
+
+        # Right: regularizer grad norm (KL+Entropy) vs mean RV
+        ax = axes5[2]
+        ax.plot(rv_means, reg_grads, "o-", color="#16a085")
+        for i, (xv, yv) in enumerate(zip(rv_means, reg_grads), start=1):
+            ax.text(xv, yv, f"Q{i}", fontsize=8, ha="left", va="bottom")
+        ax.set_title("Reg Grad Norm vs RV Mean (KL+Ent)", fontsize=13, fontweight="bold")
+        ax.set_xlabel("RV Mean")
+        ax.set_ylabel("KL+Entropy Grad Norm")
+        ax.set_ylim(0, 1)
+        ax.grid(axis="y", linestyle="--", alpha=0.5)
+
+        fig5.suptitle(f"Gradient Summary - Run: {run.name} (Step {step_key})", fontsize=16, y=0.98)
+        plt.tight_layout()
+        plt.savefig(output_file_summary, bbox_inches="tight", dpi=300)
+        print(f"Success! Summary visualization saved to: {os.path.abspath(output_file_summary)}")
+        plt.close(fig5)
+
+    print(f"All outputs written to: {os.path.abspath(output_dir)}")
+
+
+if __name__ == "__main__":
+    main()

merge.sh

@@ -0,0 +1,106 @@
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_rubikscube1_withthink_fulltraj_sa_rl/global_step_50/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_rubikscube1_withthink_fulltraj_sa_rl/global_step_50/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_rubikscube1_withthink_sa_rl/global_step_50/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_rubikscube1_withthink_sa_rl/global_step_50/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_rubikscube1_withthink_sas_rl/global_step_50/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_rubikscube1_withthink_sas_rl/global_step_50/qwen2.5_3b_actor_hf
+
+
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_rubikscube2_withthink_sa_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_rubikscube2_withthink_sa_rl/global_step_200/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_rubikscube2_withthink_fulltraj_sa_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_rubikscube2_withthink_fulltraj_sa_rl/global_step_200/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_rubikscube2_withthink_sas_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_rubikscube2_withthink_sas_rl/global_step_200/qwen2.5_3b_actor_hf
+
+
+
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_rubikscube3_withthink_fulltraj_sa_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_rubikscube3_withthink_fulltraj_sa_rl/global_step_200/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_rubikscube3_withthink_sa_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_rubikscube3_withthink_sa_rl/global_step_200/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_rubikscube3_withthink_sas_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_rubikscube3_withthink_sas_rl/global_step_200/qwen2.5_3b_actor_hf
+
+
+
+
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_sokoban1_withthink_fulltraj_sa_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_sokoban1_withthink_fulltraj_sa_rl/global_step_200/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_sokoban1_withthink_sa_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_sokoban1_withthink_sa_rl/global_step_200/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_sokoban1_withthink_sas_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_sokoban1_withthink_sas_rl/global_step_200/qwen2.5_3b_actor_hf
+
+
+
+
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_sokoban2_withthink_fulltraj_sa_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_sokoban2_withthink_fulltraj_sa_rl/global_step_200/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_sokoban2_withthink_sa_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_sokoban2_withthink_sa_rl/global_step_200/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_sokoban2_withthink_sas_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_sokoban2_withthink_sas_rl/global_step_200/qwen2.5_3b_actor_hf
+
+
+
+
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_sudoku_withthink_fulltraj_sa_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_sudoku_withthink_fulltraj_sa_rl/global_step_200/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_sudoku_withthink_sa_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_sudoku_withthink_sa_rl/global_step_200/qwen2.5_3b_actor_hf
+
+python -m verl.model_merger merge \
+  --backend fsdp \
+  --local_dir /mnt/general/wanghy/RAGEN_v2/saves/qwen2.5_3B_it_sudoku_withthink_sas_rl/global_step_200/actor \
+  --target_dir /mnt/general/wanghy/RAGEN_v2/saves_hf/qwen2.5_3B_it_sudoku_withthink_sas_rl/global_step_200/qwen2.5_3b_actor_hf

outputs/2026-04-30/11-03-16/.hydra/config.yaml

@@ -0,0 +1,989 @@
+actor_rollout_ref:
+  actor:
+    optim:
+      _target_: verl.workers.config.FSDPOptimizerConfig
+      lr: 1.0e-06
+      lr_warmup_steps_ratio: 0.0
+      total_training_steps: -1
+      weight_decay: 0.01
+      lr_warmup_steps: -1
+      betas:
+      - 0.9
+      - 0.999
+      clip_grad: 1.0
+      min_lr_ratio: 0.0
+      num_cycles: 0.5
+      warmup_style: constant
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    _target_: verl.workers.config.FSDPActorConfig
+    strategy: fsdp
+    ppo_mini_batch_size: ${ppo_mini_batch_size}
+    ppo_micro_batch_size: null
+    ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+    use_dynamic_bsz: false
+    ppo_max_token_len_per_gpu: 16384
+    clip_ratio: 0.2
+    clip_ratio_low: 0.2
+    clip_ratio_high: 0.28
+    freeze_vision_tower: false
+    policy_loss:
+      _target_: verl.workers.config.PolicyLossConfig
+      loss_mode: vanilla
+      clip_cov_ratio: 0.0002
+      clip_cov_lb: 1.0
+      clip_cov_ub: 5.0
+      kl_cov_ratio: 0.0002
+      ppo_kl_coef: 0.1
+    clip_ratio_c: 3.0
+    loss_agg_mode: token-mean
+    entropy_coeff: 0.001
+    tis_imp_ratio_cap: -1
+    use_kl_loss: false
+    use_torch_compile: true
+    kl_loss_coef: 0.0
+    kl_loss_type: kl
+    ppo_epochs: 1
+    shuffle: false
+    checkpoint:
+      _target_: verl.trainer.config.CheckpointConfig
+      save_contents:
+      - model
+      - optimizer
+      - extra
+      load_contents: ${.save_contents}
+      async_save: false
+    use_fused_kernels: ${oc.select:actor_rollout_ref.model.use_fused_kernels,false}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    grad_clip: 1.0
+    ulysses_sequence_parallel_size: 1
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+    use_remove_padding: ${oc.select:actor_rollout_ref.model.use_remove_padding,false}
+    use_ref: true
+    grpo_advantage_length_weight: ${grpo_advantage_length_weight}
+    filter_loss_scaling: none
+  ref:
+    strategy: ${actor_rollout_ref.actor.strategy}
+    use_torch_compile: ${oc.select:actor_rollout_ref.actor.use_torch_compile,true}
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    model: null
+    ulysses_sequence_parallel_size: ${oc.select:actor_rollout_ref.actor.ulysses_sequence_parallel_size,1}
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+  rollout:
+    _target_: verl.workers.config.RolloutConfig
+    name: vllm
+    mode: sync
+    temperature: 1
+    top_k: -1
+    top_p: 1
+    prompt_length: 1
+    response_length: 400
+    dtype: bfloat16
+    gpu_memory_utilization: 0.8
+    ignore_eos: false
+    enforce_eager: true
+    cudagraph_capture_sizes: null
+    free_cache_engine: true
+    tensor_model_parallel_size: 1
+    data_parallel_size: 1
+    expert_parallel_size: 1
+    max_num_batched_tokens: 8192
+    max_model_len: 3600
+    max_num_seqs: 1024
+    enable_chunked_prefill: true
+    enable_prefix_caching: true
+    load_format: auto
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    disable_log_stats: true
+    do_sample: true
+    'n': 1
+    over_sample_rate: 0
+    multi_stage_wake_up: false
+    engine_kwargs:
+      vllm: {}
+      sglang: {}
+    val_kwargs:
+      _target_: verl.workers.config.SamplingConfig
+      top_k: -1
+      top_p: 1.0
+      temperature: 0.5
+      'n': 1
+      do_sample: true
+    multi_turn:
+      _target_: verl.workers.config.MultiTurnConfig
+      enable: false
+      max_assistant_turns: null
+      tool_config_path: null
+      max_user_turns: null
+      max_parallel_calls: 1
+      max_tool_response_length: 256
+      tool_response_truncate_side: middle
+      interaction_config_path: null
+      use_inference_chat_template: false
+      tokenization_sanity_check_mode: strict
+      format: hermes
+      num_repeat_rollouts: null
+    calculate_log_probs: false
+    agent:
+      _target_: verl.workers.config.AgentLoopConfig
+      num_workers: 8
+      agent_loop_config_path: null
+      custom_async_server:
+        _target_: verl.workers.config.CustomAsyncServerConfig
+        path: null
+        name: null
+    update_weights_bucket_megabytes: 512
+    trace:
+      _target_: verl.workers.config.TraceConfig
+      backend: null
+      token2text: false
+    skip_rollout: false
+    skip_dump_dir: /tmp/rollout_dump
+    skip_tokenizer_init: true
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: ${oc.select:actor_rollout_ref.actor.profiler.enable,false}
+      all_ranks: ${oc.select:actor_rollout_ref.actor.profiler.all_ranks,false}
+      ranks: ${oc.select:actor_rollout_ref.actor.profiler.ranks,[]}
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+    layered_summon: false
+    rollout_filter_value: 0.9
+    rollout_filter_strategy: top_p
+    rollout_filter_type: largest
+    rollout_filter_include_zero: true
+    rollout_filter_top_p_prob_mode: linear
+    rollout_filter_selection_eps: 0.01
+    rollout_filter_empty_stop_steps: 5
+    rollout_filter_metric: reward_variance
+    gradient_analysis_num_buckets: 6
+    gradient_analysis_bucket_mode: quantile
+  model:
+    _target_: verl.workers.config.HFModelConfig
+    path: ${model_path}
+    hf_config_path: null
+    tokenizer_path: null
+    use_shm: false
+    trust_remote_code: false
+    custom_chat_template: null
+    external_lib: null
+    override_config: {}
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+    exclude_modules: null
+    use_liger: false
+    use_fused_kernels: false
+    fused_kernel_options:
+      impl_backend: torch
+  hybrid_engine: true
+  nccl_timeout: 600
+data:
+  tokenizer: null
+  use_shm: false
+  train_files: ~/data/rlhf/gsm8k/train.parquet
+  val_files: ~/data/rlhf/gsm8k/test.parquet
+  prompt_key: prompt
+  reward_fn_key: data_source
+  max_prompt_length: null
+  max_response_length: null
+  train_batch_size: null
+  val_batch_size: null
+  return_raw_input_ids: false
+  return_raw_chat: false
+  return_full_prompt: false
+  shuffle: true
+  dataloader_num_workers: 8
+  validation_shuffle: false
+  filter_overlong_prompts: false
+  filter_overlong_prompts_workers: 1
+  truncation: error
+  image_key: images
+  video_key: videos
+  trust_remote_code: false
+  custom_cls:
+    path: null
+    name: null
+  return_multi_modal_inputs: true
+  sampler:
+    class_path: null
+    class_name: null
+  datagen:
+    path: null
+    name: null
+  apply_chat_template_kwargs: {}
+critic:
+  optim:
+    _target_: verl.workers.config.FSDPOptimizerConfig
+    lr: 1.0e-05
+    lr_warmup_steps_ratio: 0.0
+    total_training_steps: -1
+    weight_decay: 0.01
+    lr_warmup_steps: -1
+    betas:
+    - 0.9
+    - 0.999
+    clip_grad: 1.0
+    min_lr_ratio: 0.0
+    num_cycles: 0.5
+    warmup_style: constant
+  model:
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    path: ${model_path}
+    tokenizer_path: ${oc.select:actor_rollout_ref.model.path,"~/models/deepseek-llm-7b-chat"}
+    override_config: {}
+    external_lib: ${oc.select:actor_rollout_ref.model.external_lib,null}
+    trust_remote_code: ${oc.select:actor_rollout_ref.model.trust_remote_code,false}
+    _target_: verl.workers.config.FSDPCriticModelCfg
+    use_shm: false
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+  _target_: verl.workers.config.FSDPCriticConfig
+  rollout_n: ${oc.select:actor_rollout_ref.rollout.n,1}
+  strategy: fsdp
+  enable: null
+  ppo_mini_batch_size: ${ppo_mini_batch_size}
+  ppo_micro_batch_size: null
+  ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+  use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+  ppo_max_token_len_per_gpu: 32768
+  forward_max_token_len_per_gpu: ${.ppo_max_token_len_per_gpu}
+  ppo_epochs: ${oc.select:actor_rollout_ref.actor.ppo_epochs,1}
+  shuffle: ${oc.select:actor_rollout_ref.actor.shuffle,false}
+  cliprange_value: 0.5
+  loss_agg_mode: ${oc.select:actor_rollout_ref.actor.loss_agg_mode,token-mean}
+  checkpoint:
+    _target_: verl.trainer.config.CheckpointConfig
+    save_contents:
+    - model
+    - optimizer
+    - extra
+    load_contents: ${.save_contents}
+    async_save: false
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config:
+      nsys:
+        _target_: verl.utils.profiler.config.NsightToolConfig
+        discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+      npu:
+        _target_: verl.utils.profiler.config.NPUToolConfig
+        contents: []
+        level: level1
+        analysis: true
+        discrete: false
+      torch:
+        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+        step_start: 0
+        step_end: null
+      torch_memory:
+        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+        trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+        stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+  forward_micro_batch_size: ${oc.select:.ppo_micro_batch_size,null}
+  forward_micro_batch_size_per_gpu: ${oc.select:.ppo_micro_batch_size_per_gpu,null}
+  ulysses_sequence_parallel_size: 1
+  grad_clip: 1.0
+reward_model:
+  enable: false
+  enable_resource_pool: false
+  n_gpus_per_node: 0
+  nnodes: 0
+  strategy: fsdp
+  model:
+    input_tokenizer: ${actor_rollout_ref.model.path}
+    path: ~/models/FsfairX-LLaMA3-RM-v0.1
+    external_lib: ${actor_rollout_ref.model.external_lib}
+    trust_remote_code: false
+    use_shm: false
+    use_remove_padding: false
+    use_fused_kernels: ${actor_rollout_ref.model.use_fused_kernels}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+  micro_batch_size: null
+  micro_batch_size_per_gpu: null
+  max_length: null
+  use_dynamic_bsz: ${critic.use_dynamic_bsz}
+  forward_max_token_len_per_gpu: ${critic.forward_max_token_len_per_gpu}
+  reward_manager: naive
+  launch_reward_fn_async: false
+  sandbox_fusion:
+    url: null
+    max_concurrent: 64
+    memory_limit_mb: 1024
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+  ulysses_sequence_parallel_size: 1
+custom_reward_function:
+  path: null
+  name: compute_score
+algorithm:
+  _target_: verl.trainer.config.AlgoConfig
+  gamma: 1.0
+  lam: 1.0
+  adv_estimator: gae
+  norm_adv_by_std_in_grpo: true
+  use_kl_in_reward: false
+  kl_penalty: kl
+  kl_ctrl:
+    _target_: verl.trainer.config.KLControlConfig
+    type: fixed
+    kl_coef: 0.0
+    horizon: 10000
+    target_kl: 0.1
+  use_pf_ppo: false
+  pf_ppo:
+    reweight_method: pow
+    weight_pow: 2.0
+  high_level_gamma: 0.95
+  bi_level_gae: false
+  zero_task_advantage: false
+  soft_advantage_reweight: false
+trainer:
+  balance_batch: true
+  total_epochs: 30
+  total_training_steps: 200
+  project_name: ragen
+  experiment_name: sokoban-main
+  logger:
+  - console
+  - wandb
+  log_val_generations: 0
+  rollout_data_dir: null
+  validation_data_dir: null
+  nnodes: 1
+  n_gpus_per_node: 1
+  save_freq: 100
+  esi_redundant_time: 0
+  resume_mode: auto
+  resume_from_path: null
+  val_before_train: true
+  val_only: false
+  test_freq: 10
+  critic_warmup: 0
+  default_hdfs_dir: null
+  del_local_ckpt_after_load: false
+  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
+  max_actor_ckpt_to_keep: 1
+  max_critic_ckpt_to_keep: 1
+  ray_wait_register_center_timeout: 300
+  device: cuda
+  use_legacy_worker_impl: auto
+  local_log_dir: results/
+  validation_steps: 1
+  generations_to_log_to_wandb:
+    val: 20
+  log_group_rv_table: false
+  gradient_analysis_mode: false
+  gradient_analysis_every: 50
+  gradient_analysis_env_groups: null
+  gradient_analysis_group_size: null
+  gradient_analysis_log_prefilter: false
+  gradient_analysis_only: false
+  exit_after_gradient_analysis: false
+global_profiler:
+  _target_: verl.utils.profiler.ProfilerConfig
+  tool: null
+  steps: null
+  profile_continuous_steps: false
+  save_path: outputs/profile
+  global_tool_config:
+    nsys:
+      _target_: verl.utils.profiler.config.NsightToolConfig
+      discrete: false
+      controller_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+      worker_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+        capture-range: cudaProfilerApi
+        capture-range-end: null
+        kill: none
+    torch_memory:
+      trace_alloc_max_entries: 100000
+      stack_depth: 32
+      context: all
+      stacks: all
+      kw_args: {}
+ray_kwargs:
+  ray_init:
+    num_cpus: null
+  timeline_json_file: null
+custom_envs:
+  SimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+  LargerSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 8
+      dim_y: 8
+      num_boxes: 2
+      max_steps: 100
+      search_depth: 10
+  SokobanDifferentGridVocab:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      search_depth: 30
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      grid_lookup:
+        0: W
+        1: .
+        2: G
+        3: C
+        4: B
+        5: A
+        6: '@'
+      grid_vocab:
+        W: wall
+        .: empty
+        G: target
+        C: box on target
+        B: box
+        A: player
+        '@': player on target
+  CoordSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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. \n\
+      Coordinates 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"
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      observation_format: grid_coord
+  VisualSimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      render_mode: rgb_array
+  Alfworld:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_in_distribution
+  AlfworldOOD:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_out_of_distribution
+  Countdown:
+    env_type: countdown
+    max_actions_per_traj: 1
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: null
+  Bandit:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: train
+  BanditTest:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: test
+  DeepCoder:
+    env_type: deepcoder
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving a coding task. Provide a complete Python function
+      solution only. Format: <answer>...</answer>'
+    max_tokens: 8000
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 1
+  FrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      success_rate: 0.8
+  CoordFrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>.
+
+      '
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      observation_format: grid_coord
+      success_rate: 0.8
+  MetamathQA:
+    env_type: metamathqa
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving Math problems. '
+    max_tokens: 100
+    env_config: null
+  WebShopFull:
+    env_type: webshop
+    max_actions_per_traj: 15
+    env_instruction: You are an expert autonomous agent operating in the WebShop e‑commerce
+      environment.
+    max_tokens: 200
+    env_config:
+      dataset: full
+  WebShop:
+    env_type: webshop
+    max_actions_per_traj: 9
+    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>].'
+    max_tokens: 200
+    env_config:
+      dataset: small
+  Lean:
+    env_type: lean
+    max_actions_per_traj: 30
+    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>.
+    max_tokens: 512
+    parallel_friendly: true
+    max_workers: 32
+    env_config: null
+  SimpleSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 20
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: easy
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  MediumSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 30
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: medium
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  SearchQA:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+  SearchQAMock:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+      mock_mode: true
+  game_2048:
+    env_type: game_2048
+    max_actions_per_traj: 700
+    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>
+
+      '
+    max_tokens: 8192
+    env_config: null
+  rubikscube:
+    env_type: rubikscube
+    max_actions_per_traj: 20
+    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>
+
+      '
+    max_tokens: 96
+    env_config:
+      scramble_depth: 1
+      max_steps: 20
+      render_mode: text
+system:
+  CUDA_VISIBLE_DEVICES: 0,1,2,3,4,5,6,7
+seed:
+  train: 10000
+  val: 123
+micro_batch_size_per_gpu: 1
+log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+ppo_mini_batch_size: 32
+model_path: /mnt/general/share/model/Qwen/Qwen2.5-3B-Instruct
+enable_response_mask: true
+grpo_advantage_length_weight: false
+lora:
+  rank: 0
+  alpha: 64
+  target_modules: all-linear
+agent_proxy:
+  context_window_mode: full
+  max_context_window: -1
+  batch_adjust_mode: copy
+  max_turn: 5
+  action_sep: '||'
+  max_actions_per_turn: 2
+  use_turn_scores: false
+  enable_think: true
+  reward_normalization:
+    grouping: state
+    method: identity
+collapse_detection:
+  compute_freq: 5
+  micro_batch_size: 128
+  first_turn_enabled: true
+  multi_turn_enabled: true
+  num_samples: 64
+es_manager:
+  format_penalty: -0.1
+  train:
+    env_groups: 8
+    group_size: 16
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 8
+  val:
+    env_groups: 512
+    group_size: 1
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 512
+ctx_manager:
+  generation:
+    gen_config:
+      response_length: ${actor_rollout_ref.rollout.response_length}
+      temperature: ${actor_rollout_ref.rollout.temperature}
+      top_p: ${actor_rollout_ref.rollout.top_p}
+      top_k: ${actor_rollout_ref.rollout.top_k}
+      kwargs: null

outputs/2026-04-30/11-03-16/.hydra/overrides.yaml

@@ -0,0 +1,2 @@
+- actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+- actor_rollout_ref.rollout.rollout_filter_value=0.9

outputs/2026-04-30/11-03-39/.hydra/config.yaml

@@ -0,0 +1,989 @@
+actor_rollout_ref:
+  actor:
+    optim:
+      _target_: verl.workers.config.FSDPOptimizerConfig
+      lr: 1.0e-06
+      lr_warmup_steps_ratio: 0.0
+      total_training_steps: -1
+      weight_decay: 0.01
+      lr_warmup_steps: -1
+      betas:
+      - 0.9
+      - 0.999
+      clip_grad: 1.0
+      min_lr_ratio: 0.0
+      num_cycles: 0.5
+      warmup_style: constant
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    _target_: verl.workers.config.FSDPActorConfig
+    strategy: fsdp
+    ppo_mini_batch_size: ${ppo_mini_batch_size}
+    ppo_micro_batch_size: null
+    ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+    use_dynamic_bsz: false
+    ppo_max_token_len_per_gpu: 16384
+    clip_ratio: 0.2
+    clip_ratio_low: 0.2
+    clip_ratio_high: 0.28
+    freeze_vision_tower: false
+    policy_loss:
+      _target_: verl.workers.config.PolicyLossConfig
+      loss_mode: vanilla
+      clip_cov_ratio: 0.0002
+      clip_cov_lb: 1.0
+      clip_cov_ub: 5.0
+      kl_cov_ratio: 0.0002
+      ppo_kl_coef: 0.1
+    clip_ratio_c: 3.0
+    loss_agg_mode: token-mean
+    entropy_coeff: 0.001
+    tis_imp_ratio_cap: -1
+    use_kl_loss: false
+    use_torch_compile: true
+    kl_loss_coef: 0.0
+    kl_loss_type: kl
+    ppo_epochs: 1
+    shuffle: false
+    checkpoint:
+      _target_: verl.trainer.config.CheckpointConfig
+      save_contents:
+      - model
+      - optimizer
+      - extra
+      load_contents: ${.save_contents}
+      async_save: false
+    use_fused_kernels: ${oc.select:actor_rollout_ref.model.use_fused_kernels,false}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    grad_clip: 1.0
+    ulysses_sequence_parallel_size: 1
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+    use_remove_padding: ${oc.select:actor_rollout_ref.model.use_remove_padding,false}
+    use_ref: true
+    grpo_advantage_length_weight: ${grpo_advantage_length_weight}
+    filter_loss_scaling: none
+  ref:
+    strategy: ${actor_rollout_ref.actor.strategy}
+    use_torch_compile: ${oc.select:actor_rollout_ref.actor.use_torch_compile,true}
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    model: null
+    ulysses_sequence_parallel_size: ${oc.select:actor_rollout_ref.actor.ulysses_sequence_parallel_size,1}
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+  rollout:
+    _target_: verl.workers.config.RolloutConfig
+    name: vllm
+    mode: sync
+    temperature: 1
+    top_k: -1
+    top_p: 1
+    prompt_length: 1
+    response_length: 400
+    dtype: bfloat16
+    gpu_memory_utilization: 0.8
+    ignore_eos: false
+    enforce_eager: true
+    cudagraph_capture_sizes: null
+    free_cache_engine: true
+    tensor_model_parallel_size: 1
+    data_parallel_size: 1
+    expert_parallel_size: 1
+    max_num_batched_tokens: 8192
+    max_model_len: 3600
+    max_num_seqs: 1024
+    enable_chunked_prefill: true
+    enable_prefix_caching: true
+    load_format: auto
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    disable_log_stats: true
+    do_sample: true
+    'n': 1
+    over_sample_rate: 0
+    multi_stage_wake_up: false
+    engine_kwargs:
+      vllm: {}
+      sglang: {}
+    val_kwargs:
+      _target_: verl.workers.config.SamplingConfig
+      top_k: -1
+      top_p: 1.0
+      temperature: 0.5
+      'n': 1
+      do_sample: true
+    multi_turn:
+      _target_: verl.workers.config.MultiTurnConfig
+      enable: false
+      max_assistant_turns: null
+      tool_config_path: null
+      max_user_turns: null
+      max_parallel_calls: 1
+      max_tool_response_length: 256
+      tool_response_truncate_side: middle
+      interaction_config_path: null
+      use_inference_chat_template: false
+      tokenization_sanity_check_mode: strict
+      format: hermes
+      num_repeat_rollouts: null
+    calculate_log_probs: false
+    agent:
+      _target_: verl.workers.config.AgentLoopConfig
+      num_workers: 8
+      agent_loop_config_path: null
+      custom_async_server:
+        _target_: verl.workers.config.CustomAsyncServerConfig
+        path: null
+        name: null
+    update_weights_bucket_megabytes: 512
+    trace:
+      _target_: verl.workers.config.TraceConfig
+      backend: null
+      token2text: false
+    skip_rollout: false
+    skip_dump_dir: /tmp/rollout_dump
+    skip_tokenizer_init: true
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: ${oc.select:actor_rollout_ref.actor.profiler.enable,false}
+      all_ranks: ${oc.select:actor_rollout_ref.actor.profiler.all_ranks,false}
+      ranks: ${oc.select:actor_rollout_ref.actor.profiler.ranks,[]}
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+    layered_summon: false
+    rollout_filter_value: 0.9
+    rollout_filter_strategy: top_p
+    rollout_filter_type: largest
+    rollout_filter_include_zero: true
+    rollout_filter_top_p_prob_mode: linear
+    rollout_filter_selection_eps: 0.01
+    rollout_filter_empty_stop_steps: 5
+    rollout_filter_metric: reward_variance
+    gradient_analysis_num_buckets: 6
+    gradient_analysis_bucket_mode: quantile
+  model:
+    _target_: verl.workers.config.HFModelConfig
+    path: ${model_path}
+    hf_config_path: null
+    tokenizer_path: null
+    use_shm: false
+    trust_remote_code: false
+    custom_chat_template: null
+    external_lib: null
+    override_config: {}
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+    exclude_modules: null
+    use_liger: false
+    use_fused_kernels: false
+    fused_kernel_options:
+      impl_backend: torch
+  hybrid_engine: true
+  nccl_timeout: 600
+data:
+  tokenizer: null
+  use_shm: false
+  train_files: ~/data/rlhf/gsm8k/train.parquet
+  val_files: ~/data/rlhf/gsm8k/test.parquet
+  prompt_key: prompt
+  reward_fn_key: data_source
+  max_prompt_length: null
+  max_response_length: null
+  train_batch_size: null
+  val_batch_size: null
+  return_raw_input_ids: false
+  return_raw_chat: false
+  return_full_prompt: false
+  shuffle: true
+  dataloader_num_workers: 8
+  validation_shuffle: false
+  filter_overlong_prompts: false
+  filter_overlong_prompts_workers: 1
+  truncation: error
+  image_key: images
+  video_key: videos
+  trust_remote_code: false
+  custom_cls:
+    path: null
+    name: null
+  return_multi_modal_inputs: true
+  sampler:
+    class_path: null
+    class_name: null
+  datagen:
+    path: null
+    name: null
+  apply_chat_template_kwargs: {}
+critic:
+  optim:
+    _target_: verl.workers.config.FSDPOptimizerConfig
+    lr: 1.0e-05
+    lr_warmup_steps_ratio: 0.0
+    total_training_steps: -1
+    weight_decay: 0.01
+    lr_warmup_steps: -1
+    betas:
+    - 0.9
+    - 0.999
+    clip_grad: 1.0
+    min_lr_ratio: 0.0
+    num_cycles: 0.5
+    warmup_style: constant
+  model:
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    path: ${model_path}
+    tokenizer_path: ${oc.select:actor_rollout_ref.model.path,"~/models/deepseek-llm-7b-chat"}
+    override_config: {}
+    external_lib: ${oc.select:actor_rollout_ref.model.external_lib,null}
+    trust_remote_code: ${oc.select:actor_rollout_ref.model.trust_remote_code,false}
+    _target_: verl.workers.config.FSDPCriticModelCfg
+    use_shm: false
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+  _target_: verl.workers.config.FSDPCriticConfig
+  rollout_n: ${oc.select:actor_rollout_ref.rollout.n,1}
+  strategy: fsdp
+  enable: null
+  ppo_mini_batch_size: ${ppo_mini_batch_size}
+  ppo_micro_batch_size: null
+  ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+  use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+  ppo_max_token_len_per_gpu: 32768
+  forward_max_token_len_per_gpu: ${.ppo_max_token_len_per_gpu}
+  ppo_epochs: ${oc.select:actor_rollout_ref.actor.ppo_epochs,1}
+  shuffle: ${oc.select:actor_rollout_ref.actor.shuffle,false}
+  cliprange_value: 0.5
+  loss_agg_mode: ${oc.select:actor_rollout_ref.actor.loss_agg_mode,token-mean}
+  checkpoint:
+    _target_: verl.trainer.config.CheckpointConfig
+    save_contents:
+    - model
+    - optimizer
+    - extra
+    load_contents: ${.save_contents}
+    async_save: false
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config:
+      nsys:
+        _target_: verl.utils.profiler.config.NsightToolConfig
+        discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+      npu:
+        _target_: verl.utils.profiler.config.NPUToolConfig
+        contents: []
+        level: level1
+        analysis: true
+        discrete: false
+      torch:
+        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+        step_start: 0
+        step_end: null
+      torch_memory:
+        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+        trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+        stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+  forward_micro_batch_size: ${oc.select:.ppo_micro_batch_size,null}
+  forward_micro_batch_size_per_gpu: ${oc.select:.ppo_micro_batch_size_per_gpu,null}
+  ulysses_sequence_parallel_size: 1
+  grad_clip: 1.0
+reward_model:
+  enable: false
+  enable_resource_pool: false
+  n_gpus_per_node: 0
+  nnodes: 0
+  strategy: fsdp
+  model:
+    input_tokenizer: ${actor_rollout_ref.model.path}
+    path: ~/models/FsfairX-LLaMA3-RM-v0.1
+    external_lib: ${actor_rollout_ref.model.external_lib}
+    trust_remote_code: false
+    use_shm: false
+    use_remove_padding: false
+    use_fused_kernels: ${actor_rollout_ref.model.use_fused_kernels}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+  micro_batch_size: null
+  micro_batch_size_per_gpu: null
+  max_length: null
+  use_dynamic_bsz: ${critic.use_dynamic_bsz}
+  forward_max_token_len_per_gpu: ${critic.forward_max_token_len_per_gpu}
+  reward_manager: naive
+  launch_reward_fn_async: false
+  sandbox_fusion:
+    url: null
+    max_concurrent: 64
+    memory_limit_mb: 1024
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+  ulysses_sequence_parallel_size: 1
+custom_reward_function:
+  path: null
+  name: compute_score
+algorithm:
+  _target_: verl.trainer.config.AlgoConfig
+  gamma: 1.0
+  lam: 1.0
+  adv_estimator: gae
+  norm_adv_by_std_in_grpo: true
+  use_kl_in_reward: false
+  kl_penalty: kl
+  kl_ctrl:
+    _target_: verl.trainer.config.KLControlConfig
+    type: fixed
+    kl_coef: 0.0
+    horizon: 10000
+    target_kl: 0.1
+  use_pf_ppo: false
+  pf_ppo:
+    reweight_method: pow
+    weight_pow: 2.0
+  high_level_gamma: 0.95
+  bi_level_gae: false
+  zero_task_advantage: false
+  soft_advantage_reweight: false
+trainer:
+  balance_batch: true
+  total_epochs: 30
+  total_training_steps: 200
+  project_name: ragen
+  experiment_name: sokoban-main
+  logger:
+  - console
+  - wandb
+  log_val_generations: 0
+  rollout_data_dir: null
+  validation_data_dir: null
+  nnodes: 1
+  n_gpus_per_node: 8
+  save_freq: 100
+  esi_redundant_time: 0
+  resume_mode: auto
+  resume_from_path: null
+  val_before_train: true
+  val_only: false
+  test_freq: 10
+  critic_warmup: 0
+  default_hdfs_dir: null
+  del_local_ckpt_after_load: false
+  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
+  max_actor_ckpt_to_keep: 1
+  max_critic_ckpt_to_keep: 1
+  ray_wait_register_center_timeout: 300
+  device: cuda
+  use_legacy_worker_impl: auto
+  local_log_dir: results/
+  validation_steps: 1
+  generations_to_log_to_wandb:
+    val: 20
+  log_group_rv_table: false
+  gradient_analysis_mode: false
+  gradient_analysis_every: 50
+  gradient_analysis_env_groups: null
+  gradient_analysis_group_size: null
+  gradient_analysis_log_prefilter: false
+  gradient_analysis_only: false
+  exit_after_gradient_analysis: false
+global_profiler:
+  _target_: verl.utils.profiler.ProfilerConfig
+  tool: null
+  steps: null
+  profile_continuous_steps: false
+  save_path: outputs/profile
+  global_tool_config:
+    nsys:
+      _target_: verl.utils.profiler.config.NsightToolConfig
+      discrete: false
+      controller_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+      worker_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+        capture-range: cudaProfilerApi
+        capture-range-end: null
+        kill: none
+    torch_memory:
+      trace_alloc_max_entries: 100000
+      stack_depth: 32
+      context: all
+      stacks: all
+      kw_args: {}
+ray_kwargs:
+  ray_init:
+    num_cpus: null
+  timeline_json_file: null
+custom_envs:
+  SimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+  LargerSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 8
+      dim_y: 8
+      num_boxes: 2
+      max_steps: 100
+      search_depth: 10
+  SokobanDifferentGridVocab:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      search_depth: 30
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      grid_lookup:
+        0: W
+        1: .
+        2: G
+        3: C
+        4: B
+        5: A
+        6: '@'
+      grid_vocab:
+        W: wall
+        .: empty
+        G: target
+        C: box on target
+        B: box
+        A: player
+        '@': player on target
+  CoordSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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. \n\
+      Coordinates 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"
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      observation_format: grid_coord
+  VisualSimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      render_mode: rgb_array
+  Alfworld:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_in_distribution
+  AlfworldOOD:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_out_of_distribution
+  Countdown:
+    env_type: countdown
+    max_actions_per_traj: 1
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: null
+  Bandit:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: train
+  BanditTest:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: test
+  DeepCoder:
+    env_type: deepcoder
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving a coding task. Provide a complete Python function
+      solution only. Format: <answer>...</answer>'
+    max_tokens: 8000
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 1
+  FrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      success_rate: 0.8
+  CoordFrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>.
+
+      '
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      observation_format: grid_coord
+      success_rate: 0.8
+  MetamathQA:
+    env_type: metamathqa
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving Math problems. '
+    max_tokens: 100
+    env_config: null
+  WebShopFull:
+    env_type: webshop
+    max_actions_per_traj: 15
+    env_instruction: You are an expert autonomous agent operating in the WebShop e‑commerce
+      environment.
+    max_tokens: 200
+    env_config:
+      dataset: full
+  WebShop:
+    env_type: webshop
+    max_actions_per_traj: 9
+    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>].'
+    max_tokens: 200
+    env_config:
+      dataset: small
+  Lean:
+    env_type: lean
+    max_actions_per_traj: 30
+    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>.
+    max_tokens: 512
+    parallel_friendly: true
+    max_workers: 32
+    env_config: null
+  SimpleSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 20
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: easy
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  MediumSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 30
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: medium
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  SearchQA:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+  SearchQAMock:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+      mock_mode: true
+  game_2048:
+    env_type: game_2048
+    max_actions_per_traj: 700
+    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>
+
+      '
+    max_tokens: 8192
+    env_config: null
+  rubikscube:
+    env_type: rubikscube
+    max_actions_per_traj: 20
+    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>
+
+      '
+    max_tokens: 96
+    env_config:
+      scramble_depth: 1
+      max_steps: 20
+      render_mode: text
+system:
+  CUDA_VISIBLE_DEVICES: 0,1,2,3,4,5,6,7
+seed:
+  train: 10000
+  val: 123
+micro_batch_size_per_gpu: 1
+log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+ppo_mini_batch_size: 32
+model_path: /mnt/general/share/model/Qwen/Qwen2.5-3B-Instruct
+enable_response_mask: true
+grpo_advantage_length_weight: false
+lora:
+  rank: 0
+  alpha: 64
+  target_modules: all-linear
+agent_proxy:
+  context_window_mode: full
+  max_context_window: -1
+  batch_adjust_mode: copy
+  max_turn: 5
+  action_sep: '||'
+  max_actions_per_turn: 2
+  use_turn_scores: false
+  enable_think: true
+  reward_normalization:
+    grouping: state
+    method: identity
+collapse_detection:
+  compute_freq: 5
+  micro_batch_size: 128
+  first_turn_enabled: true
+  multi_turn_enabled: true
+  num_samples: 64
+es_manager:
+  format_penalty: -0.1
+  train:
+    env_groups: 8
+    group_size: 16
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 8
+  val:
+    env_groups: 512
+    group_size: 1
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 512
+ctx_manager:
+  generation:
+    gen_config:
+      response_length: ${actor_rollout_ref.rollout.response_length}
+      temperature: ${actor_rollout_ref.rollout.temperature}
+      top_p: ${actor_rollout_ref.rollout.top_p}
+      top_k: ${actor_rollout_ref.rollout.top_k}
+      kwargs: null

outputs/2026-04-30/13-11-58/.hydra/overrides.yaml

@@ -0,0 +1,2 @@
+- actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+- actor_rollout_ref.rollout.rollout_filter_value=0.9

outputs/2026-04-30/14-13-32/.hydra/config.yaml

@@ -0,0 +1,989 @@
+actor_rollout_ref:
+  actor:
+    optim:
+      _target_: verl.workers.config.FSDPOptimizerConfig
+      lr: 1.0e-06
+      lr_warmup_steps_ratio: 0.0
+      total_training_steps: -1
+      weight_decay: 0.01
+      lr_warmup_steps: -1
+      betas:
+      - 0.9
+      - 0.999
+      clip_grad: 1.0
+      min_lr_ratio: 0.0
+      num_cycles: 0.5
+      warmup_style: constant
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    _target_: verl.workers.config.FSDPActorConfig
+    strategy: fsdp
+    ppo_mini_batch_size: ${ppo_mini_batch_size}
+    ppo_micro_batch_size: null
+    ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+    use_dynamic_bsz: false
+    ppo_max_token_len_per_gpu: 16384
+    clip_ratio: 0.2
+    clip_ratio_low: 0.2
+    clip_ratio_high: 0.28
+    freeze_vision_tower: false
+    policy_loss:
+      _target_: verl.workers.config.PolicyLossConfig
+      loss_mode: vanilla
+      clip_cov_ratio: 0.0002
+      clip_cov_lb: 1.0
+      clip_cov_ub: 5.0
+      kl_cov_ratio: 0.0002
+      ppo_kl_coef: 0.1
+    clip_ratio_c: 3.0
+    loss_agg_mode: token-mean
+    entropy_coeff: 0.001
+    tis_imp_ratio_cap: -1
+    use_kl_loss: false
+    use_torch_compile: true
+    kl_loss_coef: 0.0
+    kl_loss_type: kl
+    ppo_epochs: 1
+    shuffle: false
+    checkpoint:
+      _target_: verl.trainer.config.CheckpointConfig
+      save_contents:
+      - model
+      - optimizer
+      - extra
+      load_contents: ${.save_contents}
+      async_save: false
+    use_fused_kernels: ${oc.select:actor_rollout_ref.model.use_fused_kernels,false}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    grad_clip: 1.0
+    ulysses_sequence_parallel_size: 1
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+    use_remove_padding: ${oc.select:actor_rollout_ref.model.use_remove_padding,false}
+    use_ref: true
+    grpo_advantage_length_weight: ${grpo_advantage_length_weight}
+    filter_loss_scaling: none
+  ref:
+    strategy: ${actor_rollout_ref.actor.strategy}
+    use_torch_compile: ${oc.select:actor_rollout_ref.actor.use_torch_compile,true}
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    model: null
+    ulysses_sequence_parallel_size: ${oc.select:actor_rollout_ref.actor.ulysses_sequence_parallel_size,1}
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+  rollout:
+    _target_: verl.workers.config.RolloutConfig
+    name: vllm
+    mode: sync
+    temperature: 1
+    top_k: -1
+    top_p: 1
+    prompt_length: 1
+    response_length: 400
+    dtype: bfloat16
+    gpu_memory_utilization: 0.8
+    ignore_eos: false
+    enforce_eager: true
+    cudagraph_capture_sizes: null
+    free_cache_engine: true
+    tensor_model_parallel_size: 1
+    data_parallel_size: 1
+    expert_parallel_size: 1
+    max_num_batched_tokens: 8192
+    max_model_len: 3600
+    max_num_seqs: 1024
+    enable_chunked_prefill: true
+    enable_prefix_caching: true
+    load_format: auto
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    disable_log_stats: true
+    do_sample: true
+    'n': 1
+    over_sample_rate: 0
+    multi_stage_wake_up: false
+    engine_kwargs:
+      vllm: {}
+      sglang: {}
+    val_kwargs:
+      _target_: verl.workers.config.SamplingConfig
+      top_k: -1
+      top_p: 1.0
+      temperature: 0.5
+      'n': 1
+      do_sample: true
+    multi_turn:
+      _target_: verl.workers.config.MultiTurnConfig
+      enable: false
+      max_assistant_turns: null
+      tool_config_path: null
+      max_user_turns: null
+      max_parallel_calls: 1
+      max_tool_response_length: 256
+      tool_response_truncate_side: middle
+      interaction_config_path: null
+      use_inference_chat_template: false
+      tokenization_sanity_check_mode: strict
+      format: hermes
+      num_repeat_rollouts: null
+    calculate_log_probs: false
+    agent:
+      _target_: verl.workers.config.AgentLoopConfig
+      num_workers: 8
+      agent_loop_config_path: null
+      custom_async_server:
+        _target_: verl.workers.config.CustomAsyncServerConfig
+        path: null
+        name: null
+    update_weights_bucket_megabytes: 512
+    trace:
+      _target_: verl.workers.config.TraceConfig
+      backend: null
+      token2text: false
+    skip_rollout: false
+    skip_dump_dir: /tmp/rollout_dump
+    skip_tokenizer_init: true
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: ${oc.select:actor_rollout_ref.actor.profiler.enable,false}
+      all_ranks: ${oc.select:actor_rollout_ref.actor.profiler.all_ranks,false}
+      ranks: ${oc.select:actor_rollout_ref.actor.profiler.ranks,[]}
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+    layered_summon: false
+    rollout_filter_value: 0.9
+    rollout_filter_strategy: top_p
+    rollout_filter_type: largest
+    rollout_filter_include_zero: true
+    rollout_filter_top_p_prob_mode: linear
+    rollout_filter_selection_eps: 0.01
+    rollout_filter_empty_stop_steps: 5
+    rollout_filter_metric: reward_variance
+    gradient_analysis_num_buckets: 6
+    gradient_analysis_bucket_mode: quantile
+  model:
+    _target_: verl.workers.config.HFModelConfig
+    path: ${model_path}
+    hf_config_path: null
+    tokenizer_path: null
+    use_shm: false
+    trust_remote_code: false
+    custom_chat_template: null
+    external_lib: null
+    override_config: {}
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+    exclude_modules: null
+    use_liger: false
+    use_fused_kernels: false
+    fused_kernel_options:
+      impl_backend: torch
+  hybrid_engine: true
+  nccl_timeout: 600
+data:
+  tokenizer: null
+  use_shm: false
+  train_files: ~/data/rlhf/gsm8k/train.parquet
+  val_files: ~/data/rlhf/gsm8k/test.parquet
+  prompt_key: prompt
+  reward_fn_key: data_source
+  max_prompt_length: null
+  max_response_length: null
+  train_batch_size: null
+  val_batch_size: null
+  return_raw_input_ids: false
+  return_raw_chat: false
+  return_full_prompt: false
+  shuffle: true
+  dataloader_num_workers: 8
+  validation_shuffle: false
+  filter_overlong_prompts: false
+  filter_overlong_prompts_workers: 1
+  truncation: error
+  image_key: images
+  video_key: videos
+  trust_remote_code: false
+  custom_cls:
+    path: null
+    name: null
+  return_multi_modal_inputs: true
+  sampler:
+    class_path: null
+    class_name: null
+  datagen:
+    path: null
+    name: null
+  apply_chat_template_kwargs: {}
+critic:
+  optim:
+    _target_: verl.workers.config.FSDPOptimizerConfig
+    lr: 1.0e-05
+    lr_warmup_steps_ratio: 0.0
+    total_training_steps: -1
+    weight_decay: 0.01
+    lr_warmup_steps: -1
+    betas:
+    - 0.9
+    - 0.999
+    clip_grad: 1.0
+    min_lr_ratio: 0.0
+    num_cycles: 0.5
+    warmup_style: constant
+  model:
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    path: ${model_path}
+    tokenizer_path: ${oc.select:actor_rollout_ref.model.path,"~/models/deepseek-llm-7b-chat"}
+    override_config: {}
+    external_lib: ${oc.select:actor_rollout_ref.model.external_lib,null}
+    trust_remote_code: ${oc.select:actor_rollout_ref.model.trust_remote_code,false}
+    _target_: verl.workers.config.FSDPCriticModelCfg
+    use_shm: false
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+  _target_: verl.workers.config.FSDPCriticConfig
+  rollout_n: ${oc.select:actor_rollout_ref.rollout.n,1}
+  strategy: fsdp
+  enable: null
+  ppo_mini_batch_size: ${ppo_mini_batch_size}
+  ppo_micro_batch_size: null
+  ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+  use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+  ppo_max_token_len_per_gpu: 32768
+  forward_max_token_len_per_gpu: ${.ppo_max_token_len_per_gpu}
+  ppo_epochs: ${oc.select:actor_rollout_ref.actor.ppo_epochs,1}
+  shuffle: ${oc.select:actor_rollout_ref.actor.shuffle,false}
+  cliprange_value: 0.5
+  loss_agg_mode: ${oc.select:actor_rollout_ref.actor.loss_agg_mode,token-mean}
+  checkpoint:
+    _target_: verl.trainer.config.CheckpointConfig
+    save_contents:
+    - model
+    - optimizer
+    - extra
+    load_contents: ${.save_contents}
+    async_save: false
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config:
+      nsys:
+        _target_: verl.utils.profiler.config.NsightToolConfig
+        discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+      npu:
+        _target_: verl.utils.profiler.config.NPUToolConfig
+        contents: []
+        level: level1
+        analysis: true
+        discrete: false
+      torch:
+        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+        step_start: 0
+        step_end: null
+      torch_memory:
+        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+        trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+        stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+  forward_micro_batch_size: ${oc.select:.ppo_micro_batch_size,null}
+  forward_micro_batch_size_per_gpu: ${oc.select:.ppo_micro_batch_size_per_gpu,null}
+  ulysses_sequence_parallel_size: 1
+  grad_clip: 1.0
+reward_model:
+  enable: false
+  enable_resource_pool: false
+  n_gpus_per_node: 0
+  nnodes: 0
+  strategy: fsdp
+  model:
+    input_tokenizer: ${actor_rollout_ref.model.path}
+    path: ~/models/FsfairX-LLaMA3-RM-v0.1
+    external_lib: ${actor_rollout_ref.model.external_lib}
+    trust_remote_code: false
+    use_shm: false
+    use_remove_padding: false
+    use_fused_kernels: ${actor_rollout_ref.model.use_fused_kernels}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+  micro_batch_size: null
+  micro_batch_size_per_gpu: null
+  max_length: null
+  use_dynamic_bsz: ${critic.use_dynamic_bsz}
+  forward_max_token_len_per_gpu: ${critic.forward_max_token_len_per_gpu}
+  reward_manager: naive
+  launch_reward_fn_async: false
+  sandbox_fusion:
+    url: null
+    max_concurrent: 64
+    memory_limit_mb: 1024
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+  ulysses_sequence_parallel_size: 1
+custom_reward_function:
+  path: null
+  name: compute_score
+algorithm:
+  _target_: verl.trainer.config.AlgoConfig
+  gamma: 1.0
+  lam: 1.0
+  adv_estimator: gae
+  norm_adv_by_std_in_grpo: true
+  use_kl_in_reward: false
+  kl_penalty: kl
+  kl_ctrl:
+    _target_: verl.trainer.config.KLControlConfig
+    type: fixed
+    kl_coef: 0.0
+    horizon: 10000
+    target_kl: 0.1
+  use_pf_ppo: false
+  pf_ppo:
+    reweight_method: pow
+    weight_pow: 2.0
+  high_level_gamma: 0.95
+  bi_level_gae: false
+  zero_task_advantage: false
+  soft_advantage_reweight: false
+trainer:
+  balance_batch: true
+  total_epochs: 30
+  total_training_steps: 200
+  project_name: ragen
+  experiment_name: sokoban-main
+  logger:
+  - console
+  - wandb
+  log_val_generations: 0
+  rollout_data_dir: null
+  validation_data_dir: null
+  nnodes: 1
+  n_gpus_per_node: 8
+  save_freq: 100
+  esi_redundant_time: 0
+  resume_mode: auto
+  resume_from_path: null
+  val_before_train: true
+  val_only: false
+  test_freq: 10
+  critic_warmup: 0
+  default_hdfs_dir: null
+  del_local_ckpt_after_load: false
+  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
+  max_actor_ckpt_to_keep: 1
+  max_critic_ckpt_to_keep: 1
+  ray_wait_register_center_timeout: 300
+  device: cuda
+  use_legacy_worker_impl: auto
+  local_log_dir: results/
+  validation_steps: 1
+  generations_to_log_to_wandb:
+    val: 20
+  log_group_rv_table: false
+  gradient_analysis_mode: false
+  gradient_analysis_every: 50
+  gradient_analysis_env_groups: null
+  gradient_analysis_group_size: null
+  gradient_analysis_log_prefilter: false
+  gradient_analysis_only: false
+  exit_after_gradient_analysis: false
+global_profiler:
+  _target_: verl.utils.profiler.ProfilerConfig
+  tool: null
+  steps: null
+  profile_continuous_steps: false
+  save_path: outputs/profile
+  global_tool_config:
+    nsys:
+      _target_: verl.utils.profiler.config.NsightToolConfig
+      discrete: false
+      controller_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+      worker_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+        capture-range: cudaProfilerApi
+        capture-range-end: null
+        kill: none
+    torch_memory:
+      trace_alloc_max_entries: 100000
+      stack_depth: 32
+      context: all
+      stacks: all
+      kw_args: {}
+ray_kwargs:
+  ray_init:
+    num_cpus: null
+  timeline_json_file: null
+custom_envs:
+  SimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+  LargerSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 8
+      dim_y: 8
+      num_boxes: 2
+      max_steps: 100
+      search_depth: 10
+  SokobanDifferentGridVocab:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      search_depth: 30
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      grid_lookup:
+        0: W
+        1: .
+        2: G
+        3: C
+        4: B
+        5: A
+        6: '@'
+      grid_vocab:
+        W: wall
+        .: empty
+        G: target
+        C: box on target
+        B: box
+        A: player
+        '@': player on target
+  CoordSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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. \n\
+      Coordinates 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"
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      observation_format: grid_coord
+  VisualSimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      render_mode: rgb_array
+  Alfworld:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_in_distribution
+  AlfworldOOD:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_out_of_distribution
+  Countdown:
+    env_type: countdown
+    max_actions_per_traj: 1
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: null
+  Bandit:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: train
+  BanditTest:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: test
+  DeepCoder:
+    env_type: deepcoder
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving a coding task. Provide a complete Python function
+      solution only. Format: <answer>...</answer>'
+    max_tokens: 8000
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 1
+  FrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      success_rate: 0.8
+  CoordFrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>.
+
+      '
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      observation_format: grid_coord
+      success_rate: 0.8
+  MetamathQA:
+    env_type: metamathqa
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving Math problems. '
+    max_tokens: 100
+    env_config: null
+  WebShopFull:
+    env_type: webshop
+    max_actions_per_traj: 15
+    env_instruction: You are an expert autonomous agent operating in the WebShop e‑commerce
+      environment.
+    max_tokens: 200
+    env_config:
+      dataset: full
+  WebShop:
+    env_type: webshop
+    max_actions_per_traj: 9
+    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>].'
+    max_tokens: 200
+    env_config:
+      dataset: small
+  Lean:
+    env_type: lean
+    max_actions_per_traj: 30
+    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>.
+    max_tokens: 512
+    parallel_friendly: true
+    max_workers: 32
+    env_config: null
+  SimpleSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 20
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: easy
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  MediumSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 30
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: medium
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  SearchQA:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+  SearchQAMock:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+      mock_mode: true
+  game_2048:
+    env_type: game_2048
+    max_actions_per_traj: 700
+    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>
+
+      '
+    max_tokens: 8192
+    env_config: null
+  rubikscube:
+    env_type: rubikscube
+    max_actions_per_traj: 20
+    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>
+
+      '
+    max_tokens: 96
+    env_config:
+      scramble_depth: 1
+      max_steps: 20
+      render_mode: text
+system:
+  CUDA_VISIBLE_DEVICES: 0,1,2,3,4,5,6,7
+seed:
+  train: 10000
+  val: 123
+micro_batch_size_per_gpu: 1
+log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+ppo_mini_batch_size: 32
+model_path: /mnt/general/share/model/Qwen/Qwen2.5-3B-Instruct
+enable_response_mask: true
+grpo_advantage_length_weight: false
+lora:
+  rank: 0
+  alpha: 64
+  target_modules: all-linear
+agent_proxy:
+  context_window_mode: full
+  max_context_window: -1
+  batch_adjust_mode: copy
+  max_turn: 5
+  action_sep: '||'
+  max_actions_per_turn: 2
+  use_turn_scores: false
+  enable_think: true
+  reward_normalization:
+    grouping: state
+    method: identity
+collapse_detection:
+  compute_freq: 5
+  micro_batch_size: 128
+  first_turn_enabled: true
+  multi_turn_enabled: true
+  num_samples: 64
+es_manager:
+  format_penalty: -0.1
+  train:
+    env_groups: 8
+    group_size: 16
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 8
+  val:
+    env_groups: 512
+    group_size: 1
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 512
+ctx_manager:
+  generation:
+    gen_config:
+      response_length: ${actor_rollout_ref.rollout.response_length}
+      temperature: ${actor_rollout_ref.rollout.temperature}
+      top_p: ${actor_rollout_ref.rollout.top_p}
+      top_k: ${actor_rollout_ref.rollout.top_k}
+      kwargs: null

outputs/2026-04-30/14-13-32/.hydra/hydra.yaml

@@ -0,0 +1,175 @@
+hydra:
+  run:
+    dir: outputs/${now:%Y-%m-%d}/${now:%H-%M-%S}
+  sweep:
+    dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S}
+    subdir: ${hydra.job.num}
+  launcher:
+    _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher
+  sweeper:
+    _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper
+    max_batch_size: null
+    params: null
+  help:
+    app_name: ${hydra.job.name}
+    header: '${hydra.help.app_name} is powered by Hydra.
+
+      '
+    footer: 'Powered by Hydra (https://hydra.cc)
+
+      Use --hydra-help to view Hydra specific help
+
+      '
+    template: '${hydra.help.header}
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (group=option)
+
+
+      $APP_CONFIG_GROUPS
+
+
+      == Config ==
+
+      Override anything in the config (foo.bar=value)
+
+
+      $CONFIG
+
+
+      ${hydra.help.footer}
+
+      '
+  hydra_help:
+    template: 'Hydra (${hydra.runtime.version})
+
+      See https://hydra.cc for more info.
+
+
+      == Flags ==
+
+      $FLAGS_HELP
+
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (For example, append hydra/job_logging=disabled
+      to command line)
+
+
+      $HYDRA_CONFIG_GROUPS
+
+
+      Use ''--cfg hydra'' to Show the Hydra config.
+
+      '
+    hydra_help: ???
+  hydra_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][HYDRA] %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+    root:
+      level: INFO
+      handlers:
+      - console
+    loggers:
+      logging_example:
+        level: DEBUG
+    disable_existing_loggers: false
+  job_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+      file:
+        class: logging.FileHandler
+        formatter: simple
+        filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log
+    root:
+      level: INFO
+      handlers:
+      - console
+      - file
+    disable_existing_loggers: false
+  env: {}
+  mode: RUN
+  searchpath:
+  - pkg://verl.trainer.config
+  callbacks: {}
+  output_subdir: .hydra
+  overrides:
+    hydra:
+    - hydra.mode=RUN
+    task:
+    - actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+    - actor_rollout_ref.rollout.rollout_filter_value=0.9
+  job:
+    name: train
+    chdir: null
+    override_dirname: actor_rollout_ref.rollout.rollout_filter_strategy=top_p,actor_rollout_ref.rollout.rollout_filter_value=0.9
+    id: ???
+    num: ???
+    config_name: _2_sokoban
+    env_set: {}
+    env_copy: []
+    config:
+      override_dirname:
+        kv_sep: '='
+        item_sep: ','
+        exclude_keys: []
+  runtime:
+    version: 1.3.2
+    version_base: '1.3'
+    cwd: /mnt/general/wanghy/RAGEN_v2
+    config_sources:
+    - path: hydra.conf
+      schema: pkg
+      provider: hydra
+    - path: /mnt/general/wanghy/RAGEN_v2/config
+      schema: file
+      provider: main
+    - path: /mnt/general/wanghy/RAGEN_v2/verl/verl/trainer/config
+      schema: file
+      provider: command-line
+    - path: verl.trainer.config
+      schema: pkg
+      provider: hydra.searchpath in main
+    - path: ''
+      schema: structured
+      provider: schema
+    output_dir: /mnt/general/wanghy/RAGEN_v2/outputs/2026-04-30/14-13-32
+    choices:
+      reward_model: dp_reward_model
+      critic: dp_critic
+      critic/../engine@critic.model.fsdp_config: fsdp
+      critic/../optim@critic.optim: fsdp
+      model@actor_rollout_ref.model: hf_model
+      rollout@actor_rollout_ref.rollout: rollout
+      ref@actor_rollout_ref.ref: dp_ref
+      ref/../engine@actor_rollout_ref.ref.fsdp_config: fsdp
+      data: legacy_data
+      actor@actor_rollout_ref.actor: dp_actor
+      actor/../engine@actor_rollout_ref.actor.fsdp_config: fsdp
+      actor/../optim@actor_rollout_ref.actor.optim: fsdp
+      hydra/env: default
+      hydra/callbacks: null
+      hydra/job_logging: default
+      hydra/hydra_logging: default
+      hydra/hydra_help: default
+      hydra/help: default
+      hydra/sweeper: basic
+      hydra/launcher: basic
+      hydra/output: default
+  verbose: false

outputs/2026-04-30/14-13-32/.hydra/overrides.yaml

@@ -0,0 +1,2 @@
+- actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+- actor_rollout_ref.rollout.rollout_filter_value=0.9

outputs/2026-04-30/19-02-13/.hydra/config.yaml

@@ -0,0 +1,989 @@
+actor_rollout_ref:
+  actor:
+    optim:
+      _target_: verl.workers.config.FSDPOptimizerConfig
+      lr: 1.0e-06
+      lr_warmup_steps_ratio: 0.0
+      total_training_steps: -1
+      weight_decay: 0.01
+      lr_warmup_steps: -1
+      betas:
+      - 0.9
+      - 0.999
+      clip_grad: 1.0
+      min_lr_ratio: 0.0
+      num_cycles: 0.5
+      warmup_style: constant
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    _target_: verl.workers.config.FSDPActorConfig
+    strategy: fsdp
+    ppo_mini_batch_size: ${ppo_mini_batch_size}
+    ppo_micro_batch_size: null
+    ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+    use_dynamic_bsz: false
+    ppo_max_token_len_per_gpu: 16384
+    clip_ratio: 0.2
+    clip_ratio_low: 0.2
+    clip_ratio_high: 0.28
+    freeze_vision_tower: false
+    policy_loss:
+      _target_: verl.workers.config.PolicyLossConfig
+      loss_mode: vanilla
+      clip_cov_ratio: 0.0002
+      clip_cov_lb: 1.0
+      clip_cov_ub: 5.0
+      kl_cov_ratio: 0.0002
+      ppo_kl_coef: 0.1
+    clip_ratio_c: 3.0
+    loss_agg_mode: token-mean
+    entropy_coeff: 0.001
+    tis_imp_ratio_cap: -1
+    use_kl_loss: false
+    use_torch_compile: true
+    kl_loss_coef: 0.0
+    kl_loss_type: kl
+    ppo_epochs: 1
+    shuffle: false
+    checkpoint:
+      _target_: verl.trainer.config.CheckpointConfig
+      save_contents:
+      - model
+      - optimizer
+      - extra
+      load_contents: ${.save_contents}
+      async_save: false
+    use_fused_kernels: ${oc.select:actor_rollout_ref.model.use_fused_kernels,false}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    grad_clip: 1.0
+    ulysses_sequence_parallel_size: 1
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+    use_remove_padding: ${oc.select:actor_rollout_ref.model.use_remove_padding,false}
+    use_ref: true
+    grpo_advantage_length_weight: ${grpo_advantage_length_weight}
+    filter_loss_scaling: none
+  ref:
+    strategy: ${actor_rollout_ref.actor.strategy}
+    use_torch_compile: ${oc.select:actor_rollout_ref.actor.use_torch_compile,true}
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    model: null
+    ulysses_sequence_parallel_size: ${oc.select:actor_rollout_ref.actor.ulysses_sequence_parallel_size,1}
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+  rollout:
+    _target_: verl.workers.config.RolloutConfig
+    name: vllm
+    mode: sync
+    temperature: 1
+    top_k: -1
+    top_p: 1
+    prompt_length: 1
+    response_length: 400
+    dtype: bfloat16
+    gpu_memory_utilization: 0.8
+    ignore_eos: false
+    enforce_eager: true
+    cudagraph_capture_sizes: null
+    free_cache_engine: true
+    tensor_model_parallel_size: 1
+    data_parallel_size: 1
+    expert_parallel_size: 1
+    max_num_batched_tokens: 8192
+    max_model_len: 3600
+    max_num_seqs: 1024
+    enable_chunked_prefill: true
+    enable_prefix_caching: true
+    load_format: auto
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    disable_log_stats: true
+    do_sample: true
+    'n': 1
+    over_sample_rate: 0
+    multi_stage_wake_up: false
+    engine_kwargs:
+      vllm: {}
+      sglang: {}
+    val_kwargs:
+      _target_: verl.workers.config.SamplingConfig
+      top_k: -1
+      top_p: 1.0
+      temperature: 0.5
+      'n': 1
+      do_sample: true
+    multi_turn:
+      _target_: verl.workers.config.MultiTurnConfig
+      enable: false
+      max_assistant_turns: null
+      tool_config_path: null
+      max_user_turns: null
+      max_parallel_calls: 1
+      max_tool_response_length: 256
+      tool_response_truncate_side: middle
+      interaction_config_path: null
+      use_inference_chat_template: false
+      tokenization_sanity_check_mode: strict
+      format: hermes
+      num_repeat_rollouts: null
+    calculate_log_probs: false
+    agent:
+      _target_: verl.workers.config.AgentLoopConfig
+      num_workers: 8
+      agent_loop_config_path: null
+      custom_async_server:
+        _target_: verl.workers.config.CustomAsyncServerConfig
+        path: null
+        name: null
+    update_weights_bucket_megabytes: 512
+    trace:
+      _target_: verl.workers.config.TraceConfig
+      backend: null
+      token2text: false
+    skip_rollout: false
+    skip_dump_dir: /tmp/rollout_dump
+    skip_tokenizer_init: true
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: ${oc.select:actor_rollout_ref.actor.profiler.enable,false}
+      all_ranks: ${oc.select:actor_rollout_ref.actor.profiler.all_ranks,false}
+      ranks: ${oc.select:actor_rollout_ref.actor.profiler.ranks,[]}
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+    layered_summon: false
+    rollout_filter_value: 0.9
+    rollout_filter_strategy: top_p
+    rollout_filter_type: largest
+    rollout_filter_include_zero: true
+    rollout_filter_top_p_prob_mode: linear
+    rollout_filter_selection_eps: 0.01
+    rollout_filter_empty_stop_steps: 5
+    rollout_filter_metric: reward_variance
+    gradient_analysis_num_buckets: 6
+    gradient_analysis_bucket_mode: quantile
+  model:
+    _target_: verl.workers.config.HFModelConfig
+    path: ${model_path}
+    hf_config_path: null
+    tokenizer_path: null
+    use_shm: false
+    trust_remote_code: false
+    custom_chat_template: null
+    external_lib: null
+    override_config: {}
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+    exclude_modules: null
+    use_liger: false
+    use_fused_kernels: false
+    fused_kernel_options:
+      impl_backend: torch
+  hybrid_engine: true
+  nccl_timeout: 600
+data:
+  tokenizer: null
+  use_shm: false
+  train_files: ~/data/rlhf/gsm8k/train.parquet
+  val_files: ~/data/rlhf/gsm8k/test.parquet
+  prompt_key: prompt
+  reward_fn_key: data_source
+  max_prompt_length: null
+  max_response_length: null
+  train_batch_size: null
+  val_batch_size: null
+  return_raw_input_ids: false
+  return_raw_chat: false
+  return_full_prompt: false
+  shuffle: true
+  dataloader_num_workers: 8
+  validation_shuffle: false
+  filter_overlong_prompts: false
+  filter_overlong_prompts_workers: 1
+  truncation: error
+  image_key: images
+  video_key: videos
+  trust_remote_code: false
+  custom_cls:
+    path: null
+    name: null
+  return_multi_modal_inputs: true
+  sampler:
+    class_path: null
+    class_name: null
+  datagen:
+    path: null
+    name: null
+  apply_chat_template_kwargs: {}
+critic:
+  optim:
+    _target_: verl.workers.config.FSDPOptimizerConfig
+    lr: 1.0e-05
+    lr_warmup_steps_ratio: 0.0
+    total_training_steps: -1
+    weight_decay: 0.01
+    lr_warmup_steps: -1
+    betas:
+    - 0.9
+    - 0.999
+    clip_grad: 1.0
+    min_lr_ratio: 0.0
+    num_cycles: 0.5
+    warmup_style: constant
+  model:
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    path: ${model_path}
+    tokenizer_path: ${oc.select:actor_rollout_ref.model.path,"~/models/deepseek-llm-7b-chat"}
+    override_config: {}
+    external_lib: ${oc.select:actor_rollout_ref.model.external_lib,null}
+    trust_remote_code: ${oc.select:actor_rollout_ref.model.trust_remote_code,false}
+    _target_: verl.workers.config.FSDPCriticModelCfg
+    use_shm: false
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+  _target_: verl.workers.config.FSDPCriticConfig
+  rollout_n: ${oc.select:actor_rollout_ref.rollout.n,1}
+  strategy: fsdp
+  enable: null
+  ppo_mini_batch_size: ${ppo_mini_batch_size}
+  ppo_micro_batch_size: null
+  ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+  use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+  ppo_max_token_len_per_gpu: 32768
+  forward_max_token_len_per_gpu: ${.ppo_max_token_len_per_gpu}
+  ppo_epochs: ${oc.select:actor_rollout_ref.actor.ppo_epochs,1}
+  shuffle: ${oc.select:actor_rollout_ref.actor.shuffle,false}
+  cliprange_value: 0.5
+  loss_agg_mode: ${oc.select:actor_rollout_ref.actor.loss_agg_mode,token-mean}
+  checkpoint:
+    _target_: verl.trainer.config.CheckpointConfig
+    save_contents:
+    - model
+    - optimizer
+    - extra
+    load_contents: ${.save_contents}
+    async_save: false
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config:
+      nsys:
+        _target_: verl.utils.profiler.config.NsightToolConfig
+        discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+      npu:
+        _target_: verl.utils.profiler.config.NPUToolConfig
+        contents: []
+        level: level1
+        analysis: true
+        discrete: false
+      torch:
+        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+        step_start: 0
+        step_end: null
+      torch_memory:
+        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+        trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+        stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+  forward_micro_batch_size: ${oc.select:.ppo_micro_batch_size,null}
+  forward_micro_batch_size_per_gpu: ${oc.select:.ppo_micro_batch_size_per_gpu,null}
+  ulysses_sequence_parallel_size: 1
+  grad_clip: 1.0
+reward_model:
+  enable: false
+  enable_resource_pool: false
+  n_gpus_per_node: 0
+  nnodes: 0
+  strategy: fsdp
+  model:
+    input_tokenizer: ${actor_rollout_ref.model.path}
+    path: ~/models/FsfairX-LLaMA3-RM-v0.1
+    external_lib: ${actor_rollout_ref.model.external_lib}
+    trust_remote_code: false
+    use_shm: false
+    use_remove_padding: false
+    use_fused_kernels: ${actor_rollout_ref.model.use_fused_kernels}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+  micro_batch_size: null
+  micro_batch_size_per_gpu: null
+  max_length: null
+  use_dynamic_bsz: ${critic.use_dynamic_bsz}
+  forward_max_token_len_per_gpu: ${critic.forward_max_token_len_per_gpu}
+  reward_manager: naive
+  launch_reward_fn_async: false
+  sandbox_fusion:
+    url: null
+    max_concurrent: 64
+    memory_limit_mb: 1024
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+  ulysses_sequence_parallel_size: 1
+custom_reward_function:
+  path: null
+  name: compute_score
+algorithm:
+  _target_: verl.trainer.config.AlgoConfig
+  gamma: 1.0
+  lam: 1.0
+  adv_estimator: gae
+  norm_adv_by_std_in_grpo: true
+  use_kl_in_reward: false
+  kl_penalty: kl
+  kl_ctrl:
+    _target_: verl.trainer.config.KLControlConfig
+    type: fixed
+    kl_coef: 0.0
+    horizon: 10000
+    target_kl: 0.1
+  use_pf_ppo: false
+  pf_ppo:
+    reweight_method: pow
+    weight_pow: 2.0
+  high_level_gamma: 0.95
+  bi_level_gae: false
+  zero_task_advantage: false
+  soft_advantage_reweight: false
+trainer:
+  balance_batch: true
+  total_epochs: 30
+  total_training_steps: 600
+  project_name: ragen
+  experiment_name: sokoban-main
+  logger:
+  - console
+  - wandb
+  log_val_generations: 0
+  rollout_data_dir: null
+  validation_data_dir: null
+  nnodes: 1
+  n_gpus_per_node: 8
+  save_freq: 100
+  esi_redundant_time: 0
+  resume_mode: auto
+  resume_from_path: null
+  val_before_train: true
+  val_only: false
+  test_freq: 10
+  critic_warmup: 0
+  default_hdfs_dir: null
+  del_local_ckpt_after_load: false
+  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
+  max_actor_ckpt_to_keep: 1
+  max_critic_ckpt_to_keep: 1
+  ray_wait_register_center_timeout: 300
+  device: cuda
+  use_legacy_worker_impl: auto
+  local_log_dir: results/
+  validation_steps: 1
+  generations_to_log_to_wandb:
+    val: 20
+  log_group_rv_table: false
+  gradient_analysis_mode: false
+  gradient_analysis_every: 50
+  gradient_analysis_env_groups: null
+  gradient_analysis_group_size: null
+  gradient_analysis_log_prefilter: false
+  gradient_analysis_only: false
+  exit_after_gradient_analysis: false
+global_profiler:
+  _target_: verl.utils.profiler.ProfilerConfig
+  tool: null
+  steps: null
+  profile_continuous_steps: false
+  save_path: outputs/profile
+  global_tool_config:
+    nsys:
+      _target_: verl.utils.profiler.config.NsightToolConfig
+      discrete: false
+      controller_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+      worker_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+        capture-range: cudaProfilerApi
+        capture-range-end: null
+        kill: none
+    torch_memory:
+      trace_alloc_max_entries: 100000
+      stack_depth: 32
+      context: all
+      stacks: all
+      kw_args: {}
+ray_kwargs:
+  ray_init:
+    num_cpus: null
+  timeline_json_file: null
+custom_envs:
+  SimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+  LargerSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 8
+      dim_y: 8
+      num_boxes: 2
+      max_steps: 100
+      search_depth: 10
+  SokobanDifferentGridVocab:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      search_depth: 30
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      grid_lookup:
+        0: W
+        1: .
+        2: G
+        3: C
+        4: B
+        5: A
+        6: '@'
+      grid_vocab:
+        W: wall
+        .: empty
+        G: target
+        C: box on target
+        B: box
+        A: player
+        '@': player on target
+  CoordSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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. \n\
+      Coordinates 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"
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      observation_format: grid_coord
+  VisualSimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      render_mode: rgb_array
+  Alfworld:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_in_distribution
+  AlfworldOOD:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_out_of_distribution
+  Countdown:
+    env_type: countdown
+    max_actions_per_traj: 1
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: null
+  Bandit:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: train
+  BanditTest:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: test
+  DeepCoder:
+    env_type: deepcoder
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving a coding task. Provide a complete Python function
+      solution only. Format: <answer>...</answer>'
+    max_tokens: 8000
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 1
+  FrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      success_rate: 0.8
+  CoordFrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>.
+
+      '
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      observation_format: grid_coord
+      success_rate: 0.8
+  MetamathQA:
+    env_type: metamathqa
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving Math problems. '
+    max_tokens: 100
+    env_config: null
+  WebShopFull:
+    env_type: webshop
+    max_actions_per_traj: 15
+    env_instruction: You are an expert autonomous agent operating in the WebShop e‑commerce
+      environment.
+    max_tokens: 200
+    env_config:
+      dataset: full
+  WebShop:
+    env_type: webshop
+    max_actions_per_traj: 9
+    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>].'
+    max_tokens: 200
+    env_config:
+      dataset: small
+  Lean:
+    env_type: lean
+    max_actions_per_traj: 30
+    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>.
+    max_tokens: 512
+    parallel_friendly: true
+    max_workers: 32
+    env_config: null
+  SimpleSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 20
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: easy
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  MediumSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 30
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: medium
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  SearchQA:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+  SearchQAMock:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+      mock_mode: true
+  game_2048:
+    env_type: game_2048
+    max_actions_per_traj: 700
+    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>
+
+      '
+    max_tokens: 8192
+    env_config: null
+  rubikscube:
+    env_type: rubikscube
+    max_actions_per_traj: 20
+    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>
+
+      '
+    max_tokens: 96
+    env_config:
+      scramble_depth: 1
+      max_steps: 20
+      render_mode: text
+system:
+  CUDA_VISIBLE_DEVICES: 0,1,2,3,4,5,6,7
+seed:
+  train: 10000
+  val: 123
+micro_batch_size_per_gpu: 1
+log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+ppo_mini_batch_size: 32
+model_path: /mnt/general/share/model/Qwen/Qwen2.5-3B-Instruct
+enable_response_mask: true
+grpo_advantage_length_weight: false
+lora:
+  rank: 0
+  alpha: 64
+  target_modules: all-linear
+agent_proxy:
+  context_window_mode: full
+  max_context_window: -1
+  batch_adjust_mode: copy
+  max_turn: 5
+  action_sep: '||'
+  max_actions_per_turn: 2
+  use_turn_scores: false
+  enable_think: true
+  reward_normalization:
+    grouping: state
+    method: identity
+collapse_detection:
+  compute_freq: 5
+  micro_batch_size: 128
+  first_turn_enabled: true
+  multi_turn_enabled: true
+  num_samples: 64
+es_manager:
+  format_penalty: -0.1
+  train:
+    env_groups: 8
+    group_size: 16
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 8
+  val:
+    env_groups: 512
+    group_size: 1
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 512
+ctx_manager:
+  generation:
+    gen_config:
+      response_length: ${actor_rollout_ref.rollout.response_length}
+      temperature: ${actor_rollout_ref.rollout.temperature}
+      top_p: ${actor_rollout_ref.rollout.top_p}
+      top_k: ${actor_rollout_ref.rollout.top_k}
+      kwargs: null

outputs/2026-04-30/19-02-13/.hydra/hydra.yaml

@@ -0,0 +1,175 @@
+hydra:
+  run:
+    dir: outputs/${now:%Y-%m-%d}/${now:%H-%M-%S}
+  sweep:
+    dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S}
+    subdir: ${hydra.job.num}
+  launcher:
+    _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher
+  sweeper:
+    _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper
+    max_batch_size: null
+    params: null
+  help:
+    app_name: ${hydra.job.name}
+    header: '${hydra.help.app_name} is powered by Hydra.
+
+      '
+    footer: 'Powered by Hydra (https://hydra.cc)
+
+      Use --hydra-help to view Hydra specific help
+
+      '
+    template: '${hydra.help.header}
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (group=option)
+
+
+      $APP_CONFIG_GROUPS
+
+
+      == Config ==
+
+      Override anything in the config (foo.bar=value)
+
+
+      $CONFIG
+
+
+      ${hydra.help.footer}
+
+      '
+  hydra_help:
+    template: 'Hydra (${hydra.runtime.version})
+
+      See https://hydra.cc for more info.
+
+
+      == Flags ==
+
+      $FLAGS_HELP
+
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (For example, append hydra/job_logging=disabled
+      to command line)
+
+
+      $HYDRA_CONFIG_GROUPS
+
+
+      Use ''--cfg hydra'' to Show the Hydra config.
+
+      '
+    hydra_help: ???
+  hydra_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][HYDRA] %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+    root:
+      level: INFO
+      handlers:
+      - console
+    loggers:
+      logging_example:
+        level: DEBUG
+    disable_existing_loggers: false
+  job_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+      file:
+        class: logging.FileHandler
+        formatter: simple
+        filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log
+    root:
+      level: INFO
+      handlers:
+      - console
+      - file
+    disable_existing_loggers: false
+  env: {}
+  mode: RUN
+  searchpath:
+  - pkg://verl.trainer.config
+  callbacks: {}
+  output_subdir: .hydra
+  overrides:
+    hydra:
+    - hydra.mode=RUN
+    task:
+    - actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+    - actor_rollout_ref.rollout.rollout_filter_value=0.9
+  job:
+    name: train
+    chdir: null
+    override_dirname: actor_rollout_ref.rollout.rollout_filter_strategy=top_p,actor_rollout_ref.rollout.rollout_filter_value=0.9
+    id: ???
+    num: ???
+    config_name: _2_sokoban
+    env_set: {}
+    env_copy: []
+    config:
+      override_dirname:
+        kv_sep: '='
+        item_sep: ','
+        exclude_keys: []
+  runtime:
+    version: 1.3.2
+    version_base: '1.3'
+    cwd: /mnt/general/wanghy/RAGEN_v2
+    config_sources:
+    - path: hydra.conf
+      schema: pkg
+      provider: hydra
+    - path: /mnt/general/wanghy/RAGEN_v2/config
+      schema: file
+      provider: main
+    - path: /mnt/general/wanghy/RAGEN_v2/verl/verl/trainer/config
+      schema: file
+      provider: command-line
+    - path: verl.trainer.config
+      schema: pkg
+      provider: hydra.searchpath in main
+    - path: ''
+      schema: structured
+      provider: schema
+    output_dir: /mnt/general/wanghy/RAGEN_v2/outputs/2026-04-30/19-02-13
+    choices:
+      reward_model: dp_reward_model
+      critic: dp_critic
+      critic/../engine@critic.model.fsdp_config: fsdp
+      critic/../optim@critic.optim: fsdp
+      model@actor_rollout_ref.model: hf_model
+      rollout@actor_rollout_ref.rollout: rollout
+      ref@actor_rollout_ref.ref: dp_ref
+      ref/../engine@actor_rollout_ref.ref.fsdp_config: fsdp
+      data: legacy_data
+      actor@actor_rollout_ref.actor: dp_actor
+      actor/../engine@actor_rollout_ref.actor.fsdp_config: fsdp
+      actor/../optim@actor_rollout_ref.actor.optim: fsdp
+      hydra/env: default
+      hydra/callbacks: null
+      hydra/job_logging: default
+      hydra/hydra_logging: default
+      hydra/hydra_help: default
+      hydra/help: default
+      hydra/sweeper: basic
+      hydra/launcher: basic
+      hydra/output: default
+  verbose: false

outputs/2026-04-30/19-02-13/.hydra/overrides.yaml

@@ -0,0 +1,2 @@
+- actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+- actor_rollout_ref.rollout.rollout_filter_value=0.9

outputs/2026-05-01/08-52-01/.hydra/config.yaml

@@ -0,0 +1,989 @@
+actor_rollout_ref:
+  actor:
+    optim:
+      _target_: verl.workers.config.FSDPOptimizerConfig
+      lr: 1.0e-06
+      lr_warmup_steps_ratio: 0.0
+      total_training_steps: -1
+      weight_decay: 0.01
+      lr_warmup_steps: -1
+      betas:
+      - 0.9
+      - 0.999
+      clip_grad: 1.0
+      min_lr_ratio: 0.0
+      num_cycles: 0.5
+      warmup_style: constant
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    _target_: verl.workers.config.FSDPActorConfig
+    strategy: fsdp
+    ppo_mini_batch_size: ${ppo_mini_batch_size}
+    ppo_micro_batch_size: null
+    ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+    use_dynamic_bsz: false
+    ppo_max_token_len_per_gpu: 16384
+    clip_ratio: 0.2
+    clip_ratio_low: 0.2
+    clip_ratio_high: 0.28
+    freeze_vision_tower: false
+    policy_loss:
+      _target_: verl.workers.config.PolicyLossConfig
+      loss_mode: vanilla
+      clip_cov_ratio: 0.0002
+      clip_cov_lb: 1.0
+      clip_cov_ub: 5.0
+      kl_cov_ratio: 0.0002
+      ppo_kl_coef: 0.1
+    clip_ratio_c: 3.0
+    loss_agg_mode: token-mean
+    entropy_coeff: 0.001
+    tis_imp_ratio_cap: -1
+    use_kl_loss: false
+    use_torch_compile: true
+    kl_loss_coef: 0.0
+    kl_loss_type: kl
+    ppo_epochs: 1
+    shuffle: false
+    checkpoint:
+      _target_: verl.trainer.config.CheckpointConfig
+      save_contents:
+      - model
+      - optimizer
+      - extra
+      load_contents: ${.save_contents}
+      async_save: false
+    use_fused_kernels: ${oc.select:actor_rollout_ref.model.use_fused_kernels,false}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    grad_clip: 1.0
+    ulysses_sequence_parallel_size: 1
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+    use_remove_padding: ${oc.select:actor_rollout_ref.model.use_remove_padding,false}
+    use_ref: true
+    grpo_advantage_length_weight: ${grpo_advantage_length_weight}
+    filter_loss_scaling: none
+  ref:
+    strategy: ${actor_rollout_ref.actor.strategy}
+    use_torch_compile: ${oc.select:actor_rollout_ref.actor.use_torch_compile,true}
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    model: null
+    ulysses_sequence_parallel_size: ${oc.select:actor_rollout_ref.actor.ulysses_sequence_parallel_size,1}
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+  rollout:
+    _target_: verl.workers.config.RolloutConfig
+    name: vllm
+    mode: sync
+    temperature: 1
+    top_k: -1
+    top_p: 1
+    prompt_length: 1
+    response_length: 400
+    dtype: bfloat16
+    gpu_memory_utilization: 0.8
+    ignore_eos: false
+    enforce_eager: true
+    cudagraph_capture_sizes: null
+    free_cache_engine: true
+    tensor_model_parallel_size: 1
+    data_parallel_size: 1
+    expert_parallel_size: 1
+    max_num_batched_tokens: 8192
+    max_model_len: 3600
+    max_num_seqs: 1024
+    enable_chunked_prefill: true
+    enable_prefix_caching: true
+    load_format: auto
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    disable_log_stats: true
+    do_sample: true
+    'n': 1
+    over_sample_rate: 0
+    multi_stage_wake_up: false
+    engine_kwargs:
+      vllm: {}
+      sglang: {}
+    val_kwargs:
+      _target_: verl.workers.config.SamplingConfig
+      top_k: -1
+      top_p: 1.0
+      temperature: 0.5
+      'n': 1
+      do_sample: true
+    multi_turn:
+      _target_: verl.workers.config.MultiTurnConfig
+      enable: false
+      max_assistant_turns: null
+      tool_config_path: null
+      max_user_turns: null
+      max_parallel_calls: 1
+      max_tool_response_length: 256
+      tool_response_truncate_side: middle
+      interaction_config_path: null
+      use_inference_chat_template: false
+      tokenization_sanity_check_mode: strict
+      format: hermes
+      num_repeat_rollouts: null
+    calculate_log_probs: false
+    agent:
+      _target_: verl.workers.config.AgentLoopConfig
+      num_workers: 8
+      agent_loop_config_path: null
+      custom_async_server:
+        _target_: verl.workers.config.CustomAsyncServerConfig
+        path: null
+        name: null
+    update_weights_bucket_megabytes: 512
+    trace:
+      _target_: verl.workers.config.TraceConfig
+      backend: null
+      token2text: false
+    skip_rollout: false
+    skip_dump_dir: /tmp/rollout_dump
+    skip_tokenizer_init: true
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: ${oc.select:actor_rollout_ref.actor.profiler.enable,false}
+      all_ranks: ${oc.select:actor_rollout_ref.actor.profiler.all_ranks,false}
+      ranks: ${oc.select:actor_rollout_ref.actor.profiler.ranks,[]}
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+    layered_summon: false
+    rollout_filter_value: 0.9
+    rollout_filter_strategy: top_p
+    rollout_filter_type: largest
+    rollout_filter_include_zero: true
+    rollout_filter_top_p_prob_mode: linear
+    rollout_filter_selection_eps: 0.01
+    rollout_filter_empty_stop_steps: 5
+    rollout_filter_metric: reward_variance
+    gradient_analysis_num_buckets: 6
+    gradient_analysis_bucket_mode: quantile
+  model:
+    _target_: verl.workers.config.HFModelConfig
+    path: ${model_path}
+    hf_config_path: null
+    tokenizer_path: null
+    use_shm: false
+    trust_remote_code: false
+    custom_chat_template: null
+    external_lib: null
+    override_config: {}
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+    exclude_modules: null
+    use_liger: false
+    use_fused_kernels: false
+    fused_kernel_options:
+      impl_backend: torch
+  hybrid_engine: true
+  nccl_timeout: 600
+data:
+  tokenizer: null
+  use_shm: false
+  train_files: ~/data/rlhf/gsm8k/train.parquet
+  val_files: ~/data/rlhf/gsm8k/test.parquet
+  prompt_key: prompt
+  reward_fn_key: data_source
+  max_prompt_length: null
+  max_response_length: null
+  train_batch_size: null
+  val_batch_size: null
+  return_raw_input_ids: false
+  return_raw_chat: false
+  return_full_prompt: false
+  shuffle: true
+  dataloader_num_workers: 8
+  validation_shuffle: false
+  filter_overlong_prompts: false
+  filter_overlong_prompts_workers: 1
+  truncation: error
+  image_key: images
+  video_key: videos
+  trust_remote_code: false
+  custom_cls:
+    path: null
+    name: null
+  return_multi_modal_inputs: true
+  sampler:
+    class_path: null
+    class_name: null
+  datagen:
+    path: null
+    name: null
+  apply_chat_template_kwargs: {}
+critic:
+  optim:
+    _target_: verl.workers.config.FSDPOptimizerConfig
+    lr: 1.0e-05
+    lr_warmup_steps_ratio: 0.0
+    total_training_steps: -1
+    weight_decay: 0.01
+    lr_warmup_steps: -1
+    betas:
+    - 0.9
+    - 0.999
+    clip_grad: 1.0
+    min_lr_ratio: 0.0
+    num_cycles: 0.5
+    warmup_style: constant
+  model:
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    path: ${model_path}
+    tokenizer_path: ${oc.select:actor_rollout_ref.model.path,"~/models/deepseek-llm-7b-chat"}
+    override_config: {}
+    external_lib: ${oc.select:actor_rollout_ref.model.external_lib,null}
+    trust_remote_code: ${oc.select:actor_rollout_ref.model.trust_remote_code,false}
+    _target_: verl.workers.config.FSDPCriticModelCfg
+    use_shm: false
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+  _target_: verl.workers.config.FSDPCriticConfig
+  rollout_n: ${oc.select:actor_rollout_ref.rollout.n,1}
+  strategy: fsdp
+  enable: null
+  ppo_mini_batch_size: ${ppo_mini_batch_size}
+  ppo_micro_batch_size: null
+  ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+  use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+  ppo_max_token_len_per_gpu: 32768
+  forward_max_token_len_per_gpu: ${.ppo_max_token_len_per_gpu}
+  ppo_epochs: ${oc.select:actor_rollout_ref.actor.ppo_epochs,1}
+  shuffle: ${oc.select:actor_rollout_ref.actor.shuffle,false}
+  cliprange_value: 0.5
+  loss_agg_mode: ${oc.select:actor_rollout_ref.actor.loss_agg_mode,token-mean}
+  checkpoint:
+    _target_: verl.trainer.config.CheckpointConfig
+    save_contents:
+    - model
+    - optimizer
+    - extra
+    load_contents: ${.save_contents}
+    async_save: false
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config:
+      nsys:
+        _target_: verl.utils.profiler.config.NsightToolConfig
+        discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+      npu:
+        _target_: verl.utils.profiler.config.NPUToolConfig
+        contents: []
+        level: level1
+        analysis: true
+        discrete: false
+      torch:
+        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+        step_start: 0
+        step_end: null
+      torch_memory:
+        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+        trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+        stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+  forward_micro_batch_size: ${oc.select:.ppo_micro_batch_size,null}
+  forward_micro_batch_size_per_gpu: ${oc.select:.ppo_micro_batch_size_per_gpu,null}
+  ulysses_sequence_parallel_size: 1
+  grad_clip: 1.0
+reward_model:
+  enable: false
+  enable_resource_pool: false
+  n_gpus_per_node: 0
+  nnodes: 0
+  strategy: fsdp
+  model:
+    input_tokenizer: ${actor_rollout_ref.model.path}
+    path: ~/models/FsfairX-LLaMA3-RM-v0.1
+    external_lib: ${actor_rollout_ref.model.external_lib}
+    trust_remote_code: false
+    use_shm: false
+    use_remove_padding: false
+    use_fused_kernels: ${actor_rollout_ref.model.use_fused_kernels}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+  micro_batch_size: null
+  micro_batch_size_per_gpu: null
+  max_length: null
+  use_dynamic_bsz: ${critic.use_dynamic_bsz}
+  forward_max_token_len_per_gpu: ${critic.forward_max_token_len_per_gpu}
+  reward_manager: naive
+  launch_reward_fn_async: false
+  sandbox_fusion:
+    url: null
+    max_concurrent: 64
+    memory_limit_mb: 1024
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+  ulysses_sequence_parallel_size: 1
+custom_reward_function:
+  path: null
+  name: compute_score
+algorithm:
+  _target_: verl.trainer.config.AlgoConfig
+  gamma: 1.0
+  lam: 1.0
+  adv_estimator: gae
+  norm_adv_by_std_in_grpo: true
+  use_kl_in_reward: false
+  kl_penalty: kl
+  kl_ctrl:
+    _target_: verl.trainer.config.KLControlConfig
+    type: fixed
+    kl_coef: 0.0
+    horizon: 10000
+    target_kl: 0.1
+  use_pf_ppo: false
+  pf_ppo:
+    reweight_method: pow
+    weight_pow: 2.0
+  high_level_gamma: 0.95
+  bi_level_gae: false
+  zero_task_advantage: false
+  soft_advantage_reweight: false
+trainer:
+  balance_batch: true
+  total_epochs: 30
+  total_training_steps: 600
+  project_name: ragen
+  experiment_name: sokoban-main
+  logger:
+  - console
+  - wandb
+  log_val_generations: 0
+  rollout_data_dir: null
+  validation_data_dir: null
+  nnodes: 1
+  n_gpus_per_node: 8
+  save_freq: 100
+  esi_redundant_time: 0
+  resume_mode: auto
+  resume_from_path: null
+  val_before_train: true
+  val_only: false
+  test_freq: 10
+  critic_warmup: 0
+  default_hdfs_dir: null
+  del_local_ckpt_after_load: false
+  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
+  max_actor_ckpt_to_keep: 1
+  max_critic_ckpt_to_keep: 1
+  ray_wait_register_center_timeout: 300
+  device: cuda
+  use_legacy_worker_impl: auto
+  local_log_dir: results/
+  validation_steps: 1
+  generations_to_log_to_wandb:
+    val: 20
+  log_group_rv_table: false
+  gradient_analysis_mode: false
+  gradient_analysis_every: 50
+  gradient_analysis_env_groups: null
+  gradient_analysis_group_size: null
+  gradient_analysis_log_prefilter: false
+  gradient_analysis_only: false
+  exit_after_gradient_analysis: false
+global_profiler:
+  _target_: verl.utils.profiler.ProfilerConfig
+  tool: null
+  steps: null
+  profile_continuous_steps: false
+  save_path: outputs/profile
+  global_tool_config:
+    nsys:
+      _target_: verl.utils.profiler.config.NsightToolConfig
+      discrete: false
+      controller_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+      worker_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+        capture-range: cudaProfilerApi
+        capture-range-end: null
+        kill: none
+    torch_memory:
+      trace_alloc_max_entries: 100000
+      stack_depth: 32
+      context: all
+      stacks: all
+      kw_args: {}
+ray_kwargs:
+  ray_init:
+    num_cpus: null
+  timeline_json_file: null
+custom_envs:
+  SimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+  LargerSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 8
+      dim_y: 8
+      num_boxes: 2
+      max_steps: 100
+      search_depth: 10
+  SokobanDifferentGridVocab:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      search_depth: 30
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      grid_lookup:
+        0: W
+        1: .
+        2: G
+        3: C
+        4: B
+        5: A
+        6: '@'
+      grid_vocab:
+        W: wall
+        .: empty
+        G: target
+        C: box on target
+        B: box
+        A: player
+        '@': player on target
+  CoordSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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. \n\
+      Coordinates 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"
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      observation_format: grid_coord
+  VisualSimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      render_mode: rgb_array
+  Alfworld:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_in_distribution
+  AlfworldOOD:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_out_of_distribution
+  Countdown:
+    env_type: countdown
+    max_actions_per_traj: 1
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: null
+  Bandit:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: train
+  BanditTest:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: test
+  DeepCoder:
+    env_type: deepcoder
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving a coding task. Provide a complete Python function
+      solution only. Format: <answer>...</answer>'
+    max_tokens: 8000
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 1
+  FrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      success_rate: 0.8
+  CoordFrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>.
+
+      '
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      observation_format: grid_coord
+      success_rate: 0.8
+  MetamathQA:
+    env_type: metamathqa
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving Math problems. '
+    max_tokens: 100
+    env_config: null
+  WebShopFull:
+    env_type: webshop
+    max_actions_per_traj: 15
+    env_instruction: You are an expert autonomous agent operating in the WebShop e‑commerce
+      environment.
+    max_tokens: 200
+    env_config:
+      dataset: full
+  WebShop:
+    env_type: webshop
+    max_actions_per_traj: 9
+    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>].'
+    max_tokens: 200
+    env_config:
+      dataset: small
+  Lean:
+    env_type: lean
+    max_actions_per_traj: 30
+    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>.
+    max_tokens: 512
+    parallel_friendly: true
+    max_workers: 32
+    env_config: null
+  SimpleSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 20
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: easy
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  MediumSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 30
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: medium
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  SearchQA:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+  SearchQAMock:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+      mock_mode: true
+  game_2048:
+    env_type: game_2048
+    max_actions_per_traj: 700
+    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>
+
+      '
+    max_tokens: 8192
+    env_config: null
+  rubikscube:
+    env_type: rubikscube
+    max_actions_per_traj: 20
+    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>
+
+      '
+    max_tokens: 96
+    env_config:
+      scramble_depth: 1
+      max_steps: 20
+      render_mode: text
+system:
+  CUDA_VISIBLE_DEVICES: 0,1,2,3,4,5,6,7
+seed:
+  train: 10000
+  val: 123
+micro_batch_size_per_gpu: 1
+log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+ppo_mini_batch_size: 32
+model_path: /mnt/general/share/model/Qwen/Qwen2.5-3B-Instruct
+enable_response_mask: true
+grpo_advantage_length_weight: false
+lora:
+  rank: 0
+  alpha: 64
+  target_modules: all-linear
+agent_proxy:
+  context_window_mode: full
+  max_context_window: -1
+  batch_adjust_mode: copy
+  max_turn: 5
+  action_sep: '||'
+  max_actions_per_turn: 2
+  use_turn_scores: false
+  enable_think: true
+  reward_normalization:
+    grouping: state
+    method: identity
+collapse_detection:
+  compute_freq: 5
+  micro_batch_size: 128
+  first_turn_enabled: true
+  multi_turn_enabled: true
+  num_samples: 64
+es_manager:
+  format_penalty: -0.1
+  train:
+    env_groups: 8
+    group_size: 16
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 8
+  val:
+    env_groups: 512
+    group_size: 1
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 512
+ctx_manager:
+  generation:
+    gen_config:
+      response_length: ${actor_rollout_ref.rollout.response_length}
+      temperature: ${actor_rollout_ref.rollout.temperature}
+      top_p: ${actor_rollout_ref.rollout.top_p}
+      top_k: ${actor_rollout_ref.rollout.top_k}
+      kwargs: null

outputs/2026-05-01/08-52-01/.hydra/hydra.yaml

@@ -0,0 +1,175 @@
+hydra:
+  run:
+    dir: outputs/${now:%Y-%m-%d}/${now:%H-%M-%S}
+  sweep:
+    dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S}
+    subdir: ${hydra.job.num}
+  launcher:
+    _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher
+  sweeper:
+    _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper
+    max_batch_size: null
+    params: null
+  help:
+    app_name: ${hydra.job.name}
+    header: '${hydra.help.app_name} is powered by Hydra.
+
+      '
+    footer: 'Powered by Hydra (https://hydra.cc)
+
+      Use --hydra-help to view Hydra specific help
+
+      '
+    template: '${hydra.help.header}
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (group=option)
+
+
+      $APP_CONFIG_GROUPS
+
+
+      == Config ==
+
+      Override anything in the config (foo.bar=value)
+
+
+      $CONFIG
+
+
+      ${hydra.help.footer}
+
+      '
+  hydra_help:
+    template: 'Hydra (${hydra.runtime.version})
+
+      See https://hydra.cc for more info.
+
+
+      == Flags ==
+
+      $FLAGS_HELP
+
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (For example, append hydra/job_logging=disabled
+      to command line)
+
+
+      $HYDRA_CONFIG_GROUPS
+
+
+      Use ''--cfg hydra'' to Show the Hydra config.
+
+      '
+    hydra_help: ???
+  hydra_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][HYDRA] %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+    root:
+      level: INFO
+      handlers:
+      - console
+    loggers:
+      logging_example:
+        level: DEBUG
+    disable_existing_loggers: false
+  job_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+      file:
+        class: logging.FileHandler
+        formatter: simple
+        filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log
+    root:
+      level: INFO
+      handlers:
+      - console
+      - file
+    disable_existing_loggers: false
+  env: {}
+  mode: RUN
+  searchpath:
+  - pkg://verl.trainer.config
+  callbacks: {}
+  output_subdir: .hydra
+  overrides:
+    hydra:
+    - hydra.mode=RUN
+    task:
+    - actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+    - actor_rollout_ref.rollout.rollout_filter_value=0.9
+  job:
+    name: train
+    chdir: null
+    override_dirname: actor_rollout_ref.rollout.rollout_filter_strategy=top_p,actor_rollout_ref.rollout.rollout_filter_value=0.9
+    id: ???
+    num: ???
+    config_name: _2_sokoban
+    env_set: {}
+    env_copy: []
+    config:
+      override_dirname:
+        kv_sep: '='
+        item_sep: ','
+        exclude_keys: []
+  runtime:
+    version: 1.3.2
+    version_base: '1.3'
+    cwd: /mnt/general/wanghy/RAGEN_v2
+    config_sources:
+    - path: hydra.conf
+      schema: pkg
+      provider: hydra
+    - path: /mnt/general/wanghy/RAGEN_v2/config
+      schema: file
+      provider: main
+    - path: /mnt/general/wanghy/RAGEN_v2/verl/verl/trainer/config
+      schema: file
+      provider: command-line
+    - path: verl.trainer.config
+      schema: pkg
+      provider: hydra.searchpath in main
+    - path: ''
+      schema: structured
+      provider: schema
+    output_dir: /mnt/general/wanghy/RAGEN_v2/outputs/2026-05-01/08-52-01
+    choices:
+      reward_model: dp_reward_model
+      critic: dp_critic
+      critic/../engine@critic.model.fsdp_config: fsdp
+      critic/../optim@critic.optim: fsdp
+      model@actor_rollout_ref.model: hf_model
+      rollout@actor_rollout_ref.rollout: rollout
+      ref@actor_rollout_ref.ref: dp_ref
+      ref/../engine@actor_rollout_ref.ref.fsdp_config: fsdp
+      data: legacy_data
+      actor@actor_rollout_ref.actor: dp_actor
+      actor/../engine@actor_rollout_ref.actor.fsdp_config: fsdp
+      actor/../optim@actor_rollout_ref.actor.optim: fsdp
+      hydra/env: default
+      hydra/callbacks: null
+      hydra/job_logging: default
+      hydra/hydra_logging: default
+      hydra/hydra_help: default
+      hydra/help: default
+      hydra/sweeper: basic
+      hydra/launcher: basic
+      hydra/output: default
+  verbose: false

outputs/2026-05-01/08-52-01/.hydra/overrides.yaml

@@ -0,0 +1,2 @@
+- actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+- actor_rollout_ref.rollout.rollout_filter_value=0.9

outputs/2026-05-11/10-46-20/.hydra/overrides.yaml

@@ -0,0 +1,2 @@
+- actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+- actor_rollout_ref.rollout.rollout_filter_value=0.9

outputs/2026-05-11/10-52-37/.hydra/config.yaml

@@ -0,0 +1,989 @@
+actor_rollout_ref:
+  actor:
+    optim:
+      _target_: verl.workers.config.FSDPOptimizerConfig
+      lr: 1.0e-06
+      lr_warmup_steps_ratio: 0.0
+      total_training_steps: -1
+      weight_decay: 0.01
+      lr_warmup_steps: -1
+      betas:
+      - 0.9
+      - 0.999
+      clip_grad: 1.0
+      min_lr_ratio: 0.0
+      num_cycles: 0.5
+      warmup_style: constant
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    _target_: verl.workers.config.FSDPActorConfig
+    strategy: fsdp
+    ppo_mini_batch_size: ${ppo_mini_batch_size}
+    ppo_micro_batch_size: null
+    ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+    use_dynamic_bsz: false
+    ppo_max_token_len_per_gpu: 16384
+    clip_ratio: 0.2
+    clip_ratio_low: 0.2
+    clip_ratio_high: 0.28
+    freeze_vision_tower: false
+    policy_loss:
+      _target_: verl.workers.config.PolicyLossConfig
+      loss_mode: vanilla
+      clip_cov_ratio: 0.0002
+      clip_cov_lb: 1.0
+      clip_cov_ub: 5.0
+      kl_cov_ratio: 0.0002
+      ppo_kl_coef: 0.1
+    clip_ratio_c: 3.0
+    loss_agg_mode: token-mean
+    entropy_coeff: 0.001
+    tis_imp_ratio_cap: -1
+    use_kl_loss: false
+    use_torch_compile: true
+    kl_loss_coef: 0.0
+    kl_loss_type: kl
+    ppo_epochs: 1
+    shuffle: false
+    checkpoint:
+      _target_: verl.trainer.config.CheckpointConfig
+      save_contents:
+      - model
+      - optimizer
+      - extra
+      load_contents: ${.save_contents}
+      async_save: false
+    use_fused_kernels: ${oc.select:actor_rollout_ref.model.use_fused_kernels,false}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    grad_clip: 1.0
+    ulysses_sequence_parallel_size: 1
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+    use_remove_padding: ${oc.select:actor_rollout_ref.model.use_remove_padding,false}
+    use_ref: true
+    grpo_advantage_length_weight: ${grpo_advantage_length_weight}
+    filter_loss_scaling: none
+  ref:
+    strategy: ${actor_rollout_ref.actor.strategy}
+    use_torch_compile: ${oc.select:actor_rollout_ref.actor.use_torch_compile,true}
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    model: null
+    ulysses_sequence_parallel_size: ${oc.select:actor_rollout_ref.actor.ulysses_sequence_parallel_size,1}
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+  rollout:
+    _target_: verl.workers.config.RolloutConfig
+    name: vllm
+    mode: sync
+    temperature: 1
+    top_k: -1
+    top_p: 1
+    prompt_length: 1
+    response_length: 400
+    dtype: bfloat16
+    gpu_memory_utilization: 0.8
+    ignore_eos: false
+    enforce_eager: true
+    cudagraph_capture_sizes: null
+    free_cache_engine: true
+    tensor_model_parallel_size: 1
+    data_parallel_size: 1
+    expert_parallel_size: 1
+    max_num_batched_tokens: 8192
+    max_model_len: 3600
+    max_num_seqs: 1024
+    enable_chunked_prefill: true
+    enable_prefix_caching: true
+    load_format: auto
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    disable_log_stats: true
+    do_sample: true
+    'n': 1
+    over_sample_rate: 0
+    multi_stage_wake_up: false
+    engine_kwargs:
+      vllm: {}
+      sglang: {}
+    val_kwargs:
+      _target_: verl.workers.config.SamplingConfig
+      top_k: -1
+      top_p: 1.0
+      temperature: 0.5
+      'n': 1
+      do_sample: true
+    multi_turn:
+      _target_: verl.workers.config.MultiTurnConfig
+      enable: false
+      max_assistant_turns: null
+      tool_config_path: null
+      max_user_turns: null
+      max_parallel_calls: 1
+      max_tool_response_length: 256
+      tool_response_truncate_side: middle
+      interaction_config_path: null
+      use_inference_chat_template: false
+      tokenization_sanity_check_mode: strict
+      format: hermes
+      num_repeat_rollouts: null
+    calculate_log_probs: false
+    agent:
+      _target_: verl.workers.config.AgentLoopConfig
+      num_workers: 8
+      agent_loop_config_path: null
+      custom_async_server:
+        _target_: verl.workers.config.CustomAsyncServerConfig
+        path: null
+        name: null
+    update_weights_bucket_megabytes: 512
+    trace:
+      _target_: verl.workers.config.TraceConfig
+      backend: null
+      token2text: false
+    skip_rollout: false
+    skip_dump_dir: /tmp/rollout_dump
+    skip_tokenizer_init: true
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: ${oc.select:actor_rollout_ref.actor.profiler.enable,false}
+      all_ranks: ${oc.select:actor_rollout_ref.actor.profiler.all_ranks,false}
+      ranks: ${oc.select:actor_rollout_ref.actor.profiler.ranks,[]}
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+    layered_summon: false
+    rollout_filter_value: 0.9
+    rollout_filter_strategy: top_p
+    rollout_filter_type: largest
+    rollout_filter_include_zero: true
+    rollout_filter_top_p_prob_mode: linear
+    rollout_filter_selection_eps: 0.01
+    rollout_filter_empty_stop_steps: 5
+    rollout_filter_metric: reward_variance
+    gradient_analysis_num_buckets: 6
+    gradient_analysis_bucket_mode: quantile
+  model:
+    _target_: verl.workers.config.HFModelConfig
+    path: ${model_path}
+    hf_config_path: null
+    tokenizer_path: null
+    use_shm: false
+    trust_remote_code: false
+    custom_chat_template: null
+    external_lib: null
+    override_config: {}
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+    exclude_modules: null
+    use_liger: false
+    use_fused_kernels: false
+    fused_kernel_options:
+      impl_backend: torch
+  hybrid_engine: true
+  nccl_timeout: 600
+data:
+  tokenizer: null
+  use_shm: false
+  train_files: ~/data/rlhf/gsm8k/train.parquet
+  val_files: ~/data/rlhf/gsm8k/test.parquet
+  prompt_key: prompt
+  reward_fn_key: data_source
+  max_prompt_length: null
+  max_response_length: null
+  train_batch_size: null
+  val_batch_size: null
+  return_raw_input_ids: false
+  return_raw_chat: false
+  return_full_prompt: false
+  shuffle: true
+  dataloader_num_workers: 8
+  validation_shuffle: false
+  filter_overlong_prompts: false
+  filter_overlong_prompts_workers: 1
+  truncation: error
+  image_key: images
+  video_key: videos
+  trust_remote_code: false
+  custom_cls:
+    path: null
+    name: null
+  return_multi_modal_inputs: true
+  sampler:
+    class_path: null
+    class_name: null
+  datagen:
+    path: null
+    name: null
+  apply_chat_template_kwargs: {}
+critic:
+  optim:
+    _target_: verl.workers.config.FSDPOptimizerConfig
+    lr: 1.0e-05
+    lr_warmup_steps_ratio: 0.0
+    total_training_steps: -1
+    weight_decay: 0.01
+    lr_warmup_steps: -1
+    betas:
+    - 0.9
+    - 0.999
+    clip_grad: 1.0
+    min_lr_ratio: 0.0
+    num_cycles: 0.5
+    warmup_style: constant
+  model:
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    path: ${model_path}
+    tokenizer_path: ${oc.select:actor_rollout_ref.model.path,"~/models/deepseek-llm-7b-chat"}
+    override_config: {}
+    external_lib: ${oc.select:actor_rollout_ref.model.external_lib,null}
+    trust_remote_code: ${oc.select:actor_rollout_ref.model.trust_remote_code,false}
+    _target_: verl.workers.config.FSDPCriticModelCfg
+    use_shm: false
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+  _target_: verl.workers.config.FSDPCriticConfig
+  rollout_n: ${oc.select:actor_rollout_ref.rollout.n,1}
+  strategy: fsdp
+  enable: null
+  ppo_mini_batch_size: ${ppo_mini_batch_size}
+  ppo_micro_batch_size: null
+  ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+  use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+  ppo_max_token_len_per_gpu: 32768
+  forward_max_token_len_per_gpu: ${.ppo_max_token_len_per_gpu}
+  ppo_epochs: ${oc.select:actor_rollout_ref.actor.ppo_epochs,1}
+  shuffle: ${oc.select:actor_rollout_ref.actor.shuffle,false}
+  cliprange_value: 0.5
+  loss_agg_mode: ${oc.select:actor_rollout_ref.actor.loss_agg_mode,token-mean}
+  checkpoint:
+    _target_: verl.trainer.config.CheckpointConfig
+    save_contents:
+    - model
+    - optimizer
+    - extra
+    load_contents: ${.save_contents}
+    async_save: false
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config:
+      nsys:
+        _target_: verl.utils.profiler.config.NsightToolConfig
+        discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+      npu:
+        _target_: verl.utils.profiler.config.NPUToolConfig
+        contents: []
+        level: level1
+        analysis: true
+        discrete: false
+      torch:
+        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+        step_start: 0
+        step_end: null
+      torch_memory:
+        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+        trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+        stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+  forward_micro_batch_size: ${oc.select:.ppo_micro_batch_size,null}
+  forward_micro_batch_size_per_gpu: ${oc.select:.ppo_micro_batch_size_per_gpu,null}
+  ulysses_sequence_parallel_size: 1
+  grad_clip: 1.0
+reward_model:
+  enable: false
+  enable_resource_pool: false
+  n_gpus_per_node: 0
+  nnodes: 0
+  strategy: fsdp
+  model:
+    input_tokenizer: ${actor_rollout_ref.model.path}
+    path: ~/models/FsfairX-LLaMA3-RM-v0.1
+    external_lib: ${actor_rollout_ref.model.external_lib}
+    trust_remote_code: false
+    use_shm: false
+    use_remove_padding: false
+    use_fused_kernels: ${actor_rollout_ref.model.use_fused_kernels}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+  micro_batch_size: null
+  micro_batch_size_per_gpu: null
+  max_length: null
+  use_dynamic_bsz: ${critic.use_dynamic_bsz}
+  forward_max_token_len_per_gpu: ${critic.forward_max_token_len_per_gpu}
+  reward_manager: naive
+  launch_reward_fn_async: false
+  sandbox_fusion:
+    url: null
+    max_concurrent: 64
+    memory_limit_mb: 1024
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+  ulysses_sequence_parallel_size: 1
+custom_reward_function:
+  path: null
+  name: compute_score
+algorithm:
+  _target_: verl.trainer.config.AlgoConfig
+  gamma: 1.0
+  lam: 1.0
+  adv_estimator: gae
+  norm_adv_by_std_in_grpo: true
+  use_kl_in_reward: false
+  kl_penalty: kl
+  kl_ctrl:
+    _target_: verl.trainer.config.KLControlConfig
+    type: fixed
+    kl_coef: 0.0
+    horizon: 10000
+    target_kl: 0.1
+  use_pf_ppo: false
+  pf_ppo:
+    reweight_method: pow
+    weight_pow: 2.0
+  high_level_gamma: 0.95
+  bi_level_gae: false
+  zero_task_advantage: false
+  soft_advantage_reweight: false
+trainer:
+  balance_batch: true
+  total_epochs: 30
+  total_training_steps: 1000
+  project_name: ragen
+  experiment_name: sokoban-main
+  logger:
+  - console
+  - wandb
+  log_val_generations: 0
+  rollout_data_dir: null
+  validation_data_dir: null
+  nnodes: 1
+  n_gpus_per_node: 8
+  save_freq: -1
+  esi_redundant_time: 0
+  resume_mode: auto
+  resume_from_path: null
+  val_before_train: true
+  val_only: false
+  test_freq: 10
+  critic_warmup: 0
+  default_hdfs_dir: null
+  del_local_ckpt_after_load: false
+  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
+  max_actor_ckpt_to_keep: 1
+  max_critic_ckpt_to_keep: 1
+  ray_wait_register_center_timeout: 300
+  device: cuda
+  use_legacy_worker_impl: auto
+  local_log_dir: results/
+  validation_steps: 1
+  generations_to_log_to_wandb:
+    val: 20
+  log_group_rv_table: false
+  gradient_analysis_mode: false
+  gradient_analysis_every: 50
+  gradient_analysis_env_groups: null
+  gradient_analysis_group_size: null
+  gradient_analysis_log_prefilter: false
+  gradient_analysis_only: false
+  exit_after_gradient_analysis: false
+global_profiler:
+  _target_: verl.utils.profiler.ProfilerConfig
+  tool: null
+  steps: null
+  profile_continuous_steps: false
+  save_path: outputs/profile
+  global_tool_config:
+    nsys:
+      _target_: verl.utils.profiler.config.NsightToolConfig
+      discrete: false
+      controller_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+      worker_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+        capture-range: cudaProfilerApi
+        capture-range-end: null
+        kill: none
+    torch_memory:
+      trace_alloc_max_entries: 100000
+      stack_depth: 32
+      context: all
+      stacks: all
+      kw_args: {}
+ray_kwargs:
+  ray_init:
+    num_cpus: null
+  timeline_json_file: null
+custom_envs:
+  SimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+  LargerSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 8
+      dim_y: 8
+      num_boxes: 2
+      max_steps: 100
+      search_depth: 10
+  SokobanDifferentGridVocab:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      search_depth: 30
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      grid_lookup:
+        0: W
+        1: .
+        2: G
+        3: C
+        4: B
+        5: A
+        6: '@'
+      grid_vocab:
+        W: wall
+        .: empty
+        G: target
+        C: box on target
+        B: box
+        A: player
+        '@': player on target
+  CoordSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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. \n\
+      Coordinates 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"
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      observation_format: grid_coord
+  VisualSimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      render_mode: rgb_array
+  Alfworld:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_in_distribution
+  AlfworldOOD:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_out_of_distribution
+  Countdown:
+    env_type: countdown
+    max_actions_per_traj: 1
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: null
+  Bandit:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: train
+  BanditTest:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: test
+  DeepCoder:
+    env_type: deepcoder
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving a coding task. Provide a complete Python function
+      solution only. Format: <answer>...</answer>'
+    max_tokens: 8000
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 1
+  FrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      success_rate: 0.8
+  CoordFrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>.
+
+      '
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      observation_format: grid_coord
+      success_rate: 0.8
+  MetamathQA:
+    env_type: metamathqa
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving Math problems. '
+    max_tokens: 100
+    env_config: null
+  WebShopFull:
+    env_type: webshop
+    max_actions_per_traj: 15
+    env_instruction: You are an expert autonomous agent operating in the WebShop e‑commerce
+      environment.
+    max_tokens: 200
+    env_config:
+      dataset: full
+  WebShop:
+    env_type: webshop
+    max_actions_per_traj: 9
+    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>].'
+    max_tokens: 200
+    env_config:
+      dataset: small
+  Lean:
+    env_type: lean
+    max_actions_per_traj: 30
+    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>.
+    max_tokens: 512
+    parallel_friendly: true
+    max_workers: 32
+    env_config: null
+  SimpleSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 20
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: easy
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  MediumSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 30
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: medium
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  SearchQA:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+  SearchQAMock:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+      mock_mode: true
+  game_2048:
+    env_type: game_2048
+    max_actions_per_traj: 700
+    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>
+
+      '
+    max_tokens: 8192
+    env_config: null
+  rubikscube:
+    env_type: rubikscube
+    max_actions_per_traj: 20
+    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>
+
+      '
+    max_tokens: 96
+    env_config:
+      scramble_depth: 1
+      max_steps: 20
+      render_mode: text
+system:
+  CUDA_VISIBLE_DEVICES: 0,1,2,3,4,5,6,7
+seed:
+  train: 10000
+  val: 123
+micro_batch_size_per_gpu: 1
+log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+ppo_mini_batch_size: 32
+model_path: /mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft
+enable_response_mask: true
+grpo_advantage_length_weight: false
+lora:
+  rank: 0
+  alpha: 64
+  target_modules: all-linear
+agent_proxy:
+  context_window_mode: full
+  max_context_window: -1
+  batch_adjust_mode: copy
+  max_turn: 5
+  action_sep: '||'
+  max_actions_per_turn: 2
+  use_turn_scores: false
+  enable_think: true
+  reward_normalization:
+    grouping: state
+    method: identity
+collapse_detection:
+  compute_freq: 5
+  micro_batch_size: 128
+  first_turn_enabled: true
+  multi_turn_enabled: true
+  num_samples: 64
+es_manager:
+  format_penalty: -0.1
+  train:
+    env_groups: 8
+    group_size: 16
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 8
+  val:
+    env_groups: 512
+    group_size: 1
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 512
+ctx_manager:
+  generation:
+    gen_config:
+      response_length: ${actor_rollout_ref.rollout.response_length}
+      temperature: ${actor_rollout_ref.rollout.temperature}
+      top_p: ${actor_rollout_ref.rollout.top_p}
+      top_k: ${actor_rollout_ref.rollout.top_k}
+      kwargs: null

outputs/2026-05-11/10-52-37/.hydra/hydra.yaml

@@ -0,0 +1,177 @@
+hydra:
+  run:
+    dir: outputs/${now:%Y-%m-%d}/${now:%H-%M-%S}
+  sweep:
+    dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S}
+    subdir: ${hydra.job.num}
+  launcher:
+    _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher
+  sweeper:
+    _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper
+    max_batch_size: null
+    params: null
+  help:
+    app_name: ${hydra.job.name}
+    header: '${hydra.help.app_name} is powered by Hydra.
+
+      '
+    footer: 'Powered by Hydra (https://hydra.cc)
+
+      Use --hydra-help to view Hydra specific help
+
+      '
+    template: '${hydra.help.header}
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (group=option)
+
+
+      $APP_CONFIG_GROUPS
+
+
+      == Config ==
+
+      Override anything in the config (foo.bar=value)
+
+
+      $CONFIG
+
+
+      ${hydra.help.footer}
+
+      '
+  hydra_help:
+    template: 'Hydra (${hydra.runtime.version})
+
+      See https://hydra.cc for more info.
+
+
+      == Flags ==
+
+      $FLAGS_HELP
+
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (For example, append hydra/job_logging=disabled
+      to command line)
+
+
+      $HYDRA_CONFIG_GROUPS
+
+
+      Use ''--cfg hydra'' to Show the Hydra config.
+
+      '
+    hydra_help: ???
+  hydra_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][HYDRA] %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+    root:
+      level: INFO
+      handlers:
+      - console
+    loggers:
+      logging_example:
+        level: DEBUG
+    disable_existing_loggers: false
+  job_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+      file:
+        class: logging.FileHandler
+        formatter: simple
+        filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log
+    root:
+      level: INFO
+      handlers:
+      - console
+      - file
+    disable_existing_loggers: false
+  env: {}
+  mode: RUN
+  searchpath:
+  - pkg://verl.trainer.config
+  callbacks: {}
+  output_subdir: .hydra
+  overrides:
+    hydra:
+    - hydra.mode=RUN
+    task:
+    - actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+    - actor_rollout_ref.rollout.rollout_filter_value=0.9
+    - trainer.total_training_steps=1000
+    - model_path=/mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft
+  job:
+    name: train
+    chdir: null
+    override_dirname: actor_rollout_ref.rollout.rollout_filter_strategy=top_p,actor_rollout_ref.rollout.rollout_filter_value=0.9,model_path=/mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft,trainer.total_training_steps=1000
+    id: ???
+    num: ???
+    config_name: _2_sokoban
+    env_set: {}
+    env_copy: []
+    config:
+      override_dirname:
+        kv_sep: '='
+        item_sep: ','
+        exclude_keys: []
+  runtime:
+    version: 1.3.2
+    version_base: '1.3'
+    cwd: /mnt/general/wanghy/RAGEN_v2
+    config_sources:
+    - path: hydra.conf
+      schema: pkg
+      provider: hydra
+    - path: /mnt/general/wanghy/RAGEN_v2/config
+      schema: file
+      provider: main
+    - path: /mnt/general/wanghy/RAGEN_v2/verl/verl/trainer/config
+      schema: file
+      provider: command-line
+    - path: verl.trainer.config
+      schema: pkg
+      provider: hydra.searchpath in main
+    - path: ''
+      schema: structured
+      provider: schema
+    output_dir: /mnt/general/wanghy/RAGEN_v2/outputs/2026-05-11/10-52-37
+    choices:
+      reward_model: dp_reward_model
+      critic: dp_critic
+      critic/../engine@critic.model.fsdp_config: fsdp
+      critic/../optim@critic.optim: fsdp
+      model@actor_rollout_ref.model: hf_model
+      rollout@actor_rollout_ref.rollout: rollout
+      ref@actor_rollout_ref.ref: dp_ref
+      ref/../engine@actor_rollout_ref.ref.fsdp_config: fsdp
+      data: legacy_data
+      actor@actor_rollout_ref.actor: dp_actor
+      actor/../engine@actor_rollout_ref.actor.fsdp_config: fsdp
+      actor/../optim@actor_rollout_ref.actor.optim: fsdp
+      hydra/env: default
+      hydra/callbacks: null
+      hydra/job_logging: default
+      hydra/hydra_logging: default
+      hydra/hydra_help: default
+      hydra/help: default
+      hydra/sweeper: basic
+      hydra/launcher: basic
+      hydra/output: default
+  verbose: false

outputs/2026-05-11/10-52-37/.hydra/overrides.yaml

@@ -0,0 +1,4 @@
+- actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+- actor_rollout_ref.rollout.rollout_filter_value=0.9
+- trainer.total_training_steps=1000
+- model_path=/mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft

outputs/2026-05-11/11-23-48/.hydra/config.yaml

@@ -0,0 +1,989 @@
+actor_rollout_ref:
+  actor:
+    optim:
+      _target_: verl.workers.config.FSDPOptimizerConfig
+      lr: 1.0e-06
+      lr_warmup_steps_ratio: 0.0
+      total_training_steps: -1
+      weight_decay: 0.01
+      lr_warmup_steps: -1
+      betas:
+      - 0.9
+      - 0.999
+      clip_grad: 1.0
+      min_lr_ratio: 0.0
+      num_cycles: 0.5
+      warmup_style: constant
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    _target_: verl.workers.config.FSDPActorConfig
+    strategy: fsdp
+    ppo_mini_batch_size: ${ppo_mini_batch_size}
+    ppo_micro_batch_size: null
+    ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+    use_dynamic_bsz: false
+    ppo_max_token_len_per_gpu: 16384
+    clip_ratio: 0.2
+    clip_ratio_low: 0.2
+    clip_ratio_high: 0.28
+    freeze_vision_tower: false
+    policy_loss:
+      _target_: verl.workers.config.PolicyLossConfig
+      loss_mode: vanilla
+      clip_cov_ratio: 0.0002
+      clip_cov_lb: 1.0
+      clip_cov_ub: 5.0
+      kl_cov_ratio: 0.0002
+      ppo_kl_coef: 0.1
+    clip_ratio_c: 3.0
+    loss_agg_mode: token-mean
+    entropy_coeff: 0.001
+    tis_imp_ratio_cap: -1
+    use_kl_loss: false
+    use_torch_compile: true
+    kl_loss_coef: 0.0
+    kl_loss_type: kl
+    ppo_epochs: 1
+    shuffle: false
+    checkpoint:
+      _target_: verl.trainer.config.CheckpointConfig
+      save_contents:
+      - model
+      - optimizer
+      - extra
+      load_contents: ${.save_contents}
+      async_save: false
+    use_fused_kernels: ${oc.select:actor_rollout_ref.model.use_fused_kernels,false}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    grad_clip: 1.0
+    ulysses_sequence_parallel_size: 1
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+    use_remove_padding: ${oc.select:actor_rollout_ref.model.use_remove_padding,false}
+    use_ref: true
+    grpo_advantage_length_weight: ${grpo_advantage_length_weight}
+    filter_loss_scaling: none
+  ref:
+    strategy: ${actor_rollout_ref.actor.strategy}
+    use_torch_compile: ${oc.select:actor_rollout_ref.actor.use_torch_compile,true}
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    model: null
+    ulysses_sequence_parallel_size: ${oc.select:actor_rollout_ref.actor.ulysses_sequence_parallel_size,1}
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+  rollout:
+    _target_: verl.workers.config.RolloutConfig
+    name: vllm
+    mode: sync
+    temperature: 1
+    top_k: -1
+    top_p: 1
+    prompt_length: 1
+    response_length: 400
+    dtype: bfloat16
+    gpu_memory_utilization: 0.8
+    ignore_eos: false
+    enforce_eager: true
+    cudagraph_capture_sizes: null
+    free_cache_engine: true
+    tensor_model_parallel_size: 1
+    data_parallel_size: 1
+    expert_parallel_size: 1
+    max_num_batched_tokens: 8192
+    max_model_len: 3600
+    max_num_seqs: 1024
+    enable_chunked_prefill: true
+    enable_prefix_caching: true
+    load_format: auto
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    disable_log_stats: true
+    do_sample: true
+    'n': 1
+    over_sample_rate: 0
+    multi_stage_wake_up: false
+    engine_kwargs:
+      vllm: {}
+      sglang: {}
+    val_kwargs:
+      _target_: verl.workers.config.SamplingConfig
+      top_k: -1
+      top_p: 1.0
+      temperature: 0.5
+      'n': 1
+      do_sample: true
+    multi_turn:
+      _target_: verl.workers.config.MultiTurnConfig
+      enable: false
+      max_assistant_turns: null
+      tool_config_path: null
+      max_user_turns: null
+      max_parallel_calls: 1
+      max_tool_response_length: 256
+      tool_response_truncate_side: middle
+      interaction_config_path: null
+      use_inference_chat_template: false
+      tokenization_sanity_check_mode: strict
+      format: hermes
+      num_repeat_rollouts: null
+    calculate_log_probs: false
+    agent:
+      _target_: verl.workers.config.AgentLoopConfig
+      num_workers: 8
+      agent_loop_config_path: null
+      custom_async_server:
+        _target_: verl.workers.config.CustomAsyncServerConfig
+        path: null
+        name: null
+    update_weights_bucket_megabytes: 512
+    trace:
+      _target_: verl.workers.config.TraceConfig
+      backend: null
+      token2text: false
+    skip_rollout: false
+    skip_dump_dir: /tmp/rollout_dump
+    skip_tokenizer_init: true
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: ${oc.select:actor_rollout_ref.actor.profiler.enable,false}
+      all_ranks: ${oc.select:actor_rollout_ref.actor.profiler.all_ranks,false}
+      ranks: ${oc.select:actor_rollout_ref.actor.profiler.ranks,[]}
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+    layered_summon: false
+    rollout_filter_value: 0.9
+    rollout_filter_strategy: top_p
+    rollout_filter_type: largest
+    rollout_filter_include_zero: true
+    rollout_filter_top_p_prob_mode: linear
+    rollout_filter_selection_eps: 0.01
+    rollout_filter_empty_stop_steps: 5
+    rollout_filter_metric: reward_variance
+    gradient_analysis_num_buckets: 6
+    gradient_analysis_bucket_mode: quantile
+  model:
+    _target_: verl.workers.config.HFModelConfig
+    path: ${model_path}
+    hf_config_path: null
+    tokenizer_path: null
+    use_shm: false
+    trust_remote_code: false
+    custom_chat_template: null
+    external_lib: null
+    override_config: {}
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+    exclude_modules: null
+    use_liger: false
+    use_fused_kernels: false
+    fused_kernel_options:
+      impl_backend: torch
+  hybrid_engine: true
+  nccl_timeout: 600
+data:
+  tokenizer: null
+  use_shm: false
+  train_files: ~/data/rlhf/gsm8k/train.parquet
+  val_files: ~/data/rlhf/gsm8k/test.parquet
+  prompt_key: prompt
+  reward_fn_key: data_source
+  max_prompt_length: null
+  max_response_length: null
+  train_batch_size: null
+  val_batch_size: null
+  return_raw_input_ids: false
+  return_raw_chat: false
+  return_full_prompt: false
+  shuffle: true
+  dataloader_num_workers: 8
+  validation_shuffle: false
+  filter_overlong_prompts: false
+  filter_overlong_prompts_workers: 1
+  truncation: error
+  image_key: images
+  video_key: videos
+  trust_remote_code: false
+  custom_cls:
+    path: null
+    name: null
+  return_multi_modal_inputs: true
+  sampler:
+    class_path: null
+    class_name: null
+  datagen:
+    path: null
+    name: null
+  apply_chat_template_kwargs: {}
+critic:
+  optim:
+    _target_: verl.workers.config.FSDPOptimizerConfig
+    lr: 1.0e-05
+    lr_warmup_steps_ratio: 0.0
+    total_training_steps: -1
+    weight_decay: 0.01
+    lr_warmup_steps: -1
+    betas:
+    - 0.9
+    - 0.999
+    clip_grad: 1.0
+    min_lr_ratio: 0.0
+    num_cycles: 0.5
+    warmup_style: constant
+  model:
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    path: ${model_path}
+    tokenizer_path: ${oc.select:actor_rollout_ref.model.path,"~/models/deepseek-llm-7b-chat"}
+    override_config: {}
+    external_lib: ${oc.select:actor_rollout_ref.model.external_lib,null}
+    trust_remote_code: ${oc.select:actor_rollout_ref.model.trust_remote_code,false}
+    _target_: verl.workers.config.FSDPCriticModelCfg
+    use_shm: false
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+  _target_: verl.workers.config.FSDPCriticConfig
+  rollout_n: ${oc.select:actor_rollout_ref.rollout.n,1}
+  strategy: fsdp
+  enable: null
+  ppo_mini_batch_size: ${ppo_mini_batch_size}
+  ppo_micro_batch_size: null
+  ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+  use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+  ppo_max_token_len_per_gpu: 32768
+  forward_max_token_len_per_gpu: ${.ppo_max_token_len_per_gpu}
+  ppo_epochs: ${oc.select:actor_rollout_ref.actor.ppo_epochs,1}
+  shuffle: ${oc.select:actor_rollout_ref.actor.shuffle,false}
+  cliprange_value: 0.5
+  loss_agg_mode: ${oc.select:actor_rollout_ref.actor.loss_agg_mode,token-mean}
+  checkpoint:
+    _target_: verl.trainer.config.CheckpointConfig
+    save_contents:
+    - model
+    - optimizer
+    - extra
+    load_contents: ${.save_contents}
+    async_save: false
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config:
+      nsys:
+        _target_: verl.utils.profiler.config.NsightToolConfig
+        discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+      npu:
+        _target_: verl.utils.profiler.config.NPUToolConfig
+        contents: []
+        level: level1
+        analysis: true
+        discrete: false
+      torch:
+        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+        step_start: 0
+        step_end: null
+      torch_memory:
+        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+        trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+        stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+  forward_micro_batch_size: ${oc.select:.ppo_micro_batch_size,null}
+  forward_micro_batch_size_per_gpu: ${oc.select:.ppo_micro_batch_size_per_gpu,null}
+  ulysses_sequence_parallel_size: 1
+  grad_clip: 1.0
+reward_model:
+  enable: false
+  enable_resource_pool: false
+  n_gpus_per_node: 0
+  nnodes: 0
+  strategy: fsdp
+  model:
+    input_tokenizer: ${actor_rollout_ref.model.path}
+    path: ~/models/FsfairX-LLaMA3-RM-v0.1
+    external_lib: ${actor_rollout_ref.model.external_lib}
+    trust_remote_code: false
+    use_shm: false
+    use_remove_padding: false
+    use_fused_kernels: ${actor_rollout_ref.model.use_fused_kernels}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+  micro_batch_size: null
+  micro_batch_size_per_gpu: null
+  max_length: null
+  use_dynamic_bsz: ${critic.use_dynamic_bsz}
+  forward_max_token_len_per_gpu: ${critic.forward_max_token_len_per_gpu}
+  reward_manager: naive
+  launch_reward_fn_async: false
+  sandbox_fusion:
+    url: null
+    max_concurrent: 64
+    memory_limit_mb: 1024
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+  ulysses_sequence_parallel_size: 1
+custom_reward_function:
+  path: null
+  name: compute_score
+algorithm:
+  _target_: verl.trainer.config.AlgoConfig
+  gamma: 1.0
+  lam: 1.0
+  adv_estimator: gae
+  norm_adv_by_std_in_grpo: true
+  use_kl_in_reward: false
+  kl_penalty: kl
+  kl_ctrl:
+    _target_: verl.trainer.config.KLControlConfig
+    type: fixed
+    kl_coef: 0.0
+    horizon: 10000
+    target_kl: 0.1
+  use_pf_ppo: false
+  pf_ppo:
+    reweight_method: pow
+    weight_pow: 2.0
+  high_level_gamma: 0.95
+  bi_level_gae: false
+  zero_task_advantage: false
+  soft_advantage_reweight: false
+trainer:
+  balance_batch: true
+  total_epochs: 30
+  total_training_steps: 1000
+  project_name: ragen
+  experiment_name: sokoban-main
+  logger:
+  - console
+  - wandb
+  log_val_generations: 0
+  rollout_data_dir: null
+  validation_data_dir: null
+  nnodes: 1
+  n_gpus_per_node: 8
+  save_freq: -1
+  esi_redundant_time: 0
+  resume_mode: auto
+  resume_from_path: null
+  val_before_train: true
+  val_only: false
+  test_freq: 10
+  critic_warmup: 0
+  default_hdfs_dir: null
+  del_local_ckpt_after_load: false
+  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
+  max_actor_ckpt_to_keep: 1
+  max_critic_ckpt_to_keep: 1
+  ray_wait_register_center_timeout: 300
+  device: cuda
+  use_legacy_worker_impl: auto
+  local_log_dir: results/
+  validation_steps: 1
+  generations_to_log_to_wandb:
+    val: 20
+  log_group_rv_table: false
+  gradient_analysis_mode: false
+  gradient_analysis_every: 50
+  gradient_analysis_env_groups: null
+  gradient_analysis_group_size: null
+  gradient_analysis_log_prefilter: false
+  gradient_analysis_only: false
+  exit_after_gradient_analysis: false
+global_profiler:
+  _target_: verl.utils.profiler.ProfilerConfig
+  tool: null
+  steps: null
+  profile_continuous_steps: false
+  save_path: outputs/profile
+  global_tool_config:
+    nsys:
+      _target_: verl.utils.profiler.config.NsightToolConfig
+      discrete: false
+      controller_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+      worker_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+        capture-range: cudaProfilerApi
+        capture-range-end: null
+        kill: none
+    torch_memory:
+      trace_alloc_max_entries: 100000
+      stack_depth: 32
+      context: all
+      stacks: all
+      kw_args: {}
+ray_kwargs:
+  ray_init:
+    num_cpus: null
+  timeline_json_file: null
+custom_envs:
+  SimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+  LargerSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 8
+      dim_y: 8
+      num_boxes: 2
+      max_steps: 100
+      search_depth: 10
+  SokobanDifferentGridVocab:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      search_depth: 30
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      grid_lookup:
+        0: W
+        1: .
+        2: G
+        3: C
+        4: B
+        5: A
+        6: '@'
+      grid_vocab:
+        W: wall
+        .: empty
+        G: target
+        C: box on target
+        B: box
+        A: player
+        '@': player on target
+  CoordSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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. \n\
+      Coordinates 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"
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      observation_format: grid_coord
+  VisualSimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      render_mode: rgb_array
+  Alfworld:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_in_distribution
+  AlfworldOOD:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_out_of_distribution
+  Countdown:
+    env_type: countdown
+    max_actions_per_traj: 1
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: null
+  Bandit:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: train
+  BanditTest:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: test
+  DeepCoder:
+    env_type: deepcoder
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving a coding task. Provide a complete Python function
+      solution only. Format: <answer>...</answer>'
+    max_tokens: 8000
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 1
+  FrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      success_rate: 0.8
+  CoordFrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>.
+
+      '
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      observation_format: grid_coord
+      success_rate: 0.8
+  MetamathQA:
+    env_type: metamathqa
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving Math problems. '
+    max_tokens: 100
+    env_config: null
+  WebShopFull:
+    env_type: webshop
+    max_actions_per_traj: 15
+    env_instruction: You are an expert autonomous agent operating in the WebShop e‑commerce
+      environment.
+    max_tokens: 200
+    env_config:
+      dataset: full
+  WebShop:
+    env_type: webshop
+    max_actions_per_traj: 9
+    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>].'
+    max_tokens: 200
+    env_config:
+      dataset: small
+  Lean:
+    env_type: lean
+    max_actions_per_traj: 30
+    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>.
+    max_tokens: 512
+    parallel_friendly: true
+    max_workers: 32
+    env_config: null
+  SimpleSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 20
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: easy
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  MediumSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 30
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: medium
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  SearchQA:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+  SearchQAMock:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+      mock_mode: true
+  game_2048:
+    env_type: game_2048
+    max_actions_per_traj: 700
+    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>
+
+      '
+    max_tokens: 8192
+    env_config: null
+  rubikscube:
+    env_type: rubikscube
+    max_actions_per_traj: 20
+    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>
+
+      '
+    max_tokens: 96
+    env_config:
+      scramble_depth: 1
+      max_steps: 20
+      render_mode: text
+system:
+  CUDA_VISIBLE_DEVICES: 0,1,2,3,4,5,6,7
+seed:
+  train: 10000
+  val: 123
+micro_batch_size_per_gpu: 1
+log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+ppo_mini_batch_size: 32
+model_path: /mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft
+enable_response_mask: true
+grpo_advantage_length_weight: false
+lora:
+  rank: 0
+  alpha: 64
+  target_modules: all-linear
+agent_proxy:
+  context_window_mode: full
+  max_context_window: -1
+  batch_adjust_mode: copy
+  max_turn: 5
+  action_sep: '||'
+  max_actions_per_turn: 2
+  use_turn_scores: false
+  enable_think: true
+  reward_normalization:
+    grouping: state
+    method: identity
+collapse_detection:
+  compute_freq: 5
+  micro_batch_size: 128
+  first_turn_enabled: true
+  multi_turn_enabled: true
+  num_samples: 64
+es_manager:
+  format_penalty: -0.1
+  train:
+    env_groups: 8
+    group_size: 16
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 8
+  val:
+    env_groups: 512
+    group_size: 1
+    env_configs:
+      tags:
+      - CoordSokoban
+      n_groups:
+      - 512
+ctx_manager:
+  generation:
+    gen_config:
+      response_length: ${actor_rollout_ref.rollout.response_length}
+      temperature: ${actor_rollout_ref.rollout.temperature}
+      top_p: ${actor_rollout_ref.rollout.top_p}
+      top_k: ${actor_rollout_ref.rollout.top_k}
+      kwargs: null

outputs/2026-05-11/11-23-48/.hydra/hydra.yaml

@@ -0,0 +1,177 @@
+hydra:
+  run:
+    dir: outputs/${now:%Y-%m-%d}/${now:%H-%M-%S}
+  sweep:
+    dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S}
+    subdir: ${hydra.job.num}
+  launcher:
+    _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher
+  sweeper:
+    _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper
+    max_batch_size: null
+    params: null
+  help:
+    app_name: ${hydra.job.name}
+    header: '${hydra.help.app_name} is powered by Hydra.
+
+      '
+    footer: 'Powered by Hydra (https://hydra.cc)
+
+      Use --hydra-help to view Hydra specific help
+
+      '
+    template: '${hydra.help.header}
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (group=option)
+
+
+      $APP_CONFIG_GROUPS
+
+
+      == Config ==
+
+      Override anything in the config (foo.bar=value)
+
+
+      $CONFIG
+
+
+      ${hydra.help.footer}
+
+      '
+  hydra_help:
+    template: 'Hydra (${hydra.runtime.version})
+
+      See https://hydra.cc for more info.
+
+
+      == Flags ==
+
+      $FLAGS_HELP
+
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (For example, append hydra/job_logging=disabled
+      to command line)
+
+
+      $HYDRA_CONFIG_GROUPS
+
+
+      Use ''--cfg hydra'' to Show the Hydra config.
+
+      '
+    hydra_help: ???
+  hydra_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][HYDRA] %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+    root:
+      level: INFO
+      handlers:
+      - console
+    loggers:
+      logging_example:
+        level: DEBUG
+    disable_existing_loggers: false
+  job_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+      file:
+        class: logging.FileHandler
+        formatter: simple
+        filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log
+    root:
+      level: INFO
+      handlers:
+      - console
+      - file
+    disable_existing_loggers: false
+  env: {}
+  mode: RUN
+  searchpath:
+  - pkg://verl.trainer.config
+  callbacks: {}
+  output_subdir: .hydra
+  overrides:
+    hydra:
+    - hydra.mode=RUN
+    task:
+    - actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+    - actor_rollout_ref.rollout.rollout_filter_value=0.9
+    - trainer.total_training_steps=1000
+    - model_path=/mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft
+  job:
+    name: train
+    chdir: null
+    override_dirname: actor_rollout_ref.rollout.rollout_filter_strategy=top_p,actor_rollout_ref.rollout.rollout_filter_value=0.9,model_path=/mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft,trainer.total_training_steps=1000
+    id: ???
+    num: ???
+    config_name: _2_sokoban
+    env_set: {}
+    env_copy: []
+    config:
+      override_dirname:
+        kv_sep: '='
+        item_sep: ','
+        exclude_keys: []
+  runtime:
+    version: 1.3.2
+    version_base: '1.3'
+    cwd: /mnt/general/wanghy/RAGEN_v2
+    config_sources:
+    - path: hydra.conf
+      schema: pkg
+      provider: hydra
+    - path: /mnt/general/wanghy/RAGEN_v2/config
+      schema: file
+      provider: main
+    - path: /mnt/general/wanghy/RAGEN_v2/verl/verl/trainer/config
+      schema: file
+      provider: command-line
+    - path: verl.trainer.config
+      schema: pkg
+      provider: hydra.searchpath in main
+    - path: ''
+      schema: structured
+      provider: schema
+    output_dir: /mnt/general/wanghy/RAGEN_v2/outputs/2026-05-11/11-23-48
+    choices:
+      reward_model: dp_reward_model
+      critic: dp_critic
+      critic/../engine@critic.model.fsdp_config: fsdp
+      critic/../optim@critic.optim: fsdp
+      model@actor_rollout_ref.model: hf_model
+      rollout@actor_rollout_ref.rollout: rollout
+      ref@actor_rollout_ref.ref: dp_ref
+      ref/../engine@actor_rollout_ref.ref.fsdp_config: fsdp
+      data: legacy_data
+      actor@actor_rollout_ref.actor: dp_actor
+      actor/../engine@actor_rollout_ref.actor.fsdp_config: fsdp
+      actor/../optim@actor_rollout_ref.actor.optim: fsdp
+      hydra/env: default
+      hydra/callbacks: null
+      hydra/job_logging: default
+      hydra/hydra_logging: default
+      hydra/hydra_help: default
+      hydra/help: default
+      hydra/sweeper: basic
+      hydra/launcher: basic
+      hydra/output: default
+  verbose: false

outputs/2026-05-11/11-23-48/.hydra/overrides.yaml

@@ -0,0 +1,4 @@
+- actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+- actor_rollout_ref.rollout.rollout_filter_value=0.9
+- trainer.total_training_steps=1000
+- model_path=/mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft

outputs/2026-05-11/11-35-35/.hydra/config.yaml

@@ -0,0 +1,989 @@
+actor_rollout_ref:
+  actor:
+    optim:
+      _target_: verl.workers.config.FSDPOptimizerConfig
+      lr: 1.0e-06
+      lr_warmup_steps_ratio: 0.0
+      total_training_steps: -1
+      weight_decay: 0.01
+      lr_warmup_steps: -1
+      betas:
+      - 0.9
+      - 0.999
+      clip_grad: 1.0
+      min_lr_ratio: 0.0
+      num_cycles: 0.5
+      warmup_style: constant
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    _target_: verl.workers.config.FSDPActorConfig
+    strategy: fsdp
+    ppo_mini_batch_size: ${ppo_mini_batch_size}
+    ppo_micro_batch_size: null
+    ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+    use_dynamic_bsz: false
+    ppo_max_token_len_per_gpu: 16384
+    clip_ratio: 0.2
+    clip_ratio_low: 0.2
+    clip_ratio_high: 0.28
+    freeze_vision_tower: false
+    policy_loss:
+      _target_: verl.workers.config.PolicyLossConfig
+      loss_mode: vanilla
+      clip_cov_ratio: 0.0002
+      clip_cov_lb: 1.0
+      clip_cov_ub: 5.0
+      kl_cov_ratio: 0.0002
+      ppo_kl_coef: 0.1
+    clip_ratio_c: 3.0
+    loss_agg_mode: token-mean
+    entropy_coeff: 0.001
+    tis_imp_ratio_cap: -1
+    use_kl_loss: false
+    use_torch_compile: true
+    kl_loss_coef: 0.0
+    kl_loss_type: kl
+    ppo_epochs: 1
+    shuffle: false
+    checkpoint:
+      _target_: verl.trainer.config.CheckpointConfig
+      save_contents:
+      - model
+      - optimizer
+      - extra
+      load_contents: ${.save_contents}
+      async_save: false
+    use_fused_kernels: ${oc.select:actor_rollout_ref.model.use_fused_kernels,false}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    grad_clip: 1.0
+    ulysses_sequence_parallel_size: 1
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+    use_remove_padding: ${oc.select:actor_rollout_ref.model.use_remove_padding,false}
+    use_ref: true
+    grpo_advantage_length_weight: ${grpo_advantage_length_weight}
+    filter_loss_scaling: none
+  ref:
+    strategy: ${actor_rollout_ref.actor.strategy}
+    use_torch_compile: ${oc.select:actor_rollout_ref.actor.use_torch_compile,true}
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: false
+      all_ranks: false
+      ranks: []
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config:
+        nsys:
+          _target_: verl.utils.profiler.config.NsightToolConfig
+          discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+        npu:
+          _target_: verl.utils.profiler.config.NPUToolConfig
+          contents: []
+          level: level1
+          analysis: true
+          discrete: false
+        torch:
+          _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+          step_start: 0
+          step_end: null
+        torch_memory:
+          _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+          trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+          stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    model: null
+    ulysses_sequence_parallel_size: ${oc.select:actor_rollout_ref.actor.ulysses_sequence_parallel_size,1}
+    entropy_from_logits_with_chunking: false
+    entropy_checkpointing: false
+  rollout:
+    _target_: verl.workers.config.RolloutConfig
+    name: vllm
+    mode: sync
+    temperature: 1
+    top_k: -1
+    top_p: 1
+    prompt_length: 1
+    response_length: 400
+    dtype: bfloat16
+    gpu_memory_utilization: 0.8
+    ignore_eos: false
+    enforce_eager: true
+    cudagraph_capture_sizes: null
+    free_cache_engine: true
+    tensor_model_parallel_size: 1
+    data_parallel_size: 1
+    expert_parallel_size: 1
+    max_num_batched_tokens: 8192
+    max_model_len: 3600
+    max_num_seqs: 1024
+    enable_chunked_prefill: true
+    enable_prefix_caching: true
+    load_format: auto
+    log_prob_micro_batch_size: null
+    log_prob_micro_batch_size_per_gpu: ${log_prob_micro_batch_size_per_gpu}
+    log_prob_use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+    log_prob_max_token_len_per_gpu: ${oc.select:actor_rollout_ref.actor.ppo_max_token_len_per_gpu,16384}
+    disable_log_stats: true
+    do_sample: true
+    'n': 1
+    over_sample_rate: 0
+    multi_stage_wake_up: false
+    engine_kwargs:
+      vllm: {}
+      sglang: {}
+    val_kwargs:
+      _target_: verl.workers.config.SamplingConfig
+      top_k: -1
+      top_p: 1.0
+      temperature: 0.5
+      'n': 1
+      do_sample: true
+    multi_turn:
+      _target_: verl.workers.config.MultiTurnConfig
+      enable: false
+      max_assistant_turns: null
+      tool_config_path: null
+      max_user_turns: null
+      max_parallel_calls: 1
+      max_tool_response_length: 256
+      tool_response_truncate_side: middle
+      interaction_config_path: null
+      use_inference_chat_template: false
+      tokenization_sanity_check_mode: strict
+      format: hermes
+      num_repeat_rollouts: null
+    calculate_log_probs: false
+    agent:
+      _target_: verl.workers.config.AgentLoopConfig
+      num_workers: 8
+      agent_loop_config_path: null
+      custom_async_server:
+        _target_: verl.workers.config.CustomAsyncServerConfig
+        path: null
+        name: null
+    update_weights_bucket_megabytes: 512
+    trace:
+      _target_: verl.workers.config.TraceConfig
+      backend: null
+      token2text: false
+    skip_rollout: false
+    skip_dump_dir: /tmp/rollout_dump
+    skip_tokenizer_init: true
+    profiler:
+      _target_: verl.utils.profiler.ProfilerConfig
+      tool: ${oc.select:global_profiler.tool,null}
+      enable: ${oc.select:actor_rollout_ref.actor.profiler.enable,false}
+      all_ranks: ${oc.select:actor_rollout_ref.actor.profiler.all_ranks,false}
+      ranks: ${oc.select:actor_rollout_ref.actor.profiler.ranks,[]}
+      save_path: ${oc.select:global_profiler.save_path,null}
+      tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+    layered_summon: false
+    rollout_filter_value: 0.9
+    rollout_filter_strategy: top_p
+    rollout_filter_type: largest
+    rollout_filter_include_zero: true
+    rollout_filter_top_p_prob_mode: linear
+    rollout_filter_selection_eps: 0.01
+    rollout_filter_empty_stop_steps: 5
+    rollout_filter_metric: reward_variance
+    gradient_analysis_num_buckets: 6
+    gradient_analysis_bucket_mode: quantile
+  model:
+    _target_: verl.workers.config.HFModelConfig
+    path: ${model_path}
+    hf_config_path: null
+    tokenizer_path: null
+    use_shm: false
+    trust_remote_code: false
+    custom_chat_template: null
+    external_lib: null
+    override_config: {}
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+    exclude_modules: null
+    use_liger: false
+    use_fused_kernels: false
+    fused_kernel_options:
+      impl_backend: torch
+  hybrid_engine: true
+  nccl_timeout: 600
+data:
+  tokenizer: null
+  use_shm: false
+  train_files: ~/data/rlhf/gsm8k/train.parquet
+  val_files: ~/data/rlhf/gsm8k/test.parquet
+  prompt_key: prompt
+  reward_fn_key: data_source
+  max_prompt_length: null
+  max_response_length: null
+  train_batch_size: null
+  val_batch_size: null
+  return_raw_input_ids: false
+  return_raw_chat: false
+  return_full_prompt: false
+  shuffle: true
+  dataloader_num_workers: 8
+  validation_shuffle: false
+  filter_overlong_prompts: false
+  filter_overlong_prompts_workers: 1
+  truncation: error
+  image_key: images
+  video_key: videos
+  trust_remote_code: false
+  custom_cls:
+    path: null
+    name: null
+  return_multi_modal_inputs: true
+  sampler:
+    class_path: null
+    class_name: null
+  datagen:
+    path: null
+    name: null
+  apply_chat_template_kwargs: {}
+critic:
+  optim:
+    _target_: verl.workers.config.FSDPOptimizerConfig
+    lr: 1.0e-05
+    lr_warmup_steps_ratio: 0.0
+    total_training_steps: -1
+    weight_decay: 0.01
+    lr_warmup_steps: -1
+    betas:
+    - 0.9
+    - 0.999
+    clip_grad: 1.0
+    min_lr_ratio: 0.0
+    num_cycles: 0.5
+    warmup_style: constant
+  model:
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      optimizer_offload: false
+      offload_policy: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+      model_dtype: fp32
+      use_orig_params: false
+      ulysses_sequence_parallel_size: 1
+      entropy_from_logits_with_chunking: false
+      use_torch_compile: true
+      entropy_checkpointing: false
+      forward_only: false
+      strategy: fsdp
+    path: ${model_path}
+    tokenizer_path: ${oc.select:actor_rollout_ref.model.path,"~/models/deepseek-llm-7b-chat"}
+    override_config: {}
+    external_lib: ${oc.select:actor_rollout_ref.model.external_lib,null}
+    trust_remote_code: ${oc.select:actor_rollout_ref.model.trust_remote_code,false}
+    _target_: verl.workers.config.FSDPCriticModelCfg
+    use_shm: false
+    enable_gradient_checkpointing: true
+    enable_activation_offload: false
+    use_remove_padding: false
+    lora_rank: ${lora.rank}
+    lora_alpha: ${lora.alpha}
+    target_modules: ${lora.target_modules}
+  _target_: verl.workers.config.FSDPCriticConfig
+  rollout_n: ${oc.select:actor_rollout_ref.rollout.n,1}
+  strategy: fsdp
+  enable: null
+  ppo_mini_batch_size: ${ppo_mini_batch_size}
+  ppo_micro_batch_size: null
+  ppo_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+  use_dynamic_bsz: ${oc.select:actor_rollout_ref.actor.use_dynamic_bsz,false}
+  ppo_max_token_len_per_gpu: 32768
+  forward_max_token_len_per_gpu: ${.ppo_max_token_len_per_gpu}
+  ppo_epochs: ${oc.select:actor_rollout_ref.actor.ppo_epochs,1}
+  shuffle: ${oc.select:actor_rollout_ref.actor.shuffle,false}
+  cliprange_value: 0.5
+  loss_agg_mode: ${oc.select:actor_rollout_ref.actor.loss_agg_mode,token-mean}
+  checkpoint:
+    _target_: verl.trainer.config.CheckpointConfig
+    save_contents:
+    - model
+    - optimizer
+    - extra
+    load_contents: ${.save_contents}
+    async_save: false
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config:
+      nsys:
+        _target_: verl.utils.profiler.config.NsightToolConfig
+        discrete: ${oc.select:global_profiler.global_tool_config.nsys.discrete}
+      npu:
+        _target_: verl.utils.profiler.config.NPUToolConfig
+        contents: []
+        level: level1
+        analysis: true
+        discrete: false
+      torch:
+        _target_: verl.utils.profiler.config.TorchProfilerToolConfig
+        step_start: 0
+        step_end: null
+      torch_memory:
+        _target_: verl.utils.profiler.config.TorchMemoryToolConfig
+        trace_alloc_max_entries: ${oc.select:global_profiler.global_tool_config.torch_memory.trace_alloc_max_entries,100000}
+        stack_depth: ${oc.select:global_profiler.global_tool_config.torch_memory.stack_depth,32}
+  forward_micro_batch_size: ${oc.select:.ppo_micro_batch_size,null}
+  forward_micro_batch_size_per_gpu: ${oc.select:.ppo_micro_batch_size_per_gpu,null}
+  ulysses_sequence_parallel_size: 1
+  grad_clip: 1.0
+reward_model:
+  enable: false
+  enable_resource_pool: false
+  n_gpus_per_node: 0
+  nnodes: 0
+  strategy: fsdp
+  model:
+    input_tokenizer: ${actor_rollout_ref.model.path}
+    path: ~/models/FsfairX-LLaMA3-RM-v0.1
+    external_lib: ${actor_rollout_ref.model.external_lib}
+    trust_remote_code: false
+    use_shm: false
+    use_remove_padding: false
+    use_fused_kernels: ${actor_rollout_ref.model.use_fused_kernels}
+    fsdp_config:
+      _target_: verl.workers.config.FSDPEngineConfig
+      wrap_policy:
+        min_num_params: 0
+      param_offload: false
+      reshard_after_forward: true
+      fsdp_size: -1
+      forward_prefetch: false
+  micro_batch_size: null
+  micro_batch_size_per_gpu: null
+  max_length: null
+  use_dynamic_bsz: ${critic.use_dynamic_bsz}
+  forward_max_token_len_per_gpu: ${critic.forward_max_token_len_per_gpu}
+  reward_manager: naive
+  launch_reward_fn_async: false
+  sandbox_fusion:
+    url: null
+    max_concurrent: 64
+    memory_limit_mb: 1024
+  profiler:
+    _target_: verl.utils.profiler.ProfilerConfig
+    tool: ${oc.select:global_profiler.tool,null}
+    enable: false
+    all_ranks: false
+    ranks: []
+    save_path: ${oc.select:global_profiler.save_path,null}
+    tool_config: ${oc.select:actor_rollout_ref.actor.profiler.tool_config,null}
+  ulysses_sequence_parallel_size: 1
+custom_reward_function:
+  path: null
+  name: compute_score
+algorithm:
+  _target_: verl.trainer.config.AlgoConfig
+  gamma: 1.0
+  lam: 1.0
+  adv_estimator: gae
+  norm_adv_by_std_in_grpo: true
+  use_kl_in_reward: false
+  kl_penalty: kl
+  kl_ctrl:
+    _target_: verl.trainer.config.KLControlConfig
+    type: fixed
+    kl_coef: 0.0
+    horizon: 10000
+    target_kl: 0.1
+  use_pf_ppo: false
+  pf_ppo:
+    reweight_method: pow
+    weight_pow: 2.0
+  high_level_gamma: 0.95
+  bi_level_gae: false
+  zero_task_advantage: false
+  soft_advantage_reweight: false
+trainer:
+  balance_batch: true
+  total_epochs: 30
+  total_training_steps: 1000
+  project_name: ragen
+  experiment_name: sokoban-main
+  logger:
+  - console
+  - wandb
+  log_val_generations: 0
+  rollout_data_dir: null
+  validation_data_dir: null
+  nnodes: 1
+  n_gpus_per_node: 8
+  save_freq: -1
+  esi_redundant_time: 0
+  resume_mode: auto
+  resume_from_path: null
+  val_before_train: true
+  val_only: false
+  test_freq: 10
+  critic_warmup: 0
+  default_hdfs_dir: null
+  del_local_ckpt_after_load: false
+  default_local_dir: checkpoints/${trainer.project_name}/${trainer.experiment_name}
+  max_actor_ckpt_to_keep: 1
+  max_critic_ckpt_to_keep: 1
+  ray_wait_register_center_timeout: 300
+  device: cuda
+  use_legacy_worker_impl: auto
+  local_log_dir: results/
+  validation_steps: 1
+  generations_to_log_to_wandb:
+    val: 20
+  log_group_rv_table: false
+  gradient_analysis_mode: false
+  gradient_analysis_every: 50
+  gradient_analysis_env_groups: null
+  gradient_analysis_group_size: null
+  gradient_analysis_log_prefilter: false
+  gradient_analysis_only: false
+  exit_after_gradient_analysis: false
+global_profiler:
+  _target_: verl.utils.profiler.ProfilerConfig
+  tool: null
+  steps: null
+  profile_continuous_steps: false
+  save_path: outputs/profile
+  global_tool_config:
+    nsys:
+      _target_: verl.utils.profiler.config.NsightToolConfig
+      discrete: false
+      controller_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+      worker_nsight_options:
+        trace: cuda,nvtx,cublas,ucx
+        cuda-memory-usage: 'true'
+        cuda-graph-trace: graph
+        capture-range: cudaProfilerApi
+        capture-range-end: null
+        kill: none
+    torch_memory:
+      trace_alloc_max_entries: 100000
+      stack_depth: 32
+      context: all
+      stacks: all
+      kw_args: {}
+ray_kwargs:
+  ray_init:
+    num_cpus: null
+  timeline_json_file: null
+custom_envs:
+  SimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+  LargerSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 8
+      dim_y: 8
+      num_boxes: 2
+      max_steps: 100
+      search_depth: 10
+  SokobanDifferentGridVocab:
+    env_type: sokoban
+    max_actions_per_traj: 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"
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      search_depth: 30
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      grid_lookup:
+        0: W
+        1: .
+        2: G
+        3: C
+        4: B
+        5: A
+        6: '@'
+      grid_vocab:
+        W: wall
+        .: empty
+        G: target
+        C: box on target
+        B: box
+        A: player
+        '@': player on target
+  CoordSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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. \n\
+      Coordinates 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"
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      observation_format: grid_coord
+  VisualSimpleSokoban:
+    env_type: sokoban
+    max_actions_per_traj: 10
+    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>
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      dim_x: 6
+      dim_y: 6
+      num_boxes: 1
+      max_steps: 100
+      render_mode: rgb_array
+  Alfworld:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_in_distribution
+  AlfworldOOD:
+    env_type: alfworld
+    max_actions_per_traj: 50
+    parallel_friendly: false
+    max_workers: 1
+    env_instruction: 'You are an expert agent in the ALFRED Embodied Environment.
+
+      Complete household tasks by navigating and interacting with objects.
+
+
+      You should first reason step-by-step about the current situation. This reasoning
+      process MUST be enclosed within <think> </think> tags.
+
+      Once you''ve finished your reasoning, you should choose an admissible action
+      for current step and present it within <answer>...</answer> tags.
+
+      '
+    max_tokens: 512
+    env_config:
+      eval_dataset: eval_out_of_distribution
+  Countdown:
+    env_type: countdown
+    max_actions_per_traj: 1
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config: null
+  Bandit:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: train
+  BanditTest:
+    env_type: bandit
+    max_actions_per_traj: 1
+    env_instruction: ''
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      split: test
+  DeepCoder:
+    env_type: deepcoder
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving a coding task. Provide a complete Python function
+      solution only. Format: <answer>...</answer>'
+    max_tokens: 8000
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 1
+  FrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>'
+    max_tokens: 100
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      success_rate: 0.8
+  CoordFrozenLake:
+    env_type: frozen_lake
+    max_actions_per_traj: 10
+    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>.
+
+      '
+    max_tokens: 120
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      observation_format: grid_coord
+      success_rate: 0.8
+  MetamathQA:
+    env_type: metamathqa
+    max_actions_per_traj: 1
+    env_instruction: 'You are solving Math problems. '
+    max_tokens: 100
+    env_config: null
+  WebShopFull:
+    env_type: webshop
+    max_actions_per_traj: 15
+    env_instruction: You are an expert autonomous agent operating in the WebShop e‑commerce
+      environment.
+    max_tokens: 200
+    env_config:
+      dataset: full
+  WebShop:
+    env_type: webshop
+    max_actions_per_traj: 9
+    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>].'
+    max_tokens: 200
+    env_config:
+      dataset: small
+  Lean:
+    env_type: lean
+    max_actions_per_traj: 30
+    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>.
+    max_tokens: 512
+    parallel_friendly: true
+    max_workers: 32
+    env_config: null
+  SimpleSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 20
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: easy
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  MediumSudoku:
+    env_type: sudoku
+    max_actions_per_traj: 30
+    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.
+
+      '
+    max_tokens: 150
+    parallel_friendly: false
+    max_workers: 32
+    env_config:
+      grid_size: 9
+      difficulty: medium
+      render_format: with_feedback
+      show_conflicts: true
+      show_valid_numbers: true
+      max_steps: 81
+  SearchQA:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+  SearchQAMock:
+    env_type: search
+    max_actions_per_traj: 10
+    env_instruction: "You are a search agent answering questions by searching for\
+      \ information.\nUse search[your query] to find relevant documents, and finish[your\
+      \ answer] to submit your final answer.\n\nYou should first reason step-by-step\
+      \ about the current situation. This reasoning process MUST be enclosed within\
+      \ <think> </think> tags.\nThen provide your action within <answer>...</answer>\
+      \ tags.\n\nExamples:\n  <think>I need to find information about Ben Platt's\
+      \ father.</think><answer>search[Ben Platt father parent]</answer>\n  <think>Based\
+      \ on the search results, Ben Platt's father is Henry Platt.</think><answer>finish[Henry\
+      \ Platt]</answer>\n"
+    max_tokens: 300
+    parallel_friendly: true
+    max_workers: 32
+    env_config:
+      max_steps: 10
+      max_search_results: 5
+      mock_mode: true
+  game_2048:
+    env_type: game_2048
+    max_actions_per_traj: 700
+    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>
+
+      '
+    max_tokens: 8192
+    env_config: null
+  rubikscube:
+    env_type: rubikscube
+    max_actions_per_traj: 20
+    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>
+
+      '
+    max_tokens: 96
+    env_config:
+      scramble_depth: 1
+      max_steps: 20
+      render_mode: text
+system:
+  CUDA_VISIBLE_DEVICES: 0,1,2,3,4,5,6,7
+seed:
+  train: 10000
+  val: 123
+micro_batch_size_per_gpu: 1
+log_prob_micro_batch_size_per_gpu: ${micro_batch_size_per_gpu}
+ppo_mini_batch_size: 32
+model_path: /mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft
+enable_response_mask: true
+grpo_advantage_length_weight: false
+lora:
+  rank: 0
+  alpha: 64
+  target_modules: all-linear
+agent_proxy:
+  context_window_mode: full
+  max_context_window: -1
+  batch_adjust_mode: copy
+  max_turn: 5
+  action_sep: '||'
+  max_actions_per_turn: 2
+  use_turn_scores: false
+  enable_think: true
+  reward_normalization:
+    grouping: state
+    method: identity
+collapse_detection:
+  compute_freq: 5
+  micro_batch_size: 128
+  first_turn_enabled: true
+  multi_turn_enabled: true
+  num_samples: 64
+es_manager:
+  format_penalty: -0.1
+  train:
+    env_groups: 8
+    group_size: 16
+    env_configs:
+      tags:
+      - SimpleSokoban
+      n_groups:
+      - 8
+  val:
+    env_groups: 512
+    group_size: 1
+    env_configs:
+      tags:
+      - SimpleSokoban
+      n_groups:
+      - 512
+ctx_manager:
+  generation:
+    gen_config:
+      response_length: ${actor_rollout_ref.rollout.response_length}
+      temperature: ${actor_rollout_ref.rollout.temperature}
+      top_p: ${actor_rollout_ref.rollout.top_p}
+      top_k: ${actor_rollout_ref.rollout.top_k}
+      kwargs: null

outputs/2026-05-11/11-38-43/.hydra/hydra.yaml

@@ -0,0 +1,177 @@
+hydra:
+  run:
+    dir: outputs/${now:%Y-%m-%d}/${now:%H-%M-%S}
+  sweep:
+    dir: multirun/${now:%Y-%m-%d}/${now:%H-%M-%S}
+    subdir: ${hydra.job.num}
+  launcher:
+    _target_: hydra._internal.core_plugins.basic_launcher.BasicLauncher
+  sweeper:
+    _target_: hydra._internal.core_plugins.basic_sweeper.BasicSweeper
+    max_batch_size: null
+    params: null
+  help:
+    app_name: ${hydra.job.name}
+    header: '${hydra.help.app_name} is powered by Hydra.
+
+      '
+    footer: 'Powered by Hydra (https://hydra.cc)
+
+      Use --hydra-help to view Hydra specific help
+
+      '
+    template: '${hydra.help.header}
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (group=option)
+
+
+      $APP_CONFIG_GROUPS
+
+
+      == Config ==
+
+      Override anything in the config (foo.bar=value)
+
+
+      $CONFIG
+
+
+      ${hydra.help.footer}
+
+      '
+  hydra_help:
+    template: 'Hydra (${hydra.runtime.version})
+
+      See https://hydra.cc for more info.
+
+
+      == Flags ==
+
+      $FLAGS_HELP
+
+
+      == Configuration groups ==
+
+      Compose your configuration from those groups (For example, append hydra/job_logging=disabled
+      to command line)
+
+
+      $HYDRA_CONFIG_GROUPS
+
+
+      Use ''--cfg hydra'' to Show the Hydra config.
+
+      '
+    hydra_help: ???
+  hydra_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][HYDRA] %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+    root:
+      level: INFO
+      handlers:
+      - console
+    loggers:
+      logging_example:
+        level: DEBUG
+    disable_existing_loggers: false
+  job_logging:
+    version: 1
+    formatters:
+      simple:
+        format: '[%(asctime)s][%(name)s][%(levelname)s] - %(message)s'
+    handlers:
+      console:
+        class: logging.StreamHandler
+        formatter: simple
+        stream: ext://sys.stdout
+      file:
+        class: logging.FileHandler
+        formatter: simple
+        filename: ${hydra.runtime.output_dir}/${hydra.job.name}.log
+    root:
+      level: INFO
+      handlers:
+      - console
+      - file
+    disable_existing_loggers: false
+  env: {}
+  mode: RUN
+  searchpath:
+  - pkg://verl.trainer.config
+  callbacks: {}
+  output_subdir: .hydra
+  overrides:
+    hydra:
+    - hydra.mode=RUN
+    task:
+    - actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+    - actor_rollout_ref.rollout.rollout_filter_value=0.9
+    - trainer.total_training_steps=1000
+    - model_path=/mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft
+  job:
+    name: train
+    chdir: null
+    override_dirname: actor_rollout_ref.rollout.rollout_filter_strategy=top_p,actor_rollout_ref.rollout.rollout_filter_value=0.9,model_path=/mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft,trainer.total_training_steps=1000
+    id: ???
+    num: ???
+    config_name: _2_sokoban
+    env_set: {}
+    env_copy: []
+    config:
+      override_dirname:
+        kv_sep: '='
+        item_sep: ','
+        exclude_keys: []
+  runtime:
+    version: 1.3.2
+    version_base: '1.3'
+    cwd: /mnt/general/wanghy/RAGEN_v2
+    config_sources:
+    - path: hydra.conf
+      schema: pkg
+      provider: hydra
+    - path: /mnt/general/wanghy/RAGEN_v2/config
+      schema: file
+      provider: main
+    - path: /mnt/general/wanghy/RAGEN_v2/verl/verl/trainer/config
+      schema: file
+      provider: command-line
+    - path: verl.trainer.config
+      schema: pkg
+      provider: hydra.searchpath in main
+    - path: ''
+      schema: structured
+      provider: schema
+    output_dir: /mnt/general/wanghy/RAGEN_v2/outputs/2026-05-11/11-38-43
+    choices:
+      reward_model: dp_reward_model
+      critic: dp_critic
+      critic/../engine@critic.model.fsdp_config: fsdp
+      critic/../optim@critic.optim: fsdp
+      model@actor_rollout_ref.model: hf_model
+      rollout@actor_rollout_ref.rollout: rollout
+      ref@actor_rollout_ref.ref: dp_ref
+      ref/../engine@actor_rollout_ref.ref.fsdp_config: fsdp
+      data: legacy_data
+      actor@actor_rollout_ref.actor: dp_actor
+      actor/../engine@actor_rollout_ref.actor.fsdp_config: fsdp
+      actor/../optim@actor_rollout_ref.actor.optim: fsdp
+      hydra/env: default
+      hydra/callbacks: null
+      hydra/job_logging: default
+      hydra/hydra_logging: default
+      hydra/hydra_help: default
+      hydra/help: default
+      hydra/sweeper: basic
+      hydra/launcher: basic
+      hydra/output: default
+  verbose: false

outputs/2026-05-11/11-38-43/.hydra/overrides.yaml

@@ -0,0 +1,4 @@
+- actor_rollout_ref.rollout.rollout_filter_strategy=top_p
+- actor_rollout_ref.rollout.rollout_filter_value=0.9
+- trainer.total_training_steps=1000
+- model_path=/mnt/general/wanghy/LLaMA-Factory/saves/qwen3/full/sft/qwen2.5_3B_it_sokoban_box1_rft