├── .gitignore ├── GRPO-Loss-Analysis.ipynb ├── GRPO-Loss-Pytorch.ipynb ├── LICENSE └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | ##### Project Specification ##### 2 | output/ 3 | outputs/ 4 | wandb/ 5 | BIG-bench/ 6 | 7 | ##### Python.gitignore ##### 8 | # Byte-compiled / optimized / DLL files 9 | __pycache__/ 10 | *.py[cod] 11 | *$py.class 12 | 13 | # C extensions 14 | *.so 15 | 16 | # Distribution / packaging 17 | .Python 18 | build/ 19 | develop-eggs/ 20 | dist/ 21 | downloads/ 22 | eggs/ 23 | .eggs/ 24 | lib/ 25 | lib64/ 26 | parts/ 27 | sdist/ 28 | var/ 29 | wheels/ 30 | wheelhouse/ 31 | share/python-wheels/ 32 | *.egg-info/ 33 | .installed.cfg 34 | *.egg 35 | MANIFEST 36 | *.whl 37 | 38 | # PyInstaller 39 | # Usually these files are written by a python script from a template 40 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 41 | *.manifest 42 | *.spec 43 | 44 | # Installer logs 45 | pip-log.txt 46 | pip-delete-this-directory.txt 47 | 48 | # Unit test / coverage reports 49 | htmlcov/ 50 | .tox/ 51 | .nox/ 52 | .coverage 53 | .coverage.* 54 | .cache 55 | nosetests.xml 56 | coverage.xml 57 | *.cover 58 | *.py,cover 59 | .hypothesis/ 60 | .pytest_cache/ 61 | cover/ 62 | 63 | # Translations 64 | *.mo 65 | *.pot 66 | 67 | # Django stuff: 68 | *.log 69 | local_settings.py 70 | db.sqlite3 71 | db.sqlite3-journal 72 | 73 | # Flask stuff: 74 | instance/ 75 | .webassets-cache 76 | 77 | # Scrapy stuff: 78 | .scrapy 79 | 80 | # Sphinx documentation 81 | docs/_build/ 82 | docs/build/ 83 | docs/source/_build/ 84 | 85 | # PyBuilder 86 | .pybuilder/ 87 | target/ 88 | 89 | # Jupyter Notebook 90 | .ipynb_checkpoints 91 | 92 | # IPython 93 | profile_default/ 94 | ipython_config.py 95 | 96 | # pyenv 97 | # For a library or package, you might want to ignore these files since the code is 98 | # intended to run in multiple environments; otherwise, check them in: 99 | .python-version 100 | 101 | # pipenv 102 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 103 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 104 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 105 | # install all needed dependencies. 106 | #Pipfile.lock 107 | 108 | # poetry 109 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 110 | # This is especially recommended for binary packages to ensure reproducibility, and is more 111 | # commonly ignored for libraries. 112 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 113 | #poetry.lock 114 | 115 | # pdm 116 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. 117 | #pdm.lock 118 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it 119 | # in version control. 120 | # https://pdm.fming.dev/#use-with-ide 121 | .pdm.toml 122 | 123 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm 124 | __pypackages__/ 125 | 126 | # Celery stuff 127 | celerybeat-schedule 128 | celerybeat.pid 129 | 130 | # SageMath parsed files 131 | *.sage.py 132 | 133 | # Environments 134 | .env 135 | .venv 136 | env/ 137 | venv/ 138 | ENV/ 139 | env.bak/ 140 | venv.bak/ 141 | 142 | # Spyder project settings 143 | .spyderproject 144 | .spyproject 145 | 146 | # Rope project settings 147 | .ropeproject 148 | 149 | # mkdocs documentation 150 | /site 151 | 152 | # ruff 153 | .ruff_cache/ 154 | 155 | # mypy 156 | .mypy_cache/ 157 | .dmypy.json 158 | dmypy.json 159 | 160 | # Pyre type checker 161 | .pyre/ 162 | 163 | # pytype static type analyzer 164 | .pytype/ 165 | 166 | # Cython debug symbols 167 | cython_debug/ 168 | 169 | # PyCharm 170 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can 171 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 172 | # and can be added to the global gitignore or merged into this file. For a more nuclear 173 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 174 | .idea/ 175 | 176 | 177 | ##### macOS.gitignore ##### 178 | # General 179 | .DS_Store 180 | .AppleDouble 181 | .LSOverride 182 | 183 | # Icon must end with two \r 184 | Icon 185 | 186 | # Thumbnails 187 | ._* 188 | 189 | # Files that might appear in the root of a volume 190 | .DocumentRevisions-V100 191 | .fseventsd 192 | .Spotlight-V100 193 | .TemporaryItems 194 | .Trashes 195 | .VolumeIcon.icns 196 | .com.apple.timemachine.donotpresent 197 | 198 | # Directories potentially created on remote AFP share 199 | .AppleDB 200 | .AppleDesktop 201 | Network Trash Folder 202 | Temporary Items 203 | .apdisk 204 | 205 | 206 | ##### Linux.gitignore ##### 207 | *~ 208 | 209 | # Temporary files which can be created if a process still has a handle open of a deleted file 210 | .fuse_hidden* 211 | 212 | # KDE directory preferences 213 | .directory 214 | 215 | # Linux trash folder which might appear on any partition or disk 216 | .Trash-* 217 | 218 | # .nfs files are created when an open file is removed but is still being accessed 219 | .nfs* 220 | 221 | 222 | ##### Windows.gitignore ##### 223 | # Windows thumbnail cache files 224 | Thumbs.db 225 | Thumbs.db:encryptable 226 | ehthumbs.db 227 | ehthumbs_vista.db 228 | 229 | # Dump file 230 | *.stackdump 231 | 232 | # Folder config file 233 | [Dd]esktop.ini 234 | 235 | # Recycle Bin used on file shares 236 | $RECYCLE.BIN/ 237 | 238 | # Windows Installer files 239 | *.cab 240 | *.msi 241 | *.msix 242 | *.msm 243 | *.msp 244 | 245 | # Windows shortcuts 246 | *.lnk 247 | 248 | 249 | ##### Archives.gitignore ##### 250 | # It's better to unpack these files and commit the raw source because 251 | # git has its own built in compression methods. 252 | *.7z 253 | *.jar 254 | *.rar 255 | *.zip 256 | *.gz 257 | *.gzip 258 | *.tgz 259 | *.bzip 260 | *.bzip2 261 | *.bz2 262 | *.xz 263 | *.lzma 264 | *.cab 265 | *.xar 266 | 267 | # Packing-only formats 268 | *.iso 269 | *.tar 270 | 271 | # Package management formats 272 | *.dmg 273 | *.xpi 274 | *.gem 275 | *.egg 276 | *.deb 277 | *.rpm 278 | *.msi 279 | *.msm 280 | *.msp 281 | *.txz 282 | 283 | 284 | ##### Xcode.gitignore ##### 285 | # Xcode 286 | # 287 | # gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore 288 | 289 | ## User settings 290 | xcuserdata/ 291 | 292 | ## Compatibility with Xcode 8 and earlier (ignoring not required starting Xcode 9) 293 | *.xcscmblueprint 294 | *.xccheckout 295 | 296 | ## Compatibility with Xcode 3 and earlier (ignoring not required starting Xcode 4) 297 | build/ 298 | DerivedData/ 299 | *.moved-aside 300 | *.pbxuser 301 | !default.pbxuser 302 | *.mode1v3 303 | !default.mode1v3 304 | *.mode2v3 305 | !default.mode2v3 306 | *.perspectivev3 307 | !default.perspectivev3 308 | 309 | ## Gcc Patch 310 | /*.gcno 311 | 312 | 313 | ##### JetBrains.gitignore ##### 314 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm 315 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 316 | 317 | # User settings 318 | .idea/* 319 | 320 | # User-specific stuff 321 | .idea/**/workspace.xml 322 | .idea/**/tasks.xml 323 | .idea/**/usage.statistics.xml 324 | .idea/**/dictionaries 325 | .idea/**/shelf 326 | 327 | # Generated files 328 | .idea/**/contentModel.xml 329 | 330 | # Sensitive or high-churn files 331 | .idea/**/dataSources/ 332 | .idea/**/dataSources.ids 333 | .idea/**/dataSources.local.xml 334 | .idea/**/sqlDataSources.xml 335 | .idea/**/dynamic.xml 336 | .idea/**/uiDesigner.xml 337 | .idea/**/dbnavigator.xml 338 | 339 | # Gradle 340 | .idea/**/gradle.xml 341 | .idea/**/libraries 342 | 343 | # Gradle and Maven with auto-import 344 | # When using Gradle or Maven with auto-import, you should exclude module files, 345 | # since they will be recreated, and may cause churn. Uncomment if using 346 | # auto-import. 347 | # .idea/artifacts 348 | # .idea/compiler.xml 349 | # .idea/jarRepositories.xml 350 | # .idea/modules.xml 351 | # .idea/*.iml 352 | # .idea/modules 353 | # *.iml 354 | # *.ipr 355 | 356 | # CMake 357 | cmake-build-*/ 358 | 359 | # Mongo Explorer plugin 360 | .idea/**/mongoSettings.xml 361 | 362 | # File-based project format 363 | *.iws 364 | 365 | # IntelliJ 366 | out/ 367 | 368 | # mpeltonen/sbt-idea plugin 369 | .idea_modules/ 370 | 371 | # JIRA plugin 372 | atlassian-ide-plugin.xml 373 | 374 | # Cursive Clojure plugin 375 | .idea/replstate.xml 376 | 377 | # Crashlytics plugin (for Android Studio and IntelliJ) 378 | com_crashlytics_export_strings.xml 379 | crashlytics.properties 380 | crashlytics-build.properties 381 | fabric.properties 382 | 383 | # Editor-based Rest Client 384 | .idea/httpRequests 385 | 386 | # Android studio 3.1+ serialized cache file 387 | .idea/caches/build_file_checksums.ser 388 | 389 | 390 | ##### VisualStudioCode.gitignore ##### 391 | .vscode/* 392 | # !.vscode/settings.json 393 | # !.vscode/tasks.json 394 | # !.vscode/launch.json 395 | !.vscode/extensions.json 396 | *.code-workspace 397 | 398 | # Local History for Visual Studio Code 399 | .history/ 400 | 401 | 402 | ##### Vim.gitignore ##### 403 | # Swap 404 | .*.s[a-v][a-z] 405 | !*.svg # comment out if you don't need vector files 406 | .*.sw[a-p] 407 | .s[a-rt-v][a-z] 408 | .ss[a-gi-z] 409 | .sw[a-p] 410 | 411 | # Session 412 | Session.vim 413 | Sessionx.vim 414 | 415 | # Temporary 416 | .netrwhist 417 | *~ 418 | # Auto-generated tag files 419 | tags 420 | # Persistent undo 421 | [._]*.un~ 422 | -------------------------------------------------------------------------------- /GRPO-Loss-Analysis.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "d922cdc2-7da0-409a-9840-40e6b71b57ee", 6 | "metadata": {}, 7 | "source": [ 8 | "# Why GRPO Loss is negative and ascend?" 9 | ] 10 | }, 11 | { 12 | "cell_type": "code", 13 | "execution_count": 1, 14 | "id": "c053c97b-da27-49bc-9e98-f3fd05f74efc", 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "import torch\n", 19 | "import torch.nn as nn\n", 20 | "import torch.nn.functional as F" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "id": "cc33f0ff-bcc9-4b26-b57e-85cdba08a2ec", 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "# GRPO-KL always > 0\n", 31 | "def grpo_kl(pi_logprob, pi_ref_logprob):\n", 32 | " return pi_ref_logprob.exp() / pi_logprob.exp()- (pi_ref_logprob - pi_logprob) - 1" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 3, 38 | "id": "2e9df2eb-f389-49fd-9012-c7ee200d3e18", 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "def grpo_advantage(rewards):\n", 43 | " epsilon = 0.00001\n", 44 | " A = (rewards - rewards.mean()) / (rewards.std() + epsilon)\n", 45 | " return A" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "id": "259838e0-ca85-424d-8f2c-dcf166f8f9a7", 51 | "metadata": {}, 52 | "source": [ 53 | "## Why GRPO Loss is Negative" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "id": "0e53d9b0-58f3-49fe-b62c-65ea85816511", 59 | "metadata": {}, 60 | "source": [ 61 | "1. we only calculative `min(ration * Advantage)-kl`\n", 62 | "\n", 63 | "\\begin{equation}\n", 64 | "\\begin{aligned}\n", 65 | "\\mathcal{L}_{\\text{GRPO}}(\\theta) \n", 66 | "= & \\textcolor{red}{-} \\frac{1}{G} \\sum_{i=1}^G \\frac{1}{|o_i|} \\sum_{t=1}^{|o_i|} \\Biggl[ \n", 67 | " \\textcolor{blue}{\\min} \\Biggl( \n", 68 | " \\frac{\\pi_\\theta(o_{i,t} \\mid q, o_{i, 0\n", 135 | "pi_logprob = torch.tensor(0.5).log()\n", 136 | "pi_old_logprob = torch.tensor(0.5).log()\n", 137 | "pi_ref_logprob = torch.tensor(0.6).log()\n", 138 | "rewards_group = torch.tensor([1, 0, 0, 0, 0, 0, 0, 0], dtype = torch.float32)\n", 139 | "\n", 140 | "loss = minimal_grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, rewards_group)\n", 141 | "loss.sum()" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "id": "d7b7ca34-d87d-4880-b031-fef5e8b581b1", 147 | "metadata": {}, 148 | "source": [ 149 | "## loss negative -> positive" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": 12, 155 | "id": "8ccc557c-34ba-4216-91bd-d7513062504e", 156 | "metadata": {}, 157 | "outputs": [ 158 | { 159 | "name": "stdout", 160 | "output_type": "stream", 161 | "text": [ 162 | "[Rewards] : tensor([1., 0., 0., 0., 0., 0., 0., 0.])\n", 163 | "[Adv] : tensor([ 2.4748, -0.3535, -0.3535, -0.3535, -0.3535, -0.3535, -0.3535, -0.3535])\n", 164 | "[Loss] : tensor([-49.4961, 7.0709, 7.0709, 7.0709, 7.0709, 7.0709, 7.0709,\n", 165 | " 7.0709])\n", 166 | "tensor(-1.9073e-06)\n", 167 | "[Rewards] : tensor([1., 1., 0., 0., 0., 0., 0., 0.])\n", 168 | "[Adv] : tensor([ 1.6202, 1.6202, -0.5401, -0.5401, -0.5401, -0.5401, -0.5401, -0.5401])\n", 169 | "[Loss] : tensor([-32.4030, -32.4030, 10.8010, 10.8010, 10.8010, 10.8010, 10.8010,\n", 170 | " 10.8010])\n", 171 | "tensor(9.5367e-06)\n" 172 | ] 173 | } 174 | ], 175 | "source": [ 176 | "# ratio * A > KL , loss < 0\n", 177 | "pi_logprob = torch.tensor(0.1).log()\n", 178 | "pi_old_logprob = torch.tensor(0.005).log()\n", 179 | "pi_ref_logprob = torch.tensor(0.1001).log()\n", 180 | "\n", 181 | "# one positive reward\n", 182 | "rewards_group = torch.tensor([1, 0, 0, 0, 0, 0, 0, 0], dtype = torch.float32)\n", 183 | "loss = minimal_grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, rewards_group)\n", 184 | "print(loss.sum())\n", 185 | "\n", 186 | "# two positive reward\n", 187 | "rewards_group = torch.tensor([1, 1, 0, 0, 0, 0, 0, 0], dtype = torch.float32)\n", 188 | "loss = minimal_grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, rewards_group)\n", 189 | "print(loss.sum())" 190 | ] 191 | }, 192 | { 193 | "cell_type": "markdown", 194 | "id": "96d5bb1b-3970-42df-848f-46d86d9eec26", 195 | "metadata": {}, 196 | "source": [ 197 | "# Loss Rising" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "id": "559a9cdf-ac2d-4cfe-8ffd-44368969a468", 203 | "metadata": {}, 204 | "source": [ 205 | "## rewards change" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 13, 211 | "id": "0f0a6ac5-588e-4e66-b13d-1e593ee84fbe", 212 | "metadata": {}, 213 | "outputs": [ 214 | { 215 | "name": "stdout", 216 | "output_type": "stream", 217 | "text": [ 218 | "[Rewards] : tensor([1., 0., 0., 0., 0., 0., 0., 0.])\n", 219 | "[Adv] : tensor([ 2.4748, -0.3535, -0.3535, -0.3535, -0.3535, -0.3535, -0.3535, -0.3535])\n", 220 | "[Loss] : tensor([-3.2997, 0.4714, 0.4714, 0.4714, 0.4714, 0.4714, 0.4714, 0.4714])\n", 221 | "result: 1.0 tensor(0.) \n", 222 | "\n", 223 | "[Rewards] : tensor([1., 1., 1., 1., 0., 0., 0., 0.])\n", 224 | "[Adv] : tensor([ 0.9354, 0.9354, 0.9354, 0.9354, -0.9354, -0.9354, -0.9354, -0.9354])\n", 225 | "[Loss] : tensor([-1.2472, -1.2472, -1.2472, -1.2472, 1.2472, 1.2472, 1.2472, 1.2472])\n", 226 | "result: 4.0 tensor(-2.3842e-07) \n", 227 | "\n", 228 | "[Rewards] : tensor([1., 1., 1., 1., 1., 1., 1., 0.])\n", 229 | "[Adv] : tensor([ 0.3535, 0.3535, 0.3535, 0.3535, 0.3535, 0.3535, 0.3535, -2.4748])\n", 230 | "[Loss] : tensor([-0.4714, -0.4714, -0.4714, -0.4714, -0.4714, -0.4714, -0.4714, 3.2997])\n", 231 | "result: 7.0 tensor(2.3842e-07) \n", 232 | "\n", 233 | "[Rewards] : tensor([1., 1., 1., 1., 1., 1., 1., 1.])\n", 234 | "[Adv] : tensor([0., 0., 0., 0., 0., 0., 0., 0.])\n", 235 | "[Loss] : tensor([3.0994e-08, 3.0994e-08, 3.0994e-08, 3.0994e-08, 3.0994e-08, 3.0994e-08,\n", 236 | " 3.0994e-08, 3.0994e-08])\n", 237 | "result: 8.0 tensor(2.4796e-07) \n", 238 | "\n" 239 | ] 240 | } 241 | ], 242 | "source": [ 243 | "pi_logprob = torch.tensor(0.4).log()\n", 244 | "pi_old_logprob = torch.tensor(0.3).log()\n", 245 | "pi_ref_logprob = torch.tensor(0.401).log()\n", 246 | "rewards_group = torch.tensor([1, 0, 0, 0, 0, 0, 0, 0], dtype = torch.float32) \n", 247 | "loss = minimal_grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, rewards_group)\n", 248 | "print('result:', rewards_group.sum().item(), loss.sum(), '\\n')\n", 249 | "\n", 250 | "rewards_group = torch.tensor([1, 1, 1, 1, 0, 0, 0, 0], dtype = torch.float32) \n", 251 | "loss = minimal_grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, rewards_group)\n", 252 | "print('result:', rewards_group.sum().item(), loss.sum(), '\\n')\n", 253 | "\n", 254 | "rewards_group = torch.tensor([1, 1, 1, 1, 1, 1, 1, 0], dtype = torch.float32) \n", 255 | "loss = minimal_grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, rewards_group)\n", 256 | "print('result:', rewards_group.sum().item(), loss.sum(), '\\n')\n", 257 | "\n", 258 | "rewards_group = torch.tensor([1, 1, 1, 1, 1, 1, 1, 1], dtype = torch.float32) \n", 259 | "loss = minimal_grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, rewards_group)\n", 260 | "print('result:', rewards_group.sum().item(), loss.sum(), '\\n')" 261 | ] 262 | }, 263 | { 264 | "cell_type": "markdown", 265 | "id": "8b0888bb-59b1-462b-8cd6-ac755bd8853d", 266 | "metadata": {}, 267 | "source": [ 268 | "## policy change" 269 | ] 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": 37, 274 | "id": "e6702b26-71fb-4425-ad78-9d21e6e318a0", 275 | "metadata": {}, 276 | "outputs": [ 277 | { 278 | "name": "stdout", 279 | "output_type": "stream", 280 | "text": [ 281 | "[Rewards] : tensor([1., 1., 0., 0., 0., 0., 0., 0.])\n", 282 | "[Adv] : tensor([ 1.6202, 1.6202, -0.5401, -0.5401, -0.5401, -0.5401, -0.5401, -0.5401])\n", 283 | "[Loss] : tensor([-1.6202, -1.6202, 0.5401, 0.5401, 0.5401, 0.5401, 0.5401, 0.5401])\n", 284 | "result: 2.0 tensor(1.1921e-07) \n", 285 | "\n", 286 | "[Rewards] : tensor([1., 1., 0., 0., 0., 0., 0., 0.])\n", 287 | "[Adv] : tensor([ 1.6202, 1.6202, -0.5401, -0.5401, -0.5401, -0.5401, -0.5401, -0.5401])\n", 288 | "[Loss] : tensor([-1.6197, -1.6197, 0.5405, 0.5405, 0.5405, 0.5405, 0.5405, 0.5405])\n", 289 | "result: 2.0 tensor(0.0037) \n", 290 | "\n", 291 | "[Rewards] : tensor([1., 1., 0., 0., 0., 0., 0., 0.])\n", 292 | "[Adv] : tensor([ 1.6202, 1.6202, -0.5401, -0.5401, -0.5401, -0.5401, -0.5401, -0.5401])\n", 293 | "[Loss] : tensor([-1.6039, -1.6039, 0.5563, 0.5563, 0.5563, 0.5563, 0.5563, 0.5563])\n", 294 | "result: 2.0 tensor(0.1297) \n", 295 | "\n" 296 | ] 297 | } 298 | ], 299 | "source": [ 300 | "pi_logprob = torch.tensor(0.4).log()\n", 301 | "pi_old_logprob = torch.tensor(0.4).log()\n", 302 | "pi_ref_logprob = torch.tensor(0.401).log()\n", 303 | "rewards_group = torch.tensor([1, 1, 0, 0, 0, 0, 0, 0], dtype = torch.float32) \n", 304 | "loss = minimal_grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, rewards_group)\n", 305 | "print('result:', rewards_group.sum().item(), loss.sum(), '\\n')\n", 306 | "\n", 307 | "\n", 308 | "pi_logprob = torch.tensor(0.3).log()\n", 309 | "pi_old_logprob = torch.tensor(0.3).log()\n", 310 | "pi_ref_logprob = torch.tensor(0.401).log()\n", 311 | "rewards_group = torch.tensor([1, 1, 0, 0, 0, 0, 0, 0], dtype = torch.float32) \n", 312 | "loss = minimal_grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, rewards_group)\n", 313 | "print('result:', rewards_group.sum().item(), loss.sum(), '\\n')\n", 314 | "\n", 315 | "pi_logprob = torch.tensor(0.1).log()\n", 316 | "pi_old_logprob = torch.tensor(0.1).log()\n", 317 | "pi_ref_logprob = torch.tensor(0.401).log()\n", 318 | "rewards_group = torch.tensor([1, 1, 0, 0, 0, 0, 0, 0], dtype = torch.float32) \n", 319 | "loss = minimal_grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, rewards_group)\n", 320 | "print('result:', rewards_group.sum().item(), loss.sum(), '\\n')\n" 321 | ] 322 | }, 323 | { 324 | "cell_type": "markdown", 325 | "id": "2cb418a3-c7eb-419a-85fc-1b17e1c38a79", 326 | "metadata": {}, 327 | "source": [ 328 | "## loss curve with reward rising" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": 14, 334 | "id": "4dae4ad1-6221-4aec-beb0-26690c11f3e4", 335 | "metadata": {}, 336 | "outputs": [], 337 | "source": [ 338 | "pi_logprob = torch.tensor(0.1).log()\n", 339 | "pi_old_logprob = torch.tensor(0.005).log()\n", 340 | "pi_ref_logprob = torch.tensor(0.101).log()\n", 341 | "\n", 342 | "nums = 128\n", 343 | "rewards_group = torch.zeros(nums)\n", 344 | "loss_list = []\n", 345 | "for i in range(nums):\n", 346 | " rewards_group[i] = 1.0\n", 347 | " loss = minimal_grpo_loss(pi_logprob, \n", 348 | " pi_old_logprob, \n", 349 | " pi_ref_logprob, \n", 350 | " rewards_group, \n", 351 | " is_debug=False)\n", 352 | " loss_list.append(loss.sum().item())" 353 | ] 354 | }, 355 | { 356 | "cell_type": "code", 357 | "execution_count": 15, 358 | "id": "06727692-cd14-485f-8a7a-09d81844f69d", 359 | "metadata": {}, 360 | "outputs": [ 361 | { 362 | "data": { 363 | "image/png": "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", 364 | "text/plain": [ 365 | "
" 366 | ] 367 | }, 368 | "metadata": {}, 369 | "output_type": "display_data" 370 | } 371 | ], 372 | "source": [ 373 | "import matplotlib.pyplot as plt\n", 374 | "plt.figure(figsize=(16, 6)) \n", 375 | "plt.plot(loss_list)\n", 376 | "plt.title('grpo loss with rewards sum')\n", 377 | "plt.xlabel('reward sum')\n", 378 | "plt.ylabel('loss')\n", 379 | "plt.grid()\n", 380 | "plt.show()" 381 | ] 382 | } 383 | ], 384 | "metadata": { 385 | "kernelspec": { 386 | "display_name": "Python 3 (ipykernel)", 387 | "language": "python", 388 | "name": "python3" 389 | }, 390 | "language_info": { 391 | "codemirror_mode": { 392 | "name": "ipython", 393 | "version": 3 394 | }, 395 | "file_extension": ".py", 396 | "mimetype": "text/x-python", 397 | "name": "python", 398 | "nbconvert_exporter": "python", 399 | "pygments_lexer": "ipython3", 400 | "version": "3.11.11" 401 | } 402 | }, 403 | "nbformat": 4, 404 | "nbformat_minor": 5 405 | } 406 | -------------------------------------------------------------------------------- /GRPO-Loss-Pytorch.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "ba303ea0-7339-444f-a85a-4389873b5bf5", 6 | "metadata": {}, 7 | "source": [ 8 | "# GRPO-Loss-pytorch\n", 9 | "\n", 10 | "author: xiaodongguaAIGC\n", 11 | "\n", 12 | "git: [dhcode-cpp](https://github.com/dhcode-cpp)\n", 13 | "\n", 14 | "blog: [【手撕LLM-GRPO】你只管给Reward, 剩下的交给RL（附代码）](https://zhuanlan.zhihu.com/p/20812786520)" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 2, 20 | "id": "37d15458-8a27-4baf-afc7-6b6187013547", 21 | "metadata": {}, 22 | "outputs": [], 23 | "source": [ 24 | "import torch\n", 25 | "import torch.nn.functional as F" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "id": "b0531f35-3559-4c4f-9225-4fdc20a647e7", 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "def grpo_kl(pi_logprob, pi_ref_logprob):\n", 36 | " return pi_ref_logprob.exp() / pi_logprob.exp()- (pi_ref_logprob - pi_logprob) - 1" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 3, 42 | "id": "74242e19-4f3c-4a58-9413-cc3d6f1863db", 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [ 46 | "def grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, advantage, input_len, len_oi):\n", 47 | " epsilon = 0.2\n", 48 | " beta = 0.01\n", 49 | "\n", 50 | " bs, seq_len = pi_logprob.shape\n", 51 | " # skip计算采样的每条采样长度\n", 52 | " len_oi = torch.tensor([len_oi] * bs, dtype = torch.long)\n", 53 | " # 设定mask, 仅对response 为 1， 算loss\n", 54 | " mask = torch.zeros(bs, seq_len)\n", 55 | " mask[:, input_len:] = 1\n", 56 | "\n", 57 | " # GRPO loss\n", 58 | " ratio = torch.exp(pi_logprob - pi_old_logprob)\n", 59 | " ratio_clip = torch.clamp(ratio, 1 - epsilon, 1 + epsilon)\n", 60 | " advantage = advantage.unsqueeze(dim = 1) # [a, b ,c] -> [[a], [b], [c]]\n", 61 | " policy_gradient = torch.minimum(ratio * advantage , ratio_clip * advantage)\n", 62 | " kl = grpo_kl(pi_logprob, pi_ref_logprob)\n", 63 | "\n", 64 | " loss = (policy_gradient - beta * kl) * mask\n", 65 | " loss = (-1 / bs ) * (1/len_oi.unsqueeze(dim = 1)) * loss \n", 66 | " loss = loss.sum()\n", 67 | "\n", 68 | " return loss" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 4, 74 | "id": "50164e56-71bf-4330-80e7-1e9606c47b18", 75 | "metadata": {}, 76 | "outputs": [ 77 | { 78 | "data": { 79 | "text/html": [ 80 | "
tensor(-0.4713)\n",
 81 |        "
