Add files using upload-large-folder tool

.gitattributes

@@ -118,3 +118,4 @@ InternScenes/InternScenes_Real2Sim/textures/Concrete034_1K-JPG.blend filter=lfs
 InternScenes/InternScenes_Real2Sim/textures/Tiles093_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text
 src/train_sft/data/mllm_demo_data/2.avi filter=lfs diff=lfs merge=lfs -text
 tools/data_gen/zones_data_coarse.json filter=lfs diff=lfs merge=lfs -text
+InternScenes/InternScenes_Real2Sim/textures/WoodFloor040_1K-JPG.blend filter=lfs diff=lfs merge=lfs -text

InternScenes/InternScenes_Real2Sim/textures/WoodFloor040_1K-JPG.blend

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

eval/respace/dataset-ssr3dfront_stage2_with_doors_windows/04684207-3d45-4d33-bd9d-0f66c9a45402-a05d04de-e667-4d0d-855b-18de6d267648.json

@@ -0,0 +1,457 @@
+{
+    "bounds_top": [
+        [
+            -3.15,
+            2.8,
+            -0.2
+        ],
+        [
+            -2.95,
+            2.8,
+            -0.2
+        ],
+        [
+            -2.95,
+            2.8,
+            2.9
+        ],
+        [
+            -2.25,
+            2.8,
+            2.9
+        ],
+        [
+            -2.25,
+            2.8,
+            3.1
+        ],
+        [
+            -0.25,
+            2.8,
+            3.1
+        ],
+        [
+            -0.25,
+            2.8,
+            2.9
+        ],
+        [
+            0.45,
+            2.8,
+            2.9
+        ],
+        [
+            0.45,
+            2.8,
+            0.1
+        ],
+        [
+            0.85,
+            2.8,
+            0.1
+        ],
+        [
+            0.85,
+            2.8,
+            0.2
+        ],
+        [
+            1.55,
+            2.8,
+            0.2
+        ],
+        [
+            1.55,
+            2.8,
+            0.1
+        ],
+        [
+            3.15,
+            2.8,
+            0.1
+        ],
+        [
+            3.15,
+            2.8,
+            -1.0
+        ],
+        [
+            -0.25,
+            2.8,
+            -1.0
+        ],
+        [
+            -0.25,
+            2.8,
+            -3.1
+        ],
+        [
+            -2.95,
+            2.8,
+            -3.1
+        ],
+        [
+            -2.95,
+            2.8,
+            -0.9
+        ],
+        [
+            -3.15,
+            2.8,
+            -0.9
+        ]
+    ],
+    "bounds_bottom": [
+        [
+            -3.15,
+            0.0,
+            -0.2
+        ],
+        [
+            -2.95,
+            0.0,
+            -0.2
+        ],
+        [
+            -2.95,
+            0.0,
+            2.9
+        ],
+        [
+            -2.25,
+            0.0,
+            2.9
+        ],
+        [
+            -2.25,
+            0.0,
+            3.1
+        ],
+        [
+            -0.25,
+            0.0,
+            3.1
+        ],
+        [
+            -0.25,
+            0.0,
+            2.9
+        ],
+        [
+            0.45,
+            0.0,
+            2.9
+        ],
+        [
+            0.45,
+            0.0,
+            0.1
+        ],
+        [
+            0.85,
+            0.0,
+            0.1
+        ],
+        [
+            0.85,
+            0.0,
+            0.2
+        ],
+        [
+            1.55,
+            0.0,
+            0.2
+        ],
+        [
+            1.55,
+            0.0,
+            0.1
+        ],
+        [
+            3.15,
+            0.0,
+            0.1
+        ],
+        [
+            3.15,
+            0.0,
+            -1.0
+        ],
+        [
+            -0.25,
+            0.0,
+            -1.0
+        ],
+        [
+            -0.25,
+            0.0,
+            -3.1
+        ],
+        [
+            -2.95,
+            0.0,
+            -3.1
+        ],
+        [
+            -2.95,
+            0.0,
+            -0.9
+        ],
+        [
+            -3.15,
+            0.0,
+            -0.9
+        ]
+    ],
+    "room_type": "livingroom",
+    "room_id": "LivingDiningRoom-7220",
+    "objects": [
+        {
+            "desc": "Elegant traditional baroque pendant lamp with an antique brass finish, featuring multiple ornate arms and candle-shaped lights for classic ambiance.",
+            "size": [
+                1.05,
+                1.12,
+                1.07
+            ],
+            "pos": [
+                -1.44,
+                1.68,
+                -1.93
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "2a89f148-8de5-4100-a6f4-e0019bd6e57b"
+        },
+        {
+            "desc": "Classic-contemporary three-seat sofa with white tufted fabric, contrasting black and blue cushions, ornate wooden legs, and distinctive decorative prints.",
+            "size": [
+                2.49,
+                0.94,
+                0.79
+            ],
+            "pos": [
+                -2.54,
+                0.0,
+                1.44
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "e68fe496-a9c9-4a0b-b00a-1bbc5aab885d"
+        },
+        {
+            "desc": "Luxury Baroque armchair featuring ornate carved wooden frame with silver finish and plush beige upholstery for elegant comfort.",
+            "size": [
+                0.74,
+                1.03,
+                0.78
+            ],
+            "pos": [
+                -1.46,
+                0.0,
+                0.13
+            ],
+            "rot": [
+                0,
+                0.09971,
+                0,
+                0.99502
+            ],
+            "jid": "772e338e-3907-48ff-b695-5d0aa0088c51"
+        },
+        {
+            "desc": "Traditional round dining table with dark brown wooden top, silver ornate pedestal legs, and classic detailing.",
+            "size": [
+                1.78,
+                0.76,
+                1.73
+            ],
+            "pos": [
+                -1.45,
+                0.0,
+                -1.81
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "ffd71c3f-5625-4090-a8d7-a3caba1af504"
+        },
+        {
+            "desc": "Modern minimalist rectangular coffee table with woven synthetic rattan and textured brown patterned surface.",
+            "size": [
+                1.63,
+                0.52,
+                1.52
+            ],
+            "pos": [
+                -1.24,
+                0.0,
+                1.34
+            ],
+            "rot": [
+                0,
+                -0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "d7b7be7a-5ed6-419e-8d47-cfa909735db7"
+        },
+        {
+            "desc": "Contemporary minimalist TV stand with geometric patterned grey doors, brown wooden top, and gold metal accents.",
+            "size": [
+                2.0,
+                0.56,
+                0.51
+            ],
+            "pos": [
+                0.17,
+                0.0,
+                1.37
+            ],
+            "rot": [
+                0,
+                -0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "0b618eb2-4a1c-43c4-bee7-205c5a6a08d0"
+        },
+        {
+            "desc": "Modern minimalist sideboard with beige wood frame, three gray textured doors, and slim black metal legs.",
+            "size": [
+                1.79,
+                0.64,
+                0.47
+            ],
+            "pos": [
+                -2.7,
+                0.0,
+                -1.98
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "e736b2f5-97bd-45cf-8406-20ef69f13f82"
+        }
+    ],
+    "doors": [
+        {
+            "type": "door",
+            "pos": [
+                -1.28,
+                1.1,
+                2.99
+            ],
+            "size": [
+                1.98,
+                2.2,
+                0.24
+            ],
+            "uid": "84751593635200263/0"
+        },
+        {
+            "type": "door",
+            "pos": [
+                -0.16,
+                1.1,
+                -1.97
+            ],
+            "size": [
+                0.12,
+                2.2,
+                1.36
+            ],
+            "uid": "85651593635200301/0"
+        },
+        {
+            "type": "door",
+            "pos": [
+                3.22,
+                1.05,
+                -0.57
+            ],
+            "size": [
+                0.12,
+                2.1,
+                0.7
+            ],
+            "uid": "86591593635200319/0"
+        },
+        {
+            "type": "door",
+            "pos": [
+                1.16,
+                1.05,
+                0.11
+            ],
+            "size": [
+                0.7,
+                2.1,
+                0.12
+            ],
+            "uid": "88391593635200356/0"
+        },
+        {
+            "type": "door",
+            "pos": [
+                3.22,
+                1.05,
+                -1.47
+            ],
+            "size": [
+                0.12,
+                2.1,
+                0.64
+            ],
+            "uid": "90191593635200380/0"
+        },
+        {
+            "type": "door",
+            "pos": [
+                -3.06,
+                1.05,
+                -0.57
+            ],
+            "size": [
+                0.24,
+                2.1,
+                0.75
+            ],
+            "uid": "91191593635200390/0"
+        }
+    ],
+    "windows": [
+        {
+            "type": "window",
+            "pos": [
+                -1.24,
+                1.65,
+                -3.2
+            ],
+            "size": [
+                0.99,
+                1.5,
+                0.24
+            ],
+            "uid": "82951593635200237/0"
+        }
+    ],
+    "floor_material": {
+        "jid": "9992a6f0-5364-4c45-96ca-9f0064430902",
+        "material_type": "flooring - hardwood",
+        "texture_path": "3D-FRONT-texture/9992a6f0-5364-4c45-96ca-9f0064430902/texture.png"
+    }
+}

eval/respace/dataset-ssr3dfront_stage2_with_doors_windows/1e9ab322-0cd4-4101-985c-16d0297af49b-0d7be190-efc9-42fb-91e6-4d5e4ec8c5fc.json

@@ -0,0 +1,177 @@
+{
+    "bounds_top": [
+        [
+            -1.3,
+            2.6,
+            1.8
+        ],
+        [
+            1.3,
+            2.6,
+            1.8
+        ],
+        [
+            1.3,
+            2.6,
+            -1.8
+        ],
+        [
+            -1.3,
+            2.6,
+            -1.8
+        ]
+    ],
+    "bounds_bottom": [
+        [
+            -1.3,
+            0.0,
+            1.8
+        ],
+        [
+            1.3,
+            0.0,
+            1.8
+        ],
+        [
+            1.3,
+            0.0,
+            -1.8
+        ],
+        [
+            -1.3,
+            0.0,
+            -1.8
+        ]
+    ],
+    "room_type": "other",
+    "room_id": "ElderlyRoom-34339",
+    "objects": [
+        {
+            "desc": "Modern classic king-size canopy bed with sheer white curtains, brown wooden frame, and decorative pink pillows for a cozy, elegant aesthetic.",
+            "size": [
+                2.23,
+                2.26,
+                2.19
+            ],
+            "pos": [
+                0.15,
+                0.0,
+                -0.22
+            ],
+            "rot": [
+                0,
+                -0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "f43310eb-270b-49ec-aef9-11103921b224"
+        },
+        {
+            "desc": "A contemporary minimalist wooden wardrobe with natural light brown color, two doors, and two drawers, featuring a sleek and functional design.",
+            "size": [
+                0.9,
+                2.0,
+                0.56
+            ],
+            "pos": [
+                0.39,
+                0.0,
+                1.53
+            ],
+            "rot": [
+                0,
+                1,
+                0,
+                0
+            ],
+            "jid": "835f1b5d-cb60-4164-a1cd-927bad7f3dbd"
+        },
+        {
+            "desc": "A modern, minimalist wooden nightstand with a natural finish, featuring a single drawer, open shelf, and integrated drawer handle.",
+            "size": [
+                0.4,
+                0.45,
+                0.35
+            ],
+            "pos": [
+                1.04,
+                0.0,
+                1.08
+            ],
+            "rot": [
+                0,
+                -0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "056d9c19-ddb8-45d0-bc22-f9c4f0b41962"
+        },
+        {
+            "desc": "A modern, minimalist wooden nightstand with a natural finish, featuring a single drawer, open shelf, and integrated drawer handle.",
+            "size": [
+                0.4,
+                0.45,
+                0.35
+            ],
+            "pos": [
+                1.13,
+                0.0,
+                -1.38
+            ],
+            "rot": [
+                0,
+                -0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "056d9c19-ddb8-45d0-bc22-f9c4f0b41962"
+        },
+        {
+            "desc": "Modern black fabric armchair with high backrest, slender metal legs, and minimalist design.",
+            "size": [
+                0.78,
+                1.07,
+                0.97
+            ],
+            "pos": [
+                -0.18,
+                0.0,
+                -1.52
+            ],
+            "rot": [
+                0,
+                -0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "9a7b95c2-d2e1-45a1-89a7-b24bbbe7b2c5"
+        },
+        {
+            "desc": "Traditional pendant lamp with a circular frame and six beige fabric conical lampshades on a gold metal base.",
+            "size": [
+                1.01,
+                0.78,
+                0.9
+            ],
+            "pos": [
+                -0.08,
+                1.86,
+                -0.25
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "9110001b-e49a-4703-aebe-ee2e61d6f469"
+        }
+    ],
+    "doors": [],
+    "windows": [],
+    "floor_material": {
+        "jid": "a1543df0-d183-45bc-9814-9bf463f7caed",
+        "material_type": "flooring - reinforced",
+        "texture_path": "3D-FRONT-texture/a1543df0-d183-45bc-9814-9bf463f7caed/texture.png"
+    }
+}

eval/respace/dataset-ssr3dfront_stage2_with_doors_windows/4625da8a-48ed-4930-abd5-58dae51a9b06-79b2c882-23b1-4e39-bcb8-d11bc9033997.json

@@ -0,0 +1,332 @@
+{
+    "bounds_top": [
+        [
+            -1.6,
+            2.8,
+            2.6
+        ],
+        [
+            1.6,
+            2.8,
+            2.6
+        ],
+        [
+            1.6,
+            2.8,
+            -2.5
+        ],
+        [
+            -0.7,
+            2.8,
+            -2.5
+        ],
+        [
+            -0.7,
+            2.8,
+            -2.6
+        ],
+        [
+            -1.5,
+            2.8,
+            -2.6
+        ],
+        [
+            -1.5,
+            2.8,
+            -2.5
+        ],
+        [
+            -1.6,
+            2.8,
+            -2.5
+        ]
+    ],
+    "bounds_bottom": [
+        [
+            -1.6,
+            0.0,
+            2.6
+        ],
+        [
+            1.6,
+            0.0,
+            2.6
+        ],
+        [
+            1.6,
+            0.0,
+            -2.5
+        ],
+        [
+            -0.7,
+            0.0,
+            -2.5
+        ],
+        [
+            -0.7,
+            0.0,
+            -2.6
+        ],
+        [
+            -1.5,
+            0.0,
+            -2.6
+        ],
+        [
+            -1.5,
+            0.0,
+            -2.5
+        ],
+        [
+            -1.6,
+            0.0,
+            -2.5
+        ]
+    ],
+    "room_type": "bedroom",
+    "room_id": "Bedroom-4142",
+    "objects": [
+        {
+            "desc": "Modern white wardrobe with sleek rectangular design, gold accents, and minimalist appeal.",
+            "size": [
+                2.0,
+                2.1,
+                0.64
+            ],
+            "pos": [
+                0.55,
+                0.0,
+                -2.15
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "770a3313-2ecb-478f-b38f-e24bf7cd8fbc"
+        },
+        {
+            "desc": "A modern rustic wooden stool with a cushioned beige seat, curved leg braces, and tapered legs.",
+            "size": [
+                0.44,
+                0.68,
+                0.47
+            ],
+            "pos": [
+                0.82,
+                0.0,
+                1.92
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "4cd0fb8c-80b6-4a8d-a38f-dee8119461a1"
+        },
+        {
+            "desc": "Stylish Mid-century Modern walnut brown wooden dressing table with a lift-up mirror, two drawers, and distinctive slanted legs.",
+            "size": [
+                0.93,
+                1.13,
+                0.42
+            ],
+            "pos": [
+                1.3,
+                0.0,
+                1.94
+            ],
+            "rot": [
+                0,
+                -0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "15b94a23-059b-4c12-98f8-bd651083d20f"
+        },
+        {
+            "desc": "A modern, minimalist king-size bed featuring black fabric upholstery and sturdy wooden legs, embodying clean lines and a low-profile design.",
+            "size": [
+                2.13,
+                0.95,
+                2.34
+            ],
+            "pos": [
+                0.42,
+                0.0,
+                -0.02
+            ],
+            "rot": [
+                0,
+                -0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "5159ffde-a7c7-4d2c-8b07-8c4d088487ee"
+        },
+        {
+            "desc": "Antique vintage nightstand with curved legs, hand-painted floral drawer, and delicate metal handle.",
+            "size": [
+                0.51,
+                0.65,
+                0.44
+            ],
+            "pos": [
+                1.45,
+                0.0,
+                1.3
+            ],
+            "rot": [
+                0,
+                -0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "af8f84de-bb38-49e0-9e39-ffd0511dd65b"
+        },
+        {
+            "desc": "Antique vintage nightstand with curved legs, hand-painted floral drawer, and delicate metal handle.",
+            "size": [
+                0.51,
+                0.65,
+                0.44
+            ],
+            "pos": [
+                1.45,
+                0.0,
+                -1.33
+            ],
+            "rot": [
+                0,
+                -0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "af8f84de-bb38-49e0-9e39-ffd0511dd65b"
+        },
+        {
+            "desc": "A modern, minimalistic black metal plant stand with tall tripod legs and a square pot, offering a sleek and elevated design.",
+            "size": [
+                0.41,
+                1.04,
+                0.39
+            ],
+            "pos": [
+                -1.33,
+                0.0,
+                2.14
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "36f904b5-77ee-430d-8726-6db2d2104307"
+        },
+        {
+            "desc": "Mid-century modern sideboard with dark wood finish, sleek legs, and gold brass handles.",
+            "size": [
+                0.8,
+                0.98,
+                0.41
+            ],
+            "pos": [
+                -1.44,
+                0.0,
+                0.04
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "63fb829b-fe84-44c5-8449-ddabff483630"
+        },
+        {
+            "desc": "Modern pendant lamp with a spherical petal-like white fabric design and a central light bulb suspended by metal.",
+            "size": [
+                0.82,
+                0.82,
+                0.82
+            ],
+            "pos": [
+                -0.02,
+                1.97,
+                0.26
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "7be78e99-5ace-466f-84bf-e4509dabebb3"
+        },
+        {
+            "desc": "A striking contemporary industrial pendant lamp with a red metal frame and five black bell-shaped shades, featuring curved arms and a distinctive metallic finish.",
+            "size": [
+                0.25,
+                0.27,
+                0.22
+            ],
+            "pos": [
+                1.43,
+                2.12,
+                -1.16
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "921c632b-d082-4991-869e-e1770eeb5dba-(1.11)-(1.0)-(0.95)"
+        },
+        {
+            "desc": "A striking contemporary industrial pendant lamp with a red metal frame and five black bell-shaped shades, featuring curved arms and a distinctive metallic finish.",
+            "size": [
+                0.25,
+                0.27,
+                0.22
+            ],
+            "pos": [
+                1.43,
+                2.12,
+                1.15
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "921c632b-d082-4991-869e-e1770eeb5dba-(1.11)-(1.0)-(0.95)"
+        }
+    ],
+    "doors": [
+        {
+            "type": "door",
+            "pos": [
+                -1.09,
+                1.06,
+                -2.53
+            ],
+            "size": [
+                0.8,
+                2.11,
+                0.12
+            ],
+            "uid": "660101593784432476/0"
+        }
+    ],
+    "windows": [],
+    "floor_material": {
+        "jid": "3199e4ba-6cd0-4118-bdc6-0e2e12466466",
+        "material_type": "flooring - hardwood",
+        "texture_path": "3D-FRONT-texture/3199e4ba-6cd0-4118-bdc6-0e2e12466466/texture.png"
+    }
+}

eval/respace/dataset-ssr3dfront_stage2_with_doors_windows/53cf7da8-7c02-419d-bc4a-acf5d4337cac-957fb842-6774-4540-bb6c-81f5c7132bc9.json

@@ -0,0 +1,317 @@
+{
+    "bounds_top": [
+        [
+            -2.7,
+            2.6,
+            1.95
+        ],
+        [
+            2.7,
+            2.6,
+            1.95
+        ],
+        [
+            2.7,
+            2.6,
+            -1.95
+        ],
+        [
+            -2.7,
+            2.6,
+            -1.95
+        ]
+    ],
+    "bounds_bottom": [
+        [
+            -2.7,
+            0.0,
+            1.95
+        ],
+        [
+            2.7,
+            0.0,
+            1.95
+        ],
+        [
+            2.7,
+            0.0,
+            -1.95
+        ],
+        [
+            -2.7,
+            0.0,
+            -1.95
+        ]
+    ],
+    "room_type": "livingroom",
+    "room_id": "LivingDiningRoom-6226",
+    "objects": [
+        {
+            "desc": "A contemporary dark blue velvet three-seat sofa with a curved backrest, rounded shape, minimalist design, and multiple gray cushions for added comfort.",
+            "size": [
+                2.33,
+                0.82,
+                0.91
+            ],
+            "pos": [
+                1.04,
+                0.0,
+                -1.51
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "221f31fd-1759-4c14-b183-77a0ac51b55f"
+        },
+        {
+            "desc": "A contemporary gray dining chair with a curved backrest and dark brown wooden legs, featuring minimalist design and comfortable padded upholstery.",
+            "size": [
+                0.68,
+                0.75,
+                0.68
+            ],
+            "pos": [
+                -0.45,
+                0.0,
+                -0.43
+            ],
+            "rot": [
+                0,
+                0.49227,
+                0,
+                0.87044
+            ],
+            "jid": "1fd55b49-a16a-46b1-a196-e6d00b4ec179"
+        },
+        {
+            "desc": "A contemporary, minimalist round coffee table with a beige upholstered body and grey metal trim.",
+            "size": [
+                0.49,
+                0.25,
+                0.49
+            ],
+            "pos": [
+                1.17,
+                0.0,
+                -0.3
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "01ccb00d-2cc9-464e-a250-42adbf4eb646"
+        },
+        {
+            "desc": "Elegant modern black wooden corner table with tapered legs and raised edge top featuring ornate detailing.",
+            "size": [
+                0.47,
+                0.54,
+                0.47
+            ],
+            "pos": [
+                -0.47,
+                0.0,
+                -1.6
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "b5c2be8e-ab60-4cb8-bb59-abf7d26cef40"
+        },
+        {
+            "desc": "Elegant modern black wooden corner table with tapered legs and raised edge top featuring ornate detailing.",
+            "size": [
+                0.47,
+                0.54,
+                0.47
+            ],
+            "pos": [
+                2.46,
+                0.0,
+                -1.56
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "b5c2be8e-ab60-4cb8-bb59-abf7d26cef40"
+        },
+        {
+            "desc": "Modern minimalist dining table with rectangular wooden top and striking angled metal legs, featuring clean lines and a smooth surface.",
+            "size": [
+                2.08,
+                0.91,
+                1.12
+            ],
+            "pos": [
+                -2.16,
+                0.0,
+                -0.88
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "5ce0286c-a161-4473-82c0-febd82bc2233"
+        },
+        {
+            "desc": "Modern minimalist dining chair with a curved back, two-tone fabric upholstery, thin metal legs, and accented stitching.",
+            "size": [
+                0.59,
+                0.85,
+                0.61
+            ],
+            "pos": [
+                -1.48,
+                0.0,
+                -0.2
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                -0.70711
+            ],
+            "jid": "baa3522b-8136-47e2-b401-b413906edeb0"
+        },
+        {
+            "desc": "Modern minimalist dining chair with a curved back, two-tone fabric upholstery, thin metal legs, and accented stitching.",
+            "size": [
+                0.59,
+                0.85,
+                0.61
+            ],
+            "pos": [
+                -1.47,
+                0.0,
+                -1.4
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                -0.70711
+            ],
+            "jid": "baa3522b-8136-47e2-b401-b413906edeb0"
+        },
+        {
+            "desc": "Modern minimalist black TV stand with a geometric patterned front, wood construction, and lacquered finish.",
+            "size": [
+                2.2,
+                0.78,
+                0.52
+            ],
+            "pos": [
+                1.07,
+                0.0,
+                1.72
+            ],
+            "rot": [
+                0,
+                -1,
+                0,
+                0
+            ],
+            "jid": "232df588-db56-4982-a81e-ea9de8aa3606"
+        },
+        {
+            "desc": "A mid-century modern dark brown wooden sideboard with slanted black handles, featuring two central doors, six drawers, and tapered legs.",
+            "size": [
+                1.59,
+                0.67,
+                0.39
+            ],
+            "pos": [
+                -2.5,
+                0.0,
+                0.98
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "ab94bb57-2f95-4090-8eeb-f9dea82e3289"
+        },
+        {
+            "desc": "Contemporary pendant lamp featuring gold and white circular disks, blending modern and minimalist design with a floating geometric aesthetic.",
+            "size": [
+                0.42,
+                1.12,
+                0.39
+            ],
+            "pos": [
+                1.01,
+                1.48,
+                -0.02
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "a7621218-bd3a-48ab-9694-9f307bb4ba1e"
+        },
+        {
+            "desc": "Modern gold geometric pendant lamp with crystal accents and layered design for a luxurious touch.",
+            "size": [
+                1.11,
+                1.22,
+                1.1
+            ],
+            "pos": [
+                -2.12,
+                0.98,
+                -1.39
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "052065aa-8642-4969-abb0-98e429eb4360"
+        },
+        {
+            "desc": "Modern gold geometric pendant lamp with crystal accents and layered design for a luxurious touch.",
+            "size": [
+                1.11,
+                1.22,
+                1.1
+            ],
+            "pos": [
+                -2.12,
+                0.98,
+                -0.24
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "052065aa-8642-4969-abb0-98e429eb4360"
+        }
+    ],
+    "doors": [],
+    "windows": [],
+    "floor_material": {
+        "jid": "ef6add12-4f83-4cf5-b0f3-6cb2a79f96da",
+        "material_type": "wood grain tiles",
+        "texture_path": "3D-FRONT-texture/ef6add12-4f83-4cf5-b0f3-6cb2a79f96da/texture.png"
+    }
+}

eval/respace/dataset-ssr3dfront_stage2_with_doors_windows/83873897-a199-40c8-94f4-34a5f25f53ca-6a131d07-68c2-4049-8c15-4ac0454bf32e.json

@@ -0,0 +1,661 @@
+{
+    "bounds_top": [
+        [
+            -5.45,
+            2.6,
+            0.1
+        ],
+        [
+            0.35,
+            2.6,
+            0.1
+        ],
+        [
+            0.35,
+            2.6,
+            4.1
+        ],
+        [
+            2.15,
+            2.6,
+            4.1
+        ],
+        [
+            2.15,
+            2.6,
+            2.8
+        ],
+        [
+            1.75,
+            2.6,
+            2.8
+        ],
+        [
+            1.75,
+            2.6,
+            -0.5
+        ],
+        [
+            5.45,
+            2.6,
+            -0.5
+        ],
+        [
+            5.45,
+            2.6,
+            -2.9
+        ],
+        [
+            1.65,
+            2.6,
+            -2.9
+        ],
+        [
+            1.65,
+            2.6,
+            -4.1
+        ],
+        [
+            -5.45,
+            2.6,
+            -4.1
+        ]
+    ],
+    "bounds_bottom": [
+        [
+            -5.45,
+            0.0,
+            0.1
+        ],
+        [
+            0.35,
+            0.0,
+            0.1
+        ],
+        [
+            0.35,
+            0.0,
+            4.1
+        ],
+        [
+            2.15,
+            0.0,
+            4.1
+        ],
+        [
+            2.15,
+            0.0,
+            2.8
+        ],
+        [
+            1.75,
+            0.0,
+            2.8
+        ],
+        [
+            1.75,
+            0.0,
+            -0.5
+        ],
+        [
+            5.45,
+            0.0,
+            -0.5
+        ],
+        [
+            5.45,
+            0.0,
+            -2.9
+        ],
+        [
+            1.65,
+            0.0,
+            -2.9
+        ],
+        [
+            1.65,
+            0.0,
+            -4.1
+        ],
+        [
+            -5.45,
+            0.0,
+            -4.1
+        ]
+    ],
+    "room_type": "livingroom",
+    "room_id": "LivingDiningRoom-2919",
+    "objects": [
+        {
+            "desc": "A modern minimalist armchair with black fabric upholstery, high backrest, and slender metal legs, offering sleek design and comfort.",
+            "size": [
+                0.78,
+                1.07,
+                0.97
+            ],
+            "pos": [
+                -0.68,
+                0.0,
+                -1.36
+            ],
+            "rot": [
+                0,
+                0.92388,
+                0,
+                -0.38268
+            ],
+            "jid": "f7c601dd-90ac-485a-a9b8-8d676c87423a"
+        },
+        {
+            "desc": "Modern minimalist dark purple fabric three-seat sofa with clean lines, slightly curved arms, multicolored decorative throw pillows, and tapered wooden legs.",
+            "size": [
+                2.39,
+                0.81,
+                0.85
+            ],
+            "pos": [
+                -2.45,
+                0.0,
+                -0.32
+            ],
+            "rot": [
+                0,
+                1,
+                0,
+                0
+            ],
+            "jid": "f95c4da5-83ef-4123-af9a-3b17af255a66"
+        },
+        {
+            "desc": "A modern armchair with eclectic patterns, gray fabric upholstery, and elegant tapered legs.",
+            "size": [
+                0.68,
+                0.8,
+                0.68
+            ],
+            "pos": [
+                -4.21,
+                0.0,
+                -1.34
+            ],
+            "rot": [
+                0,
+                0.77114,
+                0,
+                0.63666
+            ],
+            "jid": "f7dce3bd-31e7-44ac-ba84-c5098c46f6fb"
+        },
+        {
+            "desc": "A modern industrial corner side table with a minimalist metal three-legged base and round metallic tabletop.",
+            "size": [
+                0.44,
+                0.63,
+                0.44
+            ],
+            "pos": [
+                -0.69,
+                0.0,
+                -0.37
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "da8570b9-119e-4a21-a23b-ca8b94000c30"
+        },
+        {
+            "desc": "A modern industrial corner side table with a minimalist metal three-legged base and round metallic tabletop.",
+            "size": [
+                0.44,
+                0.63,
+                0.44
+            ],
+            "pos": [
+                -4.19,
+                0.0,
+                -0.39
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "da8570b9-119e-4a21-a23b-ca8b94000c30"
+        },
+        {
+            "desc": "A modern, black and gray rectangular coffee table with a reflective glass surface, metal frame, and decorative spherical elements, offering a minimalist and contemporary appeal.",
+            "size": [
+                1.78,
+                0.79,
+                1.21
+            ],
+            "pos": [
+                -2.49,
+                0.0,
+                -1.66
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "fa892aee-16e1-4410-b8e1-1196e89e4455"
+        },
+        {
+            "desc": "Contemporary geometric TV stand with white, black, and wood finish, featuring a striking contrast design and metal legs.",
+            "size": [
+                2.5,
+                0.75,
+                0.4
+            ],
+            "pos": [
+                -2.69,
+                0.0,
+                -3.75
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "14a8635b-e6ef-4561-88d9-6c21f09eda27"
+        },
+        {
+            "desc": "A modern minimalist floor lamp with a tall slim metal frame and a transparent glass spherical shade.",
+            "size": [
+                0.27,
+                0.8,
+                0.55
+            ],
+            "pos": [
+                -4.67,
+                0.0,
+                -3.62
+            ],
+            "rot": [
+                0,
+                0.30356,
+                0,
+                0.95281
+            ],
+            "jid": "49508240-6ff1-4600-8f1d-333b339b58a7"
+        },
+        {
+            "desc": "Modern minimalist dining table with a white marble top and a distinctive U-shaped black metal base.",
+            "size": [
+                1.95,
+                0.87,
+                0.85
+            ],
+            "pos": [
+                4.09,
+                0.0,
+                -1.91
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "b130163c-7c15-4f9b-9294-5c81fd23e968"
+        },
+        {
+            "desc": "Modern Mid-Century black leather and wood dining chair with a curved backrest and minimalist design.",
+            "size": [
+                0.55,
+                0.86,
+                0.53
+            ],
+            "pos": [
+                3.19,
+                0.0,
+                -1.64
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "5fa11d54-53f7-4b9e-9d8f-07012eba4e90"
+        },
+        {
+            "desc": "Modern Mid-Century black leather and wood dining chair with a curved backrest and minimalist design.",
+            "size": [
+                0.55,
+                0.86,
+                0.53
+            ],
+            "pos": [
+                3.35,
+                0.0,
+                -2.38
+            ],
+            "rot": [
+                0,
+                0.70711,
+                0,
+                0.70711
+            ],
+            "jid": "5fa11d54-53f7-4b9e-9d8f-07012eba4e90"
+        },
+        {
+            "desc": "Modern Mid-Century black leather and wood dining chair with a curved backrest and minimalist design.",
+            "size": [
+                0.55,
+                0.86,
+                0.53
+            ],
+            "pos": [
+                4.76,
+                0.0,
+                -1.62
+            ],
+            "rot": [
+                0,
+                0.71096,
+                0,
+                -0.70323
+            ],
+            "jid": "5fa11d54-53f7-4b9e-9d8f-07012eba4e90"
+        },
+        {
+            "desc": "Modern Mid-Century black leather and wood dining chair with a curved backrest and minimalist design.",
+            "size": [
+                0.55,
+                0.86,
+                0.53
+            ],
+            "pos": [
+                4.76,
+                0.0,
+                -2.42
+            ],
+            "rot": [
+                0,
+                0.71096,
+                0,
+                -0.70323
+            ],
+            "jid": "5fa11d54-53f7-4b9e-9d8f-07012eba4e90"
+        },
+        {
+            "desc": "Modern Oriental wine cabinet with marble facade, gray wooden shelves and cabinets, and a central circular display featuring an artistic backdrop.",
+            "size": [
+                3.5,
+                2.63,
+                0.32
+            ],
+            "pos": [
+                2.02,
+                0.0,
+                -2.71
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "53f1bd2c-1738-42b2-a19f-fa112f09703f"
+        },
+        {
+            "desc": "Modern minimalist potted plant with large green leaves in a white round ceramic pot.",
+            "size": [
+                0.68,
+                0.97,
+                0.73
+            ],
+            "pos": [
+                0.19,
+                0.0,
+                -3.65
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "6d4046a6-e65c-4e8c-aaaa-8a59bb494aa3"
+        },
+        {
+            "desc": "A modern geometric pendant lamp with a stacked rectangular metal design in bronze brown, featuring clean lines and suspended elements.",
+            "size": [
+                1.24,
+                1.33,
+                0.23
+            ],
+            "pos": [
+                -2.47,
+                1.26,
+                -1.65
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "8693a47d-21a4-4b98-a1b4-5e901f379b8f"
+        },
+        {
+            "desc": "A modern industrial pendant lamp featuring a circular brown metal frame with clear glass tube accents and central light bulbs, exemplifying geometric and contemporary design.",
+            "size": [
+                0.84,
+                1.03,
+                0.84
+            ],
+            "pos": [
+                3.98,
+                1.77,
+                -2.08
+            ],
+            "rot": [
+                0,
+                0,
+                0,
+                1
+            ],
+            "jid": "60d66fea-b63a-43f0-b85c-748a3adc0391"
+        }
+    ],
+    "doors": [
+        {
+            "type": "door",
+            "pos": [
+                1.0,
+                1.05,
+                4.21
+            ],
+            "size": [
+                0.9,
+                2.1,
+                0.24
+            ],
+            "uid": "41d2ccb8-ed37-47ef-aaff-870dae4e391f/24585991"
+        },
+        {
+            "type": "door",
+            "pos": [
+                1.0,
+                0.0,
+                4.21
+            ],
+            "size": [
+                0.9,
+                0.0,
+                0.24
+            ],
+            "uid": "41d2ccb8-ed37-47ef-aaff-870dae4e391f/24585994"
+        },
+        {
+            "type": "door",
+            "pos": [
+                3.52,
+                1.05,
+                -0.48
+            ],
+            "size": [
+                1.5,
+                2.1,
+                0.12
+            ],
+            "uid": "68bd856b-14e4-4098-ade3-e37eb23428b8/24585999"
+        },
+        {
+            "type": "door",
+            "pos": [
+                3.52,
+                0.0,
+                -0.48
+            ],
+            "size": [
+                1.5,
+                0.0,
+                0.12
+            ],
+            "uid": "68bd856b-14e4-4098-ade3-e37eb23428b8/24586002"
+        },
+        {
+            "type": "door",
+            "pos": [
+                1.78,
+                1.05,
+                2.06
+            ],
+            "size": [
+                0.12,
+                2.1,
+                0.8
+            ],
+            "uid": "29929fc2-3a6e-4eec-bfc1-6c6c7e241093/24586141"
+        },
+        {
+            "type": "door",
+            "pos": [
+                1.78,
+                0.0,
+                2.06
+            ],
+            "size": [
+                0.12,
+                0.0,
+                0.8
+            ],
+            "uid": "29929fc2-3a6e-4eec-bfc1-6c6c7e241093/24586144"
+        },
+        {
+            "type": "door",
+            "pos": [
+                1.78,
+                1.05,
+                -3.52
+            ],
+            "size": [
+                0.24,
+                2.1,
+                0.8
+            ],
+            "uid": "e94464ee-7720-4384-bf97-5bc1623c9397/24586283"
+        },
+        {
+            "type": "door",
+            "pos": [
+                1.78,
+                0.0,
+                -3.52
+            ],
+            "size": [
+                0.24,
+                0.0,
+                0.8
+            ],
+            "uid": "e94464ee-7720-4384-bf97-5bc1623c9397/24586286"
+        },
+        {
+            "type": "door",
+            "pos": [
+                1.18,
+                1.05,
+                -4.12
+            ],
+            "size": [
+                0.8,
+                2.1,
+                0.12
+            ],
+            "uid": "8e27ff27-661c-4f99-a319-cf299557ae4c/24586425"
+        },
+        {
+            "type": "door",
+            "pos": [
+                1.18,
+                0.0,
+                -4.12
+            ],
+            "size": [
+                0.8,
+                0.0,
+                0.12
+            ],
+            "uid": "8e27ff27-661c-4f99-a319-cf299557ae4c/24586428"
+        },
+        {
+            "type": "door",
+            "pos": [
+                -0.8,
+                1.05,
+                -4.12
+            ],
+            "size": [
+                0.8,
+                2.1,
+                0.12
+            ],
+            "uid": "3a648053-81ac-4a5e-8ab1-f5b9092c2ff2/24586567"
+        },
+        {
+            "type": "door",
+            "pos": [
+                -0.8,
+                0.0,
+                -4.12
+            ],
+            "size": [
+                0.8,
+                0.0,
+                0.12
+            ],
+            "uid": "3a648053-81ac-4a5e-8ab1-f5b9092c2ff2/24586570"
+        }
+    ],
+    "windows": [
+        {
+            "type": "window",
+            "pos": [
+                5.53,
+                1.53,
+                -1.73
+            ],
+            "size": [
+                0.24,
+                1.36,
+                1.26
+            ],
+            "uid": "8f40127a-30e3-4fcf-be33-3cef56fbe309/24585469"
+        }
+    ],
+    "floor_material": {
+        "jid": "a1543df0-d183-45bc-9814-9bf463f7caed",
+        "material_type": "flooring - reinforced",
+        "texture_path": "3D-FRONT-texture/a1543df0-d183-45bc-9814-9bf463f7caed/texture.png"
+    }
+}

src/verl/recipe/entropy/32b_kl_cov.sh

@@ -0,0 +1,143 @@
+#!/usr/bin/env bash
+set -xeuo pipefail
+
+export WANDB_API_KEY=YOUR_WANDB_API_KEY
+# export VLLM_USE_V1=1
+
+project_name='Qwen2.5-32B'
+exp_name='klcov'
+
+adv_estimator=grpo
+
+use_kl_in_reward=False
+kl_coef=0.0
+use_kl_loss=False
+kl_loss_coef=0.0
+
+clip_ratio_low=0.2
+clip_ratio_high=0.2
+
+max_prompt_length=$((1024 * 2))
+max_response_length=$((1024 * 8))
+enable_overlong_buffer=False
+overlong_buffer_len=$((1024 * 2))
+overlong_penalty_factor=1.0
+
+loss_agg_mode="token-mean"
+loss_mode="kl_cov"
+enable_filter_groups=True
+filter_groups_metric=acc
+max_num_gen_batches=10
+train_prompt_bsz=256
+gen_prompt_bsz=$((train_prompt_bsz * 3))
+train_prompt_mini_bsz=32
+n_resp_per_prompt=8
+max_token=20480
+
+# Ray
+RAY_ADDRESS=${RAY_ADDRESS:-"http://localhost:8265"}
+WORKING_DIR=${WORKING_DIR:-"${PWD}"}
+RUNTIME_ENV=${RUNTIME_ENV:-"${WORKING_DIR}/verl/trainer/runtime_env.yaml"}
+NNODES=${NNODES:-4}
+# Paths
+RAY_DATA_HOME=${RAY_DATA_HOME:-"${HOME}/verl"}
+MODEL_PATH=${MODEL_PATH:-"/YOUR_MODELPATH"}
+CKPTS_DIR=${CKPTS_DIR:-"/YOUR_CKPTS_PATH"}
+TRAIN_FILE=${TRAIN_FILE:-"/YOUR_TRAIN_FILE_PATH"}
+TEST_FILE=${TEST_FILE:-["/YOUR_TRAIN_FILE_PATH"]}
+
+# Algorithm
+temperature=1.0
+top_p=1.0
+top_k=-1 # 0 for HF rollout, -1 for vLLM rollout
+ppo_kl_coef=1
+kl_cov_ratio=0.0002
+
+# Mathematically equivalent
+use_dynamic_bsz=True
+infer_micro_batch_size=null
+train_micro_batch_size=null
+offload=False
+
+HYDRA_FULL_ERROR=1 python -m recipe.entropy.main_entropy \
+    data.train_files="${TRAIN_FILE}" \
+    data.val_files="${TEST_FILE}" \
+    data.prompt_key=prompt \
+    data.truncation='left' \
+    data.filter_overlong_prompts=False \
+    data.max_prompt_length=${max_prompt_length} \
+    data.max_response_length=${max_response_length} \
+    data.gen_batch_size=${gen_prompt_bsz} \
+    data.train_batch_size=${train_prompt_bsz} \
+    data.return_raw_chat=True \
+    actor_rollout_ref.rollout.n=${n_resp_per_prompt} \
+    actor_rollout_ref.actor.use_kl_loss=${use_kl_loss} \
+    actor_rollout_ref.actor.kl_loss_coef=${kl_loss_coef} \
+    actor_rollout_ref.actor.clip_ratio_low=${clip_ratio_low} \
+    actor_rollout_ref.actor.clip_ratio_high=${clip_ratio_high} \
+    actor_rollout_ref.actor.clip_ratio_c=10.0 \
+    actor_rollout_ref.actor.loss_mode=${loss_mode} \
+    actor_rollout_ref.actor.policy_loss.loss_mode=${loss_mode} \
+    actor_rollout_ref.actor.policy_loss.kl_cov_ratio=${kl_cov_ratio} \
+    actor_rollout_ref.actor.policy_loss.ppo_kl_coef=${ppo_kl_coef} \
+    actor_rollout_ref.actor.ppo_micro_batch_size_per_gpu=8 \
+    actor_rollout_ref.rollout.mode=sync \
+    actor_rollout_ref.rollout.name=vllm \
+    algorithm.adv_estimator=${adv_estimator} \
+    algorithm.use_kl_in_reward=${use_kl_in_reward} \
+    algorithm.kl_ctrl.kl_coef=${kl_coef} \
+    algorithm.filter_groups.enable=${enable_filter_groups} \
+    algorithm.filter_groups.metric=${filter_groups_metric} \
+    algorithm.filter_groups.max_num_gen_batches=${max_num_gen_batches} \
+    actor_rollout_ref.model.use_remove_padding=True \
+    actor_rollout_ref.actor.use_dynamic_bsz=${use_dynamic_bsz} \
+    actor_rollout_ref.ref.log_prob_use_dynamic_bsz=${use_dynamic_bsz} \
+    actor_rollout_ref.rollout.log_prob_use_dynamic_bsz=${use_dynamic_bsz} \
+    actor_rollout_ref.actor.ppo_max_token_len_per_gpu=${max_token} \
+    actor_rollout_ref.ref.log_prob_max_token_len_per_gpu=${max_token} \
+    actor_rollout_ref.rollout.log_prob_max_token_len_per_gpu=${max_token} \
+    actor_rollout_ref.model.path="${MODEL_PATH}" \
+    actor_rollout_ref.model.enable_gradient_checkpointing=True \
+    actor_rollout_ref.actor.optim.lr=1e-6 \
+    actor_rollout_ref.actor.optim.weight_decay=0 \
+    actor_rollout_ref.actor.optim.warmup_style=constant \
+    actor_rollout_ref.actor.ppo_mini_batch_size=${train_prompt_mini_bsz} \
+    actor_rollout_ref.actor.ppo_micro_batch_size=${train_micro_batch_size} \
+    actor_rollout_ref.actor.fsdp_config.param_offload=${offload} \
+    actor_rollout_ref.actor.fsdp_config.optimizer_offload=${offload} \
+    actor_rollout_ref.actor.entropy_coeff=0 \
+    actor_rollout_ref.actor.grad_clip=1.0 \
+    actor_rollout_ref.actor.loss_agg_mode=${loss_agg_mode} \
+    actor_rollout_ref.actor.ulysses_sequence_parallel_size=1 \
+    actor_rollout_ref.rollout.gpu_memory_utilization=0.85 \
+    actor_rollout_ref.rollout.log_prob_micro_batch_size=${infer_micro_batch_size} \
+    actor_rollout_ref.rollout.tensor_model_parallel_size=2 \
+    actor_rollout_ref.rollout.enable_chunked_prefill=True \
+    actor_rollout_ref.rollout.max_num_batched_tokens=${max_token} \
+    actor_rollout_ref.rollout.temperature=${temperature} \
+    actor_rollout_ref.rollout.top_p=${top_p} \
+    actor_rollout_ref.rollout.top_k="${top_k}" \
+    actor_rollout_ref.rollout.val_kwargs.temperature=${temperature} \
+    actor_rollout_ref.rollout.val_kwargs.top_p=${top_p} \
+    actor_rollout_ref.rollout.val_kwargs.top_k=${top_k} \
+    actor_rollout_ref.rollout.val_kwargs.do_sample=False \
+    actor_rollout_ref.rollout.val_kwargs.n=1 \
+    actor_rollout_ref.ref.log_prob_micro_batch_size=${infer_micro_batch_size} \
+    actor_rollout_ref.ref.fsdp_config.param_offload=${offload} \
+    actor_rollout_ref.ref.ulysses_sequence_parallel_size=1 \
+    actor_rollout_ref.actor.fsdp_config.fsdp_size=-1 \
+    reward_model.reward_manager=dapo \
+    reward_model.overlong_buffer.enable=${enable_overlong_buffer} \
+    reward_model.overlong_buffer.len=${overlong_buffer_len} \
+    reward_model.overlong_buffer.penalty_factor=${overlong_penalty_factor} \
+    trainer.logger='["console","wandb"]' \
+    trainer.project_name="${project_name}" \
+    trainer.experiment_name="${exp_name}" \
+    trainer.n_gpus_per_node=8 \
+    trainer.nnodes="${NNODES}" \
+    trainer.val_before_train=False \
+    trainer.test_freq=4 \
+    trainer.save_freq=32 \
+    trainer.total_epochs=1000 \
+    trainer.default_local_dir="${CKPTS_DIR}" \
+    trainer.resume_mode=disable

src/verl/recipe/entropy/32b_kl_cov_mininbsz.sh

@@ -0,0 +1,142 @@
+#!/usr/bin/env bash
+set -xeuo pipefail
+
+export WANDB_API_KEY=YOUR_WANDB_API_KEY
+# export VLLM_USE_V1=1
+
+project_name='Qwen2.5-32B'
+exp_name='klcov'
+
+adv_estimator=grpo
+
+use_kl_in_reward=False
+kl_coef=0.0
+use_kl_loss=False
+kl_loss_coef=0.0
+
+clip_ratio_low=0.2
+clip_ratio_high=0.2
+
+max_prompt_length=$((1024 * 2))
+max_response_length=$((1024 * 8))
+enable_overlong_buffer=False
+overlong_buffer_len=$((1024 * 2))
+overlong_penalty_factor=1.0
+
+loss_agg_mode="token-mean"
+loss_mode="kl_cov"
+enable_filter_groups=True
+filter_groups_metric=acc
+max_num_gen_batches=10
+train_prompt_bsz=256
+gen_prompt_bsz=$((train_prompt_bsz * 3))
+train_prompt_mini_bsz=16
+n_resp_per_prompt=8
+max_token=20480
+
+# Ray
+RAY_ADDRESS=${RAY_ADDRESS:-"http://localhost:8265"}
+WORKING_DIR=${WORKING_DIR:-"${PWD}"}
+RUNTIME_ENV=${RUNTIME_ENV:-"${WORKING_DIR}/verl/trainer/runtime_env.yaml"}
+NNODES=${NNODES:-4}
+# Paths
+RAY_DATA_HOME=${RAY_DATA_HOME:-"${HOME}/verl"}
+MODEL_PATH=${MODEL_PATH:-"/YOUR_MODELPATH"}
+CKPTS_DIR=${CKPTS_DIR:-"/YOUR_CKPTS_PATH"}
+TRAIN_FILE=${TRAIN_FILE:-"/YOUR_TRAIN_FILE_PATH"}
+TEST_FILE=${TEST_FILE:-["/YOUR_TRAIN_FILE_PATH"]}
+
+# Algorithm
+temperature=1.0
+top_p=1.0
+top_k=-1 # 0 for HF rollout, -1 for vLLM rollout
+ppo_kl_coef=1
+kl_cov_ratio=0.0002
+
+# Mathematically equivalent
+use_dynamic_bsz=True
+infer_micro_batch_size=null
+train_micro_batch_size=null
+offload=False
+
+HYDRA_FULL_ERROR=1 python -m recipe.entropy.main_entropy \
+    data.train_files="${TRAIN_FILE}" \
+    data.val_files="${TEST_FILE}" \
+    data.prompt_key=prompt \
+    data.truncation='left' \
+    data.filter_overlong_prompts=False \
+    data.max_prompt_length=${max_prompt_length} \
+    data.max_response_length=${max_response_length} \
+    data.gen_batch_size=${gen_prompt_bsz} \
+    data.train_batch_size=${train_prompt_bsz} \
+    data.return_raw_chat=True \
+    actor_rollout_ref.rollout.n=${n_resp_per_prompt} \
+    actor_rollout_ref.actor.use_kl_loss=${use_kl_loss} \
+    actor_rollout_ref.actor.kl_loss_coef=${kl_loss_coef} \
+    actor_rollout_ref.actor.clip_ratio_low=${clip_ratio_low} \
+    actor_rollout_ref.actor.clip_ratio_high=${clip_ratio_high} \
+    actor_rollout_ref.actor.clip_ratio_c=10.0 \
+    actor_rollout_ref.actor.policy_loss.loss_mode=${loss_mode} \
+    actor_rollout_ref.actor.policy_loss.kl_cov_ratio=${kl_cov_ratio} \
+    actor_rollout_ref.actor.policy_loss.ppo_kl_coef=${ppo_kl_coef} \
+    actor_rollout_ref.actor.ppo_micro_batch_size_per_gpu=8 \
+    actor_rollout_ref.rollout.mode=sync \
+    actor_rollout_ref.rollout.name=vllm \
+    algorithm.adv_estimator=${adv_estimator} \
+    algorithm.use_kl_in_reward=${use_kl_in_reward} \
+    algorithm.kl_ctrl.kl_coef=${kl_coef} \
+    algorithm.filter_groups.enable=${enable_filter_groups} \
+    algorithm.filter_groups.metric=${filter_groups_metric} \
+    algorithm.filter_groups.max_num_gen_batches=${max_num_gen_batches} \
+    actor_rollout_ref.model.use_remove_padding=True \
+    actor_rollout_ref.actor.use_dynamic_bsz=${use_dynamic_bsz} \
+    actor_rollout_ref.ref.log_prob_use_dynamic_bsz=${use_dynamic_bsz} \
+    actor_rollout_ref.rollout.log_prob_use_dynamic_bsz=${use_dynamic_bsz} \
+    actor_rollout_ref.actor.ppo_max_token_len_per_gpu=${max_token} \
+    actor_rollout_ref.ref.log_prob_max_token_len_per_gpu=${max_token} \
+    actor_rollout_ref.rollout.log_prob_max_token_len_per_gpu=${max_token} \
+    actor_rollout_ref.model.path="${MODEL_PATH}" \
+    actor_rollout_ref.model.enable_gradient_checkpointing=True \
+    actor_rollout_ref.actor.optim.lr=1e-6 \
+    actor_rollout_ref.actor.optim.weight_decay=0 \
+    actor_rollout_ref.actor.optim.warmup_style=constant \
+    actor_rollout_ref.actor.ppo_mini_batch_size=${train_prompt_mini_bsz} \
+    actor_rollout_ref.actor.ppo_micro_batch_size=${train_micro_batch_size} \
+    actor_rollout_ref.actor.fsdp_config.param_offload=${offload} \
+    actor_rollout_ref.actor.fsdp_config.optimizer_offload=${offload} \
+    actor_rollout_ref.actor.entropy_coeff=0 \
+    actor_rollout_ref.actor.grad_clip=1.0 \
+    actor_rollout_ref.actor.loss_agg_mode=${loss_agg_mode} \
+    actor_rollout_ref.actor.ulysses_sequence_parallel_size=1 \
+    actor_rollout_ref.rollout.gpu_memory_utilization=0.85 \
+    actor_rollout_ref.rollout.log_prob_micro_batch_size=${infer_micro_batch_size} \
+    actor_rollout_ref.rollout.tensor_model_parallel_size=2 \
+    actor_rollout_ref.rollout.enable_chunked_prefill=True \
+    actor_rollout_ref.rollout.max_num_batched_tokens=${max_token} \
+    actor_rollout_ref.rollout.temperature=${temperature} \
+    actor_rollout_ref.rollout.top_p=${top_p} \
+    actor_rollout_ref.rollout.top_k="${top_k}" \
+    actor_rollout_ref.rollout.val_kwargs.temperature=${temperature} \
+    actor_rollout_ref.rollout.val_kwargs.top_p=${top_p} \
+    actor_rollout_ref.rollout.val_kwargs.top_k=${top_k} \
+    actor_rollout_ref.rollout.val_kwargs.do_sample=False \
+    actor_rollout_ref.rollout.val_kwargs.n=1 \
+    actor_rollout_ref.ref.log_prob_micro_batch_size=${infer_micro_batch_size} \
+    actor_rollout_ref.ref.fsdp_config.param_offload=${offload} \
+    actor_rollout_ref.ref.ulysses_sequence_parallel_size=1 \
+    actor_rollout_ref.actor.fsdp_config.fsdp_size=-1 \
+    reward_model.reward_manager=dapo \
+    reward_model.overlong_buffer.enable=${enable_overlong_buffer} \
+    reward_model.overlong_buffer.len=${overlong_buffer_len} \
+    reward_model.overlong_buffer.penalty_factor=${overlong_penalty_factor} \
+    trainer.logger='["console","wandb"]' \
+    trainer.project_name="${project_name}" \
+    trainer.experiment_name="${exp_name}" \
+    trainer.n_gpus_per_node=8 \
+    trainer.nnodes="${NNODES}" \
+    trainer.val_before_train=False \
+    trainer.test_freq=4 \
+    trainer.save_freq=32 \
+    trainer.total_epochs=1000 \
+    trainer.default_local_dir="${CKPTS_DIR}" \
+    trainer.resume_mode=disable

src/verl/recipe/entropy/7b_clip_cov.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+set -xeuo pipefail
+
+export WANDB_API_KEY=YOUR_WANDB_API_KEY
+# export VLLM_USE_V1=1
+
+project_name='Qwen2.5-7B'
+exp_name='clipcov'
+
+adv_estimator=grpo
+
+use_kl_in_reward=False
+kl_coef=0.0
+use_kl_loss=False
+kl_loss_coef=0.0
+
+clip_ratio_low=1
+clip_ratio_high=1
+clip_cov_ratio=0.0002
+clip_cov_lb=1.0
+clip_cov_ub=5.0
+
+max_prompt_length=$((1024 * 2))
+max_response_length=$((1024 * 8))
+enable_overlong_buffer=False
+overlong_buffer_len=$((1024 * 2))
+overlong_penalty_factor=1.0
+
+loss_agg_mode="token-mean"
+loss_mode="clip_cov"
+enable_filter_groups=True
+filter_groups_metric=acc
+max_num_gen_batches=10
+train_prompt_bsz=256
+gen_prompt_bsz=$((train_prompt_bsz * 3))
+train_prompt_mini_bsz=32
+n_resp_per_prompt=8
+max_token=30720
+
+# Ray
+RAY_ADDRESS=${RAY_ADDRESS:-"http://localhost:8265"}
+WORKING_DIR=${WORKING_DIR:-"${PWD}"}
+RUNTIME_ENV=${RUNTIME_ENV:-"${WORKING_DIR}/verl/trainer/runtime_env.yaml"}
+NNODES=${NNODES:-4}
+# Paths
+RAY_DATA_HOME=${RAY_DATA_HOME:-"${HOME}/verl"}
+MODEL_PATH=${MODEL_PATH:-"/YOUR_MODELPATH"}
+CKPTS_DIR=${CKPTS_DIR:-"/YOUR_CKPTS_PATH"}
+TRAIN_FILE=${TRAIN_FILE:-"/YOUR_TRAIN_FILE_PATH"}
+TEST_FILE=${TEST_FILE:-["/YOUR_TRAIN_FILE_PATH"]}
+
+# Algorithm
+temperature=1.0
+top_p=1.0
+top_k=-1 # 0 for HF rollout, -1 for vLLM rollout
+ppo_kl_coef=1
+kl_cov_ratio=0.2
+
+# Mathematically equivalent
+use_dynamic_bsz=True
+infer_micro_batch_size=null
+train_micro_batch_size=null
+offload=False
+
+HYDRA_FULL_ERROR=1 python -m recipe.entropy.main_entropy \
+    data.train_files="${TRAIN_FILE}" \
+    data.val_files="${TEST_FILE}" \
+    data.prompt_key=prompt \
+    data.truncation='left' \
+    data.filter_overlong_prompts=False \
+    data.max_prompt_length=${max_prompt_length} \
+    data.max_response_length=${max_response_length} \
+    data.gen_batch_size=${gen_prompt_bsz} \
+    data.train_batch_size=${train_prompt_bsz} \
+    data.return_raw_chat=True \
+    actor_rollout_ref.rollout.n=${n_resp_per_prompt} \
+    actor_rollout_ref.actor.use_kl_loss=${use_kl_loss} \
+    actor_rollout_ref.actor.kl_loss_coef=${kl_loss_coef} \
+    actor_rollout_ref.actor.clip_ratio_low=${clip_ratio_low} \
+    actor_rollout_ref.actor.clip_ratio_high=${clip_ratio_high} \
+    actor_rollout_ref.actor.clip_ratio_c=10.0 \
+    actor_rollout_ref.actor.policy_loss.loss_mode=${loss_mode} \
+    actor_rollout_ref.actor.policy_loss.clip_cov_ratio=${clip_cov_ratio} \
+    actor_rollout_ref.actor.policy_loss.clip_cov_lb=${clip_cov_lb} \
+    actor_rollout_ref.actor.policy_loss.clip_cov_ub=${clip_cov_ub} \
+    actor_rollout_ref.actor.ppo_micro_batch_size_per_gpu=8 \
+    actor_rollout_ref.rollout.mode=sync \
+    actor_rollout_ref.rollout.name=vllm \
+    algorithm.adv_estimator=${adv_estimator} \
+    algorithm.use_kl_in_reward=${use_kl_in_reward} \
+    algorithm.kl_ctrl.kl_coef=${kl_coef} \
+    algorithm.filter_groups.enable=${enable_filter_groups} \
+    algorithm.filter_groups.metric=${filter_groups_metric} \
+    algorithm.filter_groups.max_num_gen_batches=${max_num_gen_batches} \
+    actor_rollout_ref.model.use_remove_padding=True \
+    actor_rollout_ref.actor.use_dynamic_bsz=${use_dynamic_bsz} \
+    actor_rollout_ref.ref.log_prob_use_dynamic_bsz=${use_dynamic_bsz} \
+    actor_rollout_ref.rollout.log_prob_use_dynamic_bsz=${use_dynamic_bsz} \
+    actor_rollout_ref.actor.ppo_max_token_len_per_gpu=${max_token} \
+    actor_rollout_ref.ref.log_prob_max_token_len_per_gpu=${max_token} \
+    actor_rollout_ref.rollout.log_prob_max_token_len_per_gpu=${max_token} \
+    actor_rollout_ref.model.path="${MODEL_PATH}" \
+    actor_rollout_ref.model.enable_gradient_checkpointing=True \
+    actor_rollout_ref.actor.optim.lr=1e-6 \
+    actor_rollout_ref.actor.optim.weight_decay=0 \
+    actor_rollout_ref.actor.optim.warmup_style=constant \
+    actor_rollout_ref.actor.ppo_mini_batch_size=${train_prompt_mini_bsz} \
+    actor_rollout_ref.actor.ppo_micro_batch_size=${train_micro_batch_size} \
+    actor_rollout_ref.actor.fsdp_config.param_offload=${offload} \
+    actor_rollout_ref.actor.fsdp_config.optimizer_offload=${offload} \
+    actor_rollout_ref.actor.entropy_coeff=0 \
+    actor_rollout_ref.actor.grad_clip=1.0 \
+    actor_rollout_ref.actor.loss_agg_mode=${loss_agg_mode} \
+    actor_rollout_ref.actor.ulysses_sequence_parallel_size=1 \
+    actor_rollout_ref.rollout.gpu_memory_utilization=0.85 \
+    actor_rollout_ref.rollout.log_prob_micro_batch_size=${infer_micro_batch_size} \
+    actor_rollout_ref.rollout.tensor_model_parallel_size=2 \
+    actor_rollout_ref.rollout.enable_chunked_prefill=True \
+    actor_rollout_ref.rollout.max_num_batched_tokens=${max_token} \
+    actor_rollout_ref.rollout.temperature=${temperature} \
+    actor_rollout_ref.rollout.top_p=${top_p} \
+    actor_rollout_ref.rollout.top_k="${top_k}" \
+    actor_rollout_ref.rollout.val_kwargs.temperature=${temperature} \
+    actor_rollout_ref.rollout.val_kwargs.top_p=${top_p} \
+    actor_rollout_ref.rollout.val_kwargs.top_k=${top_k} \
+    actor_rollout_ref.rollout.val_kwargs.do_sample=False \
+    actor_rollout_ref.rollout.val_kwargs.n=1 \
+    actor_rollout_ref.ref.log_prob_micro_batch_size=${infer_micro_batch_size} \
+    actor_rollout_ref.ref.fsdp_config.param_offload=${offload} \
+    actor_rollout_ref.ref.ulysses_sequence_parallel_size=1 \
+    actor_rollout_ref.actor.fsdp_config.fsdp_size=-1 \
+    reward_model.reward_manager=dapo \
+    reward_model.overlong_buffer.enable=${enable_overlong_buffer} \
+    reward_model.overlong_buffer.len=${overlong_buffer_len} \
+    reward_model.overlong_buffer.penalty_factor=${overlong_penalty_factor} \
+    trainer.logger='["console","wandb"]' \
+    trainer.project_name="${project_name}" \
+    trainer.experiment_name="${exp_name}" \
+    trainer.n_gpus_per_node=8 \
+    trainer.nnodes="${NNODES}" \
+    trainer.val_before_train=False \
+    trainer.test_freq=4 \
+    trainer.save_freq=32 \
+    trainer.total_epochs=1000 \
+    trainer.default_local_dir="${CKPTS_DIR}" \
+    trainer.resume_mode=disable

src/verl/recipe/entropy/README.md

@@ -0,0 +1,110 @@
+<div align="center">
+
+# The Entropy Mechanism of Reinforcement Learning for Large Language Model Reasoning.
+
+[![Paper](https://img.shields.io/badge/paper-A42C25?style=for-the-badge&logo=arxiv&logoColor=white)](https://arxiv.org/pdf/2505.22617)  [![Github](https://img.shields.io/badge/PRIME-000000?style=for-the-badge&logo=github&logoColor=000&logoColor=white)](https://github.com/PRIME-RL/Entropy-Mechanism-of-RL) [![alphaXiv](https://img.shields.io/badge/discussion-A42C25?style=for-the-badge&logo=arxiv&logoColor=white&color=blue
+)](https://www.alphaxiv.org/abs/2505.22617) [![Twitter](https://img.shields.io/badge/Twitter-%23000000.svg?style=for-the-badge&logo=twitter&logoColor=white)](https://x.com/stingning/status/1928088554166505667) [![Twitter](https://img.shields.io/badge/Twitter-%23000000.svg?style=for-the-badge&logo=twitter&logoColor=white)](https://x.com/charlesfornlp/status/1928089451080585283) [![Twitter-ak](https://img.shields.io/badge/Twitter-%23000000.svg?style=for-the-badge&logo=twitter&logoColor=white)](https://x.com/_akhaliq/status/1928077929105268861)
+
+
+<div align="center" style="font-family: Arial, sans-serif;">
+  <p>
+    <a href="#🎉news" style="text-decoration: none; font-weight: bold;">🎉 News</a> •
+    <a href="#✨getting-started" style="text-decoration: none; font-weight: bold;">✨ Getting Started</a> •
+    <a href="#📖introduction" style="text-decoration: none; font-weight: bold;">📖 Introduction</a>
+  </p>
+  <p>
+    <a href="#🎈citation" style="text-decoration: none; font-weight: bold;">🎈 Citation</a> •
+    <a href="#🌻acknowledgement" style="text-decoration: none; font-weight: bold;">🌻 Acknowledgement</a> •
+    <a href="#📬Contact" style="text-decoration: none; font-weight: bold;">📬 Contact</a> •
+    <a href="#📈star-history" style="text-decoration: none; font-weight: bold;">📈 Star History</a>
+  </p>
+</div>
+
+</div>
+
+
+# 🎉News
+
+- **[2025/05/29]** 🎉 Ranked **#1** of the day on [Huggingface Daily Papers](https://huggingface.co/papers?date=2025-05-29).
+- **[2025/05/29]** Released our Paper on arXiv. See [here](https://arxiv.org/pdf/2505.22617). We provide insights into the entropy mechanism of RL for LLMs and propose two simple yet effective strategies to alleviate the entropy collapse. 
+
+
+
+# ✨Getting started
+
+After preparing the training data, for training Qwen2.5-7B on a single node, taking the KL-Cov approach as an example, you can simply run:
+
+```
+cd verl
+conda activate your_env
+bash recipe/dapo/7b_kl_cov.sh
+```
+
+While for training Qwen2.5-32B on multi nodes, you can run the following commands:
+
+```
+cd verl
+conda activate your_env
+bash recipe/dapo/32b_kl_cov.sh
+```
+
+# 📖Introduction
+
+<div align="left">
+  <img src="https://github.com/PRIME-RL/Entropy-Mechanism-of-RL/blob/main/figures/e2a.jpg?raw=true" alt="issue" style="width: 96%; height: auto;">
+</div>
+
+This paper addresses the entropy collapse issue in scaling reinforcement learning (RL) for large language models (LLMs), where policy entropy drops sharply during training, leading to overconfidence and performance saturation. We empirically establish a relationship between entropy ($H$) and performance ($R$): $R=−aexp(H)+b$, showing performance is bottlenecked by entropy exhaustion. 
+
+<div align="left">
+  <img src="https://github.com/PRIME-RL/Entropy-Mechanism-of-RL/blob/main/figures/cov.jpg?raw=true" alt="issue" style="width: 96%; height: auto;">
+</div>
+
+Theoretically, we find entropy changes are driven by the covariance between action probability and logit updates, which correlates with advantage in Policy Gradient methods. High-probability, high-advantage actions reduce entropy, while rare, high-advantage actions increase it. Empirically, the covariance term remains positive, explaining entropy’s monotonic decline. To mitigate this, we propose ​​Clip-Cov​​ and ​​KL-Cov​​, which restrict updates for high-covariance tokens. These methods effectively prevent entropy collapse, and improve performance. 
+
+# 📃Evaluation
+
+<div align="left">
+  <img src="https://github.com/PRIME-RL/Entropy-Mechanism-of-RL/blob/main/figures/performance_fig.jpg?raw=true" alt="issue" style="width: 96%; height: auto;">
+</div>
+
+
+Our method is able to maintain a considerably higher level of entropy throughout training. For example, when the baseline's entropy reaches a plateau and can no longer be consumed, the KL-Cov method still sustains an entropy level over 10 times higher. Meanwhile, the response length of the policy model steadily increases, and its performance on the test set consistently surpasses that of the baseline. This indicates that our model is able to explore more freely during training, learning better policy through RL. 
+| **Method**        | **AIME24** | **AIME25** |  **AMC** | **MATH-500** | **OMNI-MATH** | **OlympiadBench** | **Minerva** | **Avg.** |
+| ----------------- | ---------: | ---------: | -------: | -----------: | ------------: | ----------------: | ----------: | -------: |
+| *Qwen2.5-7B*      |            |            |          |              |               |                   |             |          |
+| GRPO              |       21.2 |        9.6 |     58.7 |         78.8 |          27.9 |              40.7 |        36.7 |     38.6 |
+| w. Clip-higher    |       18.1 |       11.5 |     56.6 |         79.2 |          29.8 |              43.3 |        40.4 |     38.8 |
+| w. **`CLIP-Cov`** |       22.1 |   **15.8** |     58.2 |         80.4 |      **30.5** |          **44.1** |    **41.1** |     40.4 |
+| w. **`KL-Cov`**   |   **22.6** |       12.9 | **61.4** |     **80.8** |          29.1 |              42.6 |        38.2 | **40.6** |
+| *Qwen2.5-32B*     |            |            |          |              |               |                   |             |          |
+| GRPO              |       21.8 |       16.2 |     69.7 |         84.2 |          35.2 |              43.6 |        45.5 |     45.8 |
+| w. Clip-higher    |       35.6 |       22.3 |     69.5 |         77.2 |          35.1 |              42.5 |        43.0 |     47.2 |
+| w. **`CLIP-Cov`** |       32.3 |       22.7 |     67.2 |     **87.0** |      **42.0** |          **57.2** |        46.0 |     50.3 |
+| w. **`KL-Cov`**   |   **36.8** |   **30.8** | **74.5** |         84.6 |          39.1 |              49.0 |    **46.3** | **52.2** |
+
+Our two approaches both achieve non-trivial improvements across all benchmarks. Compared to GRPO, our method outperforms it by 2.0% on average for the 7B model and by 6.4% for the 32B model. Moreover, we observe that our method yields more substantial gains on the larger Qwen2.5-32B. Specifically, our method achieves improvements of 15.0% and 14.6% compared to GRPO on the most challenging benchmarks, AIME24 and AIME25, respectively.
+
+
+# 🎈Citation
+If you find this paper or repo helpful, please cite us.
+
+```bibtex
+@article{cui2025entropy,
+  title={The Entropy Mechanism of Reinforcement Learning for Reasoning Language Models},
+  author={Cui, Ganqu and Zhang, Yuchen and Chen, Jiacheng and Yuan, Lifan and Wang, Zhi and Zuo, Yuxin and Li, Haozhan and Fan, Yuchen and Chen, Huayu and Chen, Weize and others},
+  journal={arXiv preprint arXiv:2505.22617},
+  year={2025}
+}
+```
+# 🌻Acknowledgement
+We implement our reinforcement learning algorithm extending from [verl](https://github.com/volcengine/verl). We utilize [vLLM](https://github.com/vllm-project/vllm) for inference. Our models are trained primarily on [Qwen2.5 family](https://github.com/QwenLM/Qwen2.5). Our training data is built from [DAPO-MATH](https://huggingface.co/datasets/BytedTsinghua-SIA/DAPO-Math-17k). Thanks for their great contributions!
+
+# 📬 Contact
+
+For questions, discussion, or collaboration opportunities, feel free to contact:
+- Ganqu Cui: cuiganqu@pjlab.org.cn
+- Yuchen Zhang: yuchen.zhang2003@gmail.com
+- Jiacheng Chen: jackchan9345@gmail.com
+- Ning Ding: ningding.cs@gmail.com
+

src/verl/recipe/entropy/entropy_ray_trainer.py

@@ -0,0 +1,347 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+FSDP PPO Trainer with Ray-based single controller.
+This trainer supports model-agonistic model initialization with huggingface
+"""
+
+import uuid
+from collections import defaultdict
+from copy import deepcopy
+from pprint import pprint
+
+import numpy as np
+import torch
+from tqdm import tqdm
+
+from verl import DataProto
+from verl.trainer.ppo.metric_utils import (
+    compute_data_metrics,
+    compute_throughout_metrics,
+    compute_timing_metrics,
+    reduce_metrics,
+)
+from verl.trainer.ppo.ray_trainer import (
+    AdvantageEstimator,
+    RayPPOTrainer,
+    apply_kl_penalty,
+    compute_advantage,
+    compute_response_mask,
+)
+from verl.utils.profiler import simple_timer
+
+
+class RayEntropyTrainer(RayPPOTrainer):
+    """
+    Note that this trainer runs on the driver process on a single CPU/GPU node.
+    """
+
+    def fit(self):
+        """
+        The training loop of PPO.
+        The driver process only need to call the compute functions of the worker group through RPC
+        to construct the PPO dataflow.
+        The light-weight advantage computation is done on the driver process.
+        """
+        from omegaconf import OmegaConf
+
+        from verl.utils.tracking import Tracking
+
+        logger = Tracking(
+            project_name=self.config.trainer.project_name,
+            experiment_name=self.config.trainer.experiment_name,
+            default_backend=self.config.trainer.logger,
+            config=OmegaConf.to_container(self.config, resolve=True),
+        )
+
+        self.global_steps = 0
+
+        # load checkpoint before doing anything
+        self._load_checkpoint()
+
+        # perform validation before training
+        # currently, we only support validation using the reward_function.
+        if self.val_reward_fn is not None and self.config.trainer.get("val_before_train", True):
+            val_metrics = self._validate()
+            assert val_metrics, f"{val_metrics=}"
+            pprint(f"Initial validation metrics: {val_metrics}")
+            logger.log(data=val_metrics, step=self.global_steps)
+            if self.config.trainer.get("val_only", False):
+                return
+
+        # add tqdm
+        progress_bar = tqdm(total=self.total_training_steps, initial=self.global_steps, desc="Training Progress")
+
+        # we start from step 1
+        self.global_steps += 1
+        last_val_metrics = None
+
+        timing_raw = defaultdict(float)
+        batch = None
+        num_prompt_in_batch = 0
+        num_gen_batches = 0
+        for epoch in range(self.config.trainer.total_epochs):
+            for batch_dict in self.train_dataloader:
+                metrics = {}
+
+                new_batch: DataProto = DataProto.from_single_dict(batch_dict)
+                num_gen_batches += 1
+                # pop those keys for generation
+                if "multi_modal_inputs" in new_batch.non_tensor_batch.keys():
+                    gen_batch = new_batch.pop(
+                        batch_keys=["input_ids", "attention_mask", "position_ids"],
+                        non_tensor_batch_keys=["raw_prompt_ids", "multi_modal_data", "multi_modal_inputs"],
+                    )
+                else:
+                    gen_batch = new_batch.pop(
+                        batch_keys=["input_ids", "attention_mask", "position_ids"],
+                        non_tensor_batch_keys=["raw_prompt_ids"],
+                    )
+                gen_batch = gen_batch.repeat(repeat_times=self.config.actor_rollout_ref.rollout.n, interleave=True)
+
+                is_last_step = self.global_steps >= self.total_training_steps
+
+                with simple_timer("step", timing_raw):
+                    # generate a batch
+                    # with simple_timer("gen", timing_raw):
+                    #     gen_batch_output = self.actor_rollout_wg.generate_sequences(gen_batch)
+                    with simple_timer("gen", timing_raw):
+                        if not self.async_rollout_mode:
+                            gen_batch_output = self.actor_rollout_wg.generate_sequences(gen_batch)
+                        else:
+                            gen_batch_output = self.async_rollout_manager.generate_sequences(gen_batch)
+
+                    if self.config.algorithm.adv_estimator == AdvantageEstimator.REMAX:
+                        with simple_timer("gen_max", timing_raw):
+                            gen_baseline_batch = deepcopy(gen_batch)
+                            gen_baseline_batch.meta_info["do_sample"] = False
+                            gen_baseline_output = self.actor_rollout_wg.generate_sequences(gen_baseline_batch)
+
+                            new_batch = new_batch.union(gen_baseline_output)
+                            reward_baseline_tensor = self.reward_fn(new_batch)
+                            reward_baseline_tensor = reward_baseline_tensor.sum(dim=-1)
+
+                            new_batch.pop(batch_keys=list(gen_baseline_output.batch.keys()))
+
+                            new_batch.batch["reward_baselines"] = reward_baseline_tensor
+
+                            del gen_baseline_batch, gen_baseline_output
+
+                    new_batch.non_tensor_batch["uid"] = np.array(
+                        [str(uuid.uuid4()) for _ in range(len(new_batch.batch))], dtype=object
+                    )
+                    # repeat to align with repeated responses in rollout
+                    new_batch = new_batch.repeat(repeat_times=self.config.actor_rollout_ref.rollout.n, interleave=True)
+                    new_batch = new_batch.union(gen_batch_output)
+
+                    with simple_timer("reward", timing_raw):
+                        # compute scores. Support both model and function-based.
+                        # We first compute the scores using reward model. Then, we call reward_fn to combine
+                        # the results from reward model and rule-based results.
+                        if self.use_rm:
+                            # we first compute reward model score
+                            reward_tensor = self.rm_wg.compute_rm_score(new_batch)
+                            new_batch = new_batch.union(reward_tensor)
+
+                        # we combine with rule-based rm
+                        reward_extra_infos_dict: dict[str, list]
+                        try:
+                            reward_result = self.reward_fn(new_batch, return_dict=True)
+                            reward_tensor = reward_result["reward_tensor"]
+                            reward_extra_infos_dict = reward_result["reward_extra_info"]
+                        except Exception as e:
+                            print(f"Error in reward_fn: {e}")
+                            reward_tensor = self.reward_fn(new_batch)
+                            reward_extra_infos_dict = {}
+
+                        new_batch.batch["token_level_scores"] = reward_tensor
+
+                        print(f"{list(reward_extra_infos_dict.keys())=}")
+                        if reward_extra_infos_dict:
+                            new_batch.non_tensor_batch.update(
+                                {k: np.array(v) for k, v in reward_extra_infos_dict.items()}
+                            )
+
+                        # compute rewards. apply_kl_penalty if available
+                        if self.config.algorithm.use_kl_in_reward:
+                            new_batch, kl_metrics = apply_kl_penalty(
+                                new_batch, kl_ctrl=self.kl_ctrl_in_reward, kl_penalty=self.config.algorithm.kl_penalty
+                            )
+                            metrics.update(
+                                kl_metrics
+                            )  # TODO: This will be cleared if we use multiple genenration batches
+                        else:
+                            new_batch.batch["token_level_rewards"] = new_batch.batch["token_level_scores"]
+
+                    if not self.config.algorithm.filter_groups.enable:
+                        batch = new_batch
+                    else:  # NOTE: When prompts after filtering is less than train batch size,
+                        # we skip to the next generation batch
+                        metric_name = self.config.algorithm.filter_groups.metric
+                        if metric_name == "seq_final_reward":
+                            # Turn to numpy for easier filtering
+                            new_batch.non_tensor_batch["seq_final_reward"] = (
+                                new_batch.batch["token_level_rewards"].sum(dim=-1).numpy()
+                            )
+                        elif metric_name == "seq_reward":
+                            new_batch.non_tensor_batch["seq_reward"] = (
+                                new_batch.batch["token_level_scores"].sum(dim=-1).numpy()
+                            )
+
+                        # Collect the sequence reward for each trajectory
+                        prompt_uid2metric_vals = defaultdict(list)
+                        for uid, metric_val in zip(
+                            new_batch.non_tensor_batch["uid"], new_batch.non_tensor_batch[metric_name], strict=True
+                        ):
+                            prompt_uid2metric_vals[uid].append(metric_val)
+
+                        prompt_uid2metric_std = {}
+                        for prompt_uid, metric_vals in prompt_uid2metric_vals.items():
+                            prompt_uid2metric_std[prompt_uid] = np.std(metric_vals)
+
+                        kept_prompt_uids = [
+                            uid
+                            for uid, std in prompt_uid2metric_std.items()
+                            if std > 0 or len(prompt_uid2metric_vals[uid]) == 1
+                        ]
+                        num_prompt_in_batch += len(kept_prompt_uids)
+
+                        kept_traj_idxs = []
+                        for idx, traj_from_prompt_uid in enumerate(new_batch.non_tensor_batch["uid"]):
+                            if traj_from_prompt_uid in kept_prompt_uids:
+                                kept_traj_idxs.append(idx)
+
+                        new_batch = new_batch[kept_traj_idxs]
+                        batch = new_batch if batch is None else DataProto.concat([batch, new_batch])
+
+                        prompt_bsz = self.config.data.train_batch_size
+                        if num_prompt_in_batch < prompt_bsz:
+                            print(f"{num_prompt_in_batch=} < {prompt_bsz=}")
+                            max_num_gen_batches = self.config.algorithm.filter_groups.max_num_gen_batches
+                            if max_num_gen_batches <= 0 or num_gen_batches < max_num_gen_batches:
+                                print(f"{num_gen_batches=}. Keep generating...")
+                                continue
+                            else:
+                                raise ValueError(
+                                    f"{num_gen_batches=} >= {max_num_gen_batches=}."
+                                    + " Generated too many. Please check if your data are too difficult."
+                                    + " You could also try set max_num_gen_batches=0 to enable endless trials."
+                                )
+                        else:
+                            # Align the batch
+                            traj_bsz = self.config.data.train_batch_size * self.config.actor_rollout_ref.rollout.n
+                            print(
+                                f"Collected {num_prompt_in_batch} / {self.config.data.train_batch_size} prompt. "
+                                f"Collecting finished."
+                            )
+                            batch = batch[:traj_bsz]
+
+                    # === Updating ===
+
+                    batch.batch["response_mask"] = compute_response_mask(batch)
+
+                    # balance the number of valid tokens on each dp rank.
+                    # Note that this breaks the order of data inside the batch.
+                    # Please take care when you implement group based adv computation such as GRPO and rloo
+                    if self.config.trainer.balance_batch:
+                        self._balance_batch(batch, metrics=metrics)
+
+                    # compute global_valid tokens
+                    batch.meta_info["global_token_num"] = torch.sum(batch.batch["attention_mask"], dim=-1).tolist()
+
+                    # recompute old_log_probs
+                    with simple_timer("old_log_prob", timing_raw):
+                        old_log_prob = self.actor_rollout_wg.compute_log_prob(batch)
+                        batch = batch.union(old_log_prob)
+
+                    if self.use_reference_policy:
+                        # compute reference log_prob
+                        with simple_timer("ref", timing_raw):
+                            ref_log_prob = self.ref_policy_wg.compute_ref_log_prob(batch)
+                            batch = batch.union(ref_log_prob)
+
+                    # compute values
+                    if self.use_critic:
+                        with simple_timer("values", timing_raw):
+                            values = self.critic_wg.compute_values(batch)
+                            batch = batch.union(values)
+
+                    with simple_timer("adv", timing_raw):
+                        # compute advantages, executed on the driver process
+                        norm_adv_by_std_in_grpo = self.config.algorithm.get("norm_adv_by_std_in_grpo", True)
+                        batch = compute_advantage(
+                            batch,
+                            adv_estimator=self.config.algorithm.adv_estimator,
+                            gamma=self.config.algorithm.gamma,
+                            lam=self.config.algorithm.lam,
+                            num_repeat=self.config.actor_rollout_ref.rollout.n,
+                            norm_adv_by_std_in_grpo=norm_adv_by_std_in_grpo,
+                        )
+
+                    # update critic
+                    if self.use_critic:
+                        with simple_timer("update_critic", timing_raw):
+                            critic_output = self.critic_wg.update_critic(batch)
+                        critic_output_metrics = reduce_metrics(critic_output.meta_info["metrics"])
+                        metrics.update(critic_output_metrics)
+
+                    # implement critic warmup
+                    if self.config.trainer.critic_warmup <= self.global_steps:
+                        # update actor
+                        with simple_timer("update_actor", timing_raw):
+                            actor_output = self.actor_rollout_wg.update_actor(batch)
+                        actor_output_metrics = reduce_metrics(actor_output.meta_info["metrics"])
+                        metrics.update(actor_output_metrics)
+
+                    # validate
+                    if (
+                        self.val_reward_fn is not None
+                        and self.config.trainer.test_freq > 0
+                        and (is_last_step or self.global_steps % self.config.trainer.test_freq == 0)
+                    ):
+                        with simple_timer("testing", timing_raw):
+                            val_metrics: dict = self._validate()
+                            if is_last_step:
+                                last_val_metrics = val_metrics
+                        metrics.update(val_metrics)
+
+                    if self.config.trainer.save_freq > 0 and (
+                        is_last_step or self.global_steps % self.config.trainer.save_freq == 0
+                    ):
+                        with simple_timer("save_checkpoint", timing_raw):
+                            self._save_checkpoint()
+
+                # collect metrics
+                metrics.update(compute_data_metrics(batch=batch, use_critic=self.use_critic))
+                metrics.update(compute_timing_metrics(batch=batch, timing_raw=timing_raw))
+                # TODO: implement actual tflpo and theoretical tflpo
+                n_gpus = self.resource_pool_manager.get_n_gpus()
+                metrics.update(compute_throughout_metrics(batch=batch, timing_raw=timing_raw, n_gpus=n_gpus))
+                timing_raw = defaultdict(float)  # clear timing
+
+                metrics["train/num_gen_batches"] = num_gen_batches
+                batch = None
+                num_prompt_in_batch = 0
+                num_gen_batches = 0
+
+                # TODO: make a canonical logger that supports various backend
+                logger.log(data=metrics, step=self.global_steps)
+
+                if is_last_step:
+                    pprint(f"Final validation metrics: {last_val_metrics}")
+                    progress_bar.close()
+                    return
+
+                progress_bar.update(1)
+                self.global_steps += 1

src/verl/recipe/spin/dp_actor.py

@@ -0,0 +1,288 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright 2023-2024 SGLang Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import itertools
+import math
+from collections import defaultdict
+
+import numpy as np
+import torch
+
+from recipe.spin.core_algos import compute_online_dpo_loss, get_batch_logps
+from verl import DataProto
+from verl.utils.device import get_device_name
+from verl.utils.seqlen_balancing import get_reverse_idx, rearrange_micro_batches
+from verl.workers.actor import DataParallelPPOActor
+
+__all__ = ["DataParallelPPOActor"]
+
+
+class SPINDataParallelPPOActor(DataParallelPPOActor):
+    def compute_log_prob(self, data: DataProto) -> torch.Tensor:
+        """Compute the log probability of the responses given input_ids, attention_mask and position_ids
+
+        Args:
+            data (DataProto): a DataProto containing keys
+
+                ``input_ids``: tensor of shape [batch_size, sequence_length]. torch.int64. Note that input_ids is the
+                concatenation of prompt and response. Note that ``sequence_length = prompt_length + response_length``.
+
+                ``attention_mask``: tensor of shape [batch_size, sequence_length]. torch.int64.
+
+                ``position_ids``: tensor of shape [batch_size, sequence_length]. torch.int64.
+
+                ``responses``:  tensor of shape [batch_size, response_length]. torch.int64.
+
+        Returns:
+            torch.Tensor: the log_prob tensor
+        """
+        # set to eval
+        self.actor_module.eval()
+
+        micro_batch_size = data.meta_info["micro_batch_size"]
+        temperature = data.meta_info["temperature"]  # temperature must be in the data.meta_info to avoid silent error
+        use_dynamic_bsz = data.meta_info["use_dynamic_bsz"]
+
+        select_keys = ["responses", "input_ids", "attention_mask", "position_ids"]
+        batch = data.select(batch_keys=select_keys).batch
+        has_multi_modal_inputs = "multi_modal_inputs" in data.non_tensor_batch.keys()
+
+        if has_multi_modal_inputs:
+            num_micro_batches = data.batch.batch_size[0] // micro_batch_size
+            non_tensor_select_keys = ["multi_modal_inputs"]
+            micro_batches = data.select(select_keys, non_tensor_select_keys).chunk(num_micro_batches)
+        elif use_dynamic_bsz:
+            # split using dynamic bsz
+            max_token_len = data.meta_info["max_token_len"] * self.ulysses_sequence_parallel_size
+            micro_batches, indices = rearrange_micro_batches(batch=batch, max_token_len=max_token_len)
+        else:
+            micro_batches = batch.split(micro_batch_size)
+
+        log_probs_lst = []
+        for micro_batch in micro_batches:
+            if isinstance(micro_batch, DataProto):
+                micro_batch = {**micro_batch.batch, **micro_batch.non_tensor_batch}
+
+            with torch.no_grad():
+                _, log_probs = self._forward_micro_batch(micro_batch, temperature=temperature)
+            log_probs_lst.append(log_probs)
+        log_probs = torch.concat(log_probs_lst, dim=0)
+
+        if use_dynamic_bsz:
+            indices = list(itertools.chain.from_iterable(indices))
+            assert len(indices) == log_probs.size(0), f"{len(indices)} vs. {log_probs.size()}"
+            revert_indices = torch.tensor(get_reverse_idx(indices), dtype=torch.long)
+            log_probs = log_probs[revert_indices]
+
+        return log_probs
+
+    def update_policy_dpo_with_ref(self, data: DataProto):
+        """
+        Performs the DPO update step using pre-calculated reference log probs
+        from an external, periodically updated reference model.
+        """
+        self.actor_module.train()  # Ensure training mode
+
+        # --- Retrieve necessary data ---
+        try:
+            # Expects batch prepared by fit_dpo loop, including reference log probs
+            batch_td = data.batch
+            chosen_labels = batch_td["chosen_labels"]
+            rejected_labels = batch_td["rejected_labels"]
+            # ... other needed tensors like chosen/rejected input_ids, attention_mask, position_ids ...
+
+            # === Get PRE-CALCULATED reference log probs from input data ===
+            reference_chosen_logps = batch_td["reference_chosen_logps"]  # Should be sequence-level logps
+            reference_rejected_logps = batch_td["reference_rejected_logps"]  # Should be sequence-level logps
+            # ============================================================
+
+            # Get DPO params from meta_info
+            # beta = data.meta_info.get('dpo_beta', 0.1) # Default beta
+            beta = self.config.get("dpo_beta", 0.1)  # Default beta
+            loss_type = data.meta_info.get("dpo_loss_type", "sigmoid")
+            label_smoothing = data.meta_info.get("dpo_label_smoothing", 0.0)
+            # reference_free should now be False as we provide ref logps
+            reference_free = data.meta_info.get("reference_free", False)  # Default False
+
+        except KeyError as e:
+            print(f"ERROR: Missing required key for DPO update (in update_policy_dpo): {e}")
+            print(f"Available keys in data.batch: {list(batch_td.keys())}")  # Debug print
+            return {}  # Return empty metrics on error
+        except Exception as e_data:
+            print(f"ERROR accessing data for DPO update (in update_policy_dpo): {e_data}")
+            return {}
+
+        # --- Micro-batching Setup ---
+        micro_batch_size = self.config.get("ppo_micro_batch_size_per_gpu")
+        if micro_batch_size is None:
+            # Fallback or default if not set, or raise error
+            micro_batch_size = 1  # Example fallback, adjust as needed
+            print(f"Warning: 'ppo_micro_batch_size_per_gpu' not set, defaulting to {micro_batch_size}")
+            # raise ValueError("Config 'ppo_micro_batch_size_per_gpu' must be set.")
+
+        # Ensure chosen_input_ids exists before getting shape
+        if "chosen_input_ids" not in batch_td:
+            print("ERROR: 'chosen_input_ids' not found in batch_td for DPO update.")
+            return {}
+        bsz = batch_td["chosen_input_ids"].shape[0]
+
+        if bsz == 0:
+            print("Warning: DPO batch size is 0 in update_policy_dpo. Skipping update.")
+            return {"actor/dpo_loss": 0.0, "actor/grad_norm": 0.0}  # Return zero metrics if batch is empty
+
+        num_micro_batches = math.ceil(bsz / micro_batch_size)
+        gradient_accumulation_steps = num_micro_batches
+
+        # --- Metrics Accumulation ---
+        total_loss = 0.0
+        accumulated_metrics = defaultdict(list)
+        metrics = {}  # Final metrics dict
+
+        # --- Zero Gradients ---
+        self.actor_optimizer.zero_grad(set_to_none=True)
+
+        # --- Micro-batch Loop ---
+        for i in range(num_micro_batches):
+            start_idx = i * micro_batch_size
+            end_idx = min(start_idx + micro_batch_size, bsz)
+            if start_idx >= end_idx:
+                continue
+
+            # Slice the full DPO batch into micro-batches
+            # Important: Slice ALL required tensors, including labels and inputs
+            micro_batch_chosen_labels = chosen_labels[start_idx:end_idx]
+            micro_batch_rejected_labels = rejected_labels[start_idx:end_idx]
+            micro_batch_chosen_inputs = {
+                "input_ids": batch_td["chosen_input_ids"][start_idx:end_idx],
+                "attention_mask": batch_td["chosen_attention_mask"][start_idx:end_idx],
+            }
+            if "chosen_position_ids" in batch_td:
+                micro_batch_chosen_inputs["position_ids"] = batch_td["chosen_position_ids"][start_idx:end_idx]
+
+            micro_batch_rejected_inputs = {
+                "input_ids": batch_td["rejected_input_ids"][start_idx:end_idx],
+                "attention_mask": batch_td["rejected_attention_mask"][start_idx:end_idx],
+            }
+            if "rejected_position_ids" in batch_td:
+                micro_batch_rejected_inputs["position_ids"] = batch_td["rejected_position_ids"][start_idx:end_idx]
+
+            # Determine autocast dtype
+            autocast_dtype = torch.bfloat16  # Or get dynamically from config/FSDP settings
+            # --- Autocast Forward Pass ---
+            with torch.autocast(device_type=get_device_name(), dtype=autocast_dtype):
+                # --- Step 1: Forward pass for CURRENT policy log probs (with grad) ---
+                policy_chosen_outputs = self.actor_module(**micro_batch_chosen_inputs, use_cache=False)
+                policy_rejected_outputs = self.actor_module(**micro_batch_rejected_inputs, use_cache=False)
+
+                # --- Step 2: Calculate CURRENT policy log probs using get_batch_logps ---
+                policy_chosen_logps = get_batch_logps(
+                    policy_chosen_outputs.logits, micro_batch_chosen_labels, average_log_prob=False
+                )
+                policy_rejected_logps = get_batch_logps(
+                    policy_rejected_outputs.logits, micro_batch_rejected_labels, average_log_prob=False
+                )
+
+                # --- Step 3: Retrieve PRE-CALCULATED reference log probs (NO grad needed) ---
+                # Slice the full batch reference logps for the current micro-batch
+                micro_ref_chosen_logps = reference_chosen_logps[start_idx:end_idx]
+                micro_ref_rejected_logps = reference_rejected_logps[start_idx:end_idx]
+                # --- The ActorAsRef calculation block is REMOVED ---
+
+                # --- Step 4: Calculate DPO Logits and Loss ---
+                pi_logratios = policy_chosen_logps - policy_rejected_logps
+                ref_logratios = micro_ref_chosen_logps - micro_ref_rejected_logps  # Uses pre-calculated values
+                logits = pi_logratios - ref_logratios  # DPO logits
+
+                loss = compute_online_dpo_loss(
+                    policy_chosen_logps=policy_chosen_logps,  # Has grad
+                    policy_rejected_logps=policy_rejected_logps,  # Has grad
+                    reference_chosen_logps=micro_ref_chosen_logps,  # No grad (from input)
+                    reference_rejected_logps=micro_ref_rejected_logps,  # No grad (from input)
+                    beta=beta,
+                    label_smoothing=label_smoothing,
+                    loss_type=loss_type,
+                    reference_free=reference_free,  # Should be False now
+                )
+
+                # --- Scale loss for gradient accumulation ---
+                scaled_loss = loss / gradient_accumulation_steps
+
+                # --- Accumulate Metrics ---
+                total_loss += loss.item()  # Unscaled loss
+                accumulated_metrics["actor/dpo_loss_batch"].append(loss.item())
+                accumulated_metrics["actor/dpo_logits_batch"].append(logits.mean().item())
+                # Accumulate policy and reference log probs/ratios if needed for debugging
+                accumulated_metrics["actor/policy_chosen_logps_batch"].append(policy_chosen_logps.mean().item())
+                accumulated_metrics["actor/policy_rejected_logps_batch"].append(policy_rejected_logps.mean().item())
+                accumulated_metrics["actor/reference_chosen_logps_batch"].append(micro_ref_chosen_logps.mean().item())
+                accumulated_metrics["actor/reference_rejected_logps_batch"].append(
+                    micro_ref_rejected_logps.mean().item()
+                )
+
+            # --- Backward Pass (outside autocast) ---
+            # Check if loss requires grad before backward
+            if scaled_loss.requires_grad:
+                scaled_loss.backward()
+            else:
+                print(f"Warning: Scaled loss at micro-batch {i} does not require grad. Skipping backward.")
+
+        # --- End Micro-batch Loop ---
+
+        # --- Optimizer Step (after accumulating gradients for all micro-batches) ---
+        grad_norm = self._optimizer_step()
+
+        # --- Populate Final Metrics ---
+        if num_micro_batches > 0 and bsz > 0:  # Check if any processing happened
+            metrics["actor/dpo_loss"] = total_loss / num_micro_batches
+            metrics["actor/grad_norm"] = (
+                grad_norm.item() if torch.is_tensor(grad_norm) and torch.isfinite(grad_norm) else float("inf")
+            )
+            # Average other accumulated metrics
+            for key, val_list in accumulated_metrics.items():
+                if val_list:
+                    metrics[key.replace("_batch", "")] = np.mean(val_list)
+
+            # Calculate accuracy / rewards / margins based on averaged logprobs if desired
+            if (
+                "actor/policy_chosen_logps" in metrics
+                and "actor/policy_rejected_logps" in metrics
+                and "actor/reference_chosen_logps" in metrics
+                and "actor/reference_rejected_logps" in metrics
+            ):
+                policy_ratio_mean = metrics["actor/policy_chosen_logps"] - metrics["actor/policy_rejected_logps"]
+                ref_ratio_mean = metrics["actor/reference_chosen_logps"] - metrics["actor/reference_rejected_logps"]
+                logits_mean = policy_ratio_mean - ref_ratio_mean
+                metrics["actor/rewards_chosen"] = beta * (
+                    metrics["actor/policy_chosen_logps"] - metrics["actor/reference_chosen_logps"]
+                )
+                metrics["actor/rewards_rejected"] = beta * (
+                    metrics["actor/policy_rejected_logps"] - metrics["actor/reference_rejected_logps"]
+                )
+                metrics["actor/rewards_accuracies"] = float(logits_mean > 0)  # Mean accuracy proxy
+                metrics["actor/rewards_margins"] = metrics["actor/rewards_chosen"] - metrics["actor/rewards_rejected"]
+
+        else:  # Handle case where no micro-batches were run (e.g., bsz=0)
+            metrics["actor/dpo_loss"] = 0.0
+            metrics["actor/grad_norm"] = 0.0
+            # Initialize other metrics to 0 or NaN as appropriate
+            for key in accumulated_metrics.keys():
+                metrics[key.replace("_batch", "")] = 0.0
+            metrics["actor/rewards_chosen"] = 0.0
+            metrics["actor/rewards_rejected"] = 0.0
+            metrics["actor/rewards_accuracies"] = 0.0
+            metrics["actor/rewards_margins"] = 0.0
+
+        return metrics  # Return aggregated metrics

src/verl/recipe/spin/fsdp_workers.py

@@ -0,0 +1,600 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright 2023-2024 SGLang Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import logging
+import os
+import warnings
+
+import numpy as np
+import psutil
+import torch
+import torch.distributed
+from codetiming import Timer
+from omegaconf import OmegaConf, open_dict
+from torch.distributed.device_mesh import init_device_mesh
+
+import verl.utils.torch_functional as verl_F
+from verl import DataProto
+from verl.single_controller.base import Worker
+from verl.single_controller.base.decorator import Dispatch, make_nd_compute_dataproto_dispatch_fn, register
+from verl.utils import hf_tokenizer
+from verl.utils.checkpoint.fsdp_checkpoint_manager import FSDPCheckpointManager
+from verl.utils.device import get_device_id, get_device_name, get_nccl_backend, get_torch_device
+from verl.utils.flops_counter import FlopsCounter
+from verl.utils.fs import copy_to_local
+from verl.utils.fsdp_utils import (
+    get_fsdp_wrap_policy,
+    get_init_weight_context_manager,
+    init_fn,
+    load_fsdp_model_to_gpu,
+    load_fsdp_optimizer,
+    offload_fsdp_model_to_cpu,
+    offload_fsdp_optimizer,
+)
+from verl.utils.import_utils import import_external_libs
+from verl.utils.model import compute_position_id_with_mask
+from verl.utils.profiler import log_gpu_memory_usage
+from verl.workers.fsdp_workers import ActorRolloutRefWorker
+from verl.workers.sharding_manager.fsdp_ulysses import FSDPUlyssesShardingManager
+
+logger = logging.getLogger(__file__)
+logger.setLevel(os.getenv("VERL_PPO_LOGGING_LEVEL", "WARN"))
+
+
+def create_device_mesh(world_size, fsdp_size):
+    if fsdp_size < 0 or fsdp_size >= world_size:
+        device_mesh = init_device_mesh(get_device_name(), mesh_shape=(world_size,), mesh_dim_names=["fsdp"])
+    else:
+        device_mesh = init_device_mesh(
+            get_device_name(), mesh_shape=(world_size // fsdp_size, fsdp_size), mesh_dim_names=["ddp", "fsdp"]
+        )
+    return device_mesh
+
+
+def get_sharding_strategy(device_mesh):
+    from torch.distributed.fsdp import ShardingStrategy
+
+    if device_mesh.ndim == 1:
+        sharding_strategy = ShardingStrategy.FULL_SHARD
+    elif device_mesh.ndim == 2:
+        sharding_strategy = ShardingStrategy.HYBRID_SHARD
+    else:
+        raise NotImplementedError(f"Get device mesh ndim={device_mesh.ndim}, but only support 1 or 2")
+    return sharding_strategy
+
+
+class SPINRolloutRefWorker(ActorRolloutRefWorker):
+    @register(dispatch_mode=Dispatch.ONE_TO_ALL)
+    def init_model(self):
+        from recipe.spin.dp_actor import SPINDataParallelPPOActor as DataParallelPPOActor
+
+        # This is used to import external_lib into the huggingface systems
+        import_external_libs(self.config.model.get("external_lib", None))
+
+        override_model_config = OmegaConf.to_container(OmegaConf.create(self.config.model.get("override_config", {})))
+        use_remove_padding = self.config.model.get("use_remove_padding", False)
+        use_fused_kernels = self.config.model.get("use_fused_kernels", False)
+
+        if self._is_actor or self._is_rollout or self._is_ref:
+            # we need the model for actor and rollout
+            if self._is_actor or self._is_ref:
+                optim_config = self.config.actor.optim
+                fsdp_config = self.config.actor.fsdp_config
+            else:
+                optim_config = None
+                fsdp_config = OmegaConf.create()
+            self.actor_module_fsdp, self.actor_optimizer, self.actor_lr_scheduler, self.actor_model_config = (
+                self._build_model_optimizer(
+                    model_path=self.config.model.path,
+                    fsdp_config=fsdp_config,
+                    optim_config=optim_config,
+                    override_model_config=override_model_config,
+                    use_remove_padding=use_remove_padding,
+                    use_fused_kernels=use_fused_kernels,
+                    enable_gradient_checkpointing=self.config.model.get("enable_gradient_checkpointing", False),
+                    trust_remote_code=self.config.model.get("trust_remote_code", False),
+                    use_liger=self.config.model.get("use_liger", False),
+                    role="actor",
+                )
+            )
+
+            # get the original unwrapped module
+            self.actor_module = self.actor_module_fsdp._fsdp_wrapped_module
+
+            if self._is_offload_optimizer:
+                offload_fsdp_optimizer(optimizer=self.actor_optimizer)
+                log_gpu_memory_usage("After offload actor optimizer during init", logger=logger)
+        # load from checkpoint
+        if self._is_actor or self._is_ref:
+            OmegaConf.set_struct(self.config.actor, True)
+            with open_dict(self.config.actor):
+                self.config.actor.use_remove_padding = use_remove_padding
+                self.config.actor.use_fused_kernels = use_fused_kernels
+            self.actor = DataParallelPPOActor(
+                config=self.config.actor, actor_module=self.actor_module_fsdp, actor_optimizer=self.actor_optimizer
+            )
+
+        if self._is_rollout:
+            self.rollout, self.rollout_sharding_manager = self._build_rollout(
+                trust_remote_code=self.config.model.get("trust_remote_code", False)
+            )
+
+        if self._is_ref:
+            self.ref_module_fsdp = self._build_model_optimizer(
+                model_path=self.config.model.path,
+                fsdp_config=self.config.ref.fsdp_config,
+                optim_config=None,
+                override_model_config=override_model_config,
+                use_remove_padding=use_remove_padding,
+                use_fused_kernels=use_fused_kernels,
+                trust_remote_code=self.config.model.get("trust_remote_code", False),
+                use_liger=self.config.model.get("use_liger", False),
+                role="ref",
+            )[0]
+            OmegaConf.set_struct(self.config.ref, True)
+            with open_dict(self.config.ref):
+                self.config.ref.use_remove_padding = use_remove_padding
+                self.config.ref.use_fused_kernels = use_fused_kernels
+            self.ref_policy = DataParallelPPOActor(config=self.config.ref, actor_module=self.ref_module_fsdp)
+            self.checkpoint_manager = FSDPCheckpointManager(
+                model=self.actor_module_fsdp,
+                optimizer=self.actor.actor_optimizer,
+                lr_scheduler=self.actor_lr_scheduler,
+                processing_class=self.processor if self.processor is not None else self.tokenizer,
+                checkpoint_config=self.config.actor.checkpoint,
+            )
+
+        if self._is_actor:
+            self.flops_counter = FlopsCounter(self.actor_model_config)
+            self.checkpoint_manager = FSDPCheckpointManager(
+                model=self.actor_module_fsdp,
+                optimizer=self.actor.actor_optimizer,
+                lr_scheduler=self.actor_lr_scheduler,
+                processing_class=self.processor if self.processor is not None else self.tokenizer,
+                checkpoint_config=self.config.actor.checkpoint,
+            )
+
+    @register(dispatch_mode=make_nd_compute_dataproto_dispatch_fn(mesh_name="actor"))
+    def compute_ref_log_prob(self, data: DataProto):
+        assert self._is_ref
+
+        # Support all hardwares
+        data = data.to(get_device_id())
+
+        micro_batch_size = self.config.ref.log_prob_micro_batch_size_per_gpu
+        data.meta_info["micro_batch_size"] = micro_batch_size
+        data.meta_info["temperature"] = self.config.rollout.temperature
+        data.meta_info["max_token_len"] = self.config.ref.log_prob_max_token_len_per_gpu
+        data.meta_info["use_dynamic_bsz"] = self.config.ref.log_prob_use_dynamic_bsz
+        with self.ulysses_sharding_manager:
+            output = self.ref_policy.compute_log_prob(data=data)
+            output = DataProto.from_dict(tensors={"ref_log_prob": output})
+
+        output = output.to("cpu")
+
+        # https://pytorch.org/docs/stable/notes/fsdp.html#fsdp-notes
+        # unshard the root FSDP module
+        if self.world_size > 1:
+            self.ref_policy.actor_module._handle.reshard(True)
+
+        return output
+
+    @register(dispatch_mode=make_nd_compute_dataproto_dispatch_fn(mesh_name="actor"))
+    def compute_log_prob(self, data: DataProto):
+        assert self._is_actor
+        if self._is_offload_param:
+            load_fsdp_model_to_gpu(self.actor_module_fsdp)
+
+        # Support all hardwares
+        data = data.to(get_device_id())
+        # we should always recompute old_log_probs when it is HybridEngine
+        data.meta_info["micro_batch_size"] = self.config.rollout.log_prob_micro_batch_size_per_gpu
+        data.meta_info["max_token_len"] = self.config.rollout.log_prob_max_token_len_per_gpu
+        data.meta_info["use_dynamic_bsz"] = self.config.rollout.log_prob_use_dynamic_bsz
+        data.meta_info["temperature"] = self.config.rollout.temperature
+        # perform recompute log_prob
+        with self.ulysses_sharding_manager:
+            output = self.actor.compute_log_prob(data=data)
+            output = DataProto.from_dict(
+                tensors={"old_log_probs": output}, meta_info={"temperature": self.config.rollout.temperature}
+            )
+
+        output = output.to("cpu")
+
+        # https://pytorch.org/docs/stable/notes/fsdp.html#fsdp-notes
+        # unshard the root FSDP module
+        if self.world_size > 1:
+            self.actor.actor_module._handle.reshard(True)
+
+        if self._is_offload_param:
+            offload_fsdp_model_to_cpu(self.actor_module_fsdp)
+
+        log_gpu_memory_usage("After compute_log_prob", logger=logger)
+        return output
+
+    @register(dispatch_mode=make_nd_compute_dataproto_dispatch_fn(mesh_name="actor"))
+    def update_actor_dpo(self, data: DataProto):
+        """
+        Wrapper for actor update step. Handles FSDP state management.
+        Calls self.actor.update_policy which now contains DPO logic based
+        on pre-calculated log probabilities.
+        """
+        # Support all hardwares
+        data = data.to(get_device_id())
+
+        assert self._is_actor  # Make sure this worker has the actor role
+        if self.actor is None:
+            raise RuntimeError("Actor instance (self.actor) not initialized in worker.")
+
+        # --- FSDP State Management ---
+        if self._is_offload_param:
+            load_fsdp_model_to_gpu(self.actor_module_fsdp)
+        if self._is_offload_optimizer:
+            load_fsdp_optimizer(optimizer=self.actor_optimizer, device_id=get_device_id())
+
+        log_gpu_memory_usage("Before update policy (DPO via PPO path)", logger=logger)
+
+        # --- Ulysses Sharding (if used) ---
+        with self.ulysses_sharding_manager:
+            # --- Call the core update method (now containing DPO logic) ---
+            with Timer(name="update_policy_dpo_via_ppo", logger=None) as timer:  # Use a distinct timer name
+                # Calls the modified update_policy method
+                metrics = self.actor.update_policy_dpo_with_ref(data=data)  # <-- THIS CALLS THE MODIFIED FUNCTION
+            delta_time = timer.last
+
+            # --- Add Performance Metrics ---
+            # MFU calculation might be less accurate/meaningful here for DPO
+            metrics["perf/approx_tokens_processed"] = torch.sum(
+                data.batch.get("attention_mask", torch.tensor(0))
+            ).item()  # Approx tokens
+            metrics["perf/max_memory_allocated_gb"] = get_torch_device().max_memory_allocated() / (1024**3)
+            metrics["perf/max_memory_reserved_gb"] = get_torch_device().max_memory_reserved() / (1024**3)
+            metrics["perf/cpu_memory_used_gb"] = psutil.virtual_memory().used / (1024**3)
+            global_num_tokens = data.meta_info["global_token_num"]
+            estimated_flops, promised_flops = self.flops_counter.estimate_flops(global_num_tokens, delta_time)
+            metrics["perf/mfu/actor"] = estimated_flops * self.config.ppo_epochs / promised_flops / self.world_size
+
+            # --- LR Scheduler Step ---
+            lr = self.actor_lr_scheduler.get_last_lr()[0]
+            metrics["actor/lr"] = lr
+            self.actor_lr_scheduler.step()
+
+            log_gpu_memory_usage("After update policy (DPO via PPO path)", logger=logger)
+
+            # --- Prepare Output ---
+            output = DataProto(meta_info={"metrics": metrics})
+            output = output.to("cpu")
+
+        # --- FSDP State Management (Offload) ---
+        if self._is_offload_param:
+            offload_fsdp_model_to_cpu(self.actor_module_fsdp)
+        if self._is_offload_optimizer:
+            offload_fsdp_optimizer(optimizer=self.actor_optimizer)
+
+        return output
+
+
+# TODO(sgm): we may need to extract it to dp_reward_model.py
+class RewardModelWorker(Worker):
+    """
+    Note that we only implement the reward model that is subclass of AutoModelForTokenClassification.
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        import torch.distributed
+
+        if not torch.distributed.is_initialized():
+            torch.distributed.init_process_group(backend=get_nccl_backend())
+        self.config = config
+
+        # build device mesh for Ulysses Sequence Parallel
+        world_size = torch.distributed.get_world_size()
+        from torch.distributed.device_mesh import init_device_mesh
+
+        fsdp_size = self.config.model.fsdp_config.fsdp_size
+        self.device_mesh = create_device_mesh(world_size=world_size, fsdp_size=fsdp_size)
+
+        self.ulysses_device_mesh = None
+        self.ulysses_sequence_parallel_size = self.config.get("ulysses_sequence_parallel_size", 1)
+        dp = world_size // self.ulysses_sequence_parallel_size
+        if self.ulysses_sequence_parallel_size > 1:
+            self.ulysses_device_mesh = init_device_mesh(
+                get_device_name(), mesh_shape=(dp, self.ulysses_sequence_parallel_size), mesh_dim_names=["dp", "sp"]
+            )
+
+        if self.ulysses_device_mesh is not None:
+            is_collect = self.ulysses_device_mesh["sp"].get_local_rank() == 0
+            self._register_dispatch_collect_info(
+                "reward", dp_rank=self.ulysses_device_mesh["dp"].get_local_rank(), is_collect=is_collect
+            )
+        else:
+            self._register_dispatch_collect_info("reward", dp_rank=self.rank, is_collect=True)
+
+        self.ulysses_sharding_manager = FSDPUlyssesShardingManager(self.ulysses_device_mesh)
+
+        self.use_remove_padding = self.config.model.get("use_remove_padding", False)
+
+        # normalize config
+        if self.config.micro_batch_size is not None:
+            self.config.micro_batch_size //= torch.distributed.get_world_size()
+            self.config.micro_batch_size_per_gpu = self.config.micro_batch_size
+
+    def _build_model(self, config):
+        # the following line is necessary
+        from torch.distributed.fsdp import CPUOffload
+        from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+        from transformers import AutoConfig, AutoModelForTokenClassification
+
+        # download the checkpoint from hdfs
+        local_path = copy_to_local(config.model.path)
+
+        if self.config.model.input_tokenizer is None:
+            self._do_switch_chat_template = False
+        else:
+            self._do_switch_chat_template = True
+            input_tokenizer_local_path = copy_to_local(config.model.input_tokenizer)
+            self.input_tokenizer = hf_tokenizer(
+                input_tokenizer_local_path, trust_remote_code=config.model.get("trust_remote_code", False)
+            )
+            self.tokenizer = hf_tokenizer(local_path, trust_remote_code=config.model.get("trust_remote_code", False))
+
+        trust_remote_code = config.model.get("trust_remote_code", False)
+        model_config = AutoConfig.from_pretrained(local_path, trust_remote_code=trust_remote_code)
+        model_config.num_labels = 1
+
+        # note that we have to create model in fp32. Otherwise, the optimizer is in bf16, which is incorrect
+        init_context = get_init_weight_context_manager(
+            use_meta_tensor=not model_config.tie_word_embeddings, mesh=self.device_mesh
+        )
+
+        with init_context(), warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            model_config.classifier_dropout = 0.0
+            reward_module = AutoModelForTokenClassification.from_pretrained(
+                pretrained_model_name_or_path=local_path,
+                config=model_config,
+                torch_dtype=torch.bfloat16,
+                attn_implementation="flash_attention_2",
+                trust_remote_code=trust_remote_code,
+            )
+
+            if config.model.get("use_remove_padding", False) or self.ulysses_sequence_parallel_size > 1:
+                from verl.models.transformers.monkey_patch import apply_monkey_patch
+
+                apply_monkey_patch(model=reward_module, ulysses_sp_size=self.ulysses_sequence_parallel_size)
+
+            reward_module.to(torch.bfloat16)
+
+        auto_wrap_policy = get_fsdp_wrap_policy(module=reward_module, config=self.config.model.fsdp_config)
+
+        fsdp_mesh = self.device_mesh
+        sharding_strategy = get_sharding_strategy(fsdp_mesh)
+
+        reward_module = FSDP(
+            reward_module,
+            param_init_fn=init_fn,
+            use_orig_params=False,
+            auto_wrap_policy=auto_wrap_policy,
+            device_id=get_device_id(),
+            sharding_strategy=sharding_strategy,  # zero3
+            sync_module_states=True,
+            cpu_offload=CPUOffload(offload_params=True),
+            forward_prefetch=False,
+            device_mesh=self.device_mesh,
+        )
+
+        return reward_module
+
+    @register(dispatch_mode=Dispatch.ONE_TO_ALL)
+    def init_model(self):
+        # This is used to import external_lib into the huggingface systems
+        import_external_libs(self.config.model.get("external_lib", None))
+        self.reward_module = self._build_model(config=self.config)
+
+    def _forward_micro_batch(self, micro_batch):
+        from flash_attn.bert_padding import index_first_axis, pad_input, rearrange, unpad_input
+
+        from verl.utils.ulysses import gather_outputs_and_unpad, ulysses_pad_and_slice_inputs
+
+        with torch.no_grad(), torch.autocast(device_type=get_device_name(), dtype=torch.bfloat16):
+            input_ids = micro_batch["input_ids"]
+            batch_size, seqlen = input_ids.shape
+            attention_mask = micro_batch["attention_mask"]
+            position_ids = micro_batch["position_ids"]
+
+            if self.use_remove_padding:
+                input_ids_rmpad, indices, *_ = unpad_input(
+                    input_ids.unsqueeze(-1), attention_mask
+                )  # input_ids_rmpad (total_nnz, ...)
+                input_ids_rmpad = input_ids_rmpad.transpose(0, 1)  # (1, total_nnz)
+
+                # unpad the position_ids to align the rotary
+                position_ids_rmpad = index_first_axis(
+                    rearrange(position_ids.unsqueeze(-1), "b s ... -> (b s) ..."), indices
+                ).transpose(0, 1)
+
+                # pad and slice the inputs if sp > 1
+                if self.ulysses_sequence_parallel_size > 1:
+                    input_ids_rmpad, position_ids_rmpad, pad_size = ulysses_pad_and_slice_inputs(
+                        input_ids_rmpad, position_ids_rmpad, sp_size=self.ulysses_sequence_parallel_size
+                    )
+
+                # only pass input_ids and position_ids to enable flash_attn_varlen
+                output = self.reward_module(
+                    input_ids=input_ids_rmpad, attention_mask=None, position_ids=position_ids_rmpad, use_cache=False
+                )  # prevent model thinks we are generating
+                reward_rmpad = output.logits
+                reward_rmpad = reward_rmpad.squeeze(0)  # (total_nnz)
+
+                # gather output if sp > 1
+                if self.ulysses_sequence_parallel_size > 1:
+                    reward_rmpad = gather_outputs_and_unpad(
+                        reward_rmpad, gather_dim=0, unpad_dim=0, padding_size=pad_size
+                    )
+
+                # pad it back
+                rm_score = pad_input(reward_rmpad, indices=indices, batch=batch_size, seqlen=seqlen).squeeze(-1)
+            else:
+                output = self.reward_module(
+                    input_ids=input_ids, attention_mask=attention_mask, position_ids=position_ids, use_cache=False
+                )
+                rm_score = output.logits  # (batch_size, seq_len, 1)
+                rm_score = rm_score.squeeze(-1)
+
+            # extract the result of the last valid token
+            eos_mask_idx = torch.argmax(position_ids * attention_mask, dim=-1)  # (bsz,)
+            rm_score = rm_score[torch.arange(batch_size), eos_mask_idx]
+            return rm_score
+
+    def _expand_to_token_level(self, data: DataProto, scores: torch.Tensor):
+        batch_size = data.batch.batch_size[0]
+        # expand as token_level_reward
+        attention_mask = data.batch["attention_mask"]
+        position_ids = data.batch["position_ids"]
+        response_length = data.batch["responses"].shape[-1]
+        eos_mask_idx = torch.argmax(position_ids * attention_mask, dim=-1)  # (bsz,)
+        token_level_scores = torch.zeros_like(attention_mask, dtype=scores.dtype)  # (bsz, seqlen)
+        token_level_scores[torch.arange(batch_size), eos_mask_idx] = scores
+
+        # select the response part
+        token_level_scores = token_level_scores[:, -response_length:]
+
+        return token_level_scores
+
+    def _switch_chat_template(self, data: DataProto):
+        src_max_length = data.batch["attention_mask"].shape[-1]
+
+        src_tokenizer = self.input_tokenizer
+        target_tokenizer = self.tokenizer
+
+        rm_input_ids = []
+        rm_attention_mask = []
+
+        for i in range(data.batch.batch_size[0]):
+            if not isinstance(data.non_tensor_batch["raw_prompt"][i], list | np.ndarray):
+                raise TypeError(
+                    f"raw_prompt must be a list or numpy array, got {type(data.non_tensor_batch['raw_prompt'][i])}"
+                )
+
+            # extract raw prompt
+            chat: list = list(data.non_tensor_batch["raw_prompt"][i])
+
+            # extract response
+            response_ids = data.batch["responses"][i]
+            response_length = response_ids.shape[-1]
+            valid_response_length = data.batch["attention_mask"][i][-response_length:].sum()
+            valid_response_ids = response_ids[:valid_response_length]
+
+            # decode
+            response = src_tokenizer.decode(valid_response_ids)
+            # remove bos and eos
+            response = response.replace(src_tokenizer.eos_token, "")
+
+            chat.append({"role": "assistant", "content": response})
+
+            prompt_with_chat_template = target_tokenizer.apply_chat_template(
+                chat, add_generation_prompt=False, tokenize=False
+            )
+            if self.rank == 0 and i == 0:
+                # for debugging purpose
+                print(f"Switch template. chat: {prompt_with_chat_template}")
+
+            # the maximum length is actually determined by the reward model itself
+            max_length = self.config.get("max_length", src_max_length)
+            if max_length is None:
+                max_length = src_max_length
+
+            model_inputs = target_tokenizer(prompt_with_chat_template, return_tensors="pt", add_special_tokens=False)
+            input_ids, attention_mask = verl_F.postprocess_data(
+                input_ids=model_inputs["input_ids"],
+                attention_mask=model_inputs["attention_mask"],
+                max_length=max_length,
+                pad_token_id=target_tokenizer.pad_token_id,
+                left_pad=False,  # right padding
+                truncation=self.config.get("truncation", "right"),
+            )  # truncate from the right
+
+            rm_input_ids.append(input_ids)
+            rm_attention_mask.append(attention_mask)
+
+        rm_input_ids = torch.cat(rm_input_ids, dim=0)
+        rm_attention_mask = torch.cat(rm_attention_mask, dim=0)
+
+        rm_position_ids = compute_position_id_with_mask(rm_attention_mask)
+
+        rm_inputs = {"input_ids": rm_input_ids, "attention_mask": rm_attention_mask, "position_ids": rm_position_ids}
+
+        return DataProto.from_dict(rm_inputs)
+
+    @register(dispatch_mode=make_nd_compute_dataproto_dispatch_fn(mesh_name="reward"))
+    def compute_rm_score(self, data: DataProto):
+        import itertools
+
+        from verl.utils.seqlen_balancing import get_reverse_idx, rearrange_micro_batches
+
+        # Support all hardwares
+        data = data.to(get_device_id())
+        if self._do_switch_chat_template:
+            rm_data = self._switch_chat_template(data)
+        else:
+            rm_input_ids = data.batch["input_ids"]
+            rm_attention_mask = data.batch["attention_mask"]
+            rm_position_ids = data.batch["position_ids"]
+            rm_inputs = {
+                "input_ids": rm_input_ids,
+                "attention_mask": rm_attention_mask,
+                "position_ids": rm_position_ids,
+            }
+            rm_data = DataProto.from_dict(rm_inputs)
+
+        # Support all hardwares
+        rm_data.batch = rm_data.batch.to(get_device_id())
+
+        # perform forward computation
+        with self.ulysses_sharding_manager:
+            rm_data = self.ulysses_sharding_manager.preprocess_data(data=rm_data)
+            data = self.ulysses_sharding_manager.preprocess_data(data=data)
+
+            use_dynamic_bsz = self.config.use_dynamic_bsz
+            if use_dynamic_bsz:
+                max_token_len = self.config.forward_max_token_len_per_gpu * self.ulysses_sequence_parallel_size
+                micro_batches, indices = rearrange_micro_batches(batch=rm_data.batch, max_token_len=max_token_len)
+            else:
+                micro_batches = rm_data.batch.split(self.config.micro_batch_size_per_gpu)
+            output = []
+            for micro_batch in micro_batches:
+                rm_score = self._forward_micro_batch(micro_batch)
+                output.append(rm_score)
+            scores = torch.cat(output, dim=0)  # (batch_size)
+
+            if use_dynamic_bsz:
+                indices = list(itertools.chain.from_iterable(indices))
+                assert len(indices) == scores.size(0), f"{len(indices)} vs. {scores.size()}"
+                revert_indices = torch.tensor(get_reverse_idx(indices), dtype=torch.long)
+                scores = scores[revert_indices]
+
+            token_level_scores = self._expand_to_token_level(data, scores)
+            # Note that this is only the scores, may not be the final rewards used to train RL
+            output = DataProto.from_dict(tensors={"rm_scores": token_level_scores})
+            output = self.ulysses_sharding_manager.postprocess_data(data=output)
+
+        # https://pytorch.org/docs/stable/notes/fsdp.html#fsdp-notes
+        # unshard the root FSDP module
+        self.reward_module._handle.reshard(True)
+
+        output = output.to("cpu")
+        return output

src/verl/recipe/spin/main_spin.py

@@ -0,0 +1,167 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright 2023-2024 SGLang Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+
+import hydra
+import ray
+
+from recipe.spin.spin_trainer import RaySPINTrainer
+from recipe.spin.utils import validate_config
+from verl.trainer.ppo.reward import get_custom_reward_fn
+from verl.trainer.ppo.utils import need_reference_policy
+
+
+@hydra.main(config_path="config", config_name="spin_trainer", version_base=None)
+def main(config):
+    run_ppo(config)
+
+
+def run_ppo(config) -> None:
+    # TODO(linjunrong.ocss884): this ENV is left for resolving SGLang conflict with ray devices
+    # isolation, will solve in the future
+    os.environ["ENSURE_CUDA_VISIBLE_DEVICES"] = os.environ.get("CUDA_VISIBLE_DEVICES", "")
+    if not ray.is_initialized():
+        # this is for local ray cluster
+        ray.init(
+            runtime_env={
+                "env_vars": {"TOKENIZERS_PARALLELISM": "true", "NCCL_DEBUG": "WARN", "VLLM_LOGGING_LEVEL": "WARN"}
+            }
+        )
+
+    runner = TaskRunner.remote()
+    ray.get(runner.run.remote(config))
+
+
+@ray.remote(num_cpus=1)  # please make sure main_task is not scheduled on head
+class TaskRunner:
+    def run(self, config):
+        # print initial config
+        from pprint import pprint
+
+        from omegaconf import OmegaConf
+
+        from verl.utils.fs import copy_to_local
+
+        pprint(OmegaConf.to_container(config, resolve=True))  # resolve=True will eval symbol values
+        OmegaConf.resolve(config)
+
+        # define worker classes
+        if config.actor_rollout_ref.actor.strategy in {"fsdp", "fsdp2"}:
+            assert config.critic.strategy in {"fsdp", "fsdp2"}
+            # from recipe.spin.fsdp_workers import ActorRolloutRefWorker
+            from recipe.spin.fsdp_workers import SPINRolloutRefWorker
+            from verl.single_controller.ray import RayWorkerGroup
+
+            ray_worker_group_cls = RayWorkerGroup
+
+        elif config.actor_rollout_ref.actor.strategy == "megatron":
+            assert config.actor_rollout_ref.actor.strategy == config.critic.strategy
+            from verl.single_controller.ray import RayWorkerGroup
+
+            ray_worker_group_cls = RayWorkerGroup
+
+        else:
+            raise NotImplementedError
+
+        from recipe.spin.spin_trainer import ResourcePoolManager, Role
+
+        role_worker_mapping = {
+            # Role.ActorRollout: ray.remote(ActorRolloutRefWorker),
+            Role.ActorRollout: ray.remote(SPINRolloutRefWorker),
+            # Role.Critic: ray.remote(CriticWorker),
+        }
+
+        global_pool_id = "global_pool"
+        resource_pool_spec = {
+            global_pool_id: [config.trainer.n_gpus_per_node] * config.trainer.nnodes,
+        }
+        mapping = {
+            Role.ActorRollout: global_pool_id,
+            # Role.Critic: global_pool_id,
+        }
+
+        if config.reward_model.enable:
+            if config.reward_model.strategy in {"fsdp", "fsdp2"}:
+                from recipe.spin.fsdp_workers import RewardModelWorker
+            elif config.reward_model.strategy == "megatron":
+                from verl.workers.megatron_workers import RewardModelWorker
+            else:
+                raise NotImplementedError
+            role_worker_mapping[Role.RewardModel] = ray.remote(RewardModelWorker)
+            mapping[Role.RewardModel] = global_pool_id
+
+        # use reference model
+        # if config.algorithm.use_kl_in_reward or config.actor_rollout_ref.actor.use_kl_loss:
+        # role_worker_mapping[Role.RefPolicy] = ray.remote(ActorRolloutRefWorker)
+        role_worker_mapping[Role.RefPolicy] = ray.remote(SPINRolloutRefWorker)
+        mapping[Role.RefPolicy] = global_pool_id
+
+        # validate config
+        validate_config(
+            config=config,
+            use_reference_policy=need_reference_policy(self.role_worker_mapping),
+            use_critic=False,
+        )
+
+        # download the checkpoint from hdfs
+        local_path = copy_to_local(config.actor_rollout_ref.model.path)
+
+        # instantiate tokenizer
+        from verl.utils import hf_processor, hf_tokenizer
+
+        trust_remote_code = config.data.get("trust_remote_code", False)
+        tokenizer = hf_tokenizer(local_path, trust_remote_code=trust_remote_code)
+        processor = hf_processor(local_path, use_fast=True)  # used for multimodal LLM, could be none
+
+        from verl.workers.reward_manager import get_reward_manager_cls
+
+        # Note(haibin.lin): please make sure custom reward managers are imported and
+        # registered via `verl.workers.reward_manager.register`
+        reward_manager_name = config.reward_model.get("reward_manager", "naive")
+        reward_manager_cls = get_reward_manager_cls(reward_manager_name)
+
+        compute_score = get_custom_reward_fn(config)
+        reward_kwargs = dict(config.reward_model.get("reward_kwargs", {}))
+        reward_fn = reward_manager_cls(
+            tokenizer=tokenizer,
+            num_examine=0,
+            compute_score=compute_score,
+            reward_fn_key=config.data.reward_fn_key,
+            **reward_kwargs,
+        )
+
+        # Note that we always use function-based RM for validation
+        val_reward_fn = reward_manager_cls(
+            tokenizer=tokenizer, num_examine=1, compute_score=compute_score, reward_fn_key=config.data.reward_fn_key
+        )
+        resource_pool_manager = ResourcePoolManager(resource_pool_spec=resource_pool_spec, mapping=mapping)
+
+        trainer = RaySPINTrainer(
+            config=config,
+            tokenizer=tokenizer,
+            processor=processor,
+            role_worker_mapping=role_worker_mapping,
+            resource_pool_manager=resource_pool_manager,
+            ray_worker_group_cls=ray_worker_group_cls,
+            reward_fn=reward_fn,
+            val_reward_fn=val_reward_fn,
+        )
+        trainer.init_workers()
+        trainer.fit_dpo()
+
+
+if __name__ == "__main__":
+    main()

src/verl/recipe/spin/run_spin.sh

@@ -0,0 +1,29 @@
+set -e
+set -x
+VISIBLE_DEVICES="4,5,6,7"
+export HYDRA_FULL_ERROR=1
+
+CUDA_VISIBLE_DEVICES=${VISIBLE_DEVICES} python3 -m recipe.spin.main_spin \
+  data.train_files=$HOME/data/gsm8k/train.parquet \
+  data.val_files=$HOME/data/gsm8k/test.parquet \
+  data.train_batch_size=1024 \
+  data.max_prompt_length=1024 \
+  data.max_response_length=1024 \
+  actor_rollout_ref.model.path=Qwen/Qwen2.5-0.5B-Instruct \
+  actor_rollout_ref.actor.optim.lr=1e-6 \
+  actor_rollout_ref.actor.ppo_mini_batch_size=64 \
+  actor_rollout_ref.actor.ppo_micro_batch_size=8 \
+  actor_rollout_ref.rollout.log_prob_micro_batch_size=64 \
+  actor_rollout_ref.rollout.tensor_model_parallel_size=1 \
+  actor_rollout_ref.rollout.gpu_memory_utilization=0.4 \
+  actor_rollout_ref.ref.log_prob_micro_batch_size=64 \
+  algorithm.kl_ctrl.kl_coef=0.001 \
+  trainer.logger=console \
+  trainer.val_before_train=True \
+  trainer.n_gpus_per_node=4 \
+  trainer.nnodes=1 \
+  trainer.save_freq=-1 \
+  trainer.test_freq=1 \
+  +trainer.log_freq=1 \
+  trainer.ref_update_freq=1 \
+  trainer.total_epochs=1000 2>&1 | tee verl_demo.log

src/verl/recipe/spin/spin_trainer.py

@@ -0,0 +1,1308 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright 2023-2024 SGLang Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import traceback
+import uuid
+from collections import defaultdict
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from pprint import pprint
+from typing import Any, Optional
+
+import numpy as np
+import ray
+import torch
+from codetiming import Timer
+from omegaconf import OmegaConf, open_dict
+from torch.utils.data import Dataset, Sampler
+from torchdata.stateful_dataloader import StatefulDataLoader
+from tqdm import tqdm
+
+from recipe.spin import core_algos
+from verl import DataProto
+from verl.protocol import pad_dataproto_to_divisor, unpad_dataproto
+from verl.single_controller.ray import RayClassWithInitArgs, RayResourcePool, RayWorkerGroup
+from verl.single_controller.ray.base import create_colocated_worker_cls
+from verl.trainer.ppo.metric_utils import (
+    compute_throughout_metrics,
+    compute_timing_metrics,
+    process_validation_metrics,
+    reduce_metrics,
+)
+from verl.trainer.ppo.utils import Role, WorkerType, need_reference_policy, need_reward_model
+from verl.utils.checkpoint.checkpoint_manager import find_latest_ckpt_path
+from verl.utils.seqlen_balancing import get_seqlen_balanced_partitions, log_seqlen_unbalance
+from verl.utils.torch_functional import masked_mean
+from verl.utils.tracking import ValidationGenerationsLogger
+
+
+@dataclass
+class ResourcePoolManager:
+    """
+    Define a resource pool specification. Resource pool will be initialized first.
+    Mapping
+    """
+
+    resource_pool_spec: dict[str, list[int]]
+    mapping: dict[Role, str]
+    resource_pool_dict: dict[str, RayResourcePool] = field(default_factory=dict)
+
+    def create_resource_pool(self):
+        for resource_pool_name, process_on_nodes in self.resource_pool_spec.items():
+            # max_colocate_count means the number of WorkerGroups (i.e. processes) in each RayResourcePool
+            # For FSDP backend, we recommend using max_colocate_count=1 that merge all WorkerGroups into one.
+            # For Megatron backend, we recommend using max_colocate_count>1 that can utilize different
+            # WorkerGroup for different models
+            resource_pool = RayResourcePool(
+                process_on_nodes=process_on_nodes, use_gpu=True, max_colocate_count=1, name_prefix=resource_pool_name
+            )
+            self.resource_pool_dict[resource_pool_name] = resource_pool
+
+        self._check_resource_available()
+
+    def get_resource_pool(self, role: Role) -> RayResourcePool:
+        """Get the resource pool of the worker_cls"""
+        return self.resource_pool_dict[self.mapping[role]]
+
+    def get_n_gpus(self) -> int:
+        """Get the number of gpus in this cluster."""
+        return sum([n_gpus for process_on_nodes in self.resource_pool_spec.values() for n_gpus in process_on_nodes])
+
+    def _check_resource_available(self):
+        """Check if the resource pool can be satisfied in this ray cluster."""
+        node_available_resources = ray._private.state.available_resources_per_node()
+        node_available_gpus = {node: node_info.get("GPU", 0) for node, node_info in node_available_resources.items()}
+
+        # check total required gpus can be satisfied
+        total_available_gpus = sum(node_available_gpus.values())
+        total_required_gpus = sum(
+            [n_gpus for process_on_nodes in self.resource_pool_spec.values() for n_gpus in process_on_nodes]
+        )
+        if total_available_gpus < total_required_gpus:
+            raise ValueError(
+                f"Total available GPUs {total_available_gpus} is less than total desired GPUs {total_required_gpus}"
+            )
+
+        # check each resource pool can be satisfied, O(#resource_pools * #nodes)
+        for resource_pool_name, process_on_nodes in self.resource_pool_spec.items():
+            num_gpus, num_nodes = process_on_nodes[0], len(process_on_nodes)
+            for node, available_gpus in node_available_gpus.items():
+                if available_gpus >= num_gpus:
+                    node_available_gpus[node] -= num_gpus
+                    num_nodes -= 1
+                    if num_nodes == 0:
+                        break
+            if num_nodes > 0:
+                raise ValueError(
+                    f"Resource pool {resource_pool_name}: {num_gpus}*{num_nodes} cannot be satisfied in this "
+                    f"ray cluster"
+                )
+
+
+def _compute_response_info(batch: DataProto) -> dict[str, Any]:
+    """Placeholder: Computes prompt and response lengths."""
+    try:
+        # Assuming 'prompts' and 'responses' keys exist after generation/union
+        prompt_len = batch.batch["prompts"].shape[1]
+        resp_len = batch.batch["responses"].shape[1]
+        # This is simplified - real implementation might use attention masks
+        # to get actual lengths per sample.
+        batch_size = batch.batch.batch_size[0]
+        prompt_lengths_tensor = torch.full((batch_size,), prompt_len, dtype=torch.float32, device=batch.batch.device)
+        response_lengths_tensor = torch.full((batch_size,), resp_len, dtype=torch.float32, device=batch.batch.device)
+
+        # Try getting actual lengths from attention mask if possible (more accurate)
+        if "response_mask" in batch.batch:
+            response_lengths_tensor = batch.batch["response_mask"].sum(dim=1).float()
+            # if "attention_mask" in batch.batch and "response_mask" in batch.batch:
+            # full_mask = batch.batch["attention_mask"]
+            # resp_mask = batch.batch["response_mask"]
+            # Infer prompt mask length based on where response mask starts or total length
+            # This logic depends heavily on how your masks are constructed.
+            # Example: prompt_lengths_tensor = full_mask.sum(dim=1).float() - response_lengths_tensor
+            # Fallback to using prompt shape if mask logic is complex:
+            prompt_lengths_tensor = torch.tensor(
+                [batch.batch["prompts"].shape[1]] * batch_size, dtype=torch.float32, device=batch.batch.device
+            )
+
+        return {
+            "prompt_length": prompt_lengths_tensor,
+            "response_length": response_lengths_tensor,
+            "max_response_length": resp_len,
+            "max_prompt_length": prompt_len,  # Or from config if fixed padding
+        }
+    except KeyError as e:
+        print(f"Warning: Missing key in _compute_response_info: {e}. Returning defaults.")
+        # Return default/dummy values if keys are missing
+        b_size = batch.batch.batch_size[0] if batch.batch.batch_size else 1
+        max_resp = batch.batch.get("responses").shape[1] if batch.batch.get("responses") is not None else 0
+        max_prompt = batch.batch.get("prompts").shape[1] if batch.batch.get("prompts") is not None else 0
+        return {
+            "prompt_length": torch.zeros(b_size),
+            "response_length": torch.zeros(b_size),
+            "max_response_length": max_resp,
+            "max_prompt_length": max_prompt,
+        }
+
+
+# --- Modified Metric Function ---
+def compute_dpo_data_metrics(batch: DataProto) -> dict[str, Any]:
+    """
+    Computes and returns metrics relevant for the DPO-like process.
+    Assumes 'batch' contains results after generation and preference marking,
+    potentially including 'dpo_logits', 'preferences', 'chosen_logps', etc.
+    Removes PPO-specific advantage/return/critic metrics.
+    """
+    print("---- [DEBUG] Computing DPO Data Metrics ----")
+    metrics = {}
+    try:
+        # --- Scores and Rewards (from reward_fn) ---
+        if "token_level_scores" in batch.batch and batch.batch["token_level_scores"] is not None:
+            sequence_score = batch.batch["token_level_scores"].sum(-1)
+            metrics.update(
+                {
+                    "reward/score/mean": torch.mean(sequence_score).item(),
+                    "reward/score/max": torch.max(sequence_score).item(),
+                    "reward/score/min": torch.min(sequence_score).item(),
+                }
+            )
+        else:
+            print("DEBUG compute_dpo_data_metrics: 'token_level_scores' not found.")
+
+        if "token_level_rewards" in batch.batch and batch.batch["token_level_rewards"] is not None:
+            sequence_reward = batch.batch["token_level_rewards"].sum(-1)
+            metrics.update(
+                {
+                    "reward/rewards/mean": torch.mean(sequence_reward).item(),
+                    "reward/rewards/max": torch.max(sequence_reward).item(),
+                    "reward/rewards/min": torch.min(sequence_reward).item(),
+                }
+            )
+        else:
+            print("DEBUG compute_dpo_data_metrics: 'token_level_rewards' not found.")
+
+        # --- DPO Specific Metrics (if stored previously) ---
+        if "dpo_logits" in batch.batch and batch.batch["dpo_logits"] is not None:
+            metrics["actor/dpo_logits"] = batch.batch["dpo_logits"].mean().item()
+        else:
+            print("DEBUG compute_dpo_data_metrics: 'dpo_logits' not found.")
+
+        if "chosen_logps" in batch.batch and batch.batch["chosen_logps"] is not None:
+            metrics["actor/chosen_logps"] = batch.batch["chosen_logps"].mean().item()
+        else:
+            print("DEBUG compute_dpo_data_metrics: 'chosen_logps' not found.")
+
+        if "rejected_logps" in batch.batch and batch.batch["rejected_logps"] is not None:
+            metrics["actor/rejected_logps"] = batch.batch["rejected_logps"].mean().item()
+        else:
+            print("DEBUG compute_dpo_data_metrics: 'rejected_logps' not found.")
+
+        # Add metrics based on the 'preferences' mask if available
+        # if "preferences" in batch.batch and batch.batch["preferences"] is not None:
+        # prefs_mask = batch.batch["preferences"]  # Shape [batch_size * n]
+        # Calculate accuracy based on RM scores (assuming higher score -> True in mask)
+        # Requires chosen/rejected scores to be available or recalculated
+        # This is complex here, better calculated in the main loop or update function
+
+        # --- Length Metrics ---
+        response_info = _compute_response_info(batch)
+        prompt_length = response_info["prompt_length"]
+        response_length = response_info["response_length"]
+        max_response_length = response_info["max_response_length"]
+        max_prompt_length = response_info["max_prompt_length"]  # Use calculated or from config
+
+        metrics.update(
+            {
+                "response_length/mean": torch.mean(response_length).item(),
+                "response_length/max": torch.max(response_length).item(),
+                "response_length/min": torch.min(response_length).item(),
+                "response_length/clip_ratio": torch.mean(torch.eq(response_length, max_response_length).float()).item(),
+                "prompt_length/mean": torch.mean(prompt_length).item(),
+                "prompt_length/max": torch.max(prompt_length).item(),
+                "prompt_length/min": torch.min(prompt_length).item(),
+                # Prompt clip ratio might need adjustment based on how max_prompt_length is defined
+                "prompt_length/clip_ratio": torch.mean(torch.eq(prompt_length, max_prompt_length).float()).item(),
+            }
+        )
+
+    except KeyError as e:
+        print(f"ERROR in compute_dpo_data_metrics: Missing key {e}")
+    except Exception as e:
+        print(f"ERROR in compute_dpo_data_metrics: {e}")
+        traceback.print_exc()
+
+    print(f"---- [DEBUG] Calculated DPO Data Metrics: {list(metrics.keys())} ----")
+    return metrics
+
+
+def apply_kl_penalty(data: DataProto, kl_ctrl: core_algos.AdaptiveKLController, kl_penalty="kl"):
+    responses = data.batch["responses"]
+    response_length = responses.size(1)
+    token_level_scores = data.batch["token_level_scores"]
+    batch_size = data.batch.batch_size[0]
+    attention_mask = data.batch["attention_mask"]
+    response_mask = attention_mask[:, -response_length:]
+
+    # compute kl between ref_policy and current policy
+    # When apply_kl_penalty, algorithm.use_kl_in_reward=True, so the reference model has been enabled.
+    kld = core_algos.kl_penalty(
+        data.batch["old_log_probs"], data.batch["ref_log_prob"], kl_penalty=kl_penalty
+    )  # (batch_size, response_length)
+    kld = kld * response_mask
+    beta = kl_ctrl.value
+
+    token_level_rewards = token_level_scores - beta * kld
+
+    current_kl = masked_mean(kld, mask=response_mask, axis=-1)  # average over sequence
+    current_kl = torch.mean(current_kl, dim=0).item()
+
+    # according to https://github.com/huggingface/trl/blob/951ca1841f29114b969b57b26c7d3e80a39f75a0/trl/trainer/ppo_trainer.py#L837
+    kl_ctrl.update(current_kl=current_kl, n_steps=batch_size)
+    data.batch["token_level_rewards"] = token_level_rewards
+
+    metrics = {"actor/reward_kl_penalty": current_kl, "actor/reward_kl_penalty_coeff": beta}
+
+    return data, metrics
+
+
+def compute_response_mask(data: DataProto):
+    responses = data.batch["responses"]
+    response_length = responses.size(1)
+    attention_mask = data.batch["attention_mask"]
+    return attention_mask[:, -response_length:]
+
+
+def compute_onlineDPO_pref(data: DataProto):
+    """
+    Wrapper to compute DPO preference and add it to the DataProto batch.
+    Includes debugging prints.
+    """
+    # print(f"\n---- [DEBUG] Entering compute_onlineDPO_pref ----")
+    # print(f"  Input batch keys: {list(data.batch.keys())}")
+
+    # Check inputs
+    rewards_tensor = data.batch.get("token_level_rewards")
+    mask_tensor = data.batch.get("response_mask")
+
+    if rewards_tensor is None or mask_tensor is None:
+        print("  ERROR: Missing 'token_level_rewards' or 'response_mask' in input data!")
+        # Handle error case - maybe return original data or raise?
+        # Returning original data for now to potentially allow skipping
+        return data
+
+    try:
+        preferences = core_algos.compute_onlinedpo_pref(token_level_rewards=rewards_tensor, response_mask=mask_tensor)
+        # Store the result
+        data.batch["preferences"] = preferences
+
+    except AttributeError:
+        print("ERROR: Function 'compute_online_dpo_preference' not found in core_algos.py!")
+        # Assign dummy value or raise error
+        data.batch["preferences"] = None  # Indicate failure
+    except Exception as e_pref:
+        print(f"ERROR during core_algos.compute_online_dpo_preference: {e_pref}")
+        import traceback
+
+        traceback.print_exc()
+        data.batch["preferences"] = None  # Indicate failure
+
+    # print(f"---- [DEBUG] Exiting compute_onlineDPO_pref ----")
+    return data
+
+
+@contextmanager
+def _timer(name: str, timing_raw: dict[str, float]):
+    with Timer(name=name, logger=None) as timer:
+        yield
+    timing_raw[name] = timer.last
+
+
+class RaySPINTrainer:
+    """
+    Note that this trainer runs on the driver process on a single CPU/GPU node.
+    """
+
+    # TODO: support each role have individual ray_worker_group_cls,
+    # i.e., support different backend of different role
+    def __init__(
+        self,
+        config,
+        tokenizer,
+        role_worker_mapping: dict[Role, WorkerType],
+        resource_pool_manager: ResourcePoolManager,
+        ray_worker_group_cls: RayWorkerGroup = RayWorkerGroup,
+        processor=None,
+        reward_fn=None,
+        val_reward_fn=None,
+        train_dataset: Optional[Dataset] = None,
+        val_dataset: Optional[Dataset] = None,
+        collate_fn=None,
+        train_sampler: Optional[Sampler] = None,
+        device_name=None,
+    ):
+        # assert get_torch_device().is_available(), 'cuda must be available on driver'
+
+        self.tokenizer = tokenizer
+        self.processor = processor
+        self.config = config
+        self.reward_fn = reward_fn
+        self.val_reward_fn = val_reward_fn
+
+        self.hybrid_engine = config.actor_rollout_ref.hybrid_engine
+        assert self.hybrid_engine, "Currently, only support hybrid engine"
+
+        if self.hybrid_engine:
+            assert Role.ActorRollout in role_worker_mapping, f"{role_worker_mapping.keys()=}"
+
+        self.role_worker_mapping = role_worker_mapping
+        self.resource_pool_manager = resource_pool_manager
+        self.use_reference_policy = need_reference_policy(role_worker_mapping)
+        self.use_rm = need_reward_model(role_worker_mapping)
+        self.use_critic = False
+        self.ray_worker_group_cls = ray_worker_group_cls
+        self.validation_generations_logger = ValidationGenerationsLogger()
+        self.async_rollout_mode = False
+        self.device_name = device_name if device_name else self.config.trainer.device
+
+        # define in-reward KL control
+        # kl loss control currently not suppoorted
+        if config.algorithm.use_kl_in_reward:
+            self.kl_ctrl_in_reward = core_algos.get_kl_controller(config.algorithm.kl_ctrl)
+
+        self._create_dataloader(train_dataset, val_dataset, collate_fn, train_sampler)
+
+    def _create_dataloader(self, train_dataset, val_dataset, collate_fn, train_sampler):
+        """
+        Creates the train and validation dataloaders.
+        """
+        # TODO: we have to make sure the batch size is divisible by the dp size
+        from verl.trainer.main_ppo import create_rl_dataset, create_rl_sampler
+
+        if train_dataset is None:
+            train_dataset = create_rl_dataset(
+                self.config.data.train_files, self.config.data, self.tokenizer, self.processor
+            )
+        if val_dataset is None:
+            val_dataset = create_rl_dataset(
+                self.config.data.val_files, self.config.data, self.tokenizer, self.processor
+            )
+        self.train_dataset, self.val_dataset = train_dataset, val_dataset
+
+        if train_sampler is None:
+            train_sampler = create_rl_sampler(self.config.data, self.train_dataset)
+        if collate_fn is None:
+            from verl.utils.dataset.rl_dataset import collate_fn as default_collate_fn
+
+            collate_fn = default_collate_fn
+
+        self.train_dataloader = StatefulDataLoader(
+            dataset=self.train_dataset,
+            batch_size=self.config.data.get("gen_batch_size", self.config.data.train_batch_size),
+            num_workers=self.config.data.get("dataloader_num_workers", 8),
+            drop_last=True,
+            collate_fn=collate_fn,
+            sampler=train_sampler,
+        )
+
+        val_batch_size = self.config.data.val_batch_size  # Prefer config value if set
+        if val_batch_size is None:
+            val_batch_size = len(self.val_dataset)
+
+        self.val_dataloader = StatefulDataLoader(
+            dataset=self.val_dataset,
+            batch_size=val_batch_size,
+            num_workers=self.config.data.get("dataloader_num_workers", 8),
+            shuffle=False,
+            drop_last=False,
+            collate_fn=collate_fn,
+        )
+
+        assert len(self.train_dataloader) >= 1, "Train dataloader is empty!"
+        assert len(self.val_dataloader) >= 1, "Validation dataloader is empty!"
+
+        print(
+            f"Size of train dataloader: {len(self.train_dataloader)}, "
+            f"Size of val dataloader: {len(self.val_dataloader)}"
+        )
+
+        total_training_steps = len(self.train_dataloader) * self.config.trainer.total_epochs
+
+        if self.config.trainer.total_training_steps is not None:
+            total_training_steps = self.config.trainer.total_training_steps
+
+        self.total_training_steps = total_training_steps
+        print(f"Total training steps: {self.total_training_steps}")
+
+        try:
+            OmegaConf.set_struct(self.config, True)
+            with open_dict(self.config):
+                if OmegaConf.select(self.config, "actor_rollout_ref.actor.optim"):
+                    self.config.actor_rollout_ref.actor.optim.total_training_steps = total_training_steps
+                if OmegaConf.select(self.config, "critic.optim"):
+                    self.config.critic.optim.total_training_steps = total_training_steps
+        except Exception as e:
+            print(f"Warning: Could not set total_training_steps in config. Structure missing? Error: {e}")
+
+    def _maybe_log_val_generations(self, inputs, outputs, scores):
+        """Log a table of validation samples to the configured logger (wandb or swanlab)"""
+
+        generations_to_log = self.config.trainer.log_val_generations
+
+        if generations_to_log == 0:
+            return
+
+        import numpy as np
+
+        # Create tuples of (input, output, score) and sort by input text
+        samples = list(zip(inputs, outputs, scores, strict=True))
+        samples.sort(key=lambda x: x[0])  # Sort by input text
+
+        # Use fixed random seed for deterministic shuffling
+        rng = np.random.RandomState(42)
+        rng.shuffle(samples)
+
+        # Take first N samples after shuffling
+        samples = samples[:generations_to_log]
+
+        # Log to each configured logger
+        self.validation_generations_logger.log(self.config.trainer.logger, samples, self.global_steps)
+
+    def _validate(self):
+        data_source_lst = []
+        reward_extra_infos_dict: dict[str, list] = defaultdict(list)
+
+        # Lists to collect samples for the table
+        sample_inputs = []
+        sample_outputs = []
+        sample_scores = []
+
+        for test_data in self.val_dataloader:
+            test_batch = DataProto.from_single_dict(test_data)
+
+            # repeat test batch
+            test_batch = test_batch.repeat(
+                repeat_times=self.config.actor_rollout_ref.rollout.val_kwargs.n, interleave=True
+            )
+
+            # we only do validation on rule-based rm
+            if self.config.reward_model.enable and test_batch[0].non_tensor_batch["reward_model"]["style"] == "model":
+                return {}
+
+            # Store original inputs
+            input_ids = test_batch.batch["input_ids"]
+            # TODO: Can we keep special tokens except for padding tokens?
+            input_texts = [self.tokenizer.decode(ids, skip_special_tokens=True) for ids in input_ids]
+            sample_inputs.extend(input_texts)
+
+            batch_keys_to_pop = ["input_ids", "attention_mask", "position_ids"]
+            non_tensor_batch_keys_to_pop = ["raw_prompt_ids"]
+            if "multi_modal_inputs" in test_batch.non_tensor_batch:
+                non_tensor_batch_keys_to_pop.extend(["multi_modal_data", "multi_modal_inputs"])
+            if "raw_prompt" in test_batch.non_tensor_batch:
+                non_tensor_batch_keys_to_pop.append("raw_prompt")
+            if "tools_kwargs" in test_batch.non_tensor_batch:
+                non_tensor_batch_keys_to_pop.append("tools_kwargs")
+            test_gen_batch = test_batch.pop(
+                batch_keys=batch_keys_to_pop,
+                non_tensor_batch_keys=non_tensor_batch_keys_to_pop,
+            )
+
+            test_gen_batch.meta_info = {
+                "eos_token_id": self.tokenizer.eos_token_id,
+                "pad_token_id": self.tokenizer.pad_token_id,
+                "recompute_log_prob": False,
+                "do_sample": self.config.actor_rollout_ref.rollout.val_kwargs.do_sample,
+                "validate": True,
+            }
+            print(f"test_gen_batch meta info: {test_gen_batch.meta_info}")
+
+            # pad to be divisible by dp_size
+            test_gen_batch_padded, pad_size = pad_dataproto_to_divisor(test_gen_batch, self.actor_rollout_wg.world_size)
+            if not self.async_rollout_mode:
+                test_output_gen_batch_padded = self.actor_rollout_wg.generate_sequences(test_gen_batch_padded)
+            else:
+                test_output_gen_batch_padded = self.async_rollout_manager.generate_sequences(test_gen_batch_padded)
+
+            # unpad
+            test_output_gen_batch = unpad_dataproto(test_output_gen_batch_padded, pad_size=pad_size)
+            print("validation generation end")
+
+            # Store generated outputs
+            output_ids = test_output_gen_batch.batch["responses"]
+            output_texts = [self.tokenizer.decode(ids, skip_special_tokens=True) for ids in output_ids]
+            sample_outputs.extend(output_texts)
+
+            test_batch = test_batch.union(test_output_gen_batch)
+
+            # evaluate using reward_function
+            result = self.val_reward_fn(test_batch, return_dict=True)
+            reward_tensor = result["reward_tensor"]
+            scores = reward_tensor.sum(-1).cpu().tolist()
+            sample_scores.extend(scores)
+
+            reward_extra_infos_dict["reward"].extend(scores)
+            if "reward_extra_info" in result:
+                for key, lst in result["reward_extra_info"].items():
+                    reward_extra_infos_dict[key].extend(lst)
+
+            data_source_lst.append(test_batch.non_tensor_batch.get("data_source", ["unknown"] * reward_tensor.shape[0]))
+
+        self._maybe_log_val_generations(inputs=sample_inputs, outputs=sample_outputs, scores=sample_scores)
+
+        # dump generations
+        val_data_dir = self.config.trainer.get("validation_data_dir", None)
+        if val_data_dir:
+            sample_gts = [
+                item.non_tensor_batch.get("reward_model", {}).get("ground_truth", None) for item in test_batch
+            ]
+            self._dump_generations(
+                inputs=sample_inputs,
+                outputs=sample_outputs,
+                gts=sample_gts,
+                scores=sample_scores,
+                reward_extra_infos_dict=reward_extra_infos_dict,
+                dump_path=val_data_dir,
+            )
+
+        for key_info, lst in reward_extra_infos_dict.items():
+            assert len(lst) == 0 or len(lst) == len(sample_scores), f"{key_info}: {len(lst)=}, {len(sample_scores)=}"
+
+        data_sources = np.concatenate(data_source_lst, axis=0)
+        print(f"DEBUG: Data sources shape: {data_sources.shape}")  # Added Print
+        print(f"DEBUG: reward_extra_infos_dict keys before processing: {reward_extra_infos_dict.keys()}")  # Added Print
+
+        data_src2var2metric2val = process_validation_metrics(data_sources, sample_inputs, reward_extra_infos_dict)
+        print(
+            f"DEBUG: Output of process_validation_metrics (data_src2var2metric2val): {data_src2var2metric2val}"
+        )  # Added Print
+        metric_dict = {}
+        for data_source, var2metric2val in data_src2var2metric2val.items():
+            core_var = "acc" if "acc" in var2metric2val else "reward"
+            for var_name, metric2val in var2metric2val.items():
+                n_max = max([int(name.split("@")[-1].split("/")[0]) for name in metric2val.keys()])
+                for metric_name, metric_val in metric2val.items():
+                    if (
+                        (var_name == core_var)
+                        and any(metric_name.startswith(pfx) for pfx in ["mean", "maj", "best"])
+                        and (f"@{n_max}" in metric_name)
+                    ):
+                        metric_sec = "val-core"
+                    else:
+                        metric_sec = "val-aux"
+                    pfx = f"{metric_sec}/{data_source}/{var_name}/{metric_name}"
+                    metric_dict[pfx] = metric_val
+
+        return metric_dict
+
+    def init_workers(self):
+        """Init resource pool and worker group"""
+        self.resource_pool_manager.create_resource_pool()
+
+        self.resource_pool_to_cls = {pool: {} for pool in self.resource_pool_manager.resource_pool_dict.values()}
+
+        # create actor and rollout
+        if self.hybrid_engine:
+            resource_pool = self.resource_pool_manager.get_resource_pool(Role.ActorRollout)
+            actor_rollout_cls = RayClassWithInitArgs(
+                cls=self.role_worker_mapping[Role.ActorRollout],
+                config=self.config.actor_rollout_ref,
+                role="actor_rollout",
+            )
+            self.resource_pool_to_cls[resource_pool]["actor_rollout"] = actor_rollout_cls
+        else:
+            raise NotImplementedError
+
+        # create critic
+        if self.use_critic:
+            resource_pool = self.resource_pool_manager.get_resource_pool(Role.Critic)
+            critic_cls = RayClassWithInitArgs(cls=self.role_worker_mapping[Role.Critic], config=self.config.critic)
+            self.resource_pool_to_cls[resource_pool]["critic"] = critic_cls
+
+        # create reference policy if needed
+        if self.use_reference_policy:
+            resource_pool = self.resource_pool_manager.get_resource_pool(Role.RefPolicy)
+            ref_policy_cls = RayClassWithInitArgs(
+                self.role_worker_mapping[Role.RefPolicy], config=self.config.actor_rollout_ref, role="ref"
+            )
+            self.resource_pool_to_cls[resource_pool]["ref"] = ref_policy_cls
+
+        # create a reward model if reward_fn is None
+        if self.use_rm:
+            # we create a RM here
+            resource_pool = self.resource_pool_manager.get_resource_pool(Role.RewardModel)
+            rm_cls = RayClassWithInitArgs(self.role_worker_mapping[Role.RewardModel], config=self.config.reward_model)
+            self.resource_pool_to_cls[resource_pool]["rm"] = rm_cls
+
+        # initialize WorkerGroup
+        # NOTE: if you want to use a different resource pool for each role, which can support different
+        # parallel size,
+        # you should not use `create_colocated_worker_cls`. Instead, directly pass different resource pool to
+        # different worker groups.
+        # See https://github.com/volcengine/verl/blob/master/examples/ray/tutorial.ipynb for more information.
+        all_wg = {}
+        self.wg_dicts = []
+        wg_kwargs = {}  # Setting up kwargs for RayWorkerGroup
+        if OmegaConf.select(self.config.trainer, "ray_wait_register_center_timeout") is not None:
+            wg_kwargs["ray_wait_register_center_timeout"] = self.config.trainer.ray_wait_register_center_timeout
+        wg_kwargs["device_name"] = self.device_name
+
+        for resource_pool, class_dict in self.resource_pool_to_cls.items():
+            worker_dict_cls = create_colocated_worker_cls(class_dict=class_dict)
+            wg_dict = self.ray_worker_group_cls(
+                resource_pool=resource_pool,
+                ray_cls_with_init=worker_dict_cls,
+                **wg_kwargs,
+            )
+            spawn_wg = wg_dict.spawn(prefix_set=class_dict.keys())
+            all_wg.update(spawn_wg)
+            # keep the referece of WorkerDict to support ray >= 2.31. Ref: https://github.com/ray-project/ray/pull/45699
+            self.wg_dicts.append(wg_dict)
+
+        if self.use_critic:
+            self.critic_wg = all_wg["critic"]
+            self.critic_wg.init_model()
+
+        if self.use_reference_policy:
+            self.ref_policy_wg = all_wg["ref"]
+            self.ref_policy_wg.init_model()
+
+        if self.use_rm:
+            self.rm_wg = all_wg["rm"]
+            self.rm_wg.init_model()
+
+        # we should create rollout at the end so that vllm can have a better estimation of kv cache memory
+        self.actor_rollout_wg = all_wg["actor_rollout"]
+        self.actor_rollout_wg.init_model()
+
+    def _save_checkpoint(self):
+        # path: given_path + `/global_step_{global_steps}` + `/actor`
+        local_global_step_folder = os.path.join(
+            self.config.trainer.default_local_dir, f"global_step_{self.global_steps}"
+        )
+
+        print(f"local_global_step_folder: {local_global_step_folder}")
+        actor_local_path = os.path.join(local_global_step_folder, "actor")
+
+        actor_remote_path = (
+            None
+            if self.config.trainer.default_hdfs_dir is None
+            else os.path.join(self.config.trainer.default_hdfs_dir, f"global_step_{self.global_steps}", "actor")
+        )
+
+        remove_previous_ckpt_in_save = self.config.trainer.get("remove_previous_ckpt_in_save", False)
+        if remove_previous_ckpt_in_save:
+            print(
+                "Warning: remove_previous_ckpt_in_save is deprecated, set max_actor_ckpt_to_keep=1 and "
+                "max_critic_ckpt_to_keep=1 instead"
+            )
+        max_actor_ckpt_to_keep = (
+            self.config.trainer.get("max_actor_ckpt_to_keep", None) if not remove_previous_ckpt_in_save else 1
+        )
+        max_critic_ckpt_to_keep = (
+            self.config.trainer.get("max_critic_ckpt_to_keep", None) if not remove_previous_ckpt_in_save else 1
+        )
+
+        self.actor_rollout_wg.save_checkpoint(
+            actor_local_path, actor_remote_path, self.global_steps, max_ckpt_to_keep=max_actor_ckpt_to_keep
+        )
+
+        if self.use_critic:
+            critic_local_path = os.path.join(local_global_step_folder, "critic")
+            critic_remote_path = (
+                None
+                if self.config.trainer.default_hdfs_dir is None
+                else os.path.join(self.config.trainer.default_hdfs_dir, f"global_step_{self.global_steps}", "critic")
+            )
+            self.critic_wg.save_checkpoint(
+                critic_local_path, critic_remote_path, self.global_steps, max_ckpt_to_keep=max_critic_ckpt_to_keep
+            )
+
+        # save dataloader
+        dataloader_local_path = os.path.join(local_global_step_folder, "data.pt")
+        dataloader_state_dict = self.train_dataloader.state_dict()
+        torch.save(dataloader_state_dict, dataloader_local_path)
+
+        # latest checkpointed iteration tracker (for atomic usage)
+        local_latest_checkpointed_iteration = os.path.join(
+            self.config.trainer.default_local_dir, "latest_checkpointed_iteration.txt"
+        )
+        with open(local_latest_checkpointed_iteration, "w") as f:
+            f.write(str(self.global_steps))
+
+    def _load_checkpoint(self):
+        if self.config.trainer.resume_mode == "disable":
+            return 0
+
+        # load from hdfs
+        if self.config.trainer.default_hdfs_dir is not None:
+            raise NotImplementedError("load from hdfs is not implemented yet")
+        else:
+            checkpoint_folder = self.config.trainer.default_local_dir  # TODO: check path
+            if not os.path.isabs(checkpoint_folder):
+                working_dir = os.getcwd()
+                checkpoint_folder = os.path.join(working_dir, checkpoint_folder)
+            global_step_folder = find_latest_ckpt_path(checkpoint_folder)  # None if no latest
+
+        # find global_step_folder
+        if self.config.trainer.resume_mode == "auto":
+            if global_step_folder is None:
+                print("Training from scratch")
+                return 0
+        else:
+            if self.config.trainer.resume_mode == "resume_path":
+                assert isinstance(self.config.trainer.resume_from_path, str), "resume ckpt must be str type"
+                assert "global_step_" in self.config.trainer.resume_from_path, (
+                    "resume ckpt must specify the global_steps"
+                )
+                global_step_folder = self.config.trainer.resume_from_path
+                if not os.path.isabs(global_step_folder):
+                    working_dir = os.getcwd()
+                    global_step_folder = os.path.join(working_dir, global_step_folder)
+        print(f"Load from checkpoint folder: {global_step_folder}")
+        # set global step
+        self.global_steps = int(global_step_folder.split("global_step_")[-1])
+
+        print(f"Setting global step to {self.global_steps}")
+        print(f"Resuming from {global_step_folder}")
+
+        actor_path = os.path.join(global_step_folder, "actor")
+        critic_path = os.path.join(global_step_folder, "critic")
+        # load actor
+        self.actor_rollout_wg.load_checkpoint(
+            actor_path, del_local_after_load=self.config.trainer.del_local_ckpt_after_load
+        )
+        # load critic
+        if self.use_critic:
+            self.critic_wg.load_checkpoint(
+                critic_path, del_local_after_load=self.config.trainer.del_local_ckpt_after_load
+            )
+
+        # load dataloader,
+        # TODO: from remote not implemented yet
+        dataloader_local_path = os.path.join(global_step_folder, "data.pt")
+        if os.path.exists(dataloader_local_path):
+            dataloader_state_dict = torch.load(dataloader_local_path, weights_only=False)
+            self.train_dataloader.load_state_dict(dataloader_state_dict)
+        else:
+            print(f"Warning: No dataloader state found at {dataloader_local_path}, will start from scratch")
+
+    def _balance_batch(self, batch: DataProto, metrics, logging_prefix="global_seqlen"):
+        """Reorder the data on single controller such that each dp rank gets similar total tokens"""
+        attention_mask = batch.batch["attention_mask"]
+        batch_size = attention_mask.shape[0]
+        global_seqlen_lst = batch.batch["attention_mask"].view(batch_size, -1).sum(-1).tolist()  # (train_batch_size,)
+        world_size = self.actor_rollout_wg.world_size
+        global_partition_lst = get_seqlen_balanced_partitions(
+            global_seqlen_lst, k_partitions=world_size, equal_size=True
+        )
+        # reorder based on index. The data will be automatically equally partitioned by dispatch function
+        global_idx = torch.tensor([j for partition in global_partition_lst for j in partition])
+        batch.reorder(global_idx)
+        global_balance_stats = log_seqlen_unbalance(
+            seqlen_list=global_seqlen_lst, partitions=global_partition_lst, prefix=logging_prefix
+        )
+        metrics.update(global_balance_stats)
+
+    def fit_dpo(self):  # Renamed for clarity as standard PPO loop
+        """
+        The training loop of Online DPO using a periodically updated reference model.
+        The driver process calls worker groups for computation.
+        Advantage computation is replaced by DPO logic.
+        """
+        import traceback  # Ensure traceback is imported
+
+        from omegaconf import OmegaConf
+
+        from verl.utils.tracking import Tracking
+
+        # Initialize logger
+        logger = None
+        try:
+            logger = Tracking(
+                project_name=self.config.trainer.project_name,
+                experiment_name=self.config.trainer.experiment_name,
+                default_backend=self.config.trainer.logger,
+                config=OmegaConf.to_container(self.config, resolve=True, throw_on_missing=False),
+            )
+        except Exception as e:
+            print(f"Warning: Failed to initialize logger: {e}")
+
+        self.global_steps = 0
+        # Load checkpoint before doing anything
+        loaded_step = self._load_checkpoint()
+        self.global_steps = loaded_step + 1 if loaded_step is not None and loaded_step > 0 else 1
+        print(
+            f"Starting Online DPO training from global step {self.global_steps}. "
+            f"Total steps: {self.total_training_steps}"
+        )
+        print(f"Reference model update frequency: {self.config.trainer.get('ref_update_freq', 'Not Set')}")
+
+        # Check if reference policy is configured correctly for this mode
+        if not self.use_reference_policy:
+            print(
+                "WARNING: 'use_reference_policy' is False. Periodic reference model update requires a "
+                "reference policy worker. DPO updates might fail or use incorrect logic."
+            )
+            # Consider raising an error if strict adherence is required:
+            # raise ValueError("Periodic reference model update requires 'use_reference_policy' to be True "
+            #                  "and a configured reference worker.")
+
+        # Perform validation before training
+        if self.val_reward_fn is not None and self.config.trainer.get("val_before_train", True):
+            print("Running validation before Online DPO training...")
+            val_metrics = self._validate()
+            pprint(f"Initial validation metrics: {val_metrics}")
+            if logger and val_metrics:
+                logger.log(data=val_metrics, step=max(0, self.global_steps - 1))
+            if self.config.trainer.get("val_only", False):
+                print("Validation only mode enabled. Exiting training.")
+                if logger and hasattr(logger, "finish"):
+                    logger.finish()
+                return
+
+        # Add tqdm progress bar
+        progress_bar = tqdm(
+            total=self.total_training_steps,
+            initial=self.global_steps,
+            desc="Online DPO Training Progress",
+            position=0,
+            leave=True,
+        )
+
+        last_val_metrics = None
+        should_stop = False
+
+        for epoch in range(self.config.trainer.total_epochs):
+            if should_stop:
+                break
+            print(f"--- Starting Online DPO Epoch {epoch} ---")
+            try:
+                train_iterator = iter(self.train_dataloader)
+            except TypeError:
+                print("Warning: Dataloader is not iterable.")
+                train_iterator = self.train_dataloader  # Fallback attempt
+
+            for batch_idx, batch_dict in enumerate(train_iterator):
+                if self.global_steps > self.total_training_steps:
+                    should_stop = True
+                    break
+
+                metrics = {}
+                timing_raw = {}
+                step_timer = Timer(logger=None)
+                ref_log_prob_computed = False  # Flag to track if ref log probs were computed
+
+                try:  # Outer try-except for the whole step
+                    step_timer.start()
+                    with _timer("step", timing_raw):
+                        batch: DataProto = DataProto.from_single_dict(batch_dict)
+                        current_batch_size = batch.batch.batch_size[0]
+                        print(
+                            f"\n[Step {self.global_steps}, Batch {batch_idx}] Processing batch size: "
+                            f"{current_batch_size}"
+                        )
+
+                        # --- Reference Model Update ---
+                        ref_update_freq = self.config.trainer.get("ref_update_freq", -1)
+                        if (
+                            self.use_reference_policy
+                            and ref_update_freq > 0
+                            and self.global_steps % ref_update_freq == 0
+                        ):
+                            print(f"\n[Step {self.global_steps}] Updating Reference Model Weights from Actor...")
+                            try:
+                                # --- This requires careful implementation with FSDP ---
+                                # 1. Save actor state dict (potentially to CPU memory or disk)
+                                #    This needs to be done collectively across actor worker ranks.
+                                #    The checkpoint_manager might be adaptable, or use FSDP APIs directly.
+                                #    Example placeholder using a conceptual save/load mechanism:
+                                actor_state_path = "/tmp/actor_state_mid"  # Temporary path
+                                self.actor_rollout_wg.save_checkpoint(actor_state_path)  # Adapt save logic
+
+                                # 2. Load the state dict onto the reference model worker group
+                                #    This also needs collective loading on the ref worker ranks.
+                                self.ref_policy_wg.load_checkpoint(actor_state_path, None, True)  # Adapt load logic
+
+                                print(f"[Step {self.global_steps}] Reference Model Weights Updated.")
+                                # Optionally remove the temporary state file
+                                # os.remove(actor_state_path) # Needs rank-aware removal or shared storage
+
+                            except Exception as sync_e:
+                                print(f"ERROR during reference model sync at step {self.global_steps}: {sync_e}")
+                                traceback.print_exc()
+
+                        # Pop keys for generation
+                        pop_batch_keys = ["input_ids", "attention_mask"]
+                        if "position_ids" in batch.batch:
+                            pop_batch_keys.append("position_ids")
+                        pop_non_tensor_keys = ["raw_prompt_ids"] if "raw_prompt_ids" in batch.non_tensor_batch else []
+                        if "multi_modal_inputs" in batch.non_tensor_batch.keys():
+                            pop_non_tensor_keys.extend(["multi_modal_data", "multi_modal_inputs"])
+                        original_non_tensor_data = batch.non_tensor_batch
+                        gen_batch = batch.pop(
+                            batch_keys=pop_batch_keys,
+                            non_tensor_batch_keys=pop_non_tensor_keys,
+                        )
+                        gen_batch = gen_batch.repeat(
+                            repeat_times=self.config.actor_rollout_ref.rollout.n, interleave=True
+                        )
+                        # (Add Debug prints for gen_batch if needed)
+
+                        # Generate sequences (chosen/rejected pairs)
+                        with _timer("gen", timing_raw):
+                            try:
+                                gen_batch_output = self.actor_rollout_wg.generate_sequences(gen_batch)
+                                # (Add Debug prints for gen_batch_output if needed)
+                            except Exception as gen_e:
+                                print(f"\n!!!!!!!! ERROR DURING GENERATION (Step {self.global_steps}) !!!!!!!!")
+                                print(gen_e)
+                                traceback.print_exc()
+                                print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                                step_timer.stop()
+                                continue
+
+                        # Combine original prompts with generated sequences
+                        batch.non_tensor_batch = original_non_tensor_data  # Restore non-tensor data
+                        batch.non_tensor_batch["uid"] = np.array(
+                            [str(uuid.uuid4()) for _ in range(current_batch_size)], dtype=object
+                        )
+                        batch = batch.repeat(repeat_times=self.config.actor_rollout_ref.rollout.n, interleave=True)
+                        batch = batch.union(gen_batch_output)
+                        # (Add Debug prints after union if needed)
+
+                        # Compute response mask (needed for ref logprob calc and DPO prep)
+                        batch.batch["response_mask"] = compute_response_mask(batch)
+
+                        if self.config.trainer.balance_batch:
+                            self._balance_batch(batch, metrics=metrics)
+
+                        batch.meta_info["global_token_num"] = torch.sum(batch.batch["attention_mask"], dim=-1).tolist()
+
+                        # --- Compute Log Probs for the CURRENT policy (used for KL if enabled, or ActorAsRef
+                        # fallback) ---
+                        # Note: For pure DPO with external ref, this 'old_log_probs' might not be strictly needed
+                        #       unless used for other metrics or a fallback. Keep it for now.
+                        with _timer("policy_log_prob", timing_raw):
+                            policy_log_prob_output = self.actor_rollout_wg.compute_log_prob(batch)
+                            batch = batch.union(policy_log_prob_output)  # Adds 'old_log_probs'
+                            # (Debug prints for old_log_probs)
+
+                        # --- Compute Log Probs using the EXTERNAL Reference Model ---
+                        if self.use_reference_policy:
+                            with _timer("ref_log_prob_dpo", timing_raw):
+                                # print(f"---- [Step {self.global_steps}] DEBUG DPO: Calling compute_ref_log_prob ----")
+                                try:
+                                    # 'batch' contains interleaved chosen/rejected sequences
+                                    ref_log_prob_output = self.ref_policy_wg.compute_ref_log_prob(
+                                        batch
+                                    )  # Returns DataProto with 'ref_log_prob'
+                                    batch = batch.union(
+                                        ref_log_prob_output
+                                    )  # Adds 'ref_log_prob' key [batch_size * n, seq_len]
+                                    ref_log_prob_computed = True  # Mark success
+                                    # print(f"---- [Step {self.global_steps}] DEBUG DPO: ref_log_prob tensor shape: "
+                                    #       f"{batch.batch['ref_log_prob'].shape} ----")
+                                except Exception as ref_e:
+                                    print(f"ERROR computing reference log probs at step {self.global_steps}: {ref_e}")
+                                    traceback.print_exc()
+                                    batch.batch["ref_log_prob"] = None  # Mark as failed
+                                    ref_log_prob_computed = False
+                        else:
+                            print(
+                                "Warning: Skipping external reference log prob calculation as use_reference_policy "
+                                "is False."
+                            )
+                            # DPO update will likely fail unless ActorAsRef logic is re-enabled in dp_actor
+
+                        # --- Compute Rewards/Scores (used to determine preference) ---
+                        with _timer("reward_calc", timing_raw):
+                            # (Reward calculation logic using RM or reward_fn as before)
+                            # ... Ensure this calculates 'token_level_rewards' or similar ...
+                            if self.use_rm:
+                                reward_tensor_rm = self.rm_wg.compute_rm_score(batch)
+                                batch = batch.union(reward_tensor_rm)  # Adds 'rm_scores'
+
+                            reward_extra_infos_dict = {}
+                            try:
+                                if self.reward_fn is None:
+                                    #  print(f"---- [DEBUG Step {self.global_steps}] ERROR: self.reward_fn is None! "
+                                    #        f"Using dummy rewards. ----")
+                                    # Use rm_scores if available, otherwise zeros
+                                    reward_tensor = batch.batch.get(
+                                        "rm_scores", torch.zeros_like(batch.batch["response_mask"], dtype=torch.float32)
+                                    )
+                                else:
+                                    reward_result = self.reward_fn(batch, return_dict=True)
+                                    reward_tensor = reward_result["reward_tensor"]  # Final combined reward
+                                    reward_extra_infos_dict = reward_result.get("reward_extra_info", {})
+
+                            except Exception:
+                                # print(f'---- [DEBUG Step {self.global_steps}] Error in reward_fn call: {e}. '
+                                #       f'Using dummy rewards. ----')
+                                traceback.print_exc()
+                                reward_tensor = torch.zeros_like(batch.batch["response_mask"], dtype=torch.float32)
+                                reward_extra_infos_dict = {}
+
+                            # Use 'token_level_rewards' as the key for preference calculation
+                            batch.batch["token_level_rewards"] = reward_tensor
+                            if reward_extra_infos_dict:
+                                batch.non_tensor_batch.update(
+                                    {k: np.array(v) for k, v in reward_extra_infos_dict.items()}
+                                )
+
+                        # --- Determine Preferences ---
+                        # Uses 'token_level_rewards' to determine chosen/rejected based on score
+                        batch = compute_onlineDPO_pref(batch)  # Adds 'preferences' key
+
+                        # --- Prepare DPO Batch ---
+                        dpo_update_batch_proto = None  # Initialize
+                        with _timer("prepare_dpo_batch", timing_raw):
+                            try:
+                                if "preferences" not in batch.batch or batch.batch["preferences"] is None:
+                                    raise ValueError("'preferences' key missing or None after compute_onlineDPO_pref.")
+
+                                # Check if reference log probs were computed successfully (if needed)
+                                if self.use_reference_policy and not ref_log_prob_computed:
+                                    raise ValueError("Reference log probs required but failed to compute.")
+
+                                # Check required base keys
+                                required_keys = ["input_ids", "attention_mask", "response_mask"]
+                                for rk in required_keys:
+                                    if rk not in batch.batch or batch.batch[rk] is None:
+                                        raise KeyError(f"Required key '{rk}' missing from batch for DPO prep.")
+
+                                preferences_mask = batch.batch["preferences"]  # Shape [batch_size * n]
+                                not_preferences_mask = ~preferences_mask
+
+                                # Gather Chosen/Rejected Base Tensors
+                                chosen_input_ids = batch.batch["input_ids"][preferences_mask]
+                                chosen_attention_mask = batch.batch["attention_mask"][preferences_mask]
+                                rejected_input_ids = batch.batch["input_ids"][not_preferences_mask]
+                                rejected_attention_mask = batch.batch["attention_mask"][not_preferences_mask]
+                                chosen_position_ids = (
+                                    batch.batch.get("position_ids")[preferences_mask]
+                                    if "position_ids" in batch.batch
+                                    else None
+                                )
+                                rejected_position_ids = (
+                                    batch.batch.get("position_ids")[not_preferences_mask]
+                                    if "position_ids" in batch.batch
+                                    else None
+                                )
+
+                                # Create Labels
+                                print("WARNING: Creating DPO labels using configured max_prompt_length...")
+                                prompt_len = self.config.data.max_prompt_length
+                                chosen_labels = chosen_input_ids.clone()
+                                chosen_labels[:, :prompt_len] = -100
+                                rejected_labels = rejected_input_ids.clone()
+                                rejected_labels[:, :prompt_len] = -100
+
+                                # Calculate and Gather Reference Log Probs (Sequence Level)
+                                if self.use_reference_policy:
+                                    ref_log_prob_tensor = batch.batch["ref_log_prob"]  # Token level [bsz * n, seq_len]
+                                    response_mask_full = batch.batch[
+                                        "response_mask"
+                                    ]  # Response mask [bsz * n, seq_len]
+                                    ref_sequence_logps = (ref_log_prob_tensor * response_mask_full).sum(
+                                        dim=-1
+                                    )  # Sequence level [bsz * n]
+                                    reference_chosen_logps = ref_sequence_logps[preferences_mask]
+                                    reference_rejected_logps = ref_sequence_logps[not_preferences_mask]
+                                else:
+                                    # If not using external ref, DPO needs ActorAsRef logic in dp_actor
+                                    # We won't add the keys here, dp_actor will handle it (or fail if not modified)
+                                    print(
+                                        "Info: Not adding explicit reference logps to DPO batch "
+                                        "(use_reference_policy=False)."
+                                    )
+                                    reference_chosen_logps = None  # Explicitly None
+                                    reference_rejected_logps = None
+
+                                # Package Tensors
+                                dpo_tensors = {
+                                    "chosen_input_ids": chosen_input_ids,
+                                    "chosen_attention_mask": chosen_attention_mask,
+                                    "chosen_labels": chosen_labels,
+                                    "rejected_input_ids": rejected_input_ids,
+                                    "rejected_attention_mask": rejected_attention_mask,
+                                    "rejected_labels": rejected_labels,
+                                }
+                                # Conditionally add reference logps if computed
+                                if reference_chosen_logps is not None:
+                                    dpo_tensors["reference_chosen_logps"] = reference_chosen_logps
+                                if reference_rejected_logps is not None:
+                                    dpo_tensors["reference_rejected_logps"] = reference_rejected_logps
+                                # Add position ids if they exist
+                                if chosen_position_ids is not None:
+                                    dpo_tensors["chosen_position_ids"] = chosen_position_ids
+                                if rejected_position_ids is not None:
+                                    dpo_tensors["rejected_position_ids"] = rejected_position_ids
+
+                                # Prepare Meta Info
+                                dpo_meta = {
+                                    "dpo_beta": OmegaConf.select(self.config.algorithm, "dpo_beta", default=0.1),
+                                    "dpo_loss_type": OmegaConf.select(
+                                        self.config.algorithm, "dpo_loss_type", default="sigmoid"
+                                    ),
+                                    "dpo_label_smoothing": OmegaConf.select(
+                                        self.config.algorithm, "dpo_label_smoothing", default=0.0
+                                    ),
+                                    "use_reference_policy": self.use_reference_policy,
+                                    "reference_free": not self.use_reference_policy,  # False if using external ref
+                                    "global_step": self.global_steps,
+                                }
+
+                                dpo_update_batch_proto = DataProto.from_dict(tensors=dpo_tensors, meta_info=dpo_meta)
+                                # print(f"---- [Step {self.global_steps}] DEBUG DPO: Prepared DPO Update Batch ----")
+                                # print(f"  Keys: {list(dpo_update_batch_proto.batch.keys())}")
+                                # print(f"  Meta Info: {dpo_meta}")
+
+                            except Exception as e_prep:
+                                print(f"ERROR preparing DPO batch at step {self.global_steps}: {e_prep}")
+                                traceback.print_exc()
+                                dpo_update_batch_proto = None  # Skip update on error
+
+                        # --- Actor Update Step ---
+                        actor_output = None
+                        if self.config.trainer.critic_warmup <= self.global_steps and dpo_update_batch_proto:
+                            with _timer("update_actor", timing_raw):
+                                # Pass the batch containing reference log probs (if computed)
+                                # The modified update_actor_dpo expects them if reference_free=False
+                                actor_output = self.actor_rollout_wg.update_actor_dpo(dpo_update_batch_proto)
+                            if actor_output and "metrics" in actor_output.meta_info:
+                                metrics.update(reduce_metrics(actor_output.meta_info["metrics"]))
+                        elif dpo_update_batch_proto is None:
+                            print(
+                                f"Skipping actor update at step {self.global_steps} due to DPO batch preparation error."
+                            )
+
+                        # --- Validation and Saving ---
+                        test_freq = OmegaConf.select(self.config.trainer, "test_freq", default=-1)
+                        is_last_step = self.global_steps >= self.total_training_steps
+                        if (
+                            self.val_reward_fn is not None
+                            and test_freq > 0
+                            and (is_last_step or self.global_steps % test_freq == 0)
+                        ):
+                            print(f"\nRunning DPO validation at step {self.global_steps}...")
+                            val_timing_raw = {}
+                            with _timer("testing", val_timing_raw):
+                                val_metrics: dict = self._validate()
+                            if is_last_step:
+                                last_val_metrics = val_metrics
+                            if val_metrics:
+                                metrics["time/validation_run"] = val_timing_raw.get("testing", 0)
+                                metrics.update(val_metrics)
+                            else:
+                                print("Validation skipped or returned no metrics.")
+
+                        save_freq = OmegaConf.select(self.config.trainer, "save_freq", default=-1)
+                        if save_freq > 0 and (is_last_step or self.global_steps % save_freq == 0):
+                            print(f"\nSaving DPO checkpoint at step {self.global_steps}...")
+                            with _timer("save_checkpoint", timing_raw):
+                                self._save_checkpoint()  # Saves actor (and potentially critic if used elsewhere)
+                            metrics["time/save_checkpoint"] = timing_raw.get("save_checkpoint", 0)
+
+                    # --- End main step timer context ---
+
+                    # --- Metrics calculation AFTER the 'step' timer block ---
+                    metrics.update(compute_dpo_data_metrics(batch=batch))  # Use DPO-specific metrics
+                    metrics.update(compute_timing_metrics(batch=batch, timing_raw=timing_raw))
+                    n_gpus = self.resource_pool_manager.get_n_gpus()
+                    if "step" in timing_raw:
+                        metrics.update(compute_throughout_metrics(batch=batch, timing_raw=timing_raw, n_gpus=n_gpus))
+                    else:
+                        print(
+                            f"Warning: 'step' key missing from timing_raw at step {self.global_steps}. "
+                            f"Skipping throughput."
+                        )
+
+                    step_timer.stop()
+                    metrics["time/step"] = step_timer.last
+
+                    # Log metrics
+                    log_freq = OmegaConf.select(self.config.trainer, "log_freq", default=1)
+                    if logger and self.global_steps % log_freq == 0:
+                        log_payload = metrics.copy()
+                        # Add learning rate to log payload
+                        if actor_output and "actor/lr" in metrics:
+                            log_payload["actor/lr"] = metrics["actor/lr"]
+
+                        print(f"[Step {self.global_steps} DPO] Logging Step Payload Keys: {list(log_payload.keys())}")
+                        try:
+                            logger.log(data=log_payload, step=self.global_steps)
+                        except Exception as e:
+                            print(f"Logging failed at step {self.global_steps}: {e}")
+
+                    # Update progress bar
+                    postfix_metrics = {
+                        k: f"{v:.3f}" if isinstance(v, float) else v
+                        for k, v in metrics.items()
+                        if isinstance(v, int | float)
+                    }
+                    progress_bar.set_postfix(postfix_metrics)
+
+                except Exception as step_e:
+                    print(f"\n!!!!!!!! ERROR DURING DPO Step {self.global_steps} !!!!!!!!")
+                    print(f"Caught Exception: {step_e}")
+                    traceback.print_exc()
+                    print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+                    step_timer.stop()
+                    should_stop = True
+                    break
+
+                if is_last_step or should_stop:
+                    print(f"Stopping DPO training at step {self.global_steps}.")
+                    break
+
+                self.global_steps += 1
+                progress_bar.update(1)
+
+            # End of epoch handling
+            if hasattr(self.train_dataloader, "reset"):
+                try:
+                    self.train_dataloader.reset()
+                except Exception as e:
+                    print(f"Warning: Failed to reset train dataloader state: {e}")
+            if should_stop:
+                break
+
+        # --- Final cleanup and logging ---
+        progress_bar.close()
+        final_step = max(0, self.global_steps - 1)
+        print(f"Online DPO Training finished at step {final_step}.")
+        # Save final checkpoint
+        save_freq = OmegaConf.select(self.config.trainer, "save_freq", default=-1)
+        if not self.config.trainer.get("val_only", False) and (save_freq <= 0 or final_step % save_freq != 0):
+            print(f"Saving final DPO checkpoint at step {final_step}...")
+            self._save_checkpoint()
+
+        # Final validation run
+        if self.val_reward_fn and last_val_metrics is None and not self.config.trainer.get("val_only", False):
+            print("Running final validation...")
+            last_val_metrics = self._validate()
+            if last_val_metrics and logger:
+                last_val_metrics["final_validation"] = True
+                try:
+                    logger.log(data=last_val_metrics, step=final_step)
+                except Exception as e:
+                    print(f"[Final Val Metrics Log Error]: {e}")
+
+        pprint(f"Final validation metrics: {last_val_metrics}")
+        if logger and hasattr(logger, "finish"):
+            logger.finish()
+        print("Online DPO Training Run Complete.")