\n" 82 | ], 83 | "text/plain": [ 84 | "\u001b[1;35mtensor\u001b[0m\u001b[1m(\u001b[0m\u001b[1;36m-0.4713\u001b[0m\u001b[1m)\u001b[0m\n" 85 | ] 86 | }, 87 | "metadata": {}, 88 | "output_type": "display_data" 89 | } 90 | ], 91 | "source": [ 92 | "# 输出分布\n", 93 | "pi_logits = torch.randn(3, 5, 32) # batch, seq_len, vocab_size\n", 94 | "pi_ref_logits = torch.randn(3, 5, 32)\n", 95 | "pi_old_logits = torch.randn(3, 5, 32)\n", 96 | "\n", 97 | "# 获取log prob\n", 98 | "pi_logprob = F.log_softmax(pi_logits, dim = -1)\n", 99 | "pi_ref_logprob = F.log_softmax(pi_ref_logits, dim = -1)\n", 100 | "pi_old_logprob = F.log_softmax(pi_old_logits, dim = -1)\n", 101 | "\n", 102 | "# group data\n", 103 | "token_ids = torch.tensor([[11, 12, 13, 14, 15], # 输入为11,12,13, 输出为:14, 15\n", 104 | " [11, 12, 13, 15, 16],\n", 105 | " [11, 12, 13, 16, 17],])\n", 106 | "\n", 107 | "# 获取policy\n", 108 | "pi_logprob = torch.gather(pi_logprob, dim=-1, index=token_ids.unsqueeze(-1)).squeeze(-1)\n", 109 | "pi_ref_logprob = torch.gather(pi_ref_logprob, dim=-1, index=token_ids.unsqueeze(-1)).squeeze(-1)\n", 110 | "pi_old_logprob = torch.gather(pi_old_logprob, dim=-1, index=token_ids.unsqueeze(-1)).squeeze(-1)\n", 111 | "loss = grpo_loss(pi_logprob, pi_old_logprob, pi_ref_logprob, torch.tensor([-1, 2, 1]), 3, 2)\n", 112 | "print(loss)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "id": "bf925213-e779-4155-b85d-fff71b4ec661", 118 | "metadata": {}, 119 | "source": [ 120 | "## Trl Implementation" 121 | ] 122 | }, 123 | { 124 | "cell_type": "markdown", 125 | "id": "3c4b0d89-6626-4e0e-99a2-57ce1f0f2544", 126 | "metadata": {}, 127 | "source": [ 128 | "- ppo clip ratio\n", 129 | "- grpo clip ratio\n", 130 | "- trl \"not\" clip ratio, it haven't minibatch, ` exp( logprob - logprob.detach()` always equal `1`" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 8, 136 | "id": "60b46980-106c-4fb0-9ca7-5f0fe18156ef", 137 | "metadata": {}, 138 | "outputs": [ 139 | { 140 | "data": { 141 | "text/html": [ 142 | "
tensor([1.])\n",
143 |        "
\n" 144 | ], 145 | "text/plain": [ 146 | "\u001b[1;35mtensor\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m1\u001b[0m.\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n" 147 | ] 148 | }, 149 | "metadata": {}, 150 | "output_type": "display_data" 151 | }, 152 | { 153 | "data": { 154 | "text/html": [ 155 | "
tensor([1.])\n",
156 |        "
\n" 157 | ], 158 | "text/plain": [ 159 | "\u001b[1;35mtensor\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m1\u001b[0m.\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n" 160 | ] 161 | }, 162 | "metadata": {}, 163 | "output_type": "display_data" 164 | } 165 | ], 166 | "source": [ 167 | "policy = torch.tensor([0.5])\n", 168 | "old_policy = torch.tensor([0.5])\n", 169 | "ratio = policy/old_policy\n", 170 | "print(ratio)\n", 171 | "\n", 172 | "ratio = torch.exp( policy.log() - old_policy.log())\n", 173 | "print(ratio)" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 9, 179 | "id": "1109e320-5872-4ba4-af99-05dee46d4a93", 180 | "metadata": {}, 181 | "outputs": [ 182 | { 183 | "data": { 184 | "text/html": [ 185 | "
tensor([0.4000])\n",
186 |        "
\n" 187 | ], 188 | "text/plain": [ 189 | "\u001b[1;35mtensor\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m0.4000\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n" 190 | ] 191 | }, 192 | "metadata": {}, 193 | "output_type": "display_data" 194 | } 195 | ], 196 | "source": [ 197 | "gradient = -0.2\n", 198 | "policy_gradient = - gradient * ( 1 / old_policy)\n", 199 | "print(policy_gradient)" 200 | ] 201 | } 202 | ], 203 | "metadata": { 204 | "kernelspec": { 205 | "display_name": "Python 3 (ipykernel)", 206 | "language": "python", 207 | "name": "python3" 208 | }, 209 | "language_info": { 210 | "codemirror_mode": { 211 | "name": "ipython", 212 | "version": 3 213 | }, 214 | "file_extension": ".py", 215 | "mimetype": "text/x-python", 216 | "name": "python", 217 | "nbconvert_exporter": "python", 218 | "pygments_lexer": "ipython3", 219 | "version": "3.11.9" 220 | } 221 | }, 222 | "nbformat": 4, 223 | "nbformat_minor": 5 224 | } 225 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2025 dhcode95 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # GRPO-Loss-Pytorch 2 | 3 | 代码节选自课程《手撕LLM》关键实现代码： 4 | 5 | blog: [【手撕LLM-GRPO】你只管给Reward, 剩下的交给RL（附代码）](https://zhuanlan.zhihu.com/p/20812786520) 6 | 7 | blog: [GRPO的Loss为什么会有负值？](https://zhuanlan.zhihu.com/p/28326620566) 8 | --------------------------------------------------------------------------------