Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,170 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+output
+tf-logs
+tmp/
+scripts_tmp/
+logs/*.log
+
+testing.ipynb

LICENSE

@@ -0,0 +1,201 @@
+                             Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+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.

README.md

@@ -0,0 +1,755 @@
+# Fine-tuning Qwen-VL Series
+
+This repository contains a script for training [Qwen2-VL](https://huggingface.co/Qwen/Qwen2-VL-7B-Instruct), [Qwen2.5-VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct)
+and [Qwen3-VL](https://huggingface.co/Qwen/Qwen3-VL-4B-Thinking) with only using HuggingFace and [Liger-Kernel](https://github.com/linkedin/Liger-Kernel).
+
+## Other projects
+
+**[[Phi3-Vision Finetuning]](https://github.com/2U1/Phi3-Vision-Finetune)**<br>
+**[[Llama3.2-Vision Finetuning]](https://github.com/2U1/Llama3.2-Vision-Ft)**<br>
+**[[Molmo Finetune]](https://github.com/2U1/Molmo-Finetune)**<br>
+**[[Pixtral Finetune]](https://github.com/2U1/Pixtral-Finetune)**<br>
+**[[SmolVLM Finetune]](https://github.com/2U1/SmolVLM-Finetune)**<br>
+**[[Gemma3 Finetune]](https://github.com/2U1/Gemma3-Finetune)**
+
+## Update
+
+- [2025/11/28] 🔥**Supports video training with DPO and GRPO.**
+- [2025/11/27] 🔥**Supports Qwen3-VL-MoE**
+- [2025/11/26] Update support for liger-kernel in Qwen3-VL.
+- [2025/10/16] 🔥**Supports Qwen3-VL(non-moe)**
+- [2025/08/21] Add option for using 2-layer mlp for classification.
+- [2025/08/21] Add option for unfreeze only few layers for llm and vision tower.
+- [2025/08/08] 🔥Monkey patch Qwen2.5-VL's window attention and forward for using less memory and speedups.
+- [2025/07/25] Updated Classification training script for experimental feature.
+- [2025/05/29] 🔥Supports GRPO training.
+- [2025/04/16] 🔥Supports DPO training.
+- [2025/03/04] Add Option for using liger kernel.
+- [2025/02/18] 🔥Supports mixed-modality dataset with zero3.
+- [2025/02/05] Fixed code for properly use image.
+- [2025/02/03] Support Liger-kernel for Qwen2.5-VL.
+- [2025/02/03] 🔥Supports Qwen2.5-VL.
+- [2025/01/24] Add option for using DoRA.
+- [2025/01/24] Fix error in LoRA training.
+- [2025/01/18] 🔥Supports mixed-modality data.
+- [2024/09/12] 🔥Now the model is trained using [Liger-Kernel](https://github.com/linkedin/Liger-Kernel).
+- [2024/09/11] Supports setting different learning rates to projector and vision model.
+- [2024/09/11] 🔥Supports multi-image and video training.
+
+## Table of Contents
+
+- [Fine-tuning Qwen-VL Series](#fine-tuning-qwen-vl-series)
+  - [Other projects](#other-projects)
+  - [Update](#update)
+  - [Table of Contents](#table-of-contents)
+  - [Supported Features](#supported-features)
+  - [Docker](#docker)
+  - [Installation](#installation)
+    - [Environments](#environments)
+    - [Using `requirements.txt`](#using-requirementstxt)
+    - [Using `environment.yaml`](#using-environmentyaml)
+  - [Dataset Preparation](#dataset-preparation)
+  - [Supervised Fine Tuning](#supervised-fine-tuning)
+    - [Full Finetuning](#full-finetuning)
+    - [Finetune with LoRA](#finetune-with-lora)
+    - [Train with video dataset](#train-with-video-dataset)
+      - [Image Resolution for vram usage](#image-resolution-for-vram-usage)
+      - [Merge LoRA Weights](#merge-lora-weights)
+    - [Evaluation during Training](#evaluation-during-training)
+      - [Step 1: Prepare Evaluation Dataset](#step-1-prepare-evaluation-dataset)
+      - [Step 2: Define compute\_metrics Function](#step-2-define-compute_metrics-function)
+      - [Step 3: Modify Training Script](#step-3-modify-training-script)
+      - [Step 4: Add Evaluation Arguments](#step-4-add-evaluation-arguments)
+  - [DPO Finetuning](#dpo-finetuning)
+  - [GRPO Finetuning](#grpo-finetuning)
+    - [Prerequisites](#prerequisites)
+  - [Classification Finetuning](#classification-finetuning)
+    - [⚠️This is an experimental feature.](#️this-is-an-experimental-feature)
+      - [Experimental Features](#experimental-features)
+  - [Inference](#inference)
+    - [Gradio Infernce (WebUI)](#gradio-infernce-webui)
+  - [Issue for libcudnn error](#issue-for-libcudnn-error)
+  - [TODO](#todo)
+  - [Known Issues](#known-issues)
+  - [License](#license)
+  - [Citation](#citation)
+  - [Acknowledgement](#acknowledgement)
+
+## Supported Features
+
+- Deepspeed
+- LoRA/QLoRA
+- Full-finetuning
+- Enable finetuning `vision_model` while using LoRA
+- Unfreeze only top-k layer
+- Disable/enable Flash Attention 2
+- Multi-image and video training
+- Training optimized with liger kernel
+- Mixed-modality dataset
+- Direct Preference Optimization (DPO)
+- Group Relative Policy Optimization (GRPO)
+
+## Docker
+
+To simplfy the setting process for training, you could use the provided pre-build environments.<br>
+The settings are done in the conda env named `train`.<br><br>
+You could find more information about the image [here](https://hub.docker.com/repository/docker/john119/vlm/general).
+
+```
+docker pull john119/vlm
+docker run --gpus all -it -v /host/path:/docker/path --name vlm --ipc=host john119/vlm /bin/bash
+```
+
+## Installation
+
+### Environments
+
+- Ubuntu 22.04
+- Nvidia-Driver 550.120
+- Cuda version 12.8
+
+Install the required packages using `environment.yaml`.
+
+### Using `requirements.txt`
+
+```bash
+pip install -r requirements.txt -f https://download.pytorch.org/whl/cu128
+pip install qwen-vl-utils
+pip install flash-attn --no-build-isolation
+```
+
+### Using `environment.yaml`
+
+```bash
+conda env create -f environment.yaml
+conda activate train
+pip install qwen-vl-utils
+pip install flash-attn --no-build-isolation
+```
+
+**Note:** You should install flash-attn after installing the other packages.
+
+## Dataset Preparation
+
+The script requires a dataset formatted according to the LLaVA specification. The dataset should be a JSON file where each entry contains information about conversations and images. Ensure that the image paths in the dataset match the provided `--image_folder`.<br>
+
+**When using a multi-image dataset, the image tokens should all be `<image>`, and the image file names should have been in a list.**<br><br>
+**Please see the example below and follow format your data.**
+
+<details>
+<summary>Example for single image dataset</summary>
+
+```json
+[
+  {
+    "id": "000000033471",
+    "image": "000000033471.jpg",
+    "conversations": [
+      {
+        "from": "human",
+        "value": "<image>\nWhat are the colors of the bus in the image?"
+      },
+      {
+        "from": "gpt",
+        "value": "The bus in the image is white and red."
+      },
+      {
+        "from": "human",
+        "value": "What feature can be seen on the back of the bus?"
+      },
+      {
+        "from": "gpt",
+        "value": "The back of the bus features an advertisement."
+      },
+      {
+        "from": "human",
+        "value": "Is the bus driving down the street or pulled off to the side?"
+      },
+      {
+        "from": "gpt",
+        "value": "The bus is driving down the street, which is crowded with people and other vehicles."
+      }
+    ]
+  }
+  ...
+]
+```
+
+</details>
+
+<details>
+<summary>Example for multi image dataset</summary>
+
+```json
+[
+  {
+    "id": "000000033471",
+    "image": ["000000033471.jpg", "000000033472.jpg"],
+    "conversations": [
+      {
+        "from": "human",
+        "value": "<image>\n<image>\nIs the perspective of the camera differnt?"
+      },
+      {
+        "from": "gpt",
+        "value": "Yes, It the perspective of the camera is different."
+      }
+    ]
+  }
+  ...
+]
+```
+
+</details>
+
+<details>
+<summary>Example for video dataset</summary>
+
+```json
+[
+  {
+    "id": "sample1",
+    "video": "sample1.mp4",
+    "conversations": [
+      {
+        "from": "human",
+        "value": "<video>\nWhat is going on in this video?"
+      },
+      {
+        "from": "gpt",
+        "value": "A man is walking down the road."
+      }
+    ]
+  }
+  ...
+]
+```
+
+</details>
+
+<details>
+<summary>Example for DPO dataet</summary>
+
+```json
+[
+  {
+    "id": "e4cd017f-3854-4019-9cc1-9dacacb5d424",
+    "image": "example_0_0.png",
+    "prompt": "<image>\nDescribe the key features of the image in great detail.",
+    "chosen": "The image features a modern, multi-colored train parked on a train track, occupying a significant portion of the scene. The train has a unique and striking design, with red, white, and blue colors, as well as yellow accents. It appears to be a high-speed train, indicating its advanced engineering and potential for fast travel.\n\nThe train is situated next to a platform, suggesting that it may be at a train station. The overall scene conveys a sense of transportation and modern technology, with the vibrant and sleek train as the main subject.",
+    "rejected": "The image features a modern, colorful train parked on a set of train tracks. The train has a striking design, with red, white, and blue colors as well as yellow accents. It appears to be a high-speed train, ready for departure.\n\nThe train spans a significant portion of the image, from the left to the right side. The train tracks can be seen clearly beneath the train, emphasizing its position on the railway line. The overall scene gives off an impression of a contemporary and efficient mode of transportation."
+  },
+  {
+    "id": "5e19e647-e5d3-4bcf-82e9-d262570743ae",
+    "image": "example_1_0.png",
+    "prompt": "<image>\nIs this bus in the USA?",
+    "chosen": "Yes, based on the image, it can be assumed that this bus is in the USA. The location of the bus cannot be accurately determined.",
+    "rejected": "No, it's not in the USA. The image does not provide specific information on where the bus is located. However, we can say that it's not in the United States."
+  }
+  ...
+]
+```
+
+</details>
+
+<details>
+<summary>Example for GRPO dataset</summary>
+
+```json
+[
+  {
+    "id": "06bc8a17-bb1c-4007-8c08-92c41e2628b2",
+    "image": "image_2.jpg",
+    "conversations": [
+      {
+        "from": "human",
+        "value": "<image>\nBased on the image, which geometric method is used to determine the bearing angle, and why is it the most appropriate choice?"
+      },
+      {
+        "from": "gpt",
+        "value": "<think>Let's analyze the image step-by-step. The image shows a right-angled triangle with points B, C, and A. The angle at point B is a right angle, indicating that trigonometric functions can be applied. To find the bearing angle, we need to relate the sides of the triangle. The tangent function is suitable here because it relates the opposite side (BC) to the adjacent side (AB) in a right-angled triangle. By using the tangent function, we can calculate the angle at point A, which is the bearing angle. Therefore, the most appropriate geometric method is the use of trigonometric functions.</think>\n\n<answer>A</answer>"
+      }
+    ]
+  }
+  ...
+]
+```
+
+</details>
+
+<br><br>
+
+Adding the new domain-specific data on top of the general data from open-source data will enhance downstream capabilities while retaining the foundational skills. Of course, you can also choose to fine-tune solely on the new data based on your requirements.
+
+## Supervised Fine Tuning
+
+⚠️**For Qwen3-VL models, using liger-kernel with full fine-tuning is awfully slow. I recommend turning off liger-kernel or use zero2 with full-finetuning.**<br><br>
+
+**Note:** Deepspeed zero2 is faster than zero3, however it consumes more memory. Also, most of the time zero2 is more stable than zero3.<br><br>
+**Tip:** You could use `adamw_bnb_8bit` for optimizer to save memory.
+
+To run the training script, use the following command:
+
+### Full Finetuning
+
+**Note:** If you want to use `unfreeze_topk_llm` or `unfreeze_topk_vision` you should set `-freeze_llm` or `--freeze_vision_tower` to `true`.
+
+```bash
+bash scripts/finetune.sh
+```
+
+### Finetune with LoRA
+
+**Note:** Liger-kernel won't work with QLoRA. You need to disable to use QLoRA.<br>
+If you want to train only the language model with LoRA and perform full training for the vision model:
+
+```bash
+bash scripts/finetune_lora.sh
+```
+
+If you want to train both the language model and the vision model with LoRA:
+
+```bash
+bash scripts/finetune_lora_vision.sh
+```
+
+**IMPORTANT:** If you want to tune the `embed_token` with LoRA, You need to tune `lm_head` together.
+
+<details>
+<summary>Training arguments</summary>
+
+- `--deepspeed` (str): Path to DeepSpeed config file (default: "scripts/zero2.json").
+- `--data_path` (str): Path to the LLaVA formatted training data (a JSON file). **(Required)**
+- `--image_folder` (str): Path to the images folder as referenced in the LLaVA formatted training data. **(Required)**
+- `--model_id` (str): Path to the Qwen2-VL model. **(Required)**
+- `--use_liger` (bool): Option for using liger kernel to save memory.
+- `--output_dir` (str): Output directory for model checkpoints
+- `--num_train_epochs` (int): Number of training epochs (default: 1).
+- `--per_device_train_batch_size` (int): Training batch size per GPU per forwarding step.
+- `--gradient_accumulation_steps` (int): Gradient accumulation steps (default: 4).
+- `--freeze_vision_tower` (bool): Option to freeze vision_model (default: False).
+- `--freeze_llm` (bool): Option to freeze LLM (default: False).
+- `--freeze_merger` (bool): Option to tune projector (default: False).
+- `--num_lora_modules` (int): Number of target modules to add LoRA (-1 means all layers).
+- `--vision_lr` (float): Learning rate for vision_model.
+- `--merger_lr` (float): Learning rate for merger(projector).
+- `--learning_rate` (float): Learning rate for language module.
+- `--bf16` (bool): Option for using bfloat16.
+- `--fp16` (bool): Option for using fp16.
+- `--image_min_pixels` (int): Option for minimum input tokens for image.
+- `--image_max_pixles` (int): Option for maximum maxmimum tokens for image.
+- `--video_min_pixels` (int): Option for minimum input tokens for video.
+- `--video_max_pixles` (int): Option for maximum maxmimum tokens for video.
+- `--image_resized_width` (int): Option for setting the width of the input image.
+- `--image_resized_height` (int): Option for setting the height of the input image.
+- `--video_resized_width` (int): Option for setting the width of the input video.
+- `--video_resized_height` (int): Option for setting the height of the input video.
+- `--fps` (float): Frames per second for video data.
+- `--nframes` (int): Number of frames for video data.
+- `--unfreeze_topk_llm` (int): Number of top layers to unfreeze in the language model.
+- `--unfreeze_topk_vision` (int): Number of top layers to unfreeze in the vision model.
+- `--lora_enable` (bool): Option for using LoRA.
+- `--vision_lora` (bool): Option for including `vision_tower` in LoRA module. `lora_enable` should be `True` to use this option.
+- `--use_dora` (bool): Option for using DoRA instead of LoRA. `lora_enable` should be `True` to use this option.
+- `--lora_namespan_exclude` (str): Exclude modules with namespans to add LoRA.
+- `--max_seq_length` (int): Maximum sequence length (default: 32K).
+- `--bits` (int): Quantization bits (default: 16).
+- `--disable_flash_attn2` (bool): Disable Flash Attention 2.
+- `--report_to` (str): Reporting tool (choices: 'tensorboard', 'wandb', 'none') (default: 'tensorboard').
+- `--logging_dir` (str): Logging directory (default: "./tf-logs").
+- `--lora_rank` (int): LoRA rank (default: 128).
+- `--lora_alpha` (int): LoRA alpha (default: 256).
+- `--lora_dropout` (float): LoRA dropout (default: 0.05).
+- `--logging_steps` (int): Logging steps (default: 1).
+- `--dataloader_num_workers` (int): Number of data loader workers (default: 4).
+
+**Note:** The learning rate of `vision_model` should be 10x ~ 5x smaller than the `language_model`.
+
+</details>
+
+### Train with video dataset
+
+You can train the model using a video dataset. You can set LoRA configs and use for LoRA too.<br>
+**Note:** You could not set `fps` and `nframes` at the same time.
+
+```bash
+bash scripts/finetune_video.sh
+```
+
+**Note:** When training with video, it just as multi-image so you should adjust the `max_pixels` for maximum resolution and `fps` based on the available VRAM.
+
+If you run out of vram, you can use [zero3_offload](./scripts/zero3_offload.json) instead of [zero3](./scripts/zero3_offload.json).<br>
+You could use [zero2_offload](./scripts/zero2_offload.json) for a bit faster training.
+
+#### Image Resolution for vram usage
+
+The model supprots a wide range of resolution inputs. By default, it uses the native resolution for input.
+For better performance using native or higer pixel numbers are recommended, however it takes too much memory and computation time for large images. So you could adjust the pixel numbers for it.
+The model splits the image into `token * 28 * 28` so you could just change the the token_num part in the script. <br><br>
+⚠️**For Qwen3-VL models, it should be `token * 32 * 32`.**<br><br>
+For example:
+
+```
+--image_min_pixels $((256 * 28 * 28))
+--image_max_pixels $((1280 * 28 * 28))
+--video_min_pixels $((128 * 28 * 28))
+--video_max_pixels $((768 * 28 * 28))
+```
+
+Besides you could directly set the image/video height and width to control over the memory.
+
+```
+--image_resized_width 448
+--image_resized_height 448
+--video_resized_width 448
+--video_resized_height 448
+```
+
+These values will be rounded to the nearest multiple of 28.
+
+#### Merge LoRA Weights
+
+```
+bash scripts/merge_lora.sh
+```
+
+**Note:** Remember to replace the paths in `finetune.sh` or `finetune_lora.sh` with your specific paths. (Also in `merge_lora.sh` when using LoRA.)
+
+### Evaluation during Training
+
+You can run generation-based evaluation during training by providing an evaluation dataset and a custom `compute_metrics` function. This allows you to monitor metrics like accuracy, BLEU, or any custom metric based on the model's generated text outputs.
+
+#### Step 1: Prepare Evaluation Dataset
+
+The evaluation dataset uses the same format as the training dataset. Place your evaluation data JSON file and specify the path using `--eval_path`.
+
+```json
+[
+  {
+    "id": "eval_001",
+    "image": "test_image.jpg",
+    "conversations": [
+      {
+        "from": "human",
+        "value": "<image>\nWhat is shown in this image?"
+      },
+      {
+        "from": "gpt",
+        "value": "A cat sitting on a couch."
+      }
+    ]
+  }
+]
+```
+
+#### Step 2: Define compute_metrics Function
+
+Create a custom `compute_metrics` function in your training script. The function receives a `GenerativeEvalPrediction` object containing:
+
+- `predictions`: List of generated text strings from the model
+- `references`: List of ground truth answer strings
+
+```python
+from src.trainer import GenerativeEvalPrediction
+
+def compute_metrics(eval_pred: GenerativeEvalPrediction):
+    predictions = eval_pred.predictions
+    references = eval_pred.references
+
+    # Example: Exact match accuracy
+    correct = sum(
+        1 for p, r in zip(predictions, references)
+        if p.strip().lower() == r.strip().lower()
+    )
+    accuracy = correct / len(predictions) if predictions else 0
+
+    return {"accuracy": accuracy}
+```
+
+#### Step 3: Modify Training Script
+
+Update your training script (`src/train/train_sft.py`) to pass `compute_metrics` to the trainer:
+
+```python
+from src.trainer import QwenSFTTrainer, GenerativeEvalPrediction
+
+def compute_metrics(eval_pred: GenerativeEvalPrediction):
+    predictions = eval_pred.predictions
+    references = eval_pred.references
+    correct = sum(1 for p, r in zip(predictions, references) if p.strip() == r.strip())
+    return {"accuracy": correct / len(predictions)}
+
+# ... (model and data setup code)
+
+trainer = QwenSFTTrainer(
+    model=model,
+    processing_class=processor,
+    args=training_args,
+    compute_metrics=compute_metrics,  # Add this line
+    **data_module
+)
+```
+
+#### Step 4: Add Evaluation Arguments
+
+Add these arguments to your training script:
+
+```bash
+  --eval_path /path/to/eval.json \
+  --eval_strategy steps \
+  --eval_steps 500 \
+  --per_device_eval_batch_size 1 \
+  --generation_max_new_tokens 256 \
+  --prediction_loss_only False \
+  # ... other arguments
+```
+
+<details>
+<summary>Evaluation Arguments</summary>
+
+- `--eval_path` (str): Path to the evaluation data JSON file.
+- `--eval_strategy` (str): Evaluation strategy - "steps" or "epoch" (default: "no").
+- `--eval_steps` (int): Number of steps between evaluations (when eval_strategy="steps").
+- `--per_device_eval_batch_size` (int): Batch size for evaluation (default: 8).
+- `--generation_max_new_tokens` (int): Maximum new tokens to generate during evaluation (default: 512).
+- `--prediction_loss_only` (bool): Set to False to enable generation-based evaluation (default: True).
+
+</details>
+
+<details>
+<summary>Example: Custom Metrics with Multiple Scores</summary>
+
+```python
+from src.trainer import GenerativeEvalPrediction
+import re
+
+def compute_metrics(eval_pred: GenerativeEvalPrediction):
+    predictions = eval_pred.predictions
+    references = eval_pred.references
+
+    # Exact match
+    exact_matches = sum(
+        1 for p, r in zip(predictions, references)
+        if p.strip().lower() == r.strip().lower()
+    )
+
+    # Contains match (reference appears in prediction)
+    contains_matches = sum(
+        1 for p, r in zip(predictions, references)
+        if r.strip().lower() in p.strip().lower()
+    )
+
+    n = len(predictions)
+    return {
+        "exact_match": exact_matches / n if n > 0 else 0,
+        "contains_match": contains_matches / n if n > 0 else 0,
+    }
+```
+
+</details>
+
+**Note:** Generation-based evaluation is slower than loss-only evaluation because it runs `model.generate()` for each sample. Consider using a smaller evaluation dataset or less frequent evaluation steps.
+
+## DPO Finetuning
+
+You can train the model using Direct Preference Optimization (DPO).<br>
+The process is quite similar to Supervised Fine-Tuning (SFT), and you can also apply LoRA during DPO training just like in SFT.
+
+```bash
+bash scripts/finetune_dpo.sh
+```
+
+Most of the training arugments are same as SFT, but few other arguments are added for DPO training.
+
+<details>
+<summary>Training arguments</summary>
+
+- `--dpo_loss` (str): Loss type for dpo. (default: 'sigmoid')
+- `--precompute_ref_log_probs` (bool): Wheter to precompute the reference log probs (default: False)
+- `--beta` (float): The beta value for DPO (default: 0.1)
+
+</details>
+
+## GRPO Finetuning
+
+You can traing the model using Group Relative Policy Optimization (GRPO) <br>
+The process is quite similar to Supervised Fine-Tuning (SFT), and you can also apply LoRA during GRPO training just like in SFT.<br>
+<br>
+
+### Prerequisites
+
+| What                      | Where                       | Notes                                                                                       |
+| ------------------------- | --------------------------- | ------------------------------------------------------------------------------------------- |
+| **Reward functions**      | `src/train/reward_funcs.py` | Add any function that ends with `_reward`. The training script picks them up automatically. |
+| **Custom system prompts** | `src/constants.py`          | Append your own prompt strings here.                                                        |
+
+You could start training using this script.<br>
+Before training, **Please check the dataset format once more.** The format is a bit different from other training methods.
+
+```bash
+bash scripts/finetune_grpo.sh
+```
+
+Most of the training arugments are same as SFT, but few other arguments are added for GRPO training.
+
+<details>
+<summary>Training arguments</summary>
+
+- `--temperature` (float): Generation config (default: 0.9)
+- `--top_p` (float): Generation config (default: 1.0)
+- `--top_k` (int): Generation config (default: 50)
+- `--min_p` (float): Generation config (default: None)
+- `--repetition_penalty` (float): Generation config (default: 1.0)
+- `--max_completion_length` (int): Max length for the completion (default: 256)
+- `--max_prompt_length` (int): Max length for the prompt (default: 512)
+- `--beta` (float): KL Coefficient. (default: 0.04)
+
+</details>
+
+## Classification Finetuning
+
+### ⚠️This is an experimental feature.
+
+The [model](src/model/modeling_cls.py) is tailored for classification tasks, such as other SequenceClassification models.
+
+For the classification task, you need to prepare the dataset in a specific format. The dataset should be a JSON file where each entry contains an image and its corresponding label. The labels should be integers starting from 0.<br>
+You can set the text in the filed `prompt` to provide a questions and options for the classification task. Also if your dataset dose not contain the `prompt` field, the script will automatically use the `USER_MESSAGE` from the [cls_dataset.py](src/dataset/cls_dataset.py).<br>
+
+**Please see the example below for the dataset format.**<br>
+
+<details>
+<summary>Example for Classification Dataset</summary>
+
+```json
+[
+  {
+    "id": "06bc8a17-bb1c-4007-8c08-92c41e2628b2",
+    "image": "image_2.jpg",
+    "prompt": "Question: What is in the image? \n Options: \n 1. A train \n 2. A bus \n 3. A car \n 4. A bicycle",
+    "label": "3",
+  }
+  ...
+]
+```
+
+**Note:** You should set the `CLASS_2_ID` variable in the [cls_dataset.py](src/dataset/cls_dataset.py).
+
+</details>
+
+<br>
+
+The dataset can contain **single/multi-image or video data**, and the model will be trained to classify the images/videos based on the provided labels.<br>
+
+For now, you can select loss from one of the following:
+
+- `cross_entropy`
+- `focal_loss`
+- `class_balanced_cross_entropy`
+- `class_balanced_focal_loss`
+
+Also you can set early stopping patience and threshold for the training.
+For example, you can set `--early_stopping_patience 5` and `--early_stopping_threshold 0.01` to stop the training if the validation loss does not improve for 5 epochs with a threshold of 0.01.
+
+Most of the training arugments are same as SFT, but few other arguments are added for classification training.<br><br>
+
+**Tip:** In models like the Qwen family, which have strong context embeddings, even a shallow nonlinearity (a 1-layer MLP) can often improve separability in the tail. This works by introducing a bit of curvature that a purely linear head cannot provide.
+
+<details>
+<summary>Training arguments</summary>
+
+- `--loss_type` (str): Loss type for classification (default: 'cross_entropy').
+- `--focal_alpha` (str): Focal Loss alpha value. If None use CrossEntropyLoss. ex '1.0,7.5' (default: None).
+- `--focal_gamma` (float): Focal Loss gamma value. (default: 0.0)
+- `--num_labels` (int): Number of labels for classification
+- `--class_balanced_beta` (float): Class Balanced beta value. (default: 0.999)
+- `--early_stopping_patience` (int): Early stopping patience (default: 0)
+- `--early_stopping_threshold` (float): Early stopping threshold (default: 0.01)
+- `--mlp_head_dim` (int): Dimension of the MLP head (default: 0)
+- `--mlp_head_dropout` (float): Dropout rate for the MLP head (default: 0.0)
+
+</details>
+
+You can run the training script using the following command:
+
+```bash
+bash scripts/finetune_cls.sh
+```
+
+#### Experimental Features
+
+- Sampler for the dataset. The trainer scripts supports the sampler for the dataset. You could make your own sampler with inherting `DistributedSampler`.
+
+## Inference
+
+**Note:** You should use the merged weight when trained with LoRA.
+
+### Gradio Infernce (WebUI)
+
+1. Install gradio
+
+```
+pip install gradio
+```
+
+2. Launch app
+
+```
+python -m src.serve.app \
+    --model-path /path/to/merged/weight
+```
+
+You can launch gradio based demo with this command. This can also set some other generation configs like `repetition_penalty`, `temperature` etc.
+
+## Issue for libcudnn error
+
+```
+Could not load library libcudnn_cnn_train.so.8. Error: /usr/local/cuda-12.1/lib/libcudnn_cnn_train.so.8: undefined symbol: _ZN5cudnn3cnn34layerNormFwd_execute_internal_implERKNS_7backend11VariantPackEP11CUstream_stRNS0_18LayerNormFwdParamsERKNS1_20NormForwardOperationEmb, version libcudnn_cnn_infer.so.8
+```
+
+You could run `unset LD_LIBRARY_PATH` for this error.
+You could see this [issue](https://github.com/andimarafioti/florence2-finetuning/issues/2)
+
+## TODO
+
+- [x] Support for video data
+- [x] Add demo for multi-image and video
+- [x] Handle mixed-modality data in dataset and collator
+- [x] Support Qwen2.5-VL
+- [x] Monkey-patch liger-kernel for Qwen2.5-VL
+- [x] Update the code base to the latest transformers.
+- [x] Add DPO
+- [x] Add GRPO
+- [x] Support Qwen3-VL(non-moe)
+- [x] Support Qwen3-VL-Moe
+
+## Known Issues
+
+- [libcudnn issue](#issue-for-libcudnn-error)
+
+## License
+
+This project is licensed under the Apache-2.0 License. See the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you find this repository useful in your project, please consider giving a :star: and citing:
+
+```bibtex
+@misc{Qwen2-VL-Finetuning,
+  author = {Yuwon Lee},
+  title = {Qwen2-VL-Finetune},
+  year = {2024},
+  publisher = {GitHub},
+  url = {https://github.com/2U1/Qwen2-VL-Finetune}
+}
+```
+
+## Acknowledgement
+
+This project is based on
+
+- [LLaVA-NeXT](https://github.com/LLaVA-VL/LLaVA-NeXT): An amazing open-source project of LMM.
+- [Mipha](https://github.com/zhuyiche/llava-phi): Open-source projcet of SMM with amazing capabilites.
+- [Qwen2-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2-VL-7B-Instruct): Awesome pretrained MLLM based on Qwen2.
+- [Liger-Kernel](https://github.com/linkedin/Liger-Kernel): Collection of Tirton kernels designed specifically for LLM training.
+- [VLM-R1](https://github.com/om-ai-lab/VLM-R1): Open-source project of Reinforcement Learning with VLMs.

environment.yaml

@@ -0,0 +1,175 @@
+name: train
+channels:
+  - conda-forge
+dependencies:
+  - _libgcc_mutex=0.1=conda_forge
+  - _openmp_mutex=4.5=2_gnu
+  - asttokens=3.0.0=pyhd8ed1ab_1
+  - bzip2=1.0.8=h4bc722e_7
+  - ca-certificates=2025.4.26=hbd8a1cb_0
+  - comm=0.2.2=pyhd8ed1ab_1
+  - debugpy=1.8.14=py311hfdbb021_0
+  - decorator=5.2.1=pyhd8ed1ab_0
+  - exceptiongroup=1.2.2=pyhd8ed1ab_1
+  - executing=2.2.0=pyhd8ed1ab_0
+  - importlib-metadata=8.6.1=pyha770c72_0
+  - ipykernel=6.29.5=pyh3099207_0
+  - ipython=9.2.0=pyhfb0248b_0
+  - ipython_pygments_lexers=1.1.1=pyhd8ed1ab_0
+  - jedi=0.19.2=pyhd8ed1ab_1
+  - jupyter_client=8.6.3=pyhd8ed1ab_1
+  - jupyter_core=5.7.2=pyh31011fe_1
+  - keyutils=1.6.1=h166bdaf_0
+  - krb5=1.21.3=h659f571_0
+  - ld_impl_linux-64=2.43=h712a8e2_4
+  - libedit=3.1.20250104=pl5321h7949ede_0
+  - libexpat=2.7.0=h5888daf_0
+  - libffi=3.4.6=h2dba641_1
+  - libgcc=14.2.0=h767d61c_2
+  - libgcc-ng=14.2.0=h69a702a_2
+  - libgomp=14.2.0=h767d61c_2
+  - liblzma=5.8.1=hb9d3cd8_0
+  - libnsl=2.0.1=hd590300_0
+  - libsodium=1.0.20=h4ab18f5_0
+  - libsqlite=3.49.1=hee588c1_2
+  - libstdcxx=14.2.0=h8f9b012_2
+  - libstdcxx-ng=14.2.0=h4852527_2
+  - libuuid=2.38.1=h0b41bf4_0
+  - libxcrypt=4.4.36=hd590300_1
+  - libzlib=1.3.1=hb9d3cd8_2
+  - matplotlib-inline=0.1.7=pyhd8ed1ab_1
+  - ncurses=6.5=h2d0b736_3
+  - nest-asyncio=1.6.0=pyhd8ed1ab_1
+  - openssl=3.5.0=h7b32b05_0
+  - packaging=25.0=pyh29332c3_1
+  - parso=0.8.4=pyhd8ed1ab_1
+  - pexpect=4.9.0=pyhd8ed1ab_1
+  - pickleshare=0.7.5=pyhd8ed1ab_1004
+  - pip=25.1=pyh8b19718_0
+  - platformdirs=4.3.7=pyh29332c3_0
+  - prompt-toolkit=3.0.51=pyha770c72_0
+  - psutil=7.0.0=py311h9ecbd09_0
+  - ptyprocess=0.7.0=pyhd8ed1ab_1
+  - pure_eval=0.2.3=pyhd8ed1ab_1
+  - pygments=2.19.1=pyhd8ed1ab_0
+  - python=3.11.12=h9e4cc4f_0_cpython
+  - python-dateutil=2.9.0.post0=pyhff2d567_1
+  - python_abi=3.11=7_cp311
+  - pyzmq=26.4.0=py311h7deb3e3_0
+  - readline=8.2=h8c095d6_2
+  - setuptools=79.0.1=pyhff2d567_0
+  - six=1.17.0=pyhd8ed1ab_0
+  - stack_data=0.6.3=pyhd8ed1ab_1
+  - tk=8.6.13=noxft_h4845f30_101
+  - tornado=6.4.2=py311h9ecbd09_0
+  - traitlets=5.14.3=pyhd8ed1ab_1
+  - typing_extensions=4.13.2=pyh29332c3_0
+  - wcwidth=0.2.13=pyhd8ed1ab_1
+  - wheel=0.45.1=pyhd8ed1ab_1
+  - zeromq=4.3.5=h3b0a872_7
+  - zipp=3.21.0=pyhd8ed1ab_1
+  - pip:
+      - accelerate==1.10.1
+      - aiohappyeyeballs==2.6.1
+      - aiohttp==3.11.18
+      - aiosignal==1.3.2
+      - annotated-types==0.7.0
+      - attrs==25.3.0
+      - av==14.3.0
+      - bitsandbytes==0.45.5
+      - certifi==2025.4.26
+      - charset-normalizer==3.4.1
+      - click==8.1.8
+      - contourpy==1.3.3
+      - cycler==0.12.1
+      - datasets==3.5.1
+      - decord==0.6.0
+      - deepspeed==0.17.5
+      - dill==0.3.8
+      - docker-pycreds==0.4.0
+      - einops==0.8.1
+      - filelock==3.13.1
+      - fonttools==4.59.2
+      - frozenlist==1.6.0
+      - fsspec==2024.6.1
+      - gitdb==4.0.12
+      - gitpython==3.1.44
+      - hf-xet==1.1.9
+      - hjson==3.1.0
+      - huggingface-hub==0.34.4
+      - idna==3.10
+      - ipywidgets==8.1.6
+      - jinja2==3.1.4
+      - joblib==1.5.2
+      - jupyterlab-widgets==3.0.14
+      - kiwisolver==1.4.9
+      - liger-kernel==0.6.4
+      - markdown-it-py==3.0.0
+      - markupsafe==2.1.5
+      - matplotlib==3.10.6
+      - mdurl==0.1.2
+      - mpmath==1.3.0
+      - msgpack==1.1.0
+      - multidict==6.4.3
+      - multiprocess==0.70.16
+      - networkx==3.3
+      - ninja==1.11.1.4
+      - numpy==2.1.2
+      - nvidia-cublas-cu12==12.8.4.1
+      - nvidia-cuda-cupti-cu12==12.8.90
+      - nvidia-cuda-nvrtc-cu12==12.8.93
+      - nvidia-cuda-runtime-cu12==12.8.90
+      - nvidia-cudnn-cu12==9.10.2.21
+      - nvidia-cufft-cu12==11.3.3.83
+      - nvidia-cufile-cu12==1.13.1.3
+      - nvidia-curand-cu12==10.3.9.90
+      - nvidia-cusolver-cu12==11.7.3.90
+      - nvidia-cusparse-cu12==12.5.8.93
+      - nvidia-cusparselt-cu12==0.7.1
+      - nvidia-ml-py==12.570.86
+      - nvidia-nccl-cu12==2.27.3
+      - nvidia-nvjitlink-cu12==12.8.93
+      - nvidia-nvtx-cu12==12.8.90
+      - opencv-python==4.11.0.86
+      - pandas==2.2.3
+      - peft==0.15.2
+      - pillow==11.3.0
+      - pillow-simd==9.5.0.post2
+      - propcache==0.3.1
+      - protobuf==6.30.2
+      - py-cpuinfo==9.0.0
+      - pyarrow==20.0.0
+      - pydantic==2.11.3
+      - pydantic-core==2.33.1
+      - pyparsing==3.2.3
+      - pytz==2025.2
+      - pyyaml==6.0.2
+      - regex==2024.11.6
+      - requests==2.32.3
+      - rich==14.0.0
+      - safetensors==0.6.2
+      - scikit-learn==1.7.2
+      - scipy==1.16.2
+      - sentry-sdk==2.27.0
+      - setproctitle==1.3.5
+      - smmap==5.0.2
+      - sympy==1.13.3
+      - tabulate==0.9.0
+      - tensorboardx==2.6.2.2
+      - threadpoolctl==3.6.0
+      - tokenizers==0.22.0
+      - torch==2.8.0
+      - torchaudio==2.8.0
+      - torchvision==0.23.0
+      - tqdm==4.67.1
+      - transformers==4.57.1
+      - triton==3.4.0
+      - trl==0.25.0
+      - typing-inspection==0.4.0
+      - tzdata==2025.2
+      - ujson==5.10.0
+      - urllib3==2.4.0
+      - wandb==0.19.10
+      - widgetsnbextension==4.0.14
+      - xxhash==3.5.0
+      - yarl==1.20.0

requirements.txt

@@ -0,0 +1,140 @@
+accelerate==1.10.1
+aiohappyeyeballs==2.6.1
+aiohttp==3.11.18
+aiosignal==1.3.2
+annotated-types==0.7.0
+asttokens==3.0.0
+attrs==25.3.0
+av==14.3.0
+bitsandbytes==0.45.5
+certifi==2025.4.26
+charset-normalizer==3.4.1
+click==8.1.8
+comm==0.2.2
+contourpy==1.3.3
+cycler==0.12.1
+datasets==3.5.1
+debugpy==1.8.14
+decorator==5.2.1
+decord==0.6.0
+deepspeed==0.17.5
+dill==0.3.8
+docker-pycreds==0.4.0
+einops==0.8.1
+exceptiongroup==1.2.2
+executing==2.2.0
+filelock==3.13.1
+fonttools==4.59.2
+frozenlist==1.6.0
+fsspec==2024.6.1
+gitdb==4.0.12
+GitPython==3.1.44
+hf-xet==1.1.9
+hjson==3.1.0
+huggingface-hub==0.34.4
+idna==3.10
+importlib_metadata==8.6.1
+ipykernel==6.29.5
+ipython==9.2.0
+ipython_pygments_lexers==1.1.1
+ipywidgets==8.1.6
+jedi==0.19.2
+Jinja2==3.1.4
+joblib==1.5.2
+jupyter_client==8.6.3
+jupyter_core==5.7.2
+jupyterlab_widgets==3.0.14
+kiwisolver==1.4.9
+liger_kernel==0.6.4
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.10.6
+matplotlib-inline==0.1.7
+mdurl==0.1.2
+mpmath==1.3.0
+msgpack==1.1.0
+multidict==6.4.3
+multiprocess==0.70.16
+nest_asyncio==1.6.0
+networkx==3.3
+ninja==1.11.1.4
+numpy==2.1.2
+nvidia-cublas-cu12==12.8.4.1
+nvidia-cuda-cupti-cu12==12.8.90
+nvidia-cuda-nvrtc-cu12==12.8.93
+nvidia-cuda-runtime-cu12==12.8.90
+nvidia-cudnn-cu12==9.10.2.21
+nvidia-cufft-cu12==11.3.3.83
+nvidia-cufile-cu12==1.13.1.3
+nvidia-curand-cu12==10.3.9.90
+nvidia-cusolver-cu12==11.7.3.90
+nvidia-cusparse-cu12==12.5.8.93
+nvidia-cusparselt-cu12==0.7.1
+nvidia-ml-py==12.570.86
+nvidia-nccl-cu12==2.27.3
+nvidia-nvjitlink-cu12==12.8.93
+nvidia-nvtx-cu12==12.8.90
+opencv-python==4.11.0.86
+packaging==25.0
+pandas==2.2.3
+parso==0.8.4
+peft==0.15.2
+pexpect==4.9.0
+pickleshare==0.7.5
+pillow==11.3.0
+pip==25.1
+platformdirs==4.3.7
+prompt_toolkit==3.0.51
+propcache==0.3.1
+protobuf==6.30.2
+psutil==7.0.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
+py-cpuinfo==9.0.0
+pyarrow==20.0.0
+pydantic==2.11.3
+pydantic_core==2.33.1
+Pygments==2.19.1
+pyparsing==3.2.3
+python-dateutil==2.9.0.post0
+pytz==2025.2
+PyYAML==6.0.2
+pyzmq==26.4.0
+regex==2024.11.6
+requests==2.32.3
+rich==14.0.0
+safetensors==0.6.2
+scikit-learn==1.7.2
+scipy==1.16.2
+sentry-sdk==2.27.0
+setproctitle==1.3.5
+setuptools==79.0.1
+six==1.17.0
+smmap==5.0.2
+stack_data==0.6.3
+sympy==1.13.3
+tabulate==0.9.0
+tensorboardX==2.6.2.2
+threadpoolctl==3.6.0
+tokenizers==0.22.0
+torch==2.8.0
+torchaudio==2.8.0
+torchvision==0.23.0
+tornado==6.4.2
+tqdm==4.67.1
+traitlets==5.14.3
+transformers==4.57.1
+triton==3.4.0
+trl==0.25.0
+typing_extensions==4.13.2
+typing-inspection==0.4.0
+tzdata==2025.2
+ujson==5.10.0
+urllib3==2.4.0
+wandb==0.19.10
+wcwidth==0.2.13
+wheel==0.45.1
+widgetsnbextension==4.0.14
+xxhash==3.5.0
+yarl==1.20.0
+zipp==3.21.0

scripts/finetune.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+# MODEL_NAME="Qwen/Qwen2-VL-7B-Instruct"
+# MODEL_NAME="Qwen/Qwen2-VL-2B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-3B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-7B-Instruct"
+
+MODEL_NAME="Qwen/Qwen3-VL-4B-Instruct"
+
+GLOBAL_BATCH_SIZE=128
+BATCH_PER_DEVICE=4
+NUM_DEVICES=8
+GRAD_ACCUM_STEPS=$((GLOBAL_BATCH_SIZE / (BATCH_PER_DEVICE * NUM_DEVICES)))
+
+export PYTHONPATH=src:$PYTHONPATH
+
+# If you want to set the min pixels and max pixels for Qwen3-VL, You should set as (N * 32 * 32)
+
+deepspeed src/train/train_sft.py \
+    --use_liger_kernel True \
+    --deepspeed scripts/zero3_offload.json \
+    --model_id $MODEL_NAME \
+    --data_path /path/to/your/training/data.json \
+    --image_folder /path/to/your/image/folder \
+    --remove_unused_columns False \
+    --freeze_vision_tower False \
+    --freeze_llm False \
+    --freeze_merger False \
+    --bf16 True \
+    --fp16 False \
+    --disable_flash_attn2 False \
+    --output_dir output/test_fft \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size $BATCH_PER_DEVICE \
+    --gradient_accumulation_steps $GRAD_ACCUM_STEPS \
+    --image_min_pixels $((512 * 28 * 28)) \
+    --image_max_pixels $((1280 * 28 * 28)) \
+    --learning_rate 1e-5 \
+    --merger_lr 1e-5 \
+    --vision_lr 2e-6 \
+    --weight_decay 0.1 \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --tf32 True \
+    --gradient_checkpointing True \
+    --report_to tensorboard \
+    --lazy_preprocess True \
+    --save_strategy "steps" \
+    --save_steps 200 \
+    --save_total_limit 10 \
+    --dataloader_num_workers 4

scripts/finetune_cls.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+# MODEL_NAME="Qwen/Qwen2-VL-7B-Instruct"
+# MODEL_NAME="Qwen/Qwen2-VL-2B-Instruct"
+MODEL_NAME="Qwen/Qwen2.5-VL-3B-Instruct"
+
+#  loss_type should be one of "cross_entropy", "focal_loss", "class_balanced_cross_entropy", or "class_balanced_focal_loss".
+
+export PYTHONPATH=src:$PYTHONPATH
+
+deepspeed src/train/train_cls.py \
+    --deepspeed scripts/zero3.json \
+    --model_id $MODEL_NAME \
+    --data_path /path/to/your/training/data.json \
+    --image_folder /path/to/your/image/folder \
+    --eval_path /path/to/your/training/data.json \
+    --eval_image_folder /path/to/your/image/folder \
+    --freeze_llm True \
+    --freeze_vision_tower False \
+    --freeze_merger False \
+    --bf16 True \
+    --fp16 False \
+    --loss_type "cross_entropy" \
+    --num_labels 2 \
+    --disable_flash_attn2 False \
+    --output_dir output/qwen_cls \
+    --num_train_epochs 3 \
+    --per_device_train_batch_size 4 \
+    --gradient_accumulation_steps 4 \
+    --learning_rate 3e-5 \
+    --head_lr 4e-5 \
+    --vision_lr 6e-6 \
+    --merger_lr 2e-5 \
+    --weight_decay 0.02 \
+    --warmup_ratio 0.05 \
+    --max_grad_norm 1.0 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --tf32 True \
+    --eval_strategy "epoch" \
+    --load_best_model_at_end True \
+    --metric_for_best_model "eval_f1" \
+    --greater_is_better True \
+    --gradient_checkpointing True \
+    --report_to tensorboard \
+    --lazy_preprocess True \
+    --save_strategy "epoch" \
+    --dataloader_num_workers 4

scripts/finetune_dpo.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+# MODEL_NAME="Qwen/Qwen2-VL-7B-Instruct"
+# MODEL_NAME="Qwen/Qwen2-VL-2B-Instruct"
+MODEL_NAME="Qwen/Qwen2.5-VL-3B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-7B-Instruct"
+
+GLOBAL_BATCH_SIZE=128
+BATCH_PER_DEVICE=4
+NUM_DEVICES=8
+GRAD_ACCUM_STEPS=$((GLOBAL_BATCH_SIZE / (BATCH_PER_DEVICE * NUM_DEVICES)))
+
+export PYTHONPATH=src:$PYTHONPATH
+
+deepspeed src/train/train_dpo.py \
+    --dpo_loss "sigmoid" \
+    --precompute_ref_log_probs False \
+    --beta 0.1 \
+    --use_liger_loss True \
+    --deepspeed scripts/zero3_offload.json \
+    --model_id $MODEL_NAME \
+    --data_path /path/to/your/training/data.json \
+    --image_folder /path/to/your/image/folder \
+    --remove_unused_columns False \
+    --freeze_vision_tower False \
+    --freeze_llm False \
+    --freeze_merger False \
+    --bf16 True \
+    --fp16 False \
+    --disable_flash_attn2 False \
+    --output_dir output/test_dpo \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size $BATCH_PER_DEVICE \
+    --gradient_accumulation_steps $GRAD_ACCUM_STEPS \
+    --image_min_pixels $((512 * 28 * 28)) \
+    --image_max_pixels $((1280 * 28 * 28)) \
+    --learning_rate 1e-5 \
+    --merger_lr 1e-5 \
+    --vision_lr 2e-6 \
+    --weight_decay 0.1 \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --tf32 True \
+    --gradient_checkpointing True \
+    --report_to tensorboard \
+    --lazy_preprocess True \
+    --save_strategy "steps" \
+    --save_steps 200 \
+    --save_total_limit 10 \
+    --dataloader_num_workers 4

scripts/finetune_grpo.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+# MODEL_NAME="Qwen/Qwen2-VL-7B-Instruct"
+# MODEL_NAME="Qwen/Qwen2-VL-2B-Instruct"
+MODEL_NAME="Qwen/Qwen2.5-VL-3B-Instruct"
+
+export PYTHONPATH=src:$PYTHONPATH
+
+deepspeed src/train/train_grpo.py \
+    --deepspeed scripts/zero3.json \
+    --use_liger_loss True \
+    --model_id $MODEL_NAME \
+    --data_path /path/to/your/training/data.json \
+    --image_folder /path/to/your/image/folder \
+    --freeze_vision_tower False \
+    --freeze_llm True \
+    --freeze_merger False \
+    --bf16 True \
+    --fp16 False \
+    --disable_flash_attn2 False \
+    --output_dir output/test_grpo \
+    --num_train_epochs 1 \
+    --num_generations 2 \
+    --per_device_train_batch_size 1 \
+    --gradient_accumulation_steps 1 \
+    --max_completion_length 256 \
+    --max_prompt_length 512 \
+    --image_min_pixels $((128 * 28 * 28)) \
+    --image_max_pixels $((256 * 28 * 28)) \
+    --learning_rate 5e-6 \
+    --remove_unused_columns False \
+    --weight_decay 0.1 \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --tf32 True \
+    --gradient_checkpointing True \
+    --report_to tensorboard \
+    --lazy_preprocess True \
+    --save_strategy "epoch" \
+    --save_total_limit 10 \
+    --dataloader_num_workers 4

scripts/finetune_lora.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+# MODEL_NAME="Qwen/Qwen2-VL-7B-Instruct"
+# MODEL_NAME="Qwen/Qwen2-VL-2B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-3B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-7B-Instruct"
+
+MODEL_NAME="/DATA/disk1/cdp/hf_models/Qwen3-VL-8B-Instruct"
+
+export PYTHONPATH=src:$PYTHONPATH
+
+GLOBAL_BATCH_SIZE=128
+BATCH_PER_DEVICE=4
+NUM_DEVICES=8
+GRAD_ACCUM_STEPS=$((GLOBAL_BATCH_SIZE / (BATCH_PER_DEVICE * NUM_DEVICES)))
+
+# If you want to tune the `embed_token` with LoRA, You need to tune `lm_head` together
+
+# If you want to set the min pixels and max pixels for Qwen3-VL, You should set as (N * 32 * 32)
+
+deepspeed src/train/train_sft.py \
+    --use_liger_kernel False \
+    --lora_enable True \
+    --use_dora False \
+    --lora_namespan_exclude "['lm_head', 'embed_tokens']" \
+    --lora_rank 32 \
+    --lora_alpha 64 \
+    --lora_dropout 0.05 \
+    --num_lora_modules -1 \
+    --deepspeed scripts/zero3.json \
+    --model_id $MODEL_NAME \
+    --data_path /DATA/disk1/cdp/hxa/dataset/dataset_merged_en_formatted.json \
+    --image_folder /DATA/disk1/cdp/hxa/dataset \
+    --remove_unused_columns False \
+    --freeze_vision_tower False \
+    --freeze_llm True \
+    --freeze_merger False \
+    --bf16 True \
+    --fp16 False \
+    --disable_flash_attn2 False \
+    --output_dir output/testing_lora_multi_qa_8b \
+    --num_train_epochs 8 \
+    --per_device_train_batch_size $BATCH_PER_DEVICE \
+    --gradient_accumulation_steps $GRAD_ACCUM_STEPS \
+    --image_min_pixels $((256 * 28 * 28)) \
+    --image_max_pixels $((1280 * 28 * 28)) \
+    --learning_rate 1e-4 \
+    --merger_lr 1e-5 \
+    --vision_lr 2e-6 \
+    --weight_decay 0.1 \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --tf32 True \
+    --gradient_checkpointing True \
+    --report_to tensorboard \
+    --lazy_preprocess True \
+    --save_strategy "steps" \
+    --save_steps 100 \
+    --save_total_limit 50 \
+    --dataloader_num_workers 4

scripts/finetune_lora_1.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+# MODEL_NAME="Qwen/Qwen2-VL-7B-Instruct"
+# MODEL_NAME="Qwen/Qwen2-VL-2B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-3B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-7B-Instruct"
+
+MODEL_NAME="/DATA/disk1/cdp/hf_models/Qwen3-VL-4B-Instruct"
+
+export PYTHONPATH=src:$PYTHONPATH
+
+GLOBAL_BATCH_SIZE=128
+BATCH_PER_DEVICE=4
+NUM_DEVICES=8
+GRAD_ACCUM_STEPS=$((GLOBAL_BATCH_SIZE / (BATCH_PER_DEVICE * NUM_DEVICES)))
+
+# If you want to tune the `embed_token` with LoRA, You need to tune `lm_head` together
+
+# If you want to set the min pixels and max pixels for Qwen3-VL, You should set as (N * 32 * 32)
+
+deepspeed src/train/train_sft.py \
+    --use_liger_kernel False \
+    --lora_enable True \
+    --use_dora False \
+    --lora_namespan_exclude "['lm_head', 'embed_tokens']" \
+    --lora_rank 32 \
+    --lora_alpha 64 \
+    --lora_dropout 0.05 \
+    --num_lora_modules -1 \
+    --deepspeed scripts/zero3.json \
+    --model_id $MODEL_NAME \
+    --data_path /DATA/disk1/cdp/hxa/dataset/dataset_merged_en_en_choice_formatted.json \
+    --image_folder /DATA/disk1/cdp/hxa/dataset \
+    --remove_unused_columns False \
+    --freeze_vision_tower False \
+    --freeze_llm True \
+    --freeze_merger False \
+    --bf16 True \
+    --fp16 False \
+    --disable_flash_attn2 False \
+    --output_dir output/testing_lora_en_choice \
+    --num_train_epochs 8 \
+    --per_device_train_batch_size $BATCH_PER_DEVICE \
+    --gradient_accumulation_steps $GRAD_ACCUM_STEPS \
+    --image_min_pixels $((256 * 28 * 28)) \
+    --image_max_pixels $((1280 * 28 * 28)) \
+    --learning_rate 1e-4 \
+    --merger_lr 1e-5 \
+    --vision_lr 2e-6 \
+    --weight_decay 0.1 \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --tf32 True \
+    --gradient_checkpointing True \
+    --report_to tensorboard \
+    --lazy_preprocess True \
+    --save_strategy "steps" \
+    --save_steps 100 \
+    --save_total_limit 50 \
+    --dataloader_num_workers 4

scripts/finetune_lora_2.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+# MODEL_NAME="Qwen/Qwen2-VL-7B-Instruct"
+# MODEL_NAME="Qwen/Qwen2-VL-2B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-3B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-7B-Instruct"
+
+MODEL_NAME="/DATA/disk1/cdp/hf_models/Qwen3-VL-4B-Instruct"
+
+export PYTHONPATH=src:$PYTHONPATH
+
+GLOBAL_BATCH_SIZE=128
+BATCH_PER_DEVICE=4
+NUM_DEVICES=8
+GRAD_ACCUM_STEPS=$((GLOBAL_BATCH_SIZE / (BATCH_PER_DEVICE * NUM_DEVICES)))
+
+# If you want to tune the `embed_token` with LoRA, You need to tune `lm_head` together
+
+# If you want to set the min pixels and max pixels for Qwen3-VL, You should set as (N * 32 * 32)
+
+deepspeed src/train/train_sft.py \
+    --use_liger_kernel False \
+    --lora_enable True \
+    --use_dora False \
+    --lora_namespan_exclude "['lm_head', 'embed_tokens']" \
+    --lora_rank 32 \
+    --lora_alpha 64 \
+    --lora_dropout 0.05 \
+    --num_lora_modules -1 \
+    --deepspeed scripts/zero3.json \
+    --model_id $MODEL_NAME \
+    --data_path /DATA/disk1/cdp/hxa/dataset/dataset_merged_en_choice_formatted.json \
+    --image_folder /DATA/disk1/cdp/hxa/dataset \
+    --remove_unused_columns False \
+    --freeze_vision_tower False \
+    --freeze_llm True \
+    --freeze_merger False \
+    --bf16 True \
+    --fp16 False \
+    --disable_flash_attn2 False \
+    --output_dir output/testing_lora_multi_choice \
+    --num_train_epochs 8 \
+    --per_device_train_batch_size $BATCH_PER_DEVICE \
+    --gradient_accumulation_steps $GRAD_ACCUM_STEPS \
+    --image_min_pixels $((256 * 28 * 28)) \
+    --image_max_pixels $((1280 * 28 * 28)) \
+    --learning_rate 1e-4 \
+    --merger_lr 1e-5 \
+    --vision_lr 2e-6 \
+    --weight_decay 0.1 \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --tf32 True \
+    --gradient_checkpointing True \
+    --report_to tensorboard \
+    --lazy_preprocess True \
+    --save_strategy "steps" \
+    --save_steps 100 \
+    --save_total_limit 50 \
+    --dataloader_num_workers 4

scripts/finetune_lora_vision.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+
+# MODEL_NAME="Qwen/Qwen2-VL-7B-Instruct"
+# MODEL_NAME="Qwen/Qwen2-VL-2B-Instruct"
+MODEL_NAME="Qwen/Qwen2.5-VL-3B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-7B-Instruct"
+
+export PYTHONPATH=src:$PYTHONPATH
+
+GLOBAL_BATCH_SIZE=128
+BATCH_PER_DEVICE=4
+NUM_DEVICES=8
+GRAD_ACCUM_STEPS=$((GLOBAL_BATCH_SIZE / (BATCH_PER_DEVICE * NUM_DEVICES)))
+
+# If you want to tune the `embed_token` with LoRA, You need to tune `lm_head` together
+# You should freeze the the merger also, becuase the merger is included in the vision_tower.
+
+# Please set the gradient_checkpointing to False when you are using LoRA with vision models.
+
+deepspeed src/train/train_sft.py \
+    --use_liger_kernel True \
+    --lora_enable True \
+    --vision_lora True \
+    --use_dora False \
+    --lora_namespan_exclude "['lm_head', 'embed_tokens']" \
+    --lora_rank 32 \
+    --lora_alpha 64 \
+    --lora_dropout 0.05 \
+    --num_lora_modules -1 \
+    --deepspeed scripts/zero3.json \
+    --model_id $MODEL_NAME \
+    --data_path /path/to/your/training/data.json \
+    --image_folder /path/to/your/image/folder \
+    --remove_unused_columns False \
+    --freeze_vision_tower True \
+    --freeze_llm True \
+    --freeze_merger True \
+    --bf16 True \
+    --fp16 False \
+    --disable_flash_attn2 False \
+    --output_dir output/lora_vision_test \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size $BATCH_PER_DEVICE \
+    --gradient_accumulation_steps $GRAD_ACCUM_STEPS \
+    --image_min_pixels $((256 * 28 * 28)) \
+    --image_max_pixels $((1280 * 28 * 28)) \
+    --learning_rate 2e-4 \
+    --weight_decay 0.1 \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --tf32 True \
+    --gradient_checkpointing False \
+    --report_to tensorboard \
+    --lazy_preprocess True \
+    --save_strategy "steps" \
+    --save_steps 200 \
+    --save_total_limit 10 \
+    --dataloader_num_workers 4

scripts/finetune_video.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+# MODEL_NAME="Qwen/Qwen2-VL-7B-Instruct"
+# MODEL_NAME="Qwen/Qwen2-VL-2B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-3B-Instruct"
+# MODEL_NAME="Qwen/Qwen2.5-VL-7B-Instruct"
+
+MODEL_NAME="Qwen/Qwen3-VL-4B-Instruct"
+
+export PYTHONPATH=src:$PYTHONPATH
+
+GLOBAL_BATCH_SIZE=128
+BATCH_PER_DEVICE=4
+NUM_DEVICES=8
+GRAD_ACCUM_STEPS=$((GLOBAL_BATCH_SIZE / (BATCH_PER_DEVICE * NUM_DEVICES)))
+
+# If your dataset is mixed with images and videos, you need to use zero2.
+# If you want to set the min pixels and max pixels for Qwen3-VL, You should set as (N * 32 * 32)
+
+deepspeed src/train/train_sft.py \
+    --use_liger_kernel True \
+    --deepspeed scripts/zero3_offload.json \
+    --model_id $MODEL_NAME \
+    --data_path /path/to/your/training/data.json \
+    --image_folder /path/to/your/image/folder \
+    --remove_unused_columns False \
+    --freeze_vision_tower False \
+    --freeze_llm False \
+    --freeze_merger False \
+    --bf16 True \
+    --fp16 False \
+    --disable_flash_attn2 False \
+    --output_dir output/test_train \
+    --num_train_epochs 1 \
+    --per_device_train_batch_size $BATCH_PER_DEVICE \
+    --gradient_accumulation_steps $GRAD_ACCUM_STEPS \
+    --video_max_pixels $((360 * 420)) \
+    --fps 1.0 \
+    --learning_rate 1e-5 \
+    --merger_lr 1e-5 \
+    --vision_lr 2e-6 \
+    --weight_decay 0.1 \
+    --warmup_ratio 0.03 \
+    --lr_scheduler_type "cosine" \
+    --logging_steps 1 \
+    --tf32 True \
+    --gradient_checkpointing True \
+    --report_to tensorboard \
+    --lazy_preprocess True \
+    --save_strategy "steps" \
+    --save_steps 1 \
+    --save_total_limit 10 \
+    --dataloader_num_workers 4

scripts/merge_lora.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+MODEL_NAME="Qwen/Qwen2-VL-7B-Instruct"
+# MODEL_NAME="Qwen/Qwen2-VL-2B-Instruct"
+
+export PYTHONPATH=src:$PYTHONPATH
+
+python src/merge_lora_weights.py \
+    --model-path /home/workspace/Qwen2-VL-Finetune/output/testing_lora \
+    --model-base $MODEL_NAME  \
+    --save-model-path /home/workspace/Qwen2-VL-Finetune/output/merge_test \
+    --safe-serialization

scripts/zero2.json

@@ -0,0 +1,23 @@
+{
+  "fp16": {
+    "enabled": "auto",
+    "loss_scale": 0,
+    "loss_scale_window": 1000,
+    "initial_scale_power": 16,
+    "hysteresis": 2,
+    "min_loss_scale": 1
+  },
+  "bf16": {
+    "enabled": "auto"
+  },
+  "train_micro_batch_size_per_gpu": "auto",
+  "train_batch_size": "auto",
+  "gradient_accumulation_steps": "auto",
+  "zero_optimization": {
+    "stage": 2,
+    "overlap_comm": true,
+    "contiguous_gradients": true,
+    "sub_group_size": 1e9,
+    "reduce_bucket_size": "auto"
+  }
+}

scripts/zero2_offload.json

@@ -0,0 +1,31 @@
+{
+  "fp16": {
+    "enabled": "auto",
+    "loss_scale": 0,
+    "loss_scale_window": 1000,
+    "initial_scale_power": 16,
+    "hysteresis": 2,
+    "min_loss_scale": 1
+  },
+  "bf16": {
+    "enabled": "auto"
+  },
+  "train_micro_batch_size_per_gpu": "auto",
+  "train_batch_size": "auto",
+  "gradient_accumulation_steps": "auto",
+  "zero_optimization": {
+    "stage": 2,
+    "offload_optimizer": {
+      "device": "cpu",
+      "pin_memory": true
+    },
+    "offload_param": {
+      "device": "cpu",
+      "pin_memory": true
+    },
+    "overlap_comm": true,
+    "contiguous_gradients": true,
+    "sub_group_size": 1e9,
+    "reduce_bucket_size": "auto"
+  }
+}

scripts/zero3.json

@@ -0,0 +1,28 @@
+{
+  "fp16": {
+    "enabled": "auto",
+    "loss_scale": 0,
+    "loss_scale_window": 1000,
+    "initial_scale_power": 16,
+    "hysteresis": 2,
+    "min_loss_scale": 1
+  },
+  "bf16": {
+    "enabled": "auto"
+  },
+  "train_micro_batch_size_per_gpu": "auto",
+  "train_batch_size": "auto",
+  "gradient_accumulation_steps": "auto",
+  "zero_optimization": {
+    "stage": 3,
+    "overlap_comm": true,
+    "contiguous_gradients": true,
+    "sub_group_size": 1e9,
+    "reduce_bucket_size": "auto",
+    "stage3_prefetch_bucket_size": "auto",
+    "stage3_param_persistence_threshold": "auto",
+    "stage3_max_live_parameters": 1e9,
+    "stage3_max_reuse_distance": 1e9,
+    "stage3_gather_16bit_weights_on_model_save": true
+  }
+}

scripts/zero3_offload.json

@@ -0,0 +1,48 @@
+{
+  "fp16": {
+    "enabled": "auto",
+    "loss_scale": 0,
+    "loss_scale_window": 1000,
+    "initial_scale_power": 16,
+    "hysteresis": 2,
+    "min_loss_scale": 1
+  },
+  "bf16": {
+    "enabled": "auto"
+  },
+  "optimizer": {
+    "type": "AdamW",
+    "params": {
+      "lr": "auto",
+      "betas": "auto",
+      "eps": "auto",
+      "weight_decay": "auto"
+    }
+  },
+  "zero_optimization": {
+    "stage": 3,
+    "offload_optimizer": {
+      "device": "cpu",
+      "pin_memory": true
+    },
+    "offload_param": {
+      "device": "cpu",
+      "pin_memory": true
+    },
+    "overlap_comm": true,
+    "contiguous_gradients": true,
+    "sub_group_size": 1e9,
+    "reduce_bucket_size": "auto",
+    "stage3_prefetch_bucket_size": "auto",
+    "stage3_param_persistence_threshold": "auto",
+    "stage3_max_live_parameters": 1e9,
+    "stage3_max_reuse_distance": 1e9,
+    "gather_16bit_weights_on_model_save": true
+  },
+  "gradient_accumulation_steps": "auto",
+  "gradient_clipping": "auto",
+  "train_batch_size": "auto",
+  "train_micro_batch_size_per_gpu": "auto",
+  "steps_per_print": 1e5,
+  "wall_clock_breakdown": false
+}

src/constants.py

@@ -0,0 +1,14 @@
+IGNORE_INDEX = -100
+
+DEFAULT_IM_START_TOKEN = "<|im_start|>"
+DEFAULT_IM_END_TOKEN = "<|im_end|>"
+DEFAULT_IMAGE_TOKEN = "<|image_pad|>"
+DEFAULT_VIDEO_TOKEN = "<|video_pad|>"
+LLAVA_IMAGE_TOKEN = "<image>"
+LLAVA_VIDEO_TOKEN = "<video>"
+VISION_START_TOKEN = "<|vision_start|>"
+VISION_END_TOKEN = "<|vision_end|>"
+
+SYSTEM_MESSAGE = "You are a helpful assistant."
+
+MULTIMODAL_KEYWORDS = ["pixel_values", "image_grid_thw", "video_grid_thw", "pixel_values_videos", "second_per_grid_ts"]

src/dataset/__init__.py

@@ -0,0 +1,11 @@
+from .dpo_dataset import make_dpo_data_module
+from .sft_dataset import make_supervised_data_module
+from .grpo_dataset import make_grpo_data_module
+from .cls_dataset import make_classification_data_module
+
+__all__ =[
+    "make_dpo_data_module",
+    "make_supervised_data_module",
+    "make_grpo_data_module",
+    "make_classification_data_module",
+]

src/dataset/cls_dataset.py

@@ -0,0 +1,265 @@
+import copy
+import os
+from typing import Dict
+import torch
+import transformers
+import ujson as json
+from torch.utils.data import Dataset
+from qwen_vl_utils import process_vision_info
+
+from src.params import DataArguments
+from src.constants import (
+    SYSTEM_MESSAGE,
+)
+
+from .data_utils import pad_sequence, samples_per_class_from_ids
+
+CLASS_2_ID = {
+    "A": 0,
+    "B": 1
+}
+
+USER_MESSAGE = """Enter your prompt here. This will be used when your data does not have a prompt field."""
+
+def get_image_content(image_path, min_pixel, max_pixel, width, height):
+    content = {
+        "type": "image", 
+        "image": image_path,
+        "min_pixels": min_pixel,
+        "max_pixels": max_pixel
+    }
+
+    if width is not None and height is not None:
+        content["resized_width"] = width
+        content["resized_height"] = height
+
+    return content
+
+def get_video_content(video_path, min_pixels, max_pixels, width, height, fps, nframes):
+    content = {
+        "type": "video", 
+        "video": video_path,
+        "min_pixels": min_pixels,
+        "max_pixels": max_pixels,
+    }
+
+    if nframes is not None:
+        content["nframes"] = nframes
+    else:
+        content["fps"] = fps
+
+    if width is not None and height is not None:
+        content["resized_width"] = width
+        content["resized_height"] = height
+    
+    return content
+
+class ClassificationDataset(Dataset):
+    """Dataset for supervised fine-tuning."""
+
+    def __init__(
+        self,
+        data_path: str | list,
+        processor: transformers.ProcessorMixin,
+        data_args: DataArguments,
+        model_id,
+        padding=True,
+    ):
+        super(ClassificationDataset, self).__init__()
+        if isinstance(data_path, str):
+            list_data_dict = json.load(open(data_path, "r"))
+        else:
+            list_data_dict = data_path
+
+        self.compute_dtype = data_args.compute_dtype
+
+        self.model_id = model_id
+        self.processor = processor
+        self.list_data_dict = list_data_dict
+        self.data_args = data_args
+        self.padding = padding
+        self.image_min_pixel = data_args.image_min_pixels
+        self.image_max_pixel = data_args.image_max_pixels
+        self.video_min_pixel = data_args.video_min_pixels
+        self.video_max_pixel = data_args.video_max_pixels
+        self.image_resized_w = data_args.image_resized_width
+        self.image_resized_h = data_args.image_resized_height
+        self.video_resized_w = data_args.video_resized_width
+        self.video_resized_h = data_args.video_resized_height
+        self.fps = data_args.fps
+        self.nframes = data_args.nframes
+
+    def __len__(self):
+        return len(self.list_data_dict)
+
+    def __getitem__(self, i) -> Dict[str, torch.Tensor]:
+        sources = self.list_data_dict[i]
+
+        contents = []
+        
+        if "image" in sources:
+            image_files = sources["image"]
+            image_folder = self.data_args.image_folder
+
+            if isinstance(image_files, str):
+                image_files = [image_files]
+            
+            for image_file in image_files:
+                if not os.path.exists(image_file):
+                    if not image_file.startswith("http"):
+                        image_file = os.path.join(image_folder, image_file)
+                contents.append(get_image_content(image_file, self.image_min_pixel, self.image_max_pixel, self.image_resized_w, self.image_resized_h))
+
+        elif "video" in sources:
+            video_files = sources["video"]
+            video_folder = self.data_args.image_folder
+
+            if isinstance(video_files, str):
+                video_files = [video_files]
+
+            frame_paths = []
+            for video_file in video_files:
+                if not os.path.exists(video_file):
+                    if not video_file.startswith("http"):
+                        video_file = os.path.join(video_folder, video_file)
+                    frame_paths.append(video_file)
+            
+            contents.append(get_video_content(frame_paths, self.video_min_pixel, self.video_max_pixel, self.video_resized_w, self.video_resized_h, self.fps, self.nframes))
+
+        if "prompt" in sources:
+            text_content = {"type": "text", "text": sources["prompt"]}
+
+        else: 
+            text_content = {"type": "text", "text": USER_MESSAGE}
+        
+        contents.append(text_content)
+
+        user_prompt = [{"role": "user", "content": contents}]
+
+        if len(SYSTEM_MESSAGE) > 0:
+            system_message = {"role": "system", "content": SYSTEM_MESSAGE}
+            user_prompt.insert(0, system_message)
+
+        text = self.processor.apply_chat_template(
+            user_prompt, tokenize=False, add_generation_prompt=True
+        )
+
+        image_inputs, video_inputs, video_kwargs = process_vision_info(user_prompt, return_video_kwargs=True)
+
+        data_dict = self.processor(
+            text=text,
+            images=image_inputs,
+            videos=video_inputs,
+            return_tensors="pt",
+            **video_kwargs
+        )
+
+        labels = [torch.tensor(CLASS_2_ID[sources["label"]], dtype=torch.long)]
+
+        # eos_token_id = processor.tokenizer.convert_tokens_to_ids(DEFAULT_IM_END_TOKEN)
+        # input_ids, labels = truncate_sequence(input_ids, labels, self.max_length, eos_token_id)
+
+        attention_mask = (data_dict['input_ids'] > -1000000).to(torch.long)
+
+        data_dict['labels'] = labels
+        data_dict['attention_mask'] = attention_mask
+
+        for key, value in data_dict.items():  # cast data dtype for paligemma
+            if torch.is_tensor(value) and torch.is_floating_point(value):
+                data_dict[key] = value.to(self.compute_dtype)
+        
+        return data_dict
+
+class DataCollatorForClassificationDataset(object):
+    """Collate examples for supervised fine-tuning."""
+
+    def __init__(self, pad_token_id: int, padding_side: str = "right"):
+        self.pad_token_id = pad_token_id
+        self.padding_side = padding_side
+
+    def __call__(self, examples):
+        batch_input_ids = []
+        batch_labels = []
+        batch_pixel_values = []
+        batch_pixel_video_values = []
+        batch_video_thw = []
+        batch_image_thw = []
+        batch_second_per_grid_ts = []
+        
+        for example in examples:
+            keys = example.keys()
+            if "pixel_values_videos" in keys:
+                batch_pixel_video_values.append(example["pixel_values_videos"])
+                batch_video_thw.append(example["video_grid_thw"])
+            elif "pixel_values" in keys:
+                batch_pixel_values.append(example["pixel_values"])
+                batch_image_thw.append(example["image_grid_thw"])
+            
+            batch_input_ids.append(example["input_ids"].squeeze(0))
+            batch_labels.extend(example["labels"])
+
+            if "second_per_grid_ts" in keys:
+                batch_second_per_grid_ts.extend(example["second_per_grid_ts"])
+        
+        input_ids = pad_sequence(
+            batch_input_ids, padding_side=self.padding_side, padding_value=self.pad_token_id
+        )
+        labels = torch.tensor(batch_labels, dtype=torch.long)
+
+        attention_mask = input_ids != self.pad_token_id
+
+        data_dict = {
+            'input_ids': input_ids,
+            'labels': labels,
+            'attention_mask': attention_mask,
+        }
+
+        if len(batch_pixel_values) > 0:
+            pixel_values = torch.cat(batch_pixel_values, dim=0)
+            image_thw = torch.cat(batch_image_thw, dim=0)
+            data_dict["pixel_values"] = pixel_values
+            data_dict["image_grid_thw"] = image_thw
+
+        if len(batch_pixel_video_values) > 0:
+            pixel_video_values = torch.cat(batch_pixel_video_values, dim=0)
+            video_thw = torch.cat(batch_video_thw, dim=0)
+            data_dict["pixel_values_videos"] = pixel_video_values
+            data_dict["video_grid_thw"] = video_thw
+
+        if len(batch_second_per_grid_ts) > 0:
+            data_dict["second_per_grid_ts"] = batch_second_per_grid_ts
+
+        return data_dict
+    
+def make_classification_data_module(model_id, processor, data_args):
+
+    eval_ds = None
+    eval_data_collator = None
+
+    cls_dataset = ClassificationDataset(
+        data_path=data_args.data_path, processor=processor, data_args=data_args, model_id=model_id
+    )
+    train_data_collator = DataCollatorForClassificationDataset(pad_token_id=processor.tokenizer.pad_token_id, padding_side="left")
+
+    labels_list = [CLASS_2_ID[s["label"]] for s in cls_dataset.list_data_dict]
+
+    samples_per_class = samples_per_class_from_ids(
+        labels_list, num_classes=len(CLASS_2_ID)
+    )
+
+    if data_args.eval_path is not None:
+        eval_data_args = copy.deepcopy(data_args)
+        eval_data_args.image_folder = data_args.eval_image_folder
+        eval_data_args.data_path = data_args.eval_path
+        eval_ds = ClassificationDataset(
+            data_path=eval_data_args.data_path, processor=processor, data_args=eval_data_args, model_id=model_id
+        )
+        eval_data_collator = DataCollatorForClassificationDataset(pad_token_id=processor.tokenizer.pad_token_id, padding_side="left")
+
+    return dict(
+            train_dataset=cls_dataset,
+            eval_dataset=eval_ds,
+            train_data_collator=train_data_collator,
+            eval_data_collator=eval_data_collator,
+            samples_per_class=samples_per_class,
+        )

src/dataset/data_utils.py

@@ -0,0 +1,134 @@
+import re
+import torch
+
+from qwen_vl_utils import process_vision_info
+
+from src.constants import (
+    DEFAULT_IMAGE_TOKEN,
+    DEFAULT_VIDEO_TOKEN,
+    LLAVA_IMAGE_TOKEN,
+    LLAVA_VIDEO_TOKEN,
+    VISION_START_TOKEN,
+    VISION_END_TOKEN,
+)
+
+
+def replace_image_tokens(input_string, is_video=False):
+    if is_video:
+        pattern = r'\n?' + re.escape(LLAVA_VIDEO_TOKEN) + r'\n?'
+        replacement = VISION_START_TOKEN + DEFAULT_VIDEO_TOKEN + VISION_END_TOKEN
+    else:
+        pattern = r'\n?' + re.escape(LLAVA_IMAGE_TOKEN) + r'\n?'
+        replacement = VISION_START_TOKEN + DEFAULT_IMAGE_TOKEN + VISION_END_TOKEN
+
+    return re.sub(pattern, replacement, input_string)
+
+def llava_to_openai(conversations, is_video=False):
+    role_mapping = {"human": "user", "gpt": "assistant"}
+
+    transformed_data = []
+    for conversation in conversations:
+        transformed_content = replace_image_tokens(conversation["value"], is_video=is_video)
+        transformed_entry = {
+            "role": role_mapping.get(conversation["from"], conversation["from"]),
+            "content": transformed_content,
+        }
+        transformed_data.append(transformed_entry)
+
+    return transformed_data
+
+
+def truncate_sequence(input_ids, labels, max_length, eos_token_id):
+    if input_ids.size(0) > max_length:
+        input_ids = input_ids[:max_length-1]
+        labels = labels[:max_length-1]
+
+    if eos_token_id is not None:
+        input_ids = torch.cat([input_ids, torch.tensor([eos_token_id])])
+        labels = torch.cat([labels, torch.tensor([eos_token_id])])
+
+    return input_ids, labels
+
+def pad_sequence(sequences, padding_side='right', padding_value=0):
+    """
+    Pad a list of sequences to the same length.
+    sequences: list of tensors in [seq_len, *] shape
+    """
+    assert padding_side in ['right', 'left']
+    max_size = sequences[0].size()
+    trailing_dims = max_size[1:]
+    max_len = max(len(seq) for seq in sequences)
+    batch_size = len(sequences)
+    output = sequences[0].new_full((batch_size, max_len) + trailing_dims, padding_value)
+    for i, seq in enumerate(sequences):
+        length = seq.size(0)
+        if padding_side == 'right':
+            output.data[i, :length] = seq
+        else:
+            output.data[i, -length:] = seq
+    return output
+
+def get_image_info(image_path, min_pixel, max_pixel, width, height, image_patch_size):
+    # Using this because of process_vision_info function
+    # Need to fix this in the future
+    content = {
+        "type": "image", 
+        "image": image_path,
+        "min_pixels": min_pixel,
+        "max_pixels": max_pixel
+    }
+
+    if width is not None and height is not None:
+        content["resized_width"] = width
+        content["resized_height"] = height
+    
+    messages = [
+        {
+            "role": "user", 
+            "content": [content]
+        }
+    ]
+
+    image_input, _ = process_vision_info(messages, image_patch_size=image_patch_size)
+
+    return image_input[0]
+
+def get_video_info(video_path, min_pixels, max_pixels, width, height, fps, image_patch_size, return_video_metadata=False):
+    # Using this because of process_vision_info function
+    # Need to fix this in the future
+    content = {
+        "type": "video", 
+        "video": video_path,
+        "min_pixels": min_pixels,
+        "max_pixels": max_pixels,
+        "fps": fps
+    }
+
+    if width is not None and height is not None:
+        content["resized_width"] = width
+        content["resized_height"] = height
+    
+    messages = [
+        {
+            "role": "user", 
+            "content": [content]
+        }
+    ]
+
+    _, video_input, video_kwargs = process_vision_info(
+        messages, 
+        return_video_kwargs=True, 
+        image_patch_size=image_patch_size, 
+        return_video_metadata=return_video_metadata
+    )
+
+    return video_input[0], video_kwargs
+
+def samples_per_class_from_ids(label_ids, num_classes):
+    
+    counts = torch.bincount(
+        torch.as_tensor(label_ids, dtype=torch.long),
+        minlength=num_classes
+    )
+    
+    return counts.tolist()

src/dataset/dpo_dataset.py

@@ -0,0 +1,314 @@
+import os
+from typing import Dict
+import torch
+import transformers
+import ujson as json
+from torch.utils.data import Dataset
+
+from src.params import DataArguments
+from src.constants import (
+    DEFAULT_IM_START_TOKEN,
+    DEFAULT_IM_END_TOKEN,
+    DEFAULT_IMAGE_TOKEN,
+    DEFAULT_VIDEO_TOKEN,
+    SYSTEM_MESSAGE,
+)
+
+from .data_utils import get_image_info, get_video_info, pad_sequence, replace_image_tokens
+
+
+class DPODataset(Dataset):
+    """Dataset for DPO training"""
+
+    def __init__(
+        self,
+        data_path: str | list,
+        processor: transformers.ProcessorMixin,
+        data_args: DataArguments,
+        model_id,
+        padding=True,
+    ):
+        super(DPODataset, self).__init__()
+        if isinstance(data_path, str):
+            list_data_dict = json.load(open(data_path, "r"))
+        else:
+            list_data_dict = data_path
+
+        self.model_id = model_id
+        self.processor = processor
+        self.list_data_dict = list_data_dict
+        self.data_args = data_args
+        self.padding = padding
+        self.image_min_pixel = data_args.image_min_pixels
+        self.image_max_pixel = data_args.image_max_pixels
+        self.video_min_pixel = data_args.video_min_pixels
+        self.video_max_pixel = data_args.video_max_pixels
+        self.image_resized_w = data_args.image_resized_width
+        self.image_resized_h = data_args.image_resized_height
+        self.video_resized_w = data_args.video_resized_width
+        self.video_resized_h = data_args.video_resized_height
+        self.fps = data_args.fps
+        self.nframes = data_args.nframes
+
+        if "Qwen3" in self.model_id:
+            self.image_patch_size = 16
+            self.return_video_metadata = True
+        else:
+            self.image_patch_size = 14
+            self.return_video_metadata = False
+
+    def __len__(self):
+        return len(self.list_data_dict)
+    
+    def __getitem__(self, i) -> Dict[str, torch.Tensor]:
+        sources = self.list_data_dict[i]
+
+        is_video = False
+        processor = self.processor
+
+        if "image" in sources:
+            videos = None
+            grid_key = "image_grid_thw"
+            pixel_key = "pixel_values"
+            
+            image_files = sources["image"]
+            image_folder = self.data_args.image_folder
+
+            if isinstance(image_files, str):
+                image_files = [image_files]
+
+            images = []
+            
+            for image_file in image_files:
+                if not os.path.exists(image_file):
+                    if not image_file.startswith("http"):
+                        image_file = os.path.join(image_folder, image_file)
+                image_input = get_image_info(
+                        image_file, 
+                        self.image_min_pixel, 
+                        self.image_max_pixel, 
+                        self.image_resized_w, 
+                        self.image_resized_h, 
+                        self.image_patch_size
+                    )
+                images.append(image_input)
+
+        elif "video" in sources:
+            is_video = True
+            images=None
+            grid_key = "video_grid_thw"
+            pixel_key = "pixel_values_videos"
+
+            video_files = sources["video"]
+            video_folder = self.data_args.image_folder
+
+            if isinstance(video_files, str):
+                video_files = [video_files]
+
+            videos = []
+            for video_file in video_files:
+                if not os.path.exists(video_file):
+                    if not video_file.startswith("http"):
+                        video_file = os.path.join(video_folder, video_file)
+                video_input, video_kwargs = get_video_info(
+                    video_file, 
+                    self.video_min_pixel, 
+                    self.video_max_pixel, 
+                    self.video_resized_w, 
+                    self.video_resized_h, 
+                    self.data_args.fps,
+                    self.image_patch_size,
+                    return_video_metadata=self.return_video_metadata
+                )
+                videos.append(video_input)
+        else:
+            grid_key = None
+            pixel_key = None
+            images=None
+            videos=None
+
+        all_input_ids = [] 
+        all_rejected = []
+        all_chosen =[]
+        all_pixel_values = []
+        all_image_grid_thw = []
+        all_second_gird = []
+
+        if len(SYSTEM_MESSAGE) > 0 and "Qwen3" not in self.model_id:
+            system_message = f"{DEFAULT_IM_START_TOKEN}system\n{SYSTEM_MESSAGE}{DEFAULT_IM_END_TOKEN}\n"
+            system_message_input_ids = processor.tokenizer(system_message, add_special_tokens=False, return_tensors='pt')['input_ids'] 
+            
+            all_input_ids.append(system_message_input_ids.squeeze(0))
+
+        user_prompt = replace_image_tokens(sources["prompt"], is_video=is_video)
+        chosen_response = sources["chosen"]
+        rejected_response = sources["rejected"]
+
+        user_input = f"{DEFAULT_IM_START_TOKEN}user\n{user_prompt}{DEFAULT_IM_END_TOKEN}\n{DEFAULT_IM_START_TOKEN}assistant\n"
+        chosen_response = f"{chosen_response}{DEFAULT_IM_END_TOKEN}\n"
+        rejected_response = f"{rejected_response}{DEFAULT_IM_END_TOKEN}\n"
+
+        if DEFAULT_IMAGE_TOKEN in user_input:
+            inputs = processor(text=[user_input], images=images, videos=videos, padding=False, do_resize=False, return_tensors='pt')
+            prompt_input_ids = inputs['input_ids']
+            all_pixel_values.append(inputs[pixel_key])
+            all_image_grid_thw.append(inputs[grid_key])
+        elif DEFAULT_VIDEO_TOKEN in user_input:
+            if "Qwen2.5" in self.model_id:
+                inputs = processor(
+                    text=[user_input], 
+                    images=images, 
+                    videos=videos, 
+                    padding=False, 
+                    do_resize=False, 
+                    return_tensors='pt', 
+                    **video_kwargs
+                )
+                
+                all_second_gird.extend(inputs["second_per_grid_ts"])
+            
+            elif "Qwen3" in self.model_id:
+
+                video_datas, video_metadatas = zip(*videos)
+                video_datas, video_metadatas = list(video_datas), list(video_metadatas)
+                
+                inputs = processor(
+                    text=[user_input], 
+                    images=images, 
+                    videos=video_datas, 
+                    padding=False, 
+                    do_resize=False, 
+                    return_tensors='pt', 
+                    **video_kwargs, 
+                    video_metadata=video_metadatas,
+                )
+            
+            else:
+                inputs = processor(
+                    text=[user_input], 
+                    images=images, 
+                    videos=videos, 
+                    padding=False, 
+                    do_resize=False, 
+                    return_tensors='pt'
+                )
+            
+            prompt_input_ids = inputs['input_ids']
+            all_pixel_values.append(inputs[pixel_key])
+            all_image_grid_thw.append(inputs[grid_key])
+
+        else:
+            prompt_input_ids = processor.tokenizer(user_input, add_special_tokens=False, padding=False, return_tensors='pt')['input_ids']
+
+        input_ids = prompt_input_ids.squeeze(0)
+        chosen_input_ids = processor.tokenizer(chosen_response, add_special_tokens=False, padding=False, return_tensors='pt')['input_ids'].squeeze(0)
+        rejected_input_ids = processor.tokenizer(rejected_response, add_special_tokens=False, padding=False, return_tensors='pt')['input_ids'].squeeze(0)
+
+        all_input_ids.append(input_ids)
+        all_chosen.append(chosen_input_ids)
+        all_rejected.append(rejected_input_ids)
+
+        input_ids = torch.cat(all_input_ids, dim=0).to(torch.long)
+        chosen = torch.cat(all_chosen, dim=0).to(torch.long)
+        rejected = torch.cat(all_rejected, dim=0).to(torch.long)
+        
+        data_dict = dict(
+            prompt_input_ids=input_ids,
+            chosen_input_ids=chosen,
+            rejected_input_ids=rejected,
+        )
+
+        if pixel_key and grid_key:
+            pixel_values = torch.cat(all_pixel_values, dim=0)
+            image_thw = torch.cat(all_image_grid_thw, dim=0)
+            data_dict[pixel_key] = pixel_values
+            data_dict[grid_key] = image_thw
+        
+        if len(all_second_gird) > 0:
+            second_gird = all_second_gird
+            data_dict["second_per_grid_ts"] = second_gird
+
+        return data_dict
+    
+class DataCollatorForDPODataset(object):
+    """Collate examples for DPO fine-tuning."""
+
+    def __init__(self, pad_token_id: int):
+        self.pad_token_id = pad_token_id
+
+    def __call__(self, examples):
+        batch_input_ids = []
+        batch_chosen_ids = []
+        batch_rejected_ids = []
+        batch_pixel_values = []
+        batch_pixel_video_values = []
+        batch_video_thw = []
+        batch_image_thw = []
+        batch_second_per_grid_ts = []
+
+        for example in examples:
+            keys = example.keys()
+            if "pixel_values_videos" in keys:
+                batch_pixel_video_values.append(example["pixel_values_videos"])
+                batch_video_thw.append(example["video_grid_thw"])
+            elif "pixel_values" in keys:
+                batch_pixel_values.append(example["pixel_values"])
+                batch_image_thw.append(example["image_grid_thw"])
+            
+            batch_input_ids.append(example["prompt_input_ids"])
+            batch_chosen_ids.append(example["chosen_input_ids"])
+            batch_rejected_ids.append(example["rejected_input_ids"])
+
+            if "second_per_grid_ts" in keys:
+                batch_second_per_grid_ts.extend(example["second_per_grid_ts"])
+
+        prompt_input_ids = pad_sequence(
+            batch_input_ids, padding_side='right', padding_value=self.pad_token_id
+        )
+
+        chosen = pad_sequence(batch_chosen_ids, padding_side='right', padding_value=self.pad_token_id)
+        rejected = pad_sequence(batch_rejected_ids, padding_side='right', padding_value=self.pad_token_id)
+
+        # torch.argmax used in `trl.trainer.utils.flush_left` does not accept bool tensors on some torch versions
+        # (e.g., torch==2.1); keep masks int to stay compatible.
+        prompt_attention_mask = (prompt_input_ids != self.pad_token_id).long()
+        chosen_attention_mask = (chosen != self.pad_token_id).long()
+        rejected_attention_mask = (rejected != self.pad_token_id).long()
+
+
+        data_dict = {
+            'prompt_input_ids': prompt_input_ids,
+            'prompt_attention_mask': prompt_attention_mask,
+            'chosen_input_ids': chosen,
+            'chosen_attention_mask': chosen_attention_mask,
+            'rejected_input_ids': rejected,
+            'rejected_attention_mask': rejected_attention_mask,
+        }
+
+        if len(batch_pixel_values) > 0:
+            pixel_values = torch.cat(batch_pixel_values, dim=0)
+            image_thw = torch.cat(batch_image_thw, dim=0)
+            data_dict["pixel_values"] = pixel_values
+            data_dict["image_grid_thw"] = image_thw
+
+        if len(batch_pixel_video_values) > 0:
+            pixel_video_values = torch.cat(batch_pixel_video_values, dim=0)
+            video_thw = torch.cat(batch_video_thw, dim=0)
+            data_dict["pixel_values_videos"] = pixel_video_values
+            data_dict["video_grid_thw"] = video_thw
+
+        if len(batch_second_per_grid_ts) > 0:
+            data_dict["second_per_grid_ts"] = batch_second_per_grid_ts
+
+        return data_dict
+    
+def make_dpo_data_module(model_id, processor, data_args):
+    """Make dataset and collator for DPO fine-tuning."""
+    dpo_dataset = DPODataset(
+        data_path=data_args.data_path, processor=processor, data_args=data_args, model_id=model_id
+    )
+    data_collator = DataCollatorForDPODataset(pad_token_id=processor.tokenizer.pad_token_id)
+
+    return dict(train_dataset=dpo_dataset,
+                eval_dataset=None,
+                data_collator=data_collator)

src/dataset/grpo_dataset.py

@@ -0,0 +1,150 @@
+import copy
+import os
+from typing import Dict
+import torch
+import transformers
+import ujson as json
+from torch.utils.data import Dataset
+
+from src.params import DataArguments
+from src.constants import (
+    DEFAULT_IM_START_TOKEN,
+    DEFAULT_IM_END_TOKEN,
+    SYSTEM_MESSAGE,
+)
+
+from .data_utils import get_image_info, get_video_info, llava_to_openai
+
+class GRPODataset(Dataset):
+    """Dataset for DPO training"""
+
+    def __init__(
+        self,
+        data_path: str | list,
+        processor: transformers.ProcessorMixin,
+        data_args: DataArguments,
+        model_id,
+        padding=True,
+    ):
+        super(GRPODataset, self).__init__()
+        if isinstance(data_path, str):
+            list_data_dict = json.load(open(data_path, "r"))
+        else:
+            list_data_dict = data_path
+
+        self.model_id = model_id
+        self.processor = processor
+        self.list_data_dict = list_data_dict
+        self.data_args = data_args
+        self.padding = padding
+        self.image_min_pixel = data_args.image_min_pixels
+        self.image_max_pixel = data_args.image_max_pixels
+        self.video_min_pixel = data_args.video_min_pixels
+        self.video_max_pixel = data_args.video_max_pixels
+        self.image_resized_w = data_args.image_resized_width
+        self.image_resized_h = data_args.image_resized_height
+        self.video_resized_w = data_args.video_resized_width
+        self.video_resized_h = data_args.video_resized_height
+        self.fps = data_args.fps
+        self.nframes = data_args.nframes
+
+        if "Qwen3" in self.model_id:
+            self.image_patch_size = 16
+            self.return_video_metadata = True
+        else:
+            self.image_patch_size = 14
+            self.return_video_metadata = False
+
+        self.processor.image_processor.do_resize = False
+
+    def __len__(self):
+        return len(self.list_data_dict)
+    
+    def __getitem__(self, i) -> Dict[str, torch.Tensor]:
+        sources = self.list_data_dict[i]
+
+        is_video = False
+
+        if "image" in sources:
+            videos = None
+            
+            image_files = sources["image"]
+            image_folder = self.data_args.image_folder
+
+            if isinstance(image_files, str):
+                image_files = [image_files]
+
+            images = []
+            
+            for image_file in image_files:
+                if not os.path.exists(image_file):
+                    if not image_file.startswith("http"):
+                        image_file = os.path.join(image_folder, image_file)
+                image_input = get_image_info(
+                        image_file, 
+                        self.image_min_pixel, 
+                        self.image_max_pixel, 
+                        self.image_resized_w, 
+                        self.image_resized_h, 
+                        self.image_patch_size
+                    )
+                images.append(image_input)
+        elif "video" in sources:
+            is_video = True
+            images=None
+
+            video_files = sources["video"]
+            video_folder = self.data_args.image_folder
+
+            if isinstance(video_files, str):
+                video_files = [video_files]
+
+            videos = []
+            for video_file in video_files:
+                if not os.path.exists(video_file):
+                    if not video_file.startswith("http"):
+                        video_file = os.path.join(video_folder, video_file)
+                video_input, video_kwargs = get_video_info(
+                    video_file, 
+                    self.video_min_pixel, 
+                    self.video_max_pixel, 
+                    self.video_resized_w, 
+                    self.video_resized_h, 
+                    self.data_args.fps,
+                    self.image_patch_size,
+                    return_video_metadata=self.return_video_metadata
+                )
+                videos.append(video_input)
+        else:
+            images=None
+            videos=None
+
+        conversations = copy.deepcopy(llava_to_openai(sources['conversations'], is_video=is_video))
+
+        user_input = conversations[0]
+        gpt_response = conversations[1]
+
+        system_message = f"{DEFAULT_IM_START_TOKEN}system\n{SYSTEM_MESSAGE}{DEFAULT_IM_END_TOKEN}\n"
+        user_message = f"{DEFAULT_IM_START_TOKEN}{user_input['role']}\n{user_input['content']}{DEFAULT_IM_END_TOKEN}\n{DEFAULT_IM_START_TOKEN}{gpt_response['role']}\n"
+
+        user_prompt = system_message + user_message
+        assistant_prompt = gpt_response['content']
+
+        data_dict = dict(
+            prompt=user_prompt,
+            assistant=assistant_prompt,
+            images=images,
+            videos=videos,
+            video_kwargs=video_kwargs if is_video else None,
+        )
+
+        return data_dict
+    
+def make_grpo_data_module(model_id, processor, data_args):
+    """Make dataset and collator for supervised fine-tuning."""
+    grpo_dataset = GRPODataset(
+        data_path=data_args.data_path, processor=processor, data_args=data_args, model_id=model_id
+    )
+
+    return dict(train_dataset=grpo_dataset,
+                eval_dataset=None)

src/dataset/sft_dataset.py

@@ -0,0 +1,338 @@
+import copy
+import os
+from typing import Dict
+import torch
+import transformers
+import ujson as json
+from torch.utils.data import Dataset
+
+from src.params import DataArguments
+from src.constants import (
+    IGNORE_INDEX,
+    DEFAULT_IM_START_TOKEN,
+    DEFAULT_IM_END_TOKEN,
+    DEFAULT_IMAGE_TOKEN,
+    DEFAULT_VIDEO_TOKEN,
+    SYSTEM_MESSAGE,
+)
+
+from .data_utils import get_image_info, get_video_info, llava_to_openai, pad_sequence
+
+class SupervisedDataset(Dataset):
+    """Dataset for supervised fine-tuning."""
+
+    def __init__(
+        self,
+        data_path: str | list,
+        processor: transformers.ProcessorMixin,
+        data_args: DataArguments,
+        model_id,
+        padding=True,
+    ):
+        super(SupervisedDataset, self).__init__()
+        if isinstance(data_path, str):
+            list_data_dict = json.load(open(data_path, "r"))
+        else:
+            list_data_dict = data_path
+
+        self.model_id = model_id
+        self.processor = processor
+        self.list_data_dict = list_data_dict
+        self.data_args = data_args
+        self.padding = padding
+        self.image_min_pixel = data_args.image_min_pixels
+        self.image_max_pixel = data_args.image_max_pixels
+        self.video_min_pixel = data_args.video_min_pixels
+        self.video_max_pixel = data_args.video_max_pixels
+        self.image_resized_w = data_args.image_resized_width
+        self.image_resized_h = data_args.image_resized_height
+        self.video_resized_w = data_args.video_resized_width
+        self.video_resized_h = data_args.video_resized_height
+        self.fps = data_args.fps
+        self.nframes = data_args.nframes
+
+        if "Qwen3" in self.model_id:
+            self.image_patch_size = 16
+            self.return_video_metadata = True
+        else:
+            self.image_patch_size = 14
+            self.return_video_metadata = False
+
+    def __len__(self):
+        return len(self.list_data_dict)
+
+    def __getitem__(self, i) -> Dict[str, torch.Tensor]:
+        sources = self.list_data_dict[i]
+
+        is_video = False
+
+        processor = self.processor
+        if "image" in sources:
+            videos = None
+            grid_key = "image_grid_thw"
+            pixel_key = "pixel_values"
+
+            image_files = sources["image"]
+            image_folder = self.data_args.image_folder
+
+            if isinstance(image_files, str):
+                image_files = [image_files]
+
+            images = []
+
+            for image_file in image_files:
+                if not os.path.exists(image_file):
+                    if not image_file.startswith("http"):
+                        image_file = os.path.join(image_folder, image_file)
+                image_input = get_image_info(
+                        image_file, 
+                        self.image_min_pixel, 
+                        self.image_max_pixel, 
+                        self.image_resized_w, 
+                        self.image_resized_h, 
+                        self.image_patch_size
+                    )
+                images.append(image_input)
+
+        elif "video" in sources:
+            is_video = True
+            images=None
+            grid_key = "video_grid_thw"
+            pixel_key = "pixel_values_videos"
+
+            video_files = sources["video"]
+            video_folder = self.data_args.image_folder
+
+            if isinstance(video_files, str):
+                video_files = [video_files]
+
+            videos = []
+            for video_file in video_files:
+                if not os.path.exists(video_file):
+                    if not video_file.startswith("http"):
+                        video_file = os.path.join(video_folder, video_file)
+                video_input, video_kwargs = get_video_info(
+                    video_file, 
+                    self.video_min_pixel, 
+                    self.video_max_pixel, 
+                    self.video_resized_w, 
+                    self.video_resized_h, 
+                    self.data_args.fps,
+                    self.image_patch_size,
+                    return_video_metadata=self.return_video_metadata
+                )
+                videos.append(video_input)
+        else:
+            grid_key = None
+            pixel_key = None
+            images=None
+            videos=None
+
+        sources = copy.deepcopy(llava_to_openai(sources['conversations'], is_video=is_video))
+
+        all_input_ids = []
+        all_labels = []
+        all_pixel_values = []
+        all_image_grid_thw = []
+        all_second_gird = []
+
+        image_curr_count = 0
+        video_curr_count = 0
+        
+        # Qwen2-VL uses a default system message so I've added this.
+        # Qwen3-Vl does not use a system message by default.
+        if len(SYSTEM_MESSAGE) > 0 and "Qwen3" not in self.model_id:
+            system_message = f"{DEFAULT_IM_START_TOKEN}system\n{SYSTEM_MESSAGE}{DEFAULT_IM_END_TOKEN}\n"
+            system_message_input_ids = processor.tokenizer(system_message, add_special_tokens=False, return_tensors='pt')['input_ids']
+            system_labels = torch.full_like(system_message_input_ids, IGNORE_INDEX)
+
+            all_input_ids.append(system_message_input_ids.squeeze(0))
+            all_labels.append(system_labels.squeeze(0))
+
+        for _, j in enumerate(range(0, len(sources), 2)):
+            user_input = sources[j]
+            gpt_response = sources[j + 1]
+
+            user_input = f"{DEFAULT_IM_START_TOKEN}{user_input['role']}\n{user_input['content']}{DEFAULT_IM_END_TOKEN}\n{DEFAULT_IM_START_TOKEN}{gpt_response['role']}\n"
+            gpt_response = f"{gpt_response['content']}{DEFAULT_IM_END_TOKEN}\n"
+
+            if DEFAULT_IMAGE_TOKEN in user_input:
+                num_images = user_input.count(DEFAULT_IMAGE_TOKEN)
+                # Slice the images list to get the images for the current turn.
+                images_for_this_turn = images[image_curr_count : image_curr_count + num_images]
+                inputs = processor(text=[user_input], images=images_for_this_turn, videos=videos, padding=False, do_resize=False, return_tensors='pt')
+                prompt_input_ids = inputs['input_ids']
+                all_pixel_values.append(inputs[pixel_key])
+                all_image_grid_thw.append(inputs[grid_key])
+                image_curr_count += num_images
+
+            elif DEFAULT_VIDEO_TOKEN in user_input:
+                num_videos = user_input.count(DEFAULT_VIDEO_TOKEN)
+                # Slice the videos list to get the videos for the current turn.
+                videos_for_this_turn = videos[video_curr_count : video_curr_count + num_videos]
+                if "Qwen2.5" in self.model_id:
+                    inputs = processor(
+                        text=[user_input], 
+                        images=images, 
+                        videos=videos_for_this_turn, 
+                        padding=False, 
+                        do_resize=False, 
+                        return_tensors='pt', 
+                        **video_kwargs
+                    )
+                    all_second_gird.extend(inputs["second_per_grid_ts"])
+                elif "Qwen3" in self.model_id:
+
+                    videos_for_this_turn = videos[video_curr_count : video_curr_count + num_videos]
+                    video_datas_for_turn, video_metadatas_for_turn = zip(*videos_for_this_turn)
+                    video_datas_for_turn = list(video_datas_for_turn)
+                    video_metadatas_for_turn = list(video_metadatas_for_turn)
+
+                    inputs = processor(
+                        text=[user_input],
+                        images=images,
+                        videos=video_datas_for_turn,
+                        padding=False,
+                        do_resize=False,
+                        return_tensors='pt',
+                        **video_kwargs,
+                        video_metadata=video_metadatas_for_turn,
+                    )
+                else:
+                    inputs = processor(
+                        text=[user_input], 
+                        images=images, 
+                        videos=videos_for_this_turn, 
+                        padding=False, 
+                        do_resize=False, 
+                        return_tensors='pt'
+                    )
+                prompt_input_ids = inputs['input_ids']
+                all_pixel_values.append(inputs[pixel_key])
+                all_image_grid_thw.append(inputs[grid_key])
+                video_curr_count += num_videos
+
+            else:
+                prompt_input_ids = processor.tokenizer(user_input, add_special_tokens=False, padding=False, return_tensors='pt')['input_ids']
+
+            response_input_ids = processor.tokenizer(gpt_response, add_special_tokens=False, padding=False, return_tensors='pt')['input_ids']
+
+            input_ids = torch.cat([prompt_input_ids, response_input_ids], dim=1).squeeze(0)
+            labels = torch.cat(
+                [
+                    torch.tensor([IGNORE_INDEX] * len(prompt_input_ids[0])),
+                    response_input_ids.squeeze(0),
+                ],
+                dim=0,
+            )
+
+            all_input_ids.append(input_ids)
+            all_labels.append(labels)
+
+        # There is no need for eos or bos tokens in the input_ids
+        # Qwen2-VL does not use them
+        input_ids = torch.cat(all_input_ids, dim=0).to(torch.long)
+        labels = torch.cat(all_labels, dim=0).to(torch.long)
+
+        # eos_token_id = processor.tokenizer.convert_tokens_to_ids(DEFAULT_IM_END_TOKEN)
+        # input_ids, labels = truncate_sequence(input_ids, labels, self.max_length, eos_token_id)
+
+        attention_mask = (input_ids > -1000000).to(torch.long)
+
+        data_dict = dict(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            labels=labels,
+        )
+
+        if pixel_key and grid_key:
+            pixel_values = torch.cat(all_pixel_values, dim=0)
+            image_thw = torch.cat(all_image_grid_thw, dim=0)
+            data_dict[pixel_key] = pixel_values
+            data_dict[grid_key] = image_thw
+
+        if len(all_second_gird) > 0:
+            second_gird = all_second_gird
+            data_dict["second_per_grid_ts"] = second_gird
+
+        return data_dict
+
+class DataCollatorForSupervisedDataset(object):
+    """Collate examples for supervised fine-tuning."""
+
+    def __init__(self, pad_token_id: int):
+        self.pad_token_id = pad_token_id
+
+    def __call__(self, examples):
+        batch_input_ids = []
+        batch_label_ids = []
+        batch_pixel_values = []
+        batch_pixel_video_values = []
+        batch_video_thw = []
+        batch_image_thw = []
+        batch_second_per_grid_ts = []
+
+        for example in examples:
+            keys = example.keys()
+            if "pixel_values_videos" in keys:
+                batch_pixel_video_values.append(example["pixel_values_videos"])
+                batch_video_thw.append(example["video_grid_thw"])
+            elif "pixel_values" in keys:
+                batch_pixel_values.append(example["pixel_values"])
+                batch_image_thw.append(example["image_grid_thw"])
+
+            batch_input_ids.append(example["input_ids"])
+            batch_label_ids.append(example["labels"])
+
+            if "second_per_grid_ts" in keys:
+                batch_second_per_grid_ts.extend(example["second_per_grid_ts"])
+
+        input_ids = pad_sequence(
+            batch_input_ids, padding_side='right', padding_value=self.pad_token_id
+        )
+
+        attention_mask = input_ids != self.pad_token_id
+        labels = pad_sequence(batch_label_ids, padding_side='right', padding_value=IGNORE_INDEX)
+
+        data_dict = {
+            'input_ids': input_ids,
+            'labels': labels,
+            'attention_mask': attention_mask,
+        }
+
+        if len(batch_pixel_values) > 0:
+            pixel_values = torch.cat(batch_pixel_values, dim=0)
+            image_thw = torch.cat(batch_image_thw, dim=0)
+            data_dict["pixel_values"] = pixel_values
+            data_dict["image_grid_thw"] = image_thw
+
+        if len(batch_pixel_video_values) > 0:
+            pixel_video_values = torch.cat(batch_pixel_video_values, dim=0)
+            video_thw = torch.cat(batch_video_thw, dim=0)
+            data_dict["pixel_values_videos"] = pixel_video_values
+            data_dict["video_grid_thw"] = video_thw
+
+        if len(batch_second_per_grid_ts) > 0:
+            data_dict["second_per_grid_ts"] = batch_second_per_grid_ts
+
+        return data_dict
+
+def make_supervised_data_module(model_id, processor, data_args):
+    """Make dataset and collator for supervised fine-tuning."""
+    sft_dataset = SupervisedDataset(
+        data_path=data_args.data_path, processor=processor, data_args=data_args, model_id=model_id
+    )
+    eval_dataset = None
+    if data_args.eval_path is not None:
+        eval_dataset = SupervisedDataset(
+              data_path=data_args.eval_path,
+              processor=processor,
+              data_args=data_args,
+              model_id=model_id
+          )
+        
+    data_collator = DataCollatorForSupervisedDataset(pad_token_id=processor.tokenizer.pad_token_id)
+
+    return dict(train_dataset=sft_dataset,
+                eval_dataset=eval_dataset,
+                data_collator=data_collator)

src/loss/__init__.py

@@ -0,0 +1,5 @@
+from .loss_factory import get_loss_function
+
+__all__= [
+    "get_loss_function",
+]

src/loss/class_balance_loss.py

@@ -0,0 +1,60 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+class ClassBalancedCrossEntropyLoss(nn.Module):
+    """
+    Class‑Balanced Cross‑Entropy (CB‑CE)
+    """
+    def __init__(self, samples_per_cls, beta=0.999, reduction="mean"):
+        """
+        samples_per_cls : list[int]  # 각 클래스로부터의 원본 샘플 개수
+        beta            : float      # 0.9~0.999 사이 권장 (0이면 일반 CE와 동일)
+        """
+        super().__init__()
+        eff_num = 1.0 - np.power(beta, samples_per_cls)
+        weights = (1.0 - beta) / np.array(eff_num)
+        weights = weights / weights.sum() * len(samples_per_cls)          # 정규화
+        self.register_buffer("weights", torch.tensor(weights, dtype=torch.float32))
+        self.reduction = reduction
+
+    def forward(self, logits, targets):
+        """
+        logits  : [B, C]
+        targets : [B]  (long)
+        """
+        loss = F.cross_entropy(
+            logits, targets,
+            weight=self.weights.to(logits.device),
+            reduction=self.reduction
+        )
+        return loss
+    
+class ClassBalancedFocalLoss(nn.Module):
+    def __init__(self, samples_per_cls, beta=0.9995, gamma=1.5, reduction="mean"):
+        super().__init__()
+        eff = 1.0 - np.power(beta, samples_per_cls)
+        w = (1.0 - beta) / eff
+        w = w / w.sum() * len(samples_per_cls)
+        self.register_buffer("weights", torch.tensor(w, dtype=torch.float32))
+        self.gamma = float(gamma)
+        self.reduction = reduction
+
+    def forward(self, logits, targets):
+        targets = targets.long().to(logits.device)
+        weights = self.weights.to(device=logits.device, dtype=logits.dtype)
+
+        log_probs = F.log_softmax(logits, dim=1)
+        log_pt = log_probs.gather(1, targets.unsqueeze(1)).squeeze(1)  # [B]
+        pt = log_pt.exp().clamp_min(1e-8)                               # [B]
+
+        cb_w = weights[targets]                                         # [B]
+        loss = -cb_w * (1.0 - pt).pow(self.gamma) * log_pt              # [B]
+
+        if self.reduction == "mean":
+            return loss.sum() / (cb_w.sum() + 1e-12)  # ← CE와 동일 스케일
+        elif self.reduction == "sum":
+            return loss.sum()
+        else:
+            return loss

src/loss/focal_loss.py

@@ -0,0 +1,44 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class FocalLossCE(nn.Module):
+    """
+    Plain Focal Loss (multi-class), optional class weights alpha
+    - gamma=0, alpha=None  → nn.CrossEntropyLoss(mean)와 동일 스케일
+    - gamma=0, alpha!=None → nn.CrossEntropyLoss(weight=alpha, mean)와 동일 스케일
+    """
+    def __init__(self, alpha=None, gamma=1.5, reduction="mean"):
+        super().__init__()
+        if alpha is not None and not torch.is_tensor(alpha):
+            alpha = torch.tensor(alpha, dtype=torch.float32)
+        # 빈 텐서는 "가중치 없음" 신호로 사용
+        self.register_buffer("alpha", alpha if alpha is not None else torch.tensor([]))
+        self.gamma = float(gamma)
+        self.reduction = reduction
+
+    def forward(self, logits, targets):
+        """
+        logits:  [B, C]
+        targets: [B] (long)
+        """
+        targets = targets.long().to(logits.device)
+        log_probs = F.log_softmax(logits, dim=1)                           # [B, C]
+        log_pt = log_probs.gather(1, targets.unsqueeze(1)).squeeze(1)      # [B]
+        pt = log_pt.exp().clamp_min(1e-8)                                   # [B]
+
+        if self.alpha.numel() > 0:
+            alpha_t = self.alpha.to(device=logits.device, dtype=logits.dtype)[targets]  # [B]
+        else:
+            alpha_t = torch.ones_like(pt)
+
+        loss = -alpha_t * (1.0 - pt).pow(self.gamma) * log_pt               # [B]
+
+        if self.reduction == "mean":
+            # CE의 "가중 평균"과 스케일 일치: 분모를 가중치 합으로
+            denom = (alpha_t.sum() if self.alpha.numel() > 0 else pt.new_tensor(len(pt)))
+            return loss.sum() / (denom + 1e-12)
+        elif self.reduction == "sum":
+            return loss.sum()
+        else:
+            return loss

src/loss/loss_factory.py

@@ -0,0 +1,21 @@
+from .class_balance_loss import ClassBalancedCrossEntropyLoss, ClassBalancedFocalLoss
+from .focal_loss import FocalLossCE
+import torch.nn as nn
+
+def get_loss_function(training_args, samples_per_class=None):
+    
+    if training_args.loss_type == "cross_entropy":
+        return nn.CrossEntropyLoss()
+    
+    elif training_args.loss_type == "focal_loss":
+        alpha = None if training_args.focal_alpha is None else [float(a) for a in training_args.focal_alpha.split(",")]
+        return FocalLossCE(alpha=alpha, gamma=training_args.focal_gamma, reduction="mean")
+    
+    elif training_args.loss_type == "class_balanced_cross_entropy":
+        return ClassBalancedCrossEntropyLoss(samples_per_cls=samples_per_class, beta=training_args.class_balanced_beta, reduction="mean")
+    
+    elif training_args.loss_type == "class_balanced_focal_loss":
+        return ClassBalancedFocalLoss(samples_per_cls=samples_per_class, beta=training_args.class_balanced_beta, gamma=training_args.focal_gamma, reduction="mean")
+
+    else:
+        raise ValueError(f"Unknown loss type: {training_args.loss_type}")

src/merge_lora_weights.py

@@ -0,0 +1,22 @@
+import argparse
+from utils import get_model_name_from_path, load_pretrained_model
+
+def merge_lora(args):
+    model_name = get_model_name_from_path(args.model_path)
+    processor, model = load_pretrained_model(model_path=args.model_path, model_base=args.model_base,
+                                             model_name=model_name, device_map='cpu')
+
+    model.save_pretrained(args.save_model_path, safe_serialization=args.safe_serialization)
+    processor.save_pretrained(args.save_model_path)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-path", type=str, required=True)
+    parser.add_argument("--model-base", type=str, required=True)
+    parser.add_argument("--save-model-path", type=str, required=True)
+    parser.add_argument("--safe-serialization", action='store_true')
+
+    args = parser.parse_args()
+
+    merge_lora(args)

src/model/__init__.py

@@ -0,0 +1,6 @@
+from .modeling_cls import Qwen2VLForSequenceClassification, Qwen2_5_VLForSequenceClassification
+
+__all__ = [
+    "Qwen2VLForSequenceClassification",
+    "Qwen2_5_VLForSequenceClassification",
+]

src/model/modeling_cls.py

@@ -0,0 +1,368 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+from typing import Optional, Tuple, Union, Dict, Any, List
+
+from transformers.modeling_outputs import SequenceClassifierOutputWithPast
+from transformers.models.qwen2_vl.modeling_qwen2_vl import (
+    Qwen2VLPreTrainedModel,
+    Qwen2VLModel,
+    Qwen2VisionTransformerPretrainedModel,
+)
+from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import (
+    Qwen2_5_VLPreTrainedModel,
+    Qwen2_5_VLModel
+)
+from transformers.models.qwen2_5_vl.configuration_qwen2_5_vl import Qwen2_5_VLConfig
+from train.monkey_patch_vision import replace_qwen2_5_vision
+
+replace_qwen2_5_vision()
+
+class Qwen2VLForSequenceClassification(Qwen2VLPreTrainedModel):
+    _checkpoint_conversion_mapping = {
+        "^visual": "model.visual",
+        r"^model(?!\.(language_model|visual))": "model.language_model",
+    }
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        bridge_h = config.mlp_head_hidden_dim
+        bridge_p = config.mlp_head_dropout
+
+        self.model = Qwen2VLModel(config)
+        
+        self.bridge = None
+        in_dim = config.hidden_size
+        if bridge_h > 0:
+            self.bridge = nn.Sequential(
+                nn.Linear(config.hidden_size, bridge_h),
+                nn.GELU(),
+                nn.Dropout(bridge_p),
+            )
+            nn.init.xavier_uniform_(self.bridge[0].weight, gain=1.0)
+            nn.init.zeros_(self.bridge[0].bias)
+            in_dim = bridge_h
+            
+        self.score = nn.Linear(in_dim, self.num_labels, bias=False)
+        nn.init.normal_(self.score.weight, std=1e-3)
+
+        self.loss_fn = None
+        
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.model.get_input_embeddings()
+
+    def set_input_embeddings(self, value):
+        self.model.set_input_embeddings(value)
+
+    def set_decoder(self, decoder):
+        self.model.set_decoder(decoder)
+
+    def get_decoder(self):
+        return self.model.get_decoder()
+    
+    def get_video_features(
+        self, pixel_values_videos: torch.FloatTensor, video_grid_thw: Optional[torch.LongTensor] = None
+    ):
+        return self.model.get_video_features(pixel_values_videos, video_grid_thw)
+
+    def get_image_features(self, pixel_values: torch.FloatTensor, image_grid_thw: Optional[torch.LongTensor] = None):
+        return self.model.get_image_features(pixel_values, image_grid_thw)
+    
+    @property
+    def language_model(self):
+        return self.model.language_model
+
+    @property
+    def visual(self):
+        return self.model.visual
+
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        pixel_values: Optional[torch.Tensor] = None,
+        pixel_values_videos: Optional[torch.FloatTensor] = None,
+        image_grid_thw: Optional[torch.LongTensor] = None,
+        video_grid_thw: Optional[torch.LongTensor] = None,
+        cache_position: Optional[torch.LongTensor] = None,
+        rope_deltas: Optional[torch.LongTensor] = None,
+        **kwargs,
+    ) -> Union[Tuple, SequenceClassifierOutputWithPast]:
+        
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        
+        outputs = self.model(
+            input_ids=input_ids,
+            pixel_values=pixel_values,
+            pixel_values_videos=pixel_values_videos,
+            image_grid_thw=image_grid_thw,
+            video_grid_thw=video_grid_thw,
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=True,
+            cache_position=cache_position,
+            **kwargs,
+        )
+
+        hidden_states = outputs.last_hidden_state
+        feats = self.bridge(hidden_states) if self.bridge is not None else hidden_states
+
+        if input_ids is not None:
+            batch_size, _ = input_ids.shape[:2]
+        else:
+            batch_size, _ = inputs_embeds.shape[:2]
+
+        if self.config.pad_token_id is None and batch_size != 1:
+            raise ValueError(
+                "Cannot handle batch sizes > 1 if no padding token is defined."
+            )
+
+        if self.config.pad_token_id is None:
+            sequence_lengths = torch.full((batch_size,), -1, device=feats.device)
+        else:
+            if input_ids is not None:
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(feats.device)
+
+                token_indices = torch.arange(
+                    input_ids.size(-1), device=feats.device, dtype=torch.long
+                )
+                sequence_lengths = (token_indices * non_pad_mask).argmax(dim=-1)
+            else:
+                sequence_lengths = torch.full((batch_size,), -1, device=feats.device)
+
+        pooled_feats = feats[torch.arange(batch_size, device=feats.device), sequence_lengths]
+        pooled_logits = self.score(pooled_feats)
+
+        loss: Optional[torch.Tensor] = None
+
+        if labels is not None:
+            labels = labels.to(pooled_logits.device)
+            if self.config.problem_type is None:
+                # automatically infer
+                if self.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.num_labels > 1 and labels.dtype in (
+                    torch.long,
+                    torch.int,
+                ):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = MSELoss()
+                loss = loss_fct(pooled_logits.squeeze(), labels.squeeze())
+            elif self.config.problem_type == "single_label_classification":
+                if hasattr(self, "loss_fn") and self.loss_fn is not None:
+                    loss_fct = self.loss_fn
+                else:
+                    loss_fct = CrossEntropyLoss()
+                loss = loss_fct(pooled_logits.view(-1, self.num_labels), labels.view(-1))
+            else:  # multi-label
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(pooled_logits, labels)
+
+        return SequenceClassifierOutputWithPast(
+            loss=loss,
+            logits=pooled_logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+    
+
+class Qwen2_5_VLForSequenceClassification(Qwen2_5_VLPreTrainedModel):
+    _checkpoint_conversion_mapping = {
+        "^visual": "model.visual",
+        r"^model(?!\.(language_model|visual))": "model.language_model",
+    }
+    accepts_loss_kwargs = False
+    
+    def __init__(self, config):
+        super().__init__(config)
+        self.num_labels = config.num_labels
+        bridge_h = config.mlp_head_hidden_dim
+        bridge_p = config.mlp_head_dropout
+        self.model = Qwen2_5_VLModel(config)
+        
+        self.bridge = None
+        in_dim = config.hidden_size
+        if bridge_h > 0:
+            self.bridge = nn.Sequential(
+                nn.Linear(config.hidden_size, bridge_h),
+                nn.GELU(),
+                nn.Dropout(bridge_p),
+            )
+            nn.init.xavier_uniform_(self.bridge[0].weight, gain=1.0)
+            nn.init.zeros_(self.bridge[0].bias)
+            in_dim = bridge_h
+            
+        self.score = nn.Linear(in_dim, self.num_labels, bias=False)
+        nn.init.normal_(self.score.weight, std=1e-3)
+
+        self.loss_fn = None
+        
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.model.get_input_embeddings()
+
+    def set_input_embeddings(self, value):
+        self.model.set_input_embeddings(value)
+
+    def set_decoder(self, decoder):
+        self.model.set_decoder(decoder)
+
+    def get_decoder(self):
+        return self.model.get_decoder()
+    
+    def get_video_features(
+        self, pixel_values_videos: torch.FloatTensor, video_grid_thw: Optional[torch.LongTensor] = None
+    ):
+        return self.model.get_video_features(pixel_values_videos, video_grid_thw)
+
+    def get_image_features(self, pixel_values: torch.FloatTensor, image_grid_thw: Optional[torch.LongTensor] = None):
+        return self.model.get_image_features(pixel_values, image_grid_thw)
+
+    # Make modules available through conditional class for BC
+    @property
+    def language_model(self):
+        return self.model.language_model
+
+    @property
+    def visual(self):
+        return self.model.visual
+
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        pixel_values: Optional[torch.Tensor] = None,
+        pixel_values_videos: Optional[torch.FloatTensor] = None,
+        image_grid_thw: Optional[torch.LongTensor] = None,
+        video_grid_thw: Optional[torch.LongTensor] = None,
+        rope_deltas: Optional[torch.LongTensor] = None,
+        cache_position: Optional[torch.LongTensor] = None,
+        second_per_grid_ts: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> Union[Tuple, SequenceClassifierOutputWithPast]:
+        
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        
+        outputs = self.model(
+            input_ids=input_ids,
+            pixel_values=pixel_values,
+            pixel_values_videos=pixel_values_videos,
+            image_grid_thw=image_grid_thw,
+            video_grid_thw=video_grid_thw,
+            second_per_grid_ts=second_per_grid_ts,
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=True,
+            cache_position=cache_position,
+            **kwargs,
+        )
+
+        hidden_states = outputs.last_hidden_state
+        feats = self.bridge(hidden_states) if self.bridge is not None else hidden_states
+
+
+        if input_ids is not None:
+            batch_size, _ = input_ids.shape[:2]
+        else:
+            batch_size, _ = inputs_embeds.shape[:2]
+
+        if self.config.pad_token_id is None and batch_size != 1:
+            raise ValueError(
+                "Cannot handle batch sizes > 1 if no padding token is defined."
+            )
+
+        if self.config.pad_token_id is None:
+            sequence_lengths = torch.full((batch_size,), -1, device=feats.device)
+        else:
+            if input_ids is not None:
+                non_pad_mask = (input_ids != self.config.pad_token_id).to(feats.device)
+
+                token_indices = torch.arange(
+                    input_ids.size(-1), device=feats.device, dtype=torch.long
+                )
+                sequence_lengths = (token_indices * non_pad_mask).argmax(dim=-1)
+            else:
+                sequence_lengths = torch.full((batch_size,), -1, device=feats.device)
+        
+        
+        pooled_feats = feats[torch.arange(batch_size, device=feats.device), sequence_lengths]
+        pooled_logits = self.score(pooled_feats)
+
+        loss: Optional[torch.Tensor] = None
+        
+        if labels is not None:
+            labels = labels.to(pooled_logits.device)
+            if self.config.problem_type is None:
+                # automatically infer
+                if self.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.num_labels > 1 and labels.dtype in (
+                    torch.long,
+                    torch.int,
+                ):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = MSELoss()
+                loss = loss_fct(pooled_logits.squeeze(), labels.squeeze())
+            elif self.config.problem_type == "single_label_classification":
+                if hasattr(self, "loss_fn") and self.loss_fn is not None:
+                    loss_fct = self.loss_fn
+                else:
+                    loss_fct = CrossEntropyLoss()
+                loss = loss_fct(pooled_logits.view(-1, self.num_labels), labels.view(-1))
+            else:  # multi-label
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(pooled_logits, labels)
+
+        return SequenceClassifierOutputWithPast(
+            loss=loss,
+            logits=pooled_logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )

src/params.py

@@ -0,0 +1,298 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+try:
+    from accelerate.utils import ParallelismConfig as _PC
+except Exception:
+    class _PC:
+        pass
+
+import transformers.training_args as _ta
+if not hasattr(_ta, "ParallelismConfig"):
+    _ta.ParallelismConfig = _PC
+
+from transformers import TrainingArguments as HFTrainingArguments
+from trl import DPOConfig as DPOConfigTRL
+from trl import GRPOConfig as GRPOConfigTRL
+
+
+@dataclass
+class ModelArguments:
+    model_id: Optional[str] = field(default="Qwen/Qwen2-VL-7B-Instruct")
+
+
+@dataclass
+class CLSArguments(HFTrainingArguments):
+    cache_dir: Optional[str] = field(default=None)
+    optim: str = field(default="adamw_torch")
+    adam_beta1: float = field(default=0.9)
+    adam_beta2: float = field(default=0.999)
+    adam_epsilon: float = field(default=1e-8)
+
+    freeze_vision_tower: bool = field(default=False)
+    freeze_llm: bool = field(default=False)
+    freeze_merger: bool = field(default=False)
+    disable_flash_attn2: bool = field(default=False)
+    unfreeze_topk_llm: int = 0
+    unfreeze_topk_vision: int = 0
+    mlp_head_dim: Optional[int] = field(default=0)
+    mlp_head_dropout: Optional[float] = field(default=0.0)
+    
+    loss_type : str = field(
+        default="cross_entropy",
+        metadata={"help": "Loss type to use. Should be one of `cross_entropy`, `focal_loss`, `class_balanced_cross_entropy`, or `class_balanced_focal_loss`."}
+    )
+    focal_alpha: Optional[str] = field(
+        default=None,
+        metadata={"help": "Focal Loss alpha value. If None use CrossEntropyLoss. ex '1.0,7.5'"}
+    )
+    focal_gamma: float = field(
+        default=0.0,
+        metadata={"help": "Focal Loss gamma value"}
+    )
+    num_labels: int = field(
+        default=2,
+        metadata={"help": "Number of labels for classification."}
+    )
+    class_balanced_beta: float = field(
+        default=0.999,
+        metadata={"help": "Beta value for Class Balanced Loss. If 0.0, use standard CrossEntropyLoss."}
+    )
+    early_stopping_patience: int = field(
+        default=0,
+        metadata={"help": "Number of epochs with no improvement after which training will be stopped."}
+    )
+    early_stopping_threshold: float = field(
+        default=0.0,
+        metadata={"help": "Minimum change in the monitored quantity to qualify as an improvement."}
+    )
+
+    max_seq_length: int = field(
+        default=32768, # This is the default value of the qwen2-vl model
+        metadata={
+            "help":
+                "Maximum sequence length. Sequences will be right padded (and possibly truncated)."
+        },
+    )
+    double_quant: bool = field(
+        default=True,
+        metadata={"help": "Compress the quantization statistics through double quantization."}
+    )
+    quant_type: str = field(
+        default="nf4",
+        metadata={"help": "Quantization data type to use. Should be one of `fp4` or `nf4`."}
+    )
+    bits: int = field(
+        default=16,
+        metadata={"help": "How many bits to use."}
+    )
+    lora_enable: bool = False
+    vision_lora: bool = False
+    use_dora: bool = False
+    lora_rank: int = 64
+    lora_alpha: int = 16
+    lora_dropout: float = 0.05
+    lora_weight_path: str = ""
+    lora_bias: str = "none"
+    vision_lr: Optional[float] = None
+    merger_lr: Optional[float] = None
+    head_lr: Optional[float] = None
+    lora_namespan_exclude: str = field(default=None, metadata={"help": "List of namespan to exclude for LoRA"})
+    num_lora_modules: int = -1
+    use_liger_kernel: bool = True
+
+
+@dataclass
+class TrainingArguments(HFTrainingArguments):
+    cache_dir: Optional[str] = field(default=None)
+    optim: str = field(default="adamw_torch")
+    adam_beta1: float = field(default=0.9)
+    adam_beta2: float = field(default=0.999)
+    adam_epsilon: float = field(default=1e-8)
+
+    freeze_vision_tower: bool = field(default=False)
+    freeze_llm: bool = field(default=False)
+    freeze_merger: bool = field(default=False)
+    disable_flash_attn2: bool = field(default=False)
+    unfreeze_topk_llm: int = 0
+    unfreeze_topk_vision: int = 0
+
+    max_seq_length: int = field(
+        default=32768, # This is the default value of the qwen2-vl model
+        metadata={
+            "help":
+                "Maximum sequence length. Sequences will be right padded (and possibly truncated)."
+        },
+    )
+
+    double_quant: bool = field(
+        default=True,
+        metadata={"help": "Compress the quantization statistics through double quantization."}
+    )
+    quant_type: str = field(
+        default="nf4",
+        metadata={"help": "Quantization data type to use. Should be one of `fp4` or `nf4`."}
+    )
+    bits: int = field(
+        default=16,
+        metadata={"help": "How many bits to use."}
+    )
+    lora_enable: bool = False
+    vision_lora: bool = False
+    use_dora: bool = False
+    lora_rank: int = 64
+    lora_alpha: int = 16
+    lora_dropout: float = 0.05
+    lora_weight_path: str = ""
+    lora_bias: str = "none"
+    vision_lr: Optional[float] = None
+    merger_lr: Optional[float] = None
+    lora_namespan_exclude: str = field(default=None, metadata={"help": "List of namespan to exclude for LoRA"})
+    num_lora_modules: int = -1
+    use_liger_kernel: bool = True
+
+    # Generation-based evaluation settings
+    generation_max_new_tokens: int = field(
+        default=512,
+        metadata={"help": "Maximum number of new tokens to generate during evaluation."}
+    )
+
+@dataclass
+class DPOArguments(DPOConfigTRL):
+    cache_dir: Optional[str] = field(default=None)
+    optim: str = field(default="adamw_torch")
+    adam_beta1: float = field(default=0.9)
+    adam_beta2: float = field(default=0.999)
+    adam_epsilon: float = field(default=1e-8)
+
+    freeze_vision_tower: bool = field(default=False)
+    freeze_llm: bool = field(default=False)
+    freeze_merger: bool = field(default=False)
+    disable_flash_attn2: bool = field(default=False)
+    unfreeze_topk_llm: int = 0
+    unfreeze_topk_vision: int = 0
+
+    max_seq_length: int = field(
+        default=32768, # This is the default value of the qwen2-vl model
+        metadata={
+            "help":
+                "Maximum sequence length. Sequences will be right padded (and possibly truncated)."
+        },
+    )
+    double_quant: bool = field(
+        default=True,
+        metadata={"help": "Compress the quantization statistics through double quantization."}
+    )
+    quant_type: str = field(
+        default="nf4",
+        metadata={"help": "Quantization data type to use. Should be one of `fp4` or `nf4`."}
+    )
+    bits: int = field(
+        default=16,
+        metadata={"help": "How many bits to use."}
+    )
+    lora_enable: bool = False
+    vision_lora: bool = False
+    use_dora: bool = False
+    lora_rank: int = 64
+    lora_alpha: int = 16
+    lora_dropout: float = 0.05
+    lora_weight_path: str = ""
+    lora_bias: str = "none"
+    vision_lr: Optional[float] = None
+    merger_lr: Optional[float] = None
+    lora_namespan_exclude: str = field(default=None, metadata={"help": "List of namespan to exclude for LoRA"})
+    num_lora_modules: int = -1
+    use_liger_loss: bool = True
+    beta: float = field(
+        default=0.1,
+        metadata={"help": "The beta value for DPO."}
+    )
+    precompute_ref_log_probs: bool = field(
+        default=False,
+        metadata={"help": "Whether to precompute the reference log probabilities."}
+    )
+    dpo_loss:str = field(
+        default="sigmoid",
+        metadata={"help": "The type of DPO loss to use."}
+    )
+
+@dataclass
+class GRPOArguments(GRPOConfigTRL):
+    cache_dir: Optional[str] = field(default=None)
+    optim: str = field(default="adamw_torch")
+    adam_beta1: float = field(default=0.9)
+    adam_beta2: float = field(default=0.999)
+    adam_epsilon: float = field(default=1e-8)
+
+    freeze_vision_tower: bool = field(default=False)
+    freeze_llm: bool = field(default=False)
+    freeze_merger: bool = field(default=False)
+    disable_flash_attn2: bool = field(default=False)
+    unfreeze_topk_llm: int = 0
+    unfreeze_topk_vision: int = 0
+
+    double_quant: bool = field(
+        default=True,
+        metadata={"help": "Compress the quantization statistics through double quantization."}
+    )
+    quant_type: str = field(
+        default="nf4",
+        metadata={"help": "Quantization data type to use. Should be one of `fp4` or `nf4`."}
+    )
+    bits: int = field(
+        default=16,
+        metadata={"help": "How many bits to use."}
+    )
+    lora_enable: bool = False
+    vision_lora: bool = False
+    use_dora: bool = False
+    lora_rank: int = 64
+    lora_alpha: int = 16
+    lora_dropout: float = 0.05
+    lora_weight_path: str = ""
+    lora_bias: str = "none"
+    vision_lr: Optional[float] = None
+    merger_lr: Optional[float] = None
+    lora_namespan_exclude: str = field(default=None, metadata={"help": "List of namespan to exclude for LoRA"})
+    num_lora_modules: int = -1
+    beta: float = field(
+        default=0.04,
+        metadata={
+            "help": "KL coefficient. If `0.0`, the reference model is not loaded, reducing memory usage and improving "
+            "training speed, but may be numerically unstable for long training runs."
+        },
+    )
+    temperature: float = 0.9
+    top_p: float = 1.0
+    top_k: int = 50
+    min_p: Optional[float] = None
+    repetition_penalty: float = 1.0
+    max_completion_length: int = 256
+    max_prompt_length: int = 512
+    use_liger_loss: bool = True
+
+
+@dataclass
+class DataArguments:
+    data_path: str = field(
+        default=None, metadata={"help": "Path to the training data."}
+    )
+    eval_path: str= field(
+        default=None, metadata={"help": "Path to the evaluation data."}
+    )
+    eval_image_folder: Optional[str] = field(
+        default=None, metadata={"help": "Path to the evaluation image data."}
+    )
+    lazy_preprocess: bool = False
+    image_folder: Optional[str] = field(default=None)
+    image_min_pixels: Optional[int] = field(default=3136)
+    image_max_pixels: Optional[int] = field(default=12845056)
+    video_min_pixels: Optional[int] = field(default=100352)
+    video_max_pixels: Optional[int] = field(default=602112)
+    image_resized_width: int = field(default=None)
+    image_resized_height: int = field(default=None)
+    video_resized_width: int = field(default=None)
+    video_resized_height: int = field(default=None)
+    fps: Optional[int] = field(default=None, metadata={"help": "Frames per second for video data."})
+    nframes: Optional[int] = field(default=None, metadata={"help": "Number of frames for video data."})

src/serve/app.py

@@ -0,0 +1,143 @@
+import argparse
+from threading import Thread
+import gradio as gr
+from PIL import Image
+from src.utils import load_pretrained_model, get_model_name_from_path, disable_torch_init
+from transformers import TextIteratorStreamer
+from functools import partial
+import warnings
+from qwen_vl_utils import process_vision_info
+
+warnings.filterwarnings("ignore")
+
+def is_video_file(filename):
+    video_extensions = ['.mp4', '.avi', '.mkv', '.mov', '.wmv', '.flv', '.webm', '.mpeg']
+    return any(filename.lower().endswith(ext) for ext in video_extensions)
+
+def bot_streaming(message, history, generation_args):
+    # Initialize variables
+    images = []
+    videos = []
+
+    if message["files"]:
+        for file_item in message["files"]:
+            if isinstance(file_item, dict):
+                file_path = file_item["path"]
+            else:
+                file_path = file_item
+            if is_video_file(file_path):
+                videos.append(file_path)
+            else:
+                images.append(file_path)
+
+    conversation = []
+    for user_turn, assistant_turn in history:
+        user_content = []
+        if isinstance(user_turn, tuple):
+            file_paths = user_turn[0]
+            user_text = user_turn[1]
+            if not isinstance(file_paths, list):
+                file_paths = [file_paths]
+            for file_path in file_paths:
+                if is_video_file(file_path):
+                    user_content.append({"type": "video", "video": file_path, "fps":1.0})
+                else:
+                    user_content.append({"type": "image", "image": file_path})
+            if user_text:
+                user_content.append({"type": "text", "text": user_text})
+        else:
+            user_content.append({"type": "text", "text": user_turn})
+        conversation.append({"role": "user", "content": user_content})
+
+        if assistant_turn is not None:
+            assistant_content = [{"type": "text", "text": assistant_turn}]
+            conversation.append({"role": "assistant", "content": assistant_content})
+
+    user_content = []
+    for image in images:
+        user_content.append({"type": "image", "image": image})
+    for video in videos:
+        user_content.append({"type": "video", "video": video, "fps":1.0})
+    user_text = message['text']
+    if user_text:
+        user_content.append({"type": "text", "text": user_text})
+    conversation.append({"role": "user", "content": user_content})
+
+    prompt = processor.apply_chat_template(conversation, tokenize=False, add_generation_prompt=True)
+    image_inputs, video_inputs = process_vision_info(conversation)
+    
+    inputs = processor(text=[prompt], images=image_inputs, videos=video_inputs, padding=True, return_tensors="pt").to(device) 
+
+    streamer = TextIteratorStreamer(processor.tokenizer, **{"skip_special_tokens": True, "skip_prompt": True, 'clean_up_tokenization_spaces':False,}) 
+    generation_kwargs = dict(inputs, streamer=streamer, eos_token_id=processor.tokenizer.eos_token_id, **generation_args)
+
+    thread = Thread(target=model.generate, kwargs=generation_kwargs)
+    thread.start()
+
+    buffer = ""
+    for new_text in streamer:
+        buffer += new_text
+        yield buffer
+
+def main(args):
+
+    global processor, model, device
+
+    device = args.device
+    
+    disable_torch_init()
+
+    use_flash_attn = True
+    
+    model_name = get_model_name_from_path(args.model_path)
+    
+    if args.disable_flash_attention:
+        use_flash_attn = False
+
+    processor, model = load_pretrained_model(model_base = args.model_base, model_path = args.model_path, 
+                                                device_map=args.device, model_name=model_name, 
+                                                load_4bit=args.load_4bit, load_8bit=args.load_8bit,
+                                                device=args.device, use_flash_attn=use_flash_attn
+    )
+
+    chatbot = gr.Chatbot(scale=2)
+    chat_input = gr.MultimodalTextbox(interactive=True, file_types=["image", "video"], placeholder="Enter message or upload file...",
+                                  show_label=False)
+    
+    generation_args = {
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": args.temperature,
+        "do_sample": True if args.temperature > 0 else False,
+        "repetition_penalty": args.repetition_penalty,
+    }
+    
+    bot_streaming_with_args = partial(bot_streaming, generation_args=generation_args)
+
+    with gr.Blocks(fill_height=True) as demo:
+        gr.ChatInterface(
+            fn=bot_streaming_with_args,
+            title="Qwen2-VL-7B Instruct",
+            stop_btn="Stop Generation",
+            multimodal=True,
+            textbox=chat_input,
+            chatbot=chatbot,
+        )
+
+
+    demo.queue(api_open=False)
+    demo.launch(show_api=False, share=False, server_name='0.0.0.0')
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-path", type=str, default=None)
+    parser.add_argument("--model-base", type=str, default="Qwen/Qwen2-VL-7B-Instruct")
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--load-8bit", action="store_true")
+    parser.add_argument("--load-4bit", action="store_true")
+    parser.add_argument("--disable_flash_attention", action="store_true")
+    parser.add_argument("--temperature", type=float, default=0)
+    parser.add_argument("--repetition-penalty", type=float, default=1.0)
+    parser.add_argument("--max-new-tokens", type=int, default=1024)
+    parser.add_argument("--debug", action="store_true")
+    args = parser.parse_args()
+    main(args)

src/train/monkey_patch_forward.py

@@ -0,0 +1,555 @@
+from transformers.models.qwen2_vl.modeling_qwen2_vl import Qwen2VLModelOutputWithPast
+from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import Qwen2_5_VLModelOutputWithPast
+from transformers.models.qwen3_vl.modeling_qwen3_vl import Qwen3VLModelOutputWithPast
+from transformers.models.qwen3_vl_moe.modeling_qwen3_vl_moe import Qwen3VLMoeModelOutputWithPast
+import torch
+from typing import Optional, List, Union, Tuple
+import transformers.models.qwen2_vl.modeling_qwen2_vl
+import transformers.models.qwen2_5_vl.modeling_qwen2_5_vl
+import transformers.models.qwen3_vl_moe.modeling_qwen3_vl_moe
+from transformers.utils import TransformersKwargs
+from transformers.processing_utils import Unpack
+from transformers.cache_utils import Cache
+from transformers.utils import is_torchdynamo_compiling
+
+def replace_qwen_2_with_mixed_modality_forward():
+    transformers.models.qwen2_vl.modeling_qwen2_vl.Qwen2VLModel.forward = qwen2_mixed_modality_forward
+
+def replace_qwen2_5_with_mixed_modality_forward():
+    transformers.models.qwen2_5_vl.modeling_qwen2_5_vl.Qwen2_5_VLModel.forward = qwen2_5_mixed_modality_forward
+
+def replace_qwen3_with_mixed_modality_forward():
+    transformers.models.qwen3_vl.modeling_qwen3_vl.Qwen3VLModel.forward = qwen3_vl_mixed_modality_forward
+
+def replace_qwen3_vl_moe_with_mixed_modality_forward():
+    transformers.models.qwen3_vl_moe.modeling_qwen3_vl_moe.Qwen3VLMoeModel.forward = qwen3_vl_moe_mixed_modality_forward
+
+def qwen3_vl_moe_mixed_modality_forward(
+    self,
+    input_ids: torch.LongTensor = None,
+    attention_mask: Optional[torch.Tensor] = None,
+    position_ids: Optional[torch.LongTensor] = None,
+    past_key_values: Optional[Cache] = None,
+    inputs_embeds: Optional[torch.FloatTensor] = None,
+    pixel_values: Optional[torch.Tensor] = None,
+    pixel_values_videos: Optional[torch.FloatTensor] = None,
+    image_grid_thw: Optional[torch.LongTensor] = None,
+    video_grid_thw: Optional[torch.LongTensor] = None,
+    cache_position: Optional[torch.LongTensor] = None,
+    second_per_grid_ts: Optional[torch.Tensor] = None,
+    **kwargs: Unpack[TransformersKwargs],
+) -> Union[tuple, Qwen3VLMoeModelOutputWithPast]:
+    
+    if (input_ids is None) ^ (inputs_embeds is not None):
+        raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+    if inputs_embeds is None:
+        inputs_embeds = self.get_input_embeddings()(input_ids)
+
+    image_mask = None
+    video_mask = None
+    
+    if pixel_values is None and pixel_values_videos is None:
+        # Create dummy pixel_values and grid_thw for avoiding deepspeed error.
+        dummy_pixel = torch.zeros(1024, 1536).to(self.visual.device)
+        dummy_grid = torch.tensor([[1, 32, 32]]).to(self.visual.device)
+
+        image_embeds, dummy_deepstack = self.get_image_features(dummy_pixel, dummy_grid)
+        image_embeds = torch.cat(image_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+        
+        inputs_embeds += image_embeds.mean() * 0
+
+    if pixel_values is not None:
+        image_embeds, deepstack_image_embeds = self.get_image_features(pixel_values, image_grid_thw)
+        image_embeds = torch.cat(image_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+        image_mask, _ = self.get_placeholder_mask(
+            input_ids, inputs_embeds=inputs_embeds, image_features=image_embeds
+        )
+        inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)
+
+    if pixel_values_videos is not None:
+        video_embeds, deepstack_video_embeds = self.get_video_features(pixel_values_videos, video_grid_thw)
+        video_embeds = torch.cat(video_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+        _, video_mask = self.get_placeholder_mask(
+            input_ids, inputs_embeds=inputs_embeds, video_features=video_embeds
+        )
+        inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)
+
+    visual_pos_masks = None
+    deepstack_visual_embeds = None
+    if image_mask is not None and video_mask is not None:
+        # aggregate visual_pos_masks and deepstack_visual_embeds
+        image_mask = image_mask[..., 0]
+        video_mask = video_mask[..., 0]
+        visual_pos_masks = image_mask | video_mask
+        deepstack_visual_embeds = []
+        image_mask_joint = image_mask[visual_pos_masks]
+        video_mask_joint = video_mask[visual_pos_masks]
+        for img_embed, vid_embed in zip(deepstack_image_embeds, deepstack_video_embeds):
+            embed_joint = img_embed.new_zeros(visual_pos_masks.sum(), img_embed.shape[-1]).to(img_embed.device)
+            embed_joint[image_mask_joint, :] = img_embed
+            embed_joint[video_mask_joint, :] = vid_embed
+            deepstack_visual_embeds.append(embed_joint)
+    elif image_mask is not None:
+        image_mask = image_mask[..., 0]
+        visual_pos_masks = image_mask
+        deepstack_visual_embeds = deepstack_image_embeds
+    elif video_mask is not None:
+        video_mask = video_mask[..., 0]
+        visual_pos_masks = video_mask
+        deepstack_visual_embeds = deepstack_video_embeds
+
+    if visual_pos_masks is None:
+        B, S, H = inputs_embeds.shape
+        visual_pos_masks = torch.zeros((B, S), dtype=torch.bool, device=inputs_embeds.device)
+        L = len(self.visual.deepstack_visual_indexes)
+        deepstack_visual_embeds = [t.narrow(0, 0, 0) for t in dummy_deepstack]
+
+    if position_ids is None:
+        attention_mask_tensor = (
+            attention_mask if not isinstance(attention_mask, dict) else attention_mask["full_attention"]
+        )
+        if attention_mask_tensor is not None and attention_mask_tensor.ndim == 4:
+            attention_mask_tensor = torch.diagonal(attention_mask_tensor[:, 0], dim1=1, dim2=2)
+            # Only apply conversion for floating point tensors (inverted masks)
+            if attention_mask_tensor.dtype.is_floating_point:
+                attention_mask_tensor = attention_mask_tensor / torch.finfo(attention_mask_tensor.dtype).min
+                attention_mask_tensor = (1.0 - attention_mask_tensor).int()
+
+        # Calculate RoPE index once per generation in the pre-fill stage only.
+        # When compiling, we can't check tensor values thus we check only input length
+        # It is safe to assume that `length!=1` means we're in pre-fill because compiled
+        # models currently cannot do asssisted decoding
+        prefill_compiled_stage = is_torchdynamo_compiling() and (
+            (input_ids is not None and input_ids.shape[1] != 1)
+            or (inputs_embeds is not None and inputs_embeds.shape[1] != 1)
+        )
+        prefill_noncompiled_stage = not is_torchdynamo_compiling() and (
+            (cache_position is not None and cache_position[0] == 0)
+            or (past_key_values is None or past_key_values.get_seq_length() == 0)
+        )
+        if (prefill_compiled_stage or prefill_noncompiled_stage) or self.rope_deltas is None:
+            position_ids, rope_deltas = self.get_rope_index(
+                input_ids,
+                image_grid_thw,
+                video_grid_thw,
+                attention_mask=attention_mask_tensor,
+            )
+            self.rope_deltas = rope_deltas
+        # then use the prev pre-calculated rope-deltas to get the correct position ids
+        else:
+            batch_size, seq_length, _ = inputs_embeds.shape
+            delta = (
+                (cache_position[0] + self.rope_deltas).to(inputs_embeds.device)
+                if cache_position is not None
+                else 0
+            )
+            position_ids = torch.arange(seq_length, device=inputs_embeds.device)
+            position_ids = position_ids.view(1, -1).expand(batch_size, -1)
+            if cache_position is not None:  # otherwise `deltas` is an int `0`
+                delta = delta.repeat_interleave(batch_size // delta.shape[0], dim=0)
+            position_ids = position_ids.add(delta)
+            position_ids = position_ids.unsqueeze(0).expand(3, -1, -1)
+
+    outputs = self.language_model(
+        input_ids=None,
+        position_ids=position_ids,
+        attention_mask=attention_mask,
+        past_key_values=past_key_values,
+        inputs_embeds=inputs_embeds,
+        cache_position=cache_position,
+        visual_pos_masks=visual_pos_masks,
+        deepstack_visual_embeds=deepstack_visual_embeds,
+        **kwargs,
+    )
+
+    return Qwen3VLMoeModelOutputWithPast(
+        last_hidden_state=outputs.last_hidden_state,
+        past_key_values=outputs.past_key_values,
+        rope_deltas=self.rope_deltas,
+    )
+
+
+def qwen3_vl_mixed_modality_forward(
+    self,
+    input_ids: torch.LongTensor = None,
+    attention_mask: Optional[torch.Tensor] = None,
+    position_ids: Optional[torch.LongTensor] = None,
+    past_key_values: Optional[Cache] = None,
+    inputs_embeds: Optional[torch.FloatTensor] = None,
+    pixel_values: Optional[torch.Tensor] = None,
+    pixel_values_videos: Optional[torch.FloatTensor] = None,
+    image_grid_thw: Optional[torch.LongTensor] = None,
+    video_grid_thw: Optional[torch.LongTensor] = None,
+    cache_position: Optional[torch.LongTensor] = None,
+    second_per_grid_ts: Optional[torch.Tensor] = None,
+    **kwargs: Unpack[TransformersKwargs],
+) -> Union[tuple, Qwen3VLModelOutputWithPast]:
+    r"""
+    image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
+        The temporal, height and width of feature shape of each image in LLM.
+    video_grid_thw (`torch.LongTensor` of shape `(num_videos, 3)`, *optional*):
+        The temporal, height and width of feature shape of each video in LLM.
+    """
+    if (input_ids is None) ^ (inputs_embeds is not None):
+        raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+    if inputs_embeds is None:
+        inputs_embeds = self.get_input_embeddings()(input_ids)
+
+    image_mask = None
+    video_mask = None
+
+    if pixel_values is None and pixel_values_videos is None:
+        # Create dummy pixel_values and grid_thw for avoiding deepspeed error.
+        dummy_pixel = torch.zeros(1024, 1536).to(self.visual.device)
+        dummy_grid = torch.tensor([[1, 32, 32]]).to(self.visual.device)
+
+        image_embeds, dummy_deepstack = self.get_image_features(dummy_pixel, dummy_grid)
+        image_embeds = torch.cat(image_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+        
+        inputs_embeds += image_embeds.mean() * 0
+
+    if pixel_values is not None:
+        image_embeds, deepstack_image_embeds = self.get_image_features(pixel_values, image_grid_thw)
+        image_embeds = torch.cat(image_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+        image_mask, _ = self.get_placeholder_mask(
+            input_ids, inputs_embeds=inputs_embeds, image_features=image_embeds
+        )
+        inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)
+
+    if pixel_values_videos is not None:
+        video_embeds, deepstack_video_embeds = self.get_video_features(pixel_values_videos, video_grid_thw)
+        video_embeds = torch.cat(video_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+        _, video_mask = self.get_placeholder_mask(
+            input_ids, inputs_embeds=inputs_embeds, video_features=video_embeds
+        )
+        inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)
+
+    visual_pos_masks = None
+    deepstack_visual_embeds = None
+    if image_mask is not None and video_mask is not None:
+        # aggregate visual_pos_masks and deepstack_visual_embeds
+        image_mask = image_mask[..., 0]
+        video_mask = video_mask[..., 0]
+        visual_pos_masks = image_mask | video_mask
+        deepstack_visual_embeds = []
+        image_mask_joint = image_mask[visual_pos_masks]
+        video_mask_joint = video_mask[visual_pos_masks]
+        for img_embed, vid_embed in zip(deepstack_image_embeds, deepstack_video_embeds):
+            embed_joint = img_embed.new_zeros(visual_pos_masks.sum(), img_embed.shape[-1]).to(img_embed.device)
+            embed_joint[image_mask_joint, :] = img_embed
+            embed_joint[video_mask_joint, :] = vid_embed
+            deepstack_visual_embeds.append(embed_joint)
+    elif image_mask is not None:
+        image_mask = image_mask[..., 0]
+        visual_pos_masks = image_mask
+        deepstack_visual_embeds = deepstack_image_embeds
+    elif video_mask is not None:
+        video_mask = video_mask[..., 0]
+        visual_pos_masks = video_mask
+        deepstack_visual_embeds = deepstack_video_embeds
+
+    if visual_pos_masks is None:
+        B, S, H = inputs_embeds.shape
+        visual_pos_masks = torch.zeros((B, S), dtype=torch.bool, device=inputs_embeds.device)
+        L = len(self.visual.deepstack_visual_indexes)
+        deepstack_visual_embeds = [t.narrow(0, 0, 0) for t in dummy_deepstack]
+
+    if position_ids is None:
+        attention_mask_tensor = (
+            attention_mask if not isinstance(attention_mask, dict) else attention_mask["full_attention"]
+        )
+        if attention_mask_tensor is not None and attention_mask_tensor.ndim == 4:
+            attention_mask_tensor = torch.diagonal(attention_mask_tensor[:, 0], dim1=1, dim2=2)
+            # Only apply conversion for floating point tensors (inverted masks)
+            if attention_mask_tensor.dtype.is_floating_point:
+                attention_mask_tensor = attention_mask_tensor / torch.finfo(attention_mask_tensor.dtype).min
+                attention_mask_tensor = (1.0 - attention_mask_tensor).int()
+
+        # Calculate RoPE index once per generation in the pre-fill stage only.
+        # When compiling, we can't check tensor values thus we check only input length
+        # It is safe to assume that `length!=1` means we're in pre-fill because compiled
+        # models currently cannot do asssisted decoding
+        prefill_compiled_stage = is_torchdynamo_compiling() and (
+            (input_ids is not None and input_ids.shape[1] != 1)
+            or (inputs_embeds is not None and inputs_embeds.shape[1] != 1)
+        )
+        prefill_noncompiled_stage = not is_torchdynamo_compiling() and (
+            (cache_position is not None and cache_position[0] == 0)
+            or (past_key_values is None or past_key_values.get_seq_length() == 0)
+        )
+        if (prefill_compiled_stage or prefill_noncompiled_stage) or self.rope_deltas is None:
+            position_ids, rope_deltas = self.get_rope_index(
+                input_ids,
+                image_grid_thw,
+                video_grid_thw,
+                attention_mask=attention_mask_tensor,
+            )
+            self.rope_deltas = rope_deltas
+        # then use the prev pre-calculated rope-deltas to get the correct position ids
+        else:
+            batch_size, seq_length, _ = inputs_embeds.shape
+            delta = (
+                (cache_position[0] + self.rope_deltas).to(inputs_embeds.device)
+                if cache_position is not None
+                else 0
+            )
+            position_ids = torch.arange(seq_length, device=inputs_embeds.device)
+            position_ids = position_ids.view(1, -1).expand(batch_size, -1)
+            if cache_position is not None:  # otherwise `deltas` is an int `0`
+                delta = delta.repeat_interleave(batch_size // delta.shape[0], dim=0)
+            position_ids = position_ids.add(delta)
+            position_ids = position_ids.unsqueeze(0).expand(3, -1, -1)
+
+    outputs = self.language_model(
+        input_ids=None,
+        position_ids=position_ids,
+        attention_mask=attention_mask,
+        past_key_values=past_key_values,
+        inputs_embeds=inputs_embeds,
+        cache_position=cache_position,
+        visual_pos_masks=visual_pos_masks,
+        deepstack_visual_embeds=deepstack_visual_embeds,
+        **kwargs,
+    )
+
+    return Qwen3VLModelOutputWithPast(
+        last_hidden_state=outputs.last_hidden_state,
+        past_key_values=outputs.past_key_values,
+        rope_deltas=self.rope_deltas,
+    )
+
+def qwen2_5_mixed_modality_forward(
+    self,
+    input_ids: torch.LongTensor = None,
+    attention_mask: Optional[torch.Tensor] = None,
+    position_ids: Optional[torch.LongTensor] = None,
+    past_key_values: Optional[Cache] = None,
+    inputs_embeds: Optional[torch.FloatTensor] = None,
+    use_cache: Optional[bool] = None,
+    output_attentions: Optional[bool] = None,
+    output_hidden_states: Optional[bool] = None,
+    return_dict: Optional[bool] = None,
+    pixel_values: Optional[torch.Tensor] = None,
+    pixel_values_videos: Optional[torch.FloatTensor] = None,
+    image_grid_thw: Optional[torch.LongTensor] = None,
+    video_grid_thw: Optional[torch.LongTensor] = None,
+    rope_deltas: Optional[torch.LongTensor] = None,
+    cache_position: Optional[torch.LongTensor] = None,
+    second_per_grid_ts: Optional[torch.Tensor] = None,
+    **kwargs: Unpack[TransformersKwargs],
+) -> Union[tuple, Qwen2_5_VLModelOutputWithPast]:
+    r"""
+    image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
+        The temporal, height and width of feature shape of each image in LLM.
+    video_grid_thw (`torch.LongTensor` of shape `(num_videos, 3)`, *optional*):
+        The temporal, height and width of feature shape of each video in LLM.
+    rope_deltas (`torch.LongTensor` of shape `(batch_size, )`, *optional*):
+        The rope index difference between sequence length and multimodal rope.
+    second_per_grid_ts (`torch.Tensor` of shape `(num_videos)`, *optional*):
+        The time interval (in seconds) for each grid along the temporal dimension in the 3D position IDs.
+    """
+
+    output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+    output_hidden_states = (
+        output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+    )
+    return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+    if inputs_embeds is None:
+        inputs_embeds = self.get_input_embeddings()(input_ids)
+
+    if pixel_values is None and pixel_values_videos is None:
+        # Create dummy pixel_values and grid_thw for avoiding deepspeed error.
+        dummy_pixel = torch.zeros(784, 1176).to(self.visual.device)
+        dummy_grid = torch.tensor([[1, 28, 28]]).to(self.visual.device)
+
+        image_embeds = self.get_image_features(dummy_pixel, dummy_grid)
+        # Operates as maksed_scatter for the image tokens
+        # However the values are all zeros so it dosen't affect the embeddings.
+        # This could avoid deepspeed error when some batch only has texts.
+        if isinstance(image_embeds, (tuple, list)):
+            image_embeds = torch.cat(list(image_embeds), dim=0)  # (sum_tokens, hidden)
+        inputs_embeds += image_embeds.mean() * 0
+
+    if pixel_values is not None:
+        image_embeds = self.get_image_features(pixel_values, image_grid_thw)
+        image_embeds = torch.cat(image_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+        image_mask, _ = self.get_placeholder_mask(
+            input_ids, inputs_embeds=inputs_embeds, image_features=image_embeds
+        )
+        inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)
+
+    if pixel_values_videos is not None:
+        video_embeds = self.get_video_features(pixel_values_videos, video_grid_thw)
+        video_embeds = torch.cat(video_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+        _, video_mask = self.get_placeholder_mask(
+            input_ids, inputs_embeds=inputs_embeds, video_features=video_embeds
+        )
+        inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)
+
+    if position_ids is None:
+        # Calculate RoPE index once per generation in the pre-fill stage only.
+        # When compiling, we can't check tensor values thus we check only input length
+        # It is safe to assume that `length!=1` means we're in pre-fill because compiled
+        # models currently cannot do asssisted decoding
+        prefill_compiled_stage = is_torchdynamo_compiling() and (
+            (input_ids is not None and input_ids.shape[1] != 1)
+            or (inputs_embeds is not None and inputs_embeds.shape[1] != 1)
+        )
+        prefill_noncompiled_stage = not is_torchdynamo_compiling() and (
+            (cache_position is not None and cache_position[0] == 0)
+            or (past_key_values is None or past_key_values.get_seq_length() == 0)
+        )
+        if (prefill_compiled_stage or prefill_noncompiled_stage) or self.rope_deltas is None:
+            position_ids, rope_deltas = self.get_rope_index(
+                input_ids,
+                image_grid_thw,
+                video_grid_thw,
+                second_per_grid_ts=second_per_grid_ts,
+                attention_mask=attention_mask,
+            )
+            self.rope_deltas = rope_deltas
+        else:
+            batch_size, seq_length, _ = inputs_embeds.shape
+            position_ids = torch.arange(seq_length, device=inputs_embeds.device)
+            position_ids = position_ids.view(1, 1, -1).expand(3, batch_size, -1)
+            if cache_position is not None:
+                delta = (cache_position[0] + self.rope_deltas).to(inputs_embeds.device)
+            else:
+                delta = torch.zeros((batch_size, seq_length), device=inputs_embeds.device)
+            delta = delta.repeat_interleave(batch_size // delta.shape[0], dim=1)
+            position_ids += delta.to(position_ids.device)
+
+    outputs = self.language_model(
+        input_ids=None,
+        position_ids=position_ids,
+        attention_mask=attention_mask,
+        past_key_values=past_key_values,
+        inputs_embeds=inputs_embeds,
+        use_cache=use_cache,
+        output_attentions=output_attentions,
+        output_hidden_states=output_hidden_states,
+        return_dict=True,
+        cache_position=cache_position,
+        **kwargs,
+    )
+
+    output = Qwen2_5_VLModelOutputWithPast(
+        last_hidden_state=outputs.last_hidden_state,
+        past_key_values=outputs.past_key_values,
+        hidden_states=outputs.hidden_states,
+        attentions=outputs.attentions,
+        rope_deltas=self.rope_deltas,
+    )
+    return output if return_dict else output.to_tuple()
+
+
+def qwen2_mixed_modality_forward(
+    self,
+    input_ids: torch.LongTensor = None,
+    attention_mask: Optional[torch.Tensor] = None,
+    position_ids: Optional[torch.LongTensor] = None,
+    past_key_values: Optional[Cache] = None,
+    inputs_embeds: Optional[torch.FloatTensor] = None,
+    use_cache: Optional[bool] = None,
+    output_attentions: Optional[bool] = None,
+    output_hidden_states: Optional[bool] = None,
+    return_dict: Optional[bool] = None,
+    pixel_values: Optional[torch.Tensor] = None,
+    pixel_values_videos: Optional[torch.FloatTensor] = None,
+    image_grid_thw: Optional[torch.LongTensor] = None,
+    video_grid_thw: Optional[torch.LongTensor] = None,
+    rope_deltas: Optional[torch.LongTensor] = None,
+    cache_position: Optional[torch.LongTensor] = None,
+    second_per_grid_ts: Optional[torch.Tensor] = None,
+    **kwargs: Unpack[TransformersKwargs],
+) -> Union[tuple, Qwen2VLModelOutputWithPast]:
+    r"""
+    image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):
+        The temporal, height and width of feature shape of each image in LLM.
+    video_grid_thw (`torch.LongTensor` of shape `(num_videos, 3)`, *optional*):
+        The temporal, height and width of feature shape of each video in LLM.
+    rope_deltas (`torch.LongTensor` of shape `(batch_size, )`, *optional*):
+        The rope index difference between sequence length and multimodal rope.
+    """
+
+    output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+    output_hidden_states = (
+        output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+    )
+    return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+    if inputs_embeds is None:
+        inputs_embeds = self.get_input_embeddings()(input_ids)
+
+    if pixel_values is None and pixel_values_videos is None:
+        # Create dummy pixel_values and grid_thw for avoiding deepspeed error.
+        dummy_pixel = torch.zeros(784, 1176).to(self.visual.get_device())
+        dummy_grid = torch.tensor([[1, 28, 28]]).to(self.visual.get_device())
+
+        image_embeds = self.get_image_features(dummy_pixel, dummy_grid)
+        # Operates as maksed_scatter for the image tokens
+        # However the values are all zeros so it dosen't affect the embeddings.
+        # This could avoid deepspeed error when some batch only has texts.
+        if isinstance(image_embeds, (tuple, list)):
+            image_embeds = torch.cat(list(image_embeds), dim=0)  # (sum_tokens, hidden)
+        inputs_embeds += image_embeds.mean() * 0
+
+    if pixel_values is not None:
+        image_embeds = self.get_image_features(pixel_values, image_grid_thw)
+        image_embeds = torch.cat(image_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+        image_mask, _ = self.get_placeholder_mask(
+            input_ids, inputs_embeds=inputs_embeds, image_features=image_embeds
+        )
+        inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)
+
+    if pixel_values_videos is not None:
+        video_embeds = self.get_video_features(pixel_values_videos, video_grid_thw)
+        video_embeds = torch.cat(video_embeds, dim=0).to(inputs_embeds.device, inputs_embeds.dtype)
+        _, video_mask = self.get_placeholder_mask(
+            input_ids, inputs_embeds=inputs_embeds, video_features=video_embeds
+        )
+        inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)
+
+    if position_ids is None:
+        if self.rope_deltas is None or cache_position is None or cache_position[0] == 0:
+            position_ids, rope_deltas = self.get_rope_index(
+                input_ids, image_grid_thw, video_grid_thw, attention_mask
+            )
+            self.rope_deltas = rope_deltas
+        # then use the prev pre-calculated rope-deltas to get the correct position ids
+        else:
+            batch_size, seq_length, _ = inputs_embeds.shape
+            position_ids = torch.arange(seq_length, device=inputs_embeds.device)
+            position_ids = position_ids.view(1, 1, -1).expand(3, batch_size, -1)
+            if cache_position is not None:
+                delta = (cache_position[0] + self.rope_deltas).to(inputs_embeds.device)
+            else:
+                delta = torch.zeros((batch_size, seq_length), device=inputs_embeds.device)
+            delta = delta.repeat_interleave(batch_size // delta.shape[0], dim=0)
+            position_ids += delta.to(position_ids.device)
+
+    outputs = self.language_model(
+        input_ids=None,
+        position_ids=position_ids,
+        attention_mask=attention_mask,
+        past_key_values=past_key_values,
+        inputs_embeds=inputs_embeds,
+        use_cache=use_cache,
+        output_attentions=output_attentions,
+        output_hidden_states=output_hidden_states,
+        return_dict=True,
+        cache_position=cache_position,
+        **kwargs,
+    )
+
+    output = Qwen2VLModelOutputWithPast(
+        last_hidden_state=outputs.last_hidden_state,
+        past_key_values=outputs.past_key_values,
+        hidden_states=outputs.hidden_states,
+        attentions=outputs.attentions,
+        rope_deltas=self.rope_deltas,
+    )
+    return output if return_dict else output.to_tuple()

src/train/monkey_patch_vision.py

@@ -0,0 +1,181 @@
+from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import (
+    Qwen2_5_VisionPatchEmbed,
+    Qwen2_5_VisionRotaryEmbedding,
+    Qwen2_5_VLVisionBlock,
+    Qwen2_5_VLPatchMerger,
+    Qwen2_5_VLPreTrainedModel
+)
+from transformers.models.qwen2_5_vl.configuration_qwen2_5_vl import Qwen2_5_VLVisionConfig
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+import transformers.models.qwen2_5_vl.modeling_qwen2_5_vl
+
+def replace_qwen2_5_vision():
+    transformers.models.qwen2_5_vl.modeling_qwen2_5_vl.Qwen2_5_VisionTransformerPretrainedModel = Qwen2_5_VisionTransformerPretrainedModelWithPatchedWindow
+
+class Qwen2_5_VisionTransformerPretrainedModelWithPatchedWindow(Qwen2_5_VLPreTrainedModel):
+    config: Qwen2_5_VLVisionConfig
+    _no_split_modules = ["Qwen2_5_VLVisionBlock"]
+
+    def __init__(self, config, *inputs, **kwargs) -> None:
+        super().__init__(config, *inputs, **kwargs)
+        self.spatial_merge_size = config.spatial_merge_size
+        self.patch_size = config.patch_size
+        self.fullatt_block_indexes = config.fullatt_block_indexes
+        self.window_size = config.window_size
+        self.spatial_merge_unit = self.spatial_merge_size * self.spatial_merge_size
+
+        self.patch_embed = Qwen2_5_VisionPatchEmbed(
+            patch_size=config.patch_size,
+            temporal_patch_size=config.temporal_patch_size,
+            in_channels=config.in_channels,
+            embed_dim=config.hidden_size,
+        )
+
+        head_dim = config.hidden_size // config.num_heads
+        self.rotary_pos_emb = Qwen2_5_VisionRotaryEmbedding(head_dim // 2)
+
+        self.blocks = nn.ModuleList(
+            [Qwen2_5_VLVisionBlock(config, config._attn_implementation) for _ in range(config.depth)]
+        )
+        self.merger = Qwen2_5_VLPatchMerger(
+            dim=config.out_hidden_size,
+            context_dim=config.hidden_size,
+            spatial_merge_size=config.spatial_merge_size,
+        )
+        self.gradient_checkpointing = False
+
+    def rot_pos_emb(self, grid_thw):
+        pos_ids = []
+        for t, h, w in grid_thw:
+            hpos_ids = torch.arange(h).unsqueeze(1).expand(-1, w)
+            hpos_ids = hpos_ids.reshape(
+                h // self.spatial_merge_size,
+                self.spatial_merge_size,
+                w // self.spatial_merge_size,
+                self.spatial_merge_size,
+            )
+            hpos_ids = hpos_ids.permute(0, 2, 1, 3)
+            hpos_ids = hpos_ids.flatten()
+
+            wpos_ids = torch.arange(w).unsqueeze(0).expand(h, -1)
+            wpos_ids = wpos_ids.reshape(
+                h // self.spatial_merge_size,
+                self.spatial_merge_size,
+                w // self.spatial_merge_size,
+                self.spatial_merge_size,
+            )
+            wpos_ids = wpos_ids.permute(0, 2, 1, 3)
+            wpos_ids = wpos_ids.flatten()
+            pos_ids.append(torch.stack([hpos_ids, wpos_ids], dim=-1).repeat(t, 1))
+        pos_ids = torch.cat(pos_ids, dim=0)
+        max_grid_size = grid_thw[:, 1:].max()
+        rotary_pos_emb_full = self.rotary_pos_emb(max_grid_size)
+        rotary_pos_emb = rotary_pos_emb_full[pos_ids].flatten(1)
+        return rotary_pos_emb
+
+    def get_window_index(self, grid_thw):
+        window_index: list = []
+        cu_window_seqlens: list = [0]
+        window_index_id = 0
+        vit_merger_window_size = self.window_size // self.spatial_merge_size // self.patch_size
+
+        for grid_t, grid_h, grid_w in grid_thw:
+            llm_grid_h, llm_grid_w = (
+                grid_h // self.spatial_merge_size,
+                grid_w // self.spatial_merge_size,
+            )
+            index = torch.arange(grid_t * llm_grid_h * llm_grid_w).reshape(grid_t, llm_grid_h, llm_grid_w)
+
+            pad_h = (vit_merger_window_size - llm_grid_h % vit_merger_window_size) % vit_merger_window_size
+            pad_w = (vit_merger_window_size - llm_grid_w % vit_merger_window_size) % vit_merger_window_size
+
+            num_windows_h = (llm_grid_h + pad_h) // vit_merger_window_size
+            num_windows_w = (llm_grid_w + pad_w) // vit_merger_window_size
+
+            index_padded = F.pad(index, (0, pad_w, 0, pad_h), "constant", -100)
+            index_padded = index_padded.reshape(
+                grid_t,
+                num_windows_h,
+                vit_merger_window_size,
+                num_windows_w,
+                vit_merger_window_size,
+            )
+            index_padded = index_padded.permute(0, 1, 3, 2, 4).reshape(
+                grid_t,
+                num_windows_h * num_windows_w,
+                vit_merger_window_size,
+                vit_merger_window_size,
+            )
+            seqlens = (index_padded != -100).sum([2, 3]).reshape(-1)
+            index_padded = index_padded.reshape(-1)
+            index_new = index_padded[index_padded != -100]
+            window_index.append(index_new + window_index_id)
+            cu_seqlens_tmp = seqlens.cumsum(0) * self.spatial_merge_unit + cu_window_seqlens[-1]
+            cu_window_seqlens.extend(cu_seqlens_tmp.tolist())
+            window_index_id += (grid_t * llm_grid_h * llm_grid_w).item()
+        window_index = torch.cat(window_index, dim=0)
+
+        return window_index, cu_window_seqlens
+
+
+    def forward(self, hidden_states: torch.Tensor, grid_thw: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.patch_embed(hidden_states)
+        seq_len, dim = hidden_states.size()
+
+        rotary_pos_emb = self.rot_pos_emb(grid_thw)
+
+        window_index, cu_window_seqlens_list = self.get_window_index(grid_thw)
+
+        cu_window_seqlens = torch.tensor(
+            cu_window_seqlens_list,
+            device=hidden_states.device,
+            dtype=grid_thw.dtype if torch.jit.is_tracing() else torch.int32,
+        )
+        cu_window_seqlens = torch.unique_consecutive(cu_window_seqlens)
+
+        group = self.spatial_merge_unit
+        G = seq_len // group
+
+        hidden_states = hidden_states.view(G, group, dim)
+        rotary_pos_emb = rotary_pos_emb.view(G, group, -1)
+
+        window_index_dev = window_index.to(hidden_states.device, non_blocking=True)
+
+        hidden_states = hidden_states.index_select(0, window_index_dev).reshape(seq_len, dim)
+        rotary_pos_emb = rotary_pos_emb.index_select(0, window_index_dev).reshape(seq_len, -1)
+
+        emb = torch.cat((rotary_pos_emb, rotary_pos_emb), dim=-1)
+        position_embeddings = (emb.cos(), emb.sin())
+
+        cu_seqlens = torch.repeat_interleave(grid_thw[:, 1] * grid_thw[:, 2], grid_thw[:, 0]).cumsum(
+            dim=0,
+            dtype=grid_thw.dtype if torch.jit.is_tracing() else torch.int32,
+        )
+        cu_seqlens = F.pad(cu_seqlens, (1, 0), value=0)
+
+        if cu_seqlens.device != hidden_states.device:
+             cu_seqlens = cu_seqlens.to(hidden_states.device, non_blocking=True)
+             
+        for layer_num, blk in enumerate(self.blocks):
+            if layer_num in self.fullatt_block_indexes:
+                cu_seqlens_now = cu_seqlens
+            else:
+                cu_seqlens_now = cu_window_seqlens
+
+            if self.gradient_checkpointing and self.training:
+                hidden_states = self._gradient_checkpointing_func(
+                    blk.__call__, hidden_states, cu_seqlens_now, None, position_embeddings
+                )
+            else:
+                hidden_states = blk(hidden_states, cu_seqlens=cu_seqlens_now, position_embeddings=position_embeddings)
+
+        hidden_states = self.merger(hidden_states)
+
+        reverse_indices = torch.empty_like(window_index_dev)
+        reverse_indices.scatter_(0, window_index_dev, torch.arange(window_index_dev.numel(), dtype=torch.long, device=window_index_dev.device))
+        hidden_states = hidden_states.index_select(0, reverse_indices)
+
+        return hidden_states

src/train/reward_funcs.py

@@ -0,0 +1,52 @@
+import re
+from math_verify import LatexExtractionConfig, parse, verify
+from latex2sympy2_extended import NormalizationConfig
+
+def accuracy_reward(completions, assistant, **kwargs):
+    """Reward function that checks if the completion is correct using either symbolic verification or exact string matching."""
+    rewards = []
+
+    for completion, sol in zip(completions, assistant):
+        try:
+            gold_parsed = parse(sol, extraction_mode="first_match")
+        except Exception as e:
+            gold_parsed = []
+
+        if len(gold_parsed) != 0:
+            # Try parsing predicted answer too
+            try:
+                answer_parsed = parse(
+                    completion,
+                    extraction_config=[
+                        LatexExtractionConfig(
+                            normalization_config=NormalizationConfig(
+                                nits=False,
+                                malformed_operators=False,
+                                basic_latex=True,
+                                boxed="all",
+                                units=True,
+                            ),
+                            boxed_match_priority=0,
+                            try_extract_without_anchor=False,
+                        )
+                    ],
+                    extraction_mode="first_match",
+                )
+                reward = float(verify(gold_parsed, answer_parsed))
+            except Exception as e:
+                print(f"verify failed: {e}, answer: {completion}, gold: {sol}")
+                reward = None
+        else:
+            # fallback to text match
+            reward = float(completion.strip().lower() == sol.strip().lower())
+
+        rewards.append(reward)
+
+    return rewards
+
+def format_reward(completions, **kwargs):
+    """Reward function that checks if the completion has a specific format."""
+    pattern = r"^<think>\n.*?\n</think>\n<answer>\n.*?\n</answer>$"
+    matches = [re.match(pattern, content, re.DOTALL | re.MULTILINE) for content in completions]
+    rewards = [1.0 if match else 0.0 for match in matches]
+    return rewards

src/train/train_cls.py

@@ -0,0 +1,283 @@
+import os
+import torch
+from peft import LoraConfig, get_peft_model
+import ast
+from transformers import AutoProcessor, BitsAndBytesConfig, HfArgumentParser, AutoConfig
+from src.trainer import QwenCLSTrainer
+from src.model import Qwen2VLForSequenceClassification, Qwen2_5_VLForSequenceClassification
+from src.dataset import make_classification_data_module
+from src.loss import get_loss_function
+from src.params import DataArguments, ModelArguments, CLSArguments
+from train.train_utils import get_peft_state_maybe_zero_3, get_peft_state_non_lora_maybe_zero_3, safe_save_model_for_hf_trainer
+import pathlib
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from transformers import EarlyStoppingCallback
+
+
+def compute_metrics(pred):
+    preds = pred.predictions.argmax(axis=-1)
+    labels = pred.label_ids
+    acc     = accuracy_score(labels, preds)
+    prec, rec, f1, _ = precision_recall_fscore_support(
+        labels, preds, average="weighted")
+    return {
+        "acc": acc,
+        "precision": prec,
+        "recall": rec,
+        "f1": f1,
+    }
+
+local_rank = None
+
+def rank0_print(*args):
+    if local_rank == 0 or local_rank == '0' or local_rank is None:
+        print(*args)
+
+def find_target_linear_names(model, num_lora_modules=-1, lora_namespan_exclude=[], verbose=True):
+    linear_cls = torch.nn.modules.Linear
+    embedding_cls = torch.nn.modules.Embedding
+    lora_module_names = []
+
+    for name, module in model.named_modules():
+        if any(ex_keyword in name for ex_keyword in lora_namespan_exclude):
+            continue
+        if isinstance(module, (linear_cls, embedding_cls)):
+            lora_module_names.append(name)
+    
+    if num_lora_modules > 0:
+        lora_module_names = lora_module_names[-num_lora_modules:]
+    if verbose:
+        rank0_print(f"Found {len(lora_module_names)} lora modules: {lora_module_names}")
+    return lora_module_names
+
+def set_requires_grad(parameters, requires_grad):
+    for p in parameters:
+        p.requires_grad = requires_grad
+
+def configure_vision_tower(model, training_args, compute_dtype, device):
+    vision_model_params = model.visual.parameters()
+    set_requires_grad(vision_model_params, not training_args.freeze_vision_tower)
+    
+    # Handle merger specifically
+    merger_params = model.visual.merger.parameters()
+    set_requires_grad(merger_params, not training_args.freeze_merger)
+
+def configure_llm(model, training_args):
+    llm_params = model.language_model.parameters()
+    set_requires_grad(llm_params, not training_args.freeze_llm)
+
+def unfreeze_topk_layers(model, k_llm: int = 0, k_vis: int = 0):
+    if k_llm and hasattr(model, "language_model") and hasattr(model.language_model, "layers"):
+        for layer in model.language_model.layers[-k_llm:]:
+            for p in layer.parameters():
+                p.requires_grad = True
+
+    if k_vis and hasattr(model, "visual") and hasattr(model.visual, "blocks"):
+        for blk in model.visual.blocks[-k_vis:]:
+            for p in blk.parameters():
+                p.requires_grad = True
+
+def train():
+    global local_rank
+
+    parser = HfArgumentParser(
+        (ModelArguments, DataArguments, CLSArguments))
+    
+    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+    
+    if training_args.lora_enable and not training_args.freeze_llm:
+        raise ValueError("If `lora_enable` is True, `freeze_llm` must also be True.")
+
+    if not training_args.lora_enable:
+        assert not training_args.vision_lora, \
+            "Error: training_args.lora_enable is not enabled, but training_args.vision_lora is enabled."
+        
+    if training_args.vision_lora and not training_args.freeze_vision_tower:
+        raise ValueError("If `vision_lora` is True, `freeze_vision_tower` must also be True.")
+
+    else:
+        if training_args.lora_namespan_exclude is not None:
+            training_args.lora_namespan_exclude = ast.literal_eval(training_args.lora_namespan_exclude)
+        else:
+            training_args.lora_namespan_exclude = []
+
+        if not training_args.vision_lora:
+            training_args.lora_namespan_exclude += ["visual"]
+
+    local_rank = training_args.local_rank
+    compute_dtype = (torch.float16 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32))
+    data_args.compute_dtype = compute_dtype
+
+    bnb_model_from_pretrained_args = {}
+    if training_args.bits in [4,8]:
+        bnb_model_from_pretrained_args.update(dict(
+            device_map={"":training_args.device},
+            quantization_config = BitsAndBytesConfig(
+                load_in_4bit=training_args.bits==4,
+                load_in_8bit=training_args.bits==8,
+                llm_int8_skip_modules=["visual", "score"],
+                llm_int8_threshold=6.0,
+                llm_int8_has_fp16_weight=False,
+                bnb_4bit_compute_dtype=compute_dtype,
+                bnb_4bit_use_double_quant=training_args.double_quant,
+                bnb_4bit_quant_type=training_args.quant_type,
+            )
+        ))
+
+    if "Qwen2.5" in model_args.model_id:
+        cfg = AutoConfig.from_pretrained(model_args.model_id)
+        cfg.mlp_head_hidden_dim = training_args.mlp_head_dim
+        cfg.mlp_head_dropout = training_args.mlp_head_dropout
+        cfg.num_labels = training_args.num_labels
+        
+        model = Qwen2_5_VLForSequenceClassification.from_pretrained(
+            model_args.model_id,
+            config=cfg,
+            torch_dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa",
+            **bnb_model_from_pretrained_args
+        )
+    else:
+        cfg = AutoConfig.from_pretrained(model_args.model_id)
+        cfg.mlp_head_hidden_dim = training_args.mlp_head_dim
+        cfg.mlp_head_dropout = training_args.mlp_head_dropout
+        cfg.num_labels = training_args.num_labels
+        
+        model = Qwen2VLForSequenceClassification.from_pretrained(
+            model_args.model_id,
+            config=cfg,
+            torch_dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa",
+            **bnb_model_from_pretrained_args
+        )
+
+    model.config.use_cache = False
+    model.config.num_labels = training_args.num_labels
+    model_to_configure = model
+    configure_llm(model_to_configure, training_args)
+    configure_vision_tower(model_to_configure, training_args, compute_dtype, training_args.device)
+
+    unfreeze_topk_layers(
+        model_to_configure,
+        k_llm=getattr(training_args, "unfreeze_topk_llm", 0),
+        k_vis=getattr(training_args, "unfreeze_topk_vision", 0),
+    )
+
+    if training_args.bits in [4,8]:
+        model.config.torch_dtype = (torch.float32 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32))
+        from peft import prepare_model_for_kbit_training
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=training_args.gradient_checkpointing, gradient_checkpointing_kwargs={"use_reentrant": True})
+    
+    if training_args.gradient_checkpointing:
+        model.enable_input_require_grads()
+        if hasattr(model, "enable_input_require_grads"):
+            model.enable_input_require_grads()
+        else:
+            def make_inputs_require_grad(module, input, output):
+                output.requires_grad_(True)
+
+            model.get_input_embeddings().register_forward_hook(make_inputs_require_grad)
+            
+        training_args.gradient_checkpointing_kwargs = {"use_reentrant": True}
+
+    if training_args.lora_enable:
+        lora_namespan_exclude = training_args.lora_namespan_exclude
+        peft_config = LoraConfig(
+            r=training_args.lora_rank,
+            lora_alpha=training_args.lora_alpha,
+            target_modules=find_target_linear_names(model, lora_namespan_exclude=lora_namespan_exclude, num_lora_modules=training_args.num_lora_modules),
+            lora_dropout=training_args.lora_dropout,
+            bias=training_args.lora_bias,
+            task_type="CAUSAL_LM",
+        )
+        rank0_print("Adding LoRA to the model...")
+        model = get_peft_model(model, peft_config)
+
+        # Peft maodel makes vision tower and merger freezed again.
+        # Configuring fuction could be called here, but sometimes it does not work properly.
+        # So I just made it this way.
+        # Need to be fixed in the future.
+
+        if not training_args.freeze_vision_tower:
+            for name, param in model.named_parameters():
+                if "visual" in name:
+                    param.requires_grad = True
+
+        if not training_args.freeze_merger:
+            for name, param in model.named_parameters():
+                if "merger" in name:
+                    param.requires_grad = True
+
+    processor = AutoProcessor.from_pretrained(model_args.model_id)
+
+    # model.config.tokenizer_model_max_length = processor.tokenizer.model_max_length
+    model.config.pad_token_id = processor.tokenizer.pad_token_id
+
+    if training_args.bits in [4, 8]:
+        from peft.tuners.lora import LoraLayer
+        for name, module in model.named_modules():
+            if isinstance(module, LoraLayer):
+                if training_args.bf16:
+                    module = module.to(torch.bfloat16)
+            if 'norm' in name:
+                module = module.to(torch.float32)
+            
+            if 'score' in name or 'embed_token' in name:
+                if hasattr(module, 'weight'):
+                    if training_args.bf16 and module.weight.dtype == torch.float32:
+                        module = module.to(torch.bfloat16)
+
+    data_module = make_classification_data_module(model_id=model_args.model_id,
+                                              processor=processor,
+                                              data_args=data_args)
+    
+    samples_per_class = data_module.pop("samples_per_class")
+
+    loss_fn = get_loss_function(training_args, samples_per_class=samples_per_class)
+    model.loss_fn = loss_fn.to(model.dtype if hasattr(model, "dtype") else torch.float32)
+
+    callback_list = None
+
+    if training_args.early_stopping_patience > 0:
+        early_stop_cb = EarlyStoppingCallback(
+            early_stopping_patience=training_args.early_stopping_patience,
+            early_stopping_threshold=training_args.early_stopping_threshold,
+        )
+        callback_list = [early_stop_cb]
+
+    trainer = QwenCLSTrainer(
+        model=model,
+        processing_class=processor,
+        args=training_args,
+        compute_metrics=compute_metrics,
+        callbacks=callback_list,
+        **data_module,
+    )
+
+    if list(pathlib.Path(training_args.output_dir).glob("checkpoint-*")):
+        trainer.train(resume_from_checkpoint=True)
+    else:
+        trainer.train()
+
+    trainer.save_state()
+
+    model.config.use_cache = True
+    
+    if training_args.lora_enable:
+        state_dict = get_peft_state_maybe_zero_3(
+            model.named_parameters(), training_args.lora_bias
+        )
+
+        non_lora_state_dict = get_peft_state_non_lora_maybe_zero_3(
+            model.named_parameters(), require_grad_only=True
+        )
+
+        if local_rank == 0 or local_rank == -1:
+            model.config.save_pretrained(training_args.output_dir)
+            model.save_pretrained(training_args.output_dir, state_dict=state_dict)
+            torch.save(non_lora_state_dict, os.path.join(training_args.output_dir, "non_lora_state_dict.bin"))
+    else:
+        safe_save_model_for_hf_trainer(trainer, output_dir=training_args.output_dir)
+
+if __name__ == "__main__":
+    train()

src/train/train_dpo.py

@@ -0,0 +1,329 @@
+import os
+import torch
+from peft import LoraConfig, get_peft_model
+import ast
+from transformers import (
+    AutoProcessor,
+    AutoConfig,
+    BitsAndBytesConfig,
+    Qwen2VLForConditionalGeneration, 
+    HfArgumentParser, 
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from src.trainer import QwenDPOTrainer
+from src.dataset import make_dpo_data_module
+from src.params import DataArguments, ModelArguments, DPOArguments
+from train.train_utils import get_peft_state_maybe_zero_3, get_peft_state_non_lora_maybe_zero_3, safe_save_model_for_hf_trainer
+import pathlib
+from monkey_patch_forward import (
+    replace_qwen2_5_with_mixed_modality_forward, 
+    replace_qwen_2_with_mixed_modality_forward,
+    replace_qwen3_with_mixed_modality_forward,
+    replace_qwen3_vl_moe_with_mixed_modality_forward
+)
+from monkey_patch_vision import replace_qwen2_5_vision
+
+local_rank = None
+
+def rank0_print(*args):
+    if local_rank == 0 or local_rank == '0' or local_rank is None:
+        print(*args)
+
+def find_target_linear_names(model, num_lora_modules=-1, lora_namespan_exclude=[], verbose=True):
+    linear_cls = torch.nn.modules.Linear
+    embedding_cls = torch.nn.modules.Embedding
+    lora_module_names = []
+
+    for name, module in model.named_modules():
+        if any(ex_keyword in name for ex_keyword in lora_namespan_exclude):
+            continue
+        if isinstance(module, (linear_cls, embedding_cls)):
+            lora_module_names.append(name)
+    
+    if num_lora_modules > 0:
+        lora_module_names = lora_module_names[-num_lora_modules:]
+    if verbose:
+        rank0_print(f"Found {len(lora_module_names)} lora modules: {lora_module_names}")
+    return lora_module_names
+
+def set_requires_grad(parameters, requires_grad):
+    for p in parameters:
+        p.requires_grad = requires_grad
+
+def configure_vision_tower(model, training_args, compute_dtype, device):
+    vision_tower = model.visual
+    vision_tower.to(dtype=compute_dtype, device=device)
+
+    vision_model_params = model.visual.parameters()
+    set_requires_grad(vision_model_params, not training_args.freeze_vision_tower)
+    
+    # Handle merger specifically
+    merger_params = model.visual.merger.parameters()
+    set_requires_grad(merger_params, not training_args.freeze_merger)
+
+    if hasattr(model.visual, "deepstack_merger_list"):
+        deepstack_merger_list_params = model.visual.deepstack_merger_list.parameters()
+        set_requires_grad(deepstack_merger_list_params, not training_args.freeze_merger)
+
+def configure_llm(model, training_args):
+    lm_head = model.lm_head.parameters()
+    set_requires_grad(lm_head, not training_args.freeze_llm)
+
+    llm_params = model.language_model.parameters()
+    set_requires_grad(llm_params, not training_args.freeze_llm)
+
+def unfreeze_topk_layers(model, k_llm: int = 0, k_vis: int = 0):
+    if k_llm and hasattr(model, "language_model") and hasattr(model.language_model, "layers"):
+        for layer in model.language_model.layers[-k_llm:]:
+            for p in layer.parameters():
+                p.requires_grad = True
+
+    if k_vis and hasattr(model, "visual") and hasattr(model.visual, "blocks"):
+        for blk in model.visual.blocks[-k_vis:]:
+            for p in blk.parameters():
+                p.requires_grad = True
+
+def train():
+    global local_rank
+
+    parser = HfArgumentParser(
+        (ModelArguments, DataArguments, DPOArguments))
+    
+    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+    
+    if data_args.nframes is not None and data_args.fps is not None:
+        raise ValueError("You cannot set both `nframes` and `fps` at the same time. Please set only one of them.")
+
+    if training_args.lora_enable and not training_args.freeze_llm:
+        raise ValueError("If `lora_enable` is True, `freeze_llm` must also be True.")
+
+    if not training_args.lora_enable:
+        assert not training_args.vision_lora, \
+            "Error: training_args.lora_enable is not enabled, but training_args.vision_lora is enabled."
+        
+    if training_args.vision_lora and not training_args.freeze_vision_tower:
+        raise ValueError("If `vision_lora` is True, `freeze_vision_tower` must also be True.")
+
+    else:
+        if training_args.lora_namespan_exclude is not None:
+            training_args.lora_namespan_exclude = ast.literal_eval(training_args.lora_namespan_exclude)
+        else:
+            training_args.lora_namespan_exclude = []
+
+        if not training_args.vision_lora:
+            training_args.lora_namespan_exclude += ["visual"]
+
+    local_rank = training_args.local_rank
+    compute_dtype = (torch.float16 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32))
+
+    bnb_model_from_pretrained_args = {}
+    if training_args.bits in [4,8]:
+        bnb_model_from_pretrained_args.update(dict(
+            device_map={"":training_args.device},
+            quantization_config = BitsAndBytesConfig(
+                load_in_4bit=training_args.bits==4,
+                load_in_8bit=training_args.bits==8,
+                llm_int8_skip_modules=["visual", "lm_head"],
+                llm_int8_threshold=6.0,
+                llm_int8_has_fp16_weight=False,
+                bnb_4bit_compute_dtype=compute_dtype,
+                bnb_4bit_use_double_quant=training_args.double_quant,
+                bnb_4bit_quant_type=training_args.quant_type,
+            )
+        ))
+
+    ref_model = None
+
+    config = AutoConfig.from_pretrained(model_args.model_id)
+
+    if config.model_type == "qwen3_vl_moe":
+        replace_qwen3_vl_moe_with_mixed_modality_forward()
+        model = Qwen3VLMoeForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa",
+            **bnb_model_from_pretrained_args
+        )
+        if not training_args.lora_enable:
+            ref_model = Qwen3VLMoeForConditionalGeneration.from_pretrained(
+                model_args.model_id,
+                dtype=compute_dtype,
+                attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa",
+                **bnb_model_from_pretrained_args
+            )
+
+    elif config.model_type == "qwen3_vl":
+        replace_qwen3_with_mixed_modality_forward()
+        model = Qwen3VLForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa",
+            **bnb_model_from_pretrained_args
+        )
+        if not training_args.lora_enable:
+            ref_model = Qwen3VLForConditionalGeneration.from_pretrained(
+                model_args.model_id,
+                dtype=compute_dtype,
+                attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa",
+                **bnb_model_from_pretrained_args
+            )
+
+    elif config.model_type == "qwen2_5_vl":
+        replace_qwen2_5_with_mixed_modality_forward()
+        replace_qwen2_5_vision()
+        model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa", 
+            **bnb_model_from_pretrained_args
+        )
+        if not training_args.lora_enable:
+            ref_model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+                model_args.model_id,
+                dtype=compute_dtype,
+                attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa", 
+                **bnb_model_from_pretrained_args
+            )
+        
+    else:
+        replace_qwen_2_with_mixed_modality_forward()
+        model = Qwen2VLForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa", 
+            **bnb_model_from_pretrained_args
+        )
+        if not training_args.lora_enable:
+            ref_model = Qwen2VLForConditionalGeneration.from_pretrained(
+                model_args.model_id,
+                dtype=compute_dtype,
+                attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa", 
+                **bnb_model_from_pretrained_args
+            )
+
+    model.config.use_cache = False
+    model_to_configure = model
+    configure_llm(model_to_configure, training_args)
+    configure_vision_tower(model_to_configure, training_args, compute_dtype, training_args.device)
+
+    unfreeze_topk_layers(
+        model_to_configure,
+        k_llm=getattr(training_args, "unfreeze_topk_llm", 0),
+        k_vis=getattr(training_args, "unfreeze_topk_vision", 0),
+    )
+
+    if training_args.gradient_checkpointing:
+        if training_args.vision_lora:
+            training_args.gradient_checkpointing_kwargs = {"use_reentrant": False}
+        else:
+            training_args.gradient_checkpointing_kwargs = {"use_reentrant": True}
+        
+        model.enable_input_require_grads()
+
+    if training_args.bits in [4,8]:
+        model.config.dtype = (torch.float32 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32))
+        from peft import prepare_model_for_kbit_training
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=training_args.gradient_checkpointing, gradient_checkpointing_kwargs=training_args.gradient_checkpointing_kwargs)
+
+    if training_args.lora_enable:
+        lora_namespan_exclude = training_args.lora_namespan_exclude
+        peft_config = LoraConfig(
+            r=training_args.lora_rank,
+            lora_alpha=training_args.lora_alpha,
+            target_modules=find_target_linear_names(model, lora_namespan_exclude=lora_namespan_exclude, num_lora_modules=training_args.num_lora_modules),
+            lora_dropout=training_args.lora_dropout,
+            bias=training_args.lora_bias
+        )
+        if training_args.bits == 16:
+            if training_args.bf16:
+                model.to(torch.bfloat16)
+            if training_args.fp16:
+                model.to(torch.float16)
+        rank0_print("Adding LoRA to the model...")
+        model = get_peft_model(model, peft_config)
+
+        # Peft maodel makes vision tower and merger freezed again.
+        # Configuring fuction could be called here, but sometimes it does not work properly.
+        # So I just made it this way.
+        # Need to be fixed in the future.
+
+        if not training_args.freeze_vision_tower:
+            for name, param in model.named_parameters():
+                if "visual" in name:
+                    param.requires_grad = True
+
+        if not training_args.freeze_merger:
+            for name, param in model.named_parameters():
+                if "merger" in name:
+                    param.requires_grad = True
+
+    processor = AutoProcessor.from_pretrained(model_args.model_id)
+
+    # model.config.tokenizer_model_max_length = processor.tokenizer.model_max_length
+
+    if ref_model is not None:
+        ref_model.eval()
+        ref_model.config.use_cache = False
+
+    if training_args.bits in [4, 8]:
+        from peft.tuners.lora import LoraLayer
+        for name, module in model.named_modules():
+            if isinstance(module, LoraLayer):
+                if training_args.bf16:
+                    module = module.to(torch.bfloat16)
+            if 'norm' in name:
+                module = module.to(torch.float32)
+            
+            if 'lm_head' in name or 'embed_token' in name:
+                if hasattr(module, 'weight'):
+                    if training_args.bf16 and module.weight.dtype == torch.float32:
+                        module = module.to(torch.bfloat16)
+
+    dataset_module = make_dpo_data_module(model_id=model_args.model_id,
+                                              processor=processor,
+                                              data_args=data_args)
+    
+    training_args.padding_value = processor.tokenizer.pad_token_id
+
+    trainer = QwenDPOTrainer(
+        model=model,
+        ref_model = ref_model,
+        train_dataset=dataset_module["train_dataset"],
+        eval_dataset = dataset_module["eval_dataset"],
+        data_collator= dataset_module["data_collator"],
+        processing_class=processor,
+        args=training_args,
+    )
+
+    if list(pathlib.Path(training_args.output_dir).glob("checkpoint-*")):
+        trainer.train(resume_from_checkpoint=True)
+    else:
+        trainer.train()
+
+    trainer.save_state()
+
+    model.config.use_cache = True
+    
+    if training_args.lora_enable:
+        state_dict = get_peft_state_maybe_zero_3(
+            model.named_parameters(), training_args.lora_bias
+        )
+
+        non_lora_state_dict = get_peft_state_non_lora_maybe_zero_3(
+            model.named_parameters(), require_grad_only=True
+        )
+
+        if local_rank == 0 or local_rank == -1:
+            model.config.save_pretrained(training_args.output_dir)
+            model.save_pretrained(training_args.output_dir, state_dict=state_dict)
+            processor.save_pretrained(training_args.output_dir)
+            torch.save(non_lora_state_dict, os.path.join(training_args.output_dir, "non_lora_state_dict.bin"))
+    else:
+        safe_save_model_for_hf_trainer(trainer, output_dir=training_args.output_dir)
+
+
+
+if __name__ == "__main__":
+    train()

src/train/train_grpo.py

@@ -0,0 +1,284 @@
+import os
+import torch
+from peft import LoraConfig
+import ast
+import pathlib
+from transformers import (
+    AutoProcessor, 
+    AutoConfig,
+    BitsAndBytesConfig, 
+    Qwen2VLForConditionalGeneration, 
+    HfArgumentParser, 
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+
+from src.trainer import QwenGRPOTrainer
+from src.dataset import make_grpo_data_module
+from src.params import DataArguments, ModelArguments, GRPOArguments
+from train.train_utils import get_peft_state_maybe_zero_3, get_peft_state_non_lora_maybe_zero_3, safe_save_model_for_hf_trainer
+from monkey_patch_forward import (
+    replace_qwen2_5_with_mixed_modality_forward, 
+    replace_qwen_2_with_mixed_modality_forward,
+    replace_qwen3_with_mixed_modality_forward,
+    replace_qwen3_vl_moe_with_mixed_modality_forward
+)
+from monkey_patch_vision import replace_qwen2_5_vision
+from src.utils import  load_reward_funcs
+
+local_rank = None
+
+def rank0_print(*args):
+    if local_rank == 0 or local_rank == '0' or local_rank is None:
+        print(*args)
+
+def find_target_linear_names(model, num_lora_modules=-1, lora_namespan_exclude=[], verbose=True):
+    linear_cls = torch.nn.modules.Linear
+    embedding_cls = torch.nn.modules.Embedding
+    lora_module_names = []
+
+    for name, module in model.named_modules():
+        if any(ex_keyword in name for ex_keyword in lora_namespan_exclude):
+            continue
+        if isinstance(module, (linear_cls, embedding_cls)):
+            lora_module_names.append(name)
+    
+    if num_lora_modules > 0:
+        lora_module_names = lora_module_names[-num_lora_modules:]
+    if verbose:
+        rank0_print(f"Found {len(lora_module_names)} lora modules: {lora_module_names}")
+    return lora_module_names
+
+def set_requires_grad(parameters, requires_grad):
+    for p in parameters:
+        p.requires_grad = requires_grad
+
+def configure_vision_tower(model, training_args, compute_dtype, device):
+    vision_tower = model.visual
+    vision_tower.to(dtype=compute_dtype, device=device)
+
+    vision_model_params = model.visual.parameters()
+    set_requires_grad(vision_model_params, not training_args.freeze_vision_tower)
+    
+    # Handle merger specifically
+    merger_params = model.visual.merger.parameters()
+    set_requires_grad(merger_params, not training_args.freeze_merger)
+
+    if hasattr(model.visual, "deepstack_merger_list"):
+        deepstack_merger_list_params = model.visual.deepstack_merger_list.parameters()
+        set_requires_grad(deepstack_merger_list_params, not training_args.freeze_merger)
+
+def configure_llm(model, training_args):
+    lm_head = model.lm_head.parameters()
+    set_requires_grad(lm_head, not training_args.freeze_llm)
+
+    llm_params = model.language_model.parameters()
+    set_requires_grad(llm_params, not training_args.freeze_llm)
+
+def unfreeze_topk_layers(model, k_llm: int = 0, k_vis: int = 0):
+    if k_llm and hasattr(model, "language_model") and hasattr(model.language_model, "layers"):
+        for layer in model.language_model.layers[-k_llm:]:
+            for p in layer.parameters():
+                p.requires_grad = True
+
+    if k_vis and hasattr(model, "visual") and hasattr(model.visual, "blocks"):
+        for blk in model.visual.blocks[-k_vis:]:
+            for p in blk.parameters():
+                p.requires_grad = True
+
+
+
+def train():
+    global local_rank
+
+    parser = HfArgumentParser(
+        (ModelArguments, DataArguments, GRPOArguments))
+    
+    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    if data_args.nframes is not None and data_args.fps is not None:
+        raise ValueError("You cannot set both `nframes` and `fps` at the same time. Please set only one of them.")
+
+    if training_args.lora_enable and not training_args.freeze_llm:
+        raise ValueError("If `lora_enable` is True, `freeze_llm` must also be True.")
+
+    if not training_args.lora_enable:
+        assert not training_args.vision_lora, \
+            "Error: training_args.lora_enable is not enabled, but training_args.vision_lora is enabled."
+        
+    if training_args.vision_lora and not training_args.freeze_vision_tower:
+        raise ValueError("If `vision_lora` is True, `freeze_vision_tower` must also be True.")
+
+    else:
+        if training_args.lora_namespan_exclude is not None:
+            training_args.lora_namespan_exclude = ast.literal_eval(training_args.lora_namespan_exclude)
+        else:
+            training_args.lora_namespan_exclude = []
+
+        if not training_args.vision_lora:
+            training_args.lora_namespan_exclude += ["visual"]
+
+    local_rank = training_args.local_rank
+    compute_dtype = (torch.float16 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32))
+
+    bnb_model_from_pretrained_args = {}
+    if training_args.bits in [4,8]:
+        bnb_model_from_pretrained_args.update(dict(
+            device_map={"":training_args.device},
+            quantization_config = BitsAndBytesConfig(
+                load_in_4bit=training_args.bits==4,
+                load_in_8bit=training_args.bits==8,
+                llm_int8_skip_modules=["visual"],
+                llm_int8_threshold=6.0,
+                llm_int8_has_fp16_weight=False,
+                bnb_4bit_compute_dtype=compute_dtype,
+                bnb_4bit_use_double_quant=training_args.double_quant,
+                bnb_4bit_quant_type=training_args.quant_type,
+            )
+        ))
+
+    config = AutoConfig.from_pretrained(model_args.model_id)
+
+    if config.model_type == "qwen3_vl_moe":
+        replace_qwen3_vl_moe_with_mixed_modality_forward()
+        model = Qwen3VLMoeForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa",
+            **bnb_model_from_pretrained_args
+        )
+
+    elif config.model_type == "qwen3_vl":
+        replace_qwen3_with_mixed_modality_forward()
+        model = Qwen3VLForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa",
+            **bnb_model_from_pretrained_args
+        )
+
+    elif config.model_type == "qwen2_5_vl":
+        replace_qwen2_5_with_mixed_modality_forward()
+        replace_qwen2_5_vision()
+        model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa", 
+            **bnb_model_from_pretrained_args
+        )
+        
+    else:
+        replace_qwen_2_with_mixed_modality_forward()
+        model = Qwen2VLForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa", 
+            **bnb_model_from_pretrained_args
+        )
+
+
+    model.config.use_cache = False
+    model_to_configure = model
+    configure_llm(model_to_configure, training_args)
+    configure_vision_tower(model_to_configure, training_args, compute_dtype, training_args.device)
+
+    unfreeze_topk_layers(
+        model_to_configure,
+        k_llm=getattr(training_args, "unfreeze_topk_llm", 0),
+        k_vis=getattr(training_args, "unfreeze_topk_vision", 0),
+    )
+
+    if training_args.gradient_checkpointing:
+        if training_args.vision_lora:
+            training_args.gradient_checkpointing_kwargs = {"use_reentrant": False}
+        else:
+            training_args.gradient_checkpointing_kwargs = {"use_reentrant": True}
+        
+        model.enable_input_require_grads()
+
+    if training_args.bits in [4,8]:
+        model.config.dtype = (torch.float32 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32))
+        from peft import prepare_model_for_kbit_training
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=training_args.gradient_checkpointing, gradient_checkpointing_kwargs=training_args.gradient_checkpointing_kwargs)
+
+    peft_config = None
+
+    if training_args.lora_enable:
+        lora_namespan_exclude = training_args.lora_namespan_exclude
+        peft_config = LoraConfig(
+            r=training_args.lora_rank,
+            lora_alpha=training_args.lora_alpha,
+            target_modules=find_target_linear_names(model, lora_namespan_exclude=lora_namespan_exclude, num_lora_modules=training_args.num_lora_modules),
+            lora_dropout=training_args.lora_dropout,
+            bias=training_args.lora_bias
+        )
+        if training_args.bits == 16:
+            if training_args.bf16:
+                model.to(torch.bfloat16)
+            if training_args.fp16:
+                model.to(torch.float16)
+
+    processor = AutoProcessor.from_pretrained(model_args.model_id)
+    processor.image_processor.do_resize = False
+
+    if training_args.bits in [4, 8]:
+        from peft.tuners.lora import LoraLayer
+        for name, module in model.named_modules():
+            if isinstance(module, LoraLayer):
+                if training_args.bf16:
+                    module = module.to(torch.bfloat16)
+            if 'norm' in name:
+                module = module.to(torch.float32)
+            
+            if 'lm_head' in name or 'embed_token' in name:
+                if hasattr(module, 'weight'):
+                    if training_args.bf16 and module.weight.dtype == torch.float32:
+                        module = module.to(torch.bfloat16)
+
+    dataset_module = make_grpo_data_module(model_id=model_args.model_id,
+                                              processor=processor,
+                                              data_args=data_args)
+
+    reward_funcs = load_reward_funcs("src.train.reward_funcs")
+
+    trainer = QwenGRPOTrainer(
+        model=model,
+        train_dataset=dataset_module["train_dataset"],
+        eval_dataset=dataset_module["eval_dataset"],
+        processing_class=processor,
+        reward_funcs=reward_funcs,
+        args=training_args,
+        peft_config=peft_config,
+    )
+
+    if list(pathlib.Path(training_args.output_dir).glob("checkpoint-*")):
+        trainer.train(resume_from_checkpoint=True)
+    else:
+        trainer.train()
+
+    trainer.save_state()
+
+    model.config.use_cache = True
+    
+    if training_args.lora_enable:
+        state_dict = get_peft_state_maybe_zero_3(
+            model.named_parameters(), training_args.lora_bias
+        )
+
+        non_lora_state_dict = get_peft_state_non_lora_maybe_zero_3(
+            model.named_parameters(), require_grad_only=False
+        )
+
+        if local_rank == 0 or local_rank == -1:
+            model.config.save_pretrained(training_args.output_dir)
+            model.save_pretrained(training_args.output_dir, state_dict=state_dict)
+            processor.save_pretrained(training_args.output_dir)
+            torch.save(non_lora_state_dict, os.path.join(training_args.output_dir, "non_lora_state_dict.bin"))
+    else:
+        safe_save_model_for_hf_trainer(trainer, output_dir=training_args.output_dir)
+
+
+
+if __name__ == "__main__":
+    train()

src/train/train_sft.py

@@ -0,0 +1,291 @@
+import os
+import torch
+from peft import LoraConfig, get_peft_model
+import ast
+from transformers import (
+    AutoProcessor,
+    AutoConfig,
+    BitsAndBytesConfig, 
+    Qwen2VLForConditionalGeneration, 
+    HfArgumentParser, 
+    Qwen2_5_VLForConditionalGeneration,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLMoeForConditionalGeneration
+)
+from src.trainer import QwenSFTTrainer
+from src.dataset import make_supervised_data_module
+from src.params import DataArguments, ModelArguments, TrainingArguments
+from train.train_utils import get_peft_state_maybe_zero_3, get_peft_state_non_lora_maybe_zero_3, safe_save_model_for_hf_trainer
+import pathlib
+from monkey_patch_forward import (
+    replace_qwen3_with_mixed_modality_forward,
+    replace_qwen2_5_with_mixed_modality_forward, 
+    replace_qwen_2_with_mixed_modality_forward,
+    replace_qwen3_vl_moe_with_mixed_modality_forward
+)
+from monkey_patch_vision import replace_qwen2_5_vision
+
+local_rank = None
+
+def rank0_print(*args):
+    if local_rank == 0 or local_rank == '0' or local_rank is None:
+        print(*args)
+
+def find_target_linear_names(model, num_lora_modules=-1, lora_namespan_exclude=[], verbose=True):
+    linear_cls = torch.nn.modules.Linear
+    embedding_cls = torch.nn.modules.Embedding
+    lora_module_names = []
+
+    for name, module in model.named_modules():
+        if any(ex_keyword in name for ex_keyword in lora_namespan_exclude):
+            continue
+        if isinstance(module, (linear_cls, embedding_cls)):
+            lora_module_names.append(name)
+    
+    if num_lora_modules > 0:
+        lora_module_names = lora_module_names[-num_lora_modules:]
+    if verbose:
+        rank0_print(f"Found {len(lora_module_names)} lora modules: {lora_module_names}")
+    return lora_module_names
+
+def set_requires_grad(parameters, requires_grad):
+    for p in parameters:
+        p.requires_grad = requires_grad
+
+def configure_vision_tower(model, training_args, compute_dtype, device):
+    vision_tower = model.visual
+    vision_tower.to(dtype=compute_dtype, device=device)
+
+    vision_model_params = model.visual.parameters()
+    set_requires_grad(vision_model_params, not training_args.freeze_vision_tower)
+    
+    # Handle merger specifically
+    merger_params = model.visual.merger.parameters()
+    set_requires_grad(merger_params, not training_args.freeze_merger)
+
+    if hasattr(model.visual, "deepstack_merger_list"):
+        deepstack_merger_list_params = model.visual.deepstack_merger_list.parameters()
+        set_requires_grad(deepstack_merger_list_params, not training_args.freeze_merger)
+
+def configure_llm(model, training_args):
+    lm_head = model.lm_head.parameters()
+    set_requires_grad(lm_head, not training_args.freeze_llm)
+
+    llm_params = model.language_model.parameters()
+    set_requires_grad(llm_params, not training_args.freeze_llm)
+
+def unfreeze_topk_layers(model, k_llm: int = 0, k_vis: int = 0):
+    if k_llm and hasattr(model, "language_model") and hasattr(model.language_model, "layers"):
+        for layer in model.language_model.layers[-k_llm:]:
+            for p in layer.parameters():
+                p.requires_grad = True
+
+    if k_vis and hasattr(model, "visual") and hasattr(model.visual, "blocks"):
+        for blk in model.visual.blocks[-k_vis:]:
+            for p in blk.parameters():
+                p.requires_grad = True
+
+
+def train():
+    global local_rank
+
+    parser = HfArgumentParser(
+        (ModelArguments, DataArguments, TrainingArguments))
+    
+    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+    
+    if data_args.nframes is not None and data_args.fps is not None:
+        raise ValueError("You cannot set both `nframes` and `fps` at the same time. Please set only one of them.")
+
+    if training_args.lora_enable and not training_args.freeze_llm:
+        raise ValueError("If `lora_enable` is True, `freeze_llm` must also be True.")
+
+    if not training_args.lora_enable:
+        assert not training_args.vision_lora, \
+            "Error: training_args.lora_enable is not enabled, but training_args.vision_lora is enabled."
+        
+    if training_args.vision_lora and not training_args.freeze_vision_tower:
+        raise ValueError("If `vision_lora` is True, `freeze_vision_tower` must also be True.")
+
+    else:
+        if training_args.lora_namespan_exclude is not None:
+            training_args.lora_namespan_exclude = ast.literal_eval(training_args.lora_namespan_exclude)
+        else:
+            training_args.lora_namespan_exclude = []
+
+        if not training_args.vision_lora:
+            training_args.lora_namespan_exclude += ["visual"]
+
+    local_rank = training_args.local_rank
+    compute_dtype = (torch.float16 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32))
+
+    bnb_model_from_pretrained_args = {}
+    if training_args.bits in [4,8]:
+        bnb_model_from_pretrained_args.update(dict(
+            device_map={"":training_args.device},
+            quantization_config = BitsAndBytesConfig(
+                load_in_4bit=training_args.bits==4,
+                load_in_8bit=training_args.bits==8,
+                llm_int8_skip_modules=["visual", "lm_head"],
+                llm_int8_threshold=6.0,
+                llm_int8_has_fp16_weight=False,
+                bnb_4bit_compute_dtype=compute_dtype,
+                bnb_4bit_use_double_quant=training_args.double_quant,
+                bnb_4bit_quant_type=training_args.quant_type,
+            )
+        ))
+
+    config = AutoConfig.from_pretrained(model_args.model_id)
+
+    if config.model_type == "qwen3_vl_moe":
+        replace_qwen3_vl_moe_with_mixed_modality_forward()
+        model = Qwen3VLMoeForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa",
+            **bnb_model_from_pretrained_args
+        )
+
+    elif config.model_type == "qwen3_vl":
+        replace_qwen3_with_mixed_modality_forward()
+        model = Qwen3VLForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa",
+            **bnb_model_from_pretrained_args
+        )
+
+    elif config.model_type == "qwen2_5_vl":
+        replace_qwen2_5_with_mixed_modality_forward()
+        replace_qwen2_5_vision()
+        model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa", 
+            **bnb_model_from_pretrained_args
+        )
+        
+    else:
+        replace_qwen_2_with_mixed_modality_forward()
+        model = Qwen2VLForConditionalGeneration.from_pretrained(
+            model_args.model_id,
+            dtype=compute_dtype,
+            attn_implementation="flash_attention_2" if not training_args.disable_flash_attn2 else "sdpa", 
+            **bnb_model_from_pretrained_args
+        )
+
+    model.config.use_cache = False
+    model_to_configure = model
+    configure_llm(model_to_configure, training_args)
+    configure_vision_tower(model_to_configure, training_args, compute_dtype, training_args.device)
+
+    unfreeze_topk_layers(
+        model_to_configure,
+        k_llm=getattr(training_args, "unfreeze_topk_llm", 0),
+        k_vis=getattr(training_args, "unfreeze_topk_vision", 0),
+    )
+
+    if training_args.gradient_checkpointing:
+        if training_args.vision_lora:
+            training_args.gradient_checkpointing_kwargs = {"use_reentrant": False}
+        else:
+            training_args.gradient_checkpointing_kwargs = {"use_reentrant": True}
+        
+        model.enable_input_require_grads()
+
+    if training_args.bits in [4,8]:
+        model.config.dtype = (torch.float32 if training_args.fp16 else (torch.bfloat16 if training_args.bf16 else torch.float32))
+        from peft import prepare_model_for_kbit_training
+        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=training_args.gradient_checkpointing, gradient_checkpointing_kwargs=training_args.gradient_checkpointing_kwargs)
+    
+    if training_args.lora_enable:
+        lora_namespan_exclude = training_args.lora_namespan_exclude
+        peft_config = LoraConfig(
+            r=training_args.lora_rank,
+            lora_alpha=training_args.lora_alpha,
+            target_modules=find_target_linear_names(model, lora_namespan_exclude=lora_namespan_exclude, num_lora_modules=training_args.num_lora_modules),
+            lora_dropout=training_args.lora_dropout,
+            bias=training_args.lora_bias
+        )
+        if training_args.bits == 16:
+            if training_args.bf16:
+                model.to(torch.bfloat16)
+            if training_args.fp16:
+                model.to(torch.float16)
+        rank0_print("Adding LoRA to the model...")
+        model = get_peft_model(model, peft_config)
+
+        # Peft maodel makes vision tower and merger freezed again.
+        # Configuring fuction could be called here, but sometimes it does not work properly.
+        # So I just made it this way.
+        # Need to be fixed in the future.
+
+        if not training_args.freeze_vision_tower:
+            for name, param in model.named_parameters():
+                if "visual" in name:
+                    param.requires_grad = True
+
+        if not training_args.freeze_merger:
+            for name, param in model.named_parameters():
+                if "merger" in name:
+                    param.requires_grad = True
+
+    processor = AutoProcessor.from_pretrained(model_args.model_id)
+
+    # model.config.tokenizer_model_max_length = processor.tokenizer.model_max_length
+
+    if training_args.bits in [4, 8]:
+        from peft.tuners.lora import LoraLayer
+        for name, module in model.named_modules():
+            if isinstance(module, LoraLayer):
+                if training_args.bf16:
+                    module = module.to(torch.bfloat16)
+            if 'norm' in name:
+                module = module.to(torch.float32)
+            
+            if 'lm_head' in name or 'embed_token' in name:
+                if hasattr(module, 'weight'):
+                    if training_args.bf16 and module.weight.dtype == torch.float32:
+                        module = module.to(torch.bfloat16)
+
+    data_module = make_supervised_data_module(model_id=model_args.model_id,
+                                              processor=processor,
+                                              data_args=data_args)
+
+    trainer = QwenSFTTrainer(
+        model=model,
+        processing_class=processor,
+        args=training_args,
+        **data_module
+    )
+
+    if list(pathlib.Path(training_args.output_dir).glob("checkpoint-*")):
+        trainer.train(resume_from_checkpoint=True)
+    else:
+        trainer.train()
+
+    trainer.save_state()
+
+    model.config.use_cache = True
+    
+    if training_args.lora_enable:
+        state_dict = get_peft_state_maybe_zero_3(
+            model.named_parameters(), training_args.lora_bias
+        )
+
+        non_lora_state_dict = get_peft_state_non_lora_maybe_zero_3(
+            model.named_parameters(), require_grad_only=True
+        )
+
+        if local_rank == 0 or local_rank == -1:
+            model.config.save_pretrained(training_args.output_dir)
+            model.save_pretrained(training_args.output_dir, state_dict=state_dict)
+            processor.save_pretrained(training_args.output_dir)
+            torch.save(non_lora_state_dict, os.path.join(training_args.output_dir, "non_lora_state_dict.bin"))
+    else:
+        safe_save_model_for_hf_trainer(trainer, output_dir=training_args.output_dir)
+
+
+
+if __name__ == "__main__":
+    train()

src/train/train_utils.py

@@ -0,0 +1,74 @@
+import transformers
+import torch
+import logging
+
+
+def maybe_zero_3(param, ignore_status=False, name=None, device=torch.device('cpu')):
+    from deepspeed import zero
+    from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
+    if type(device) is str:
+        device = torch.device(device)
+    if hasattr(param, "ds_id"):
+        if param.ds_status == ZeroParamStatus.NOT_AVAILABLE:
+            if not ignore_status:
+                logging.warning(f"{name}: param.ds_status != ZeroParamStatus.NOT_AVAILABLE: {param.ds_status}")
+        with zero.GatheredParameters([param]):
+            param = param.data.detach()
+    else:
+        param = param.detach()
+    if device == param.device:
+        return param.clone()
+    else:
+        return param.to(device)
+
+# Borrowed from peft.utils.get_peft_model_state_dict
+def get_peft_state_maybe_zero_3(named_params, bias):
+    if bias == "none":
+        to_return = {k: t for k, t in named_params if "lora_" in k}
+    elif bias == "all":
+        to_return = {k: t for k, t in named_params if "lora_" in k or "bias" in k}
+    elif bias == "lora_only":
+        to_return = {}
+        maybe_lora_bias = {}
+        lora_bias_names = set()
+        for k, t in named_params:
+            if "lora_" in k:
+                to_return[k] = t
+                bias_name = k.split("lora_")[0] + "bias"
+                lora_bias_names.add(bias_name)
+            elif "bias" in k:
+                maybe_lora_bias[k] = t
+        for k, t in maybe_lora_bias:
+            if bias_name in lora_bias_names:
+                to_return[bias_name] = t
+    else:
+        raise NotImplementedError
+    to_return = {k: maybe_zero_3(v, ignore_status=True) for k, v in to_return.items()}
+    return to_return
+
+
+def get_peft_state_non_lora_maybe_zero_3(named_params, require_grad_only=True):
+    to_return = {k: t for k, t in named_params if "lora_" not in k}
+    if require_grad_only:
+        to_return = {k: t for k, t in to_return.items() if t.requires_grad}
+    to_return = {k: maybe_zero_3(v, ignore_status=True) for k, v in to_return.items()}
+    return to_return
+
+def safe_save_model_for_hf_trainer(trainer: transformers.Trainer,
+                                   output_dir: str):
+    """Collects the state dict and dump to disk."""
+
+    if trainer.deepspeed:
+        torch.cuda.synchronize()
+        trainer.save_model(output_dir)
+        return
+
+    state_dict = trainer.model.state_dict()
+    if trainer.args.should_save:
+        cpu_state_dict = {
+            key: value.cpu()
+            for key, value in state_dict.items()
+        }
+        del state_dict
+        trainer._save(output_dir, state_dict=cpu_state_dict)  # noqa
+        trainer.model.config.save_pretrained(output_dir)

src/trainer/__init__.py

@@ -0,0 +1,6 @@
+from .dpo_trainer import QwenDPOTrainer
+from .sft_trainer import QwenSFTTrainer, GenerativeEvalPrediction
+from .grpo_trainer import QwenGRPOTrainer
+from .cls_trainer import QwenCLSTrainer
+
+__all__ = ["QwenSFTTrainer", "QwenDPOTrainer", "QwenGRPOTrainer", "QwenCLSTrainer", "GenerativeEvalPrediction"]

src/trainer/cls_trainer.py

@@ -0,0 +1,283 @@
+import os
+import torch
+import torch.nn as nn
+
+from transformers import Trainer
+from transformers.trainer import (
+    is_sagemaker_mp_enabled,
+    get_parameter_names,
+    TRAINER_STATE_NAME,
+    PREFIX_CHECKPOINT_DIR,
+    logger,
+    ExportableState,
+    SaveStrategy
+)
+from transformers.pytorch_utils import (
+    ALL_LAYERNORM_LAYERS
+)
+from transformers.trainer_utils import seed_worker
+from transformers.utils import is_datasets_available
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+import datasets
+from typing import Optional, Callable
+from functools import partial
+from torch.utils.data import Dataset
+
+from src.train.train_utils import get_peft_state_non_lora_maybe_zero_3
+
+def maybe_zero_3(param, ignore_status=False, name=None):
+    from deepspeed import zero
+    from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
+
+    if hasattr(param, "ds_id"):
+        if param.ds_status == ZeroParamStatus.NOT_AVAILABLE:
+            if not ignore_status:
+                print(name, "no ignore status")
+        with zero.GatheredParameters([param]):
+            param = param.data.detach().cpu().clone()
+    else:
+        param = param.detach().cpu().clone()
+    return param
+
+class QwenCLSTrainer(Trainer):
+
+    def __init__(self, *args, sampler=None, train_data_collator=None, eval_data_collator=None, **kwargs):
+        self._custom_sampler = sampler
+        self._train_data_collator = train_data_collator
+        self._eval_data_collator = eval_data_collator
+        super().__init__(*args, data_collator=self._train_data_collator,**kwargs)
+    
+    def get_eval_dataloader(self, eval_dataset=None):
+        dl = super().get_eval_dataloader(eval_dataset)
+        dl.collate_fn = self._eval_data_collator
+        return dl
+
+    def get_train_dataloader(self) -> DataLoader:
+        """
+        Returns the training [`~torch.utils.data.DataLoader`].
+
+        Will use no sampler if `train_dataset` does not implement `__len__`, a random sampler (adapted to distributed
+        training if necessary) otherwise.
+
+        Subclass and override this method if you want to inject some custom behavior.
+        """
+        if self.train_dataset is None:
+            raise ValueError("Trainer: training requires a train_dataset.")
+
+        sampler = self._custom_sampler if self._custom_sampler is not None else self._get_train_sampler
+
+        return self._get_dataloader(
+            dataset=self.train_dataset,
+            description="Training",
+            batch_size=self._train_batch_size,
+            sampler_fn=sampler,
+            is_training=True,
+        )
+    
+    def _get_dataloader(
+        self,
+        dataset: Dataset,
+        description: str,
+        batch_size: int,
+        sampler_fn: Optional[Callable[[Dataset], torch.utils.data.Sampler]] = None,
+        is_training: bool = False,
+        dataloader_key: Optional[str] = None,
+    ) -> DataLoader:
+        """Create a [`~torch.utils.data.DataLoader`] from the given dataset."""
+
+        data_collator = self.data_collator
+        if is_datasets_available() and isinstance(dataset, datasets.Dataset):
+            dataset = self._remove_unused_columns(dataset, description=description)
+        else:
+            data_collator = self._get_collator_with_removed_columns(self.data_collator, description=description)
+
+        dataloader_params = {
+            "batch_size": batch_size,
+            "collate_fn": data_collator,
+            "num_workers": self.args.dataloader_num_workers,
+            "pin_memory": self.args.dataloader_pin_memory,
+            "persistent_workers": self.args.dataloader_persistent_workers,
+        }
+
+        if not isinstance(dataset, torch.utils.data.IterableDataset):
+            if sampler_fn is not None:
+                dataloader_params["sampler"] = sampler_fn(dataset)
+            dataloader_params["drop_last"] = self.args.dataloader_drop_last
+            dataloader_params["prefetch_factor"] = self.args.dataloader_prefetch_factor
+            if is_training:
+                dataloader_params["worker_init_fn"] = partial(
+                    seed_worker, num_workers=self.args.dataloader_num_workers, rank=self.args.process_index
+                )
+
+        dataloader = DataLoader(dataset, **dataloader_params)
+        
+        if isinstance(sampler_fn, DistributedSampler):
+            dataloader = self.accelerator.prepare(dataloader)
+
+        # Store the prepared dataloader for subsequent evaluations if using persistent workers.
+        if dataloader_key is not None and self.args.dataloader_persistent_workers:
+            if hasattr(self, "_eval_dataloaders"):
+                self._eval_dataloaders[dataloader_key] = dataloader
+            else:
+                self._eval_dataloaders = {dataloader_key: dataloader}
+
+        return dataloader
+
+
+    def create_optimizer(self):
+        """
+        Setup the optimizer.
+        We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the
+        Trainer's init through `optimizers`, or subclass and override this method in a subclass.
+        """
+        if is_sagemaker_mp_enabled():
+            return super().create_optimizer()
+        
+        opt_model = self.model
+
+        if self.optimizer is None:
+            decay_parameters = get_parameter_names(opt_model, ALL_LAYERNORM_LAYERS)
+            decay_parameters = [name for name in decay_parameters if "bias" not in name]
+            lr_mapper = {}
+            visual_parameters = []
+            merger_parameters = []
+            head_parameters = []
+
+            if self.args.vision_lr is not None:
+                lr_mapper["visual"] = self.args.vision_lr
+                visual_parameters = [name for name, _ in opt_model.named_parameters() if "visual" in name and "merger" not in name]
+            if self.args.merger_lr is not None:
+                lr_mapper["merger"] = self.args.merger_lr
+                merger_parameters = [name for name, _ in opt_model.named_parameters() if "merger" in name]
+            if self.args.head_lr is not None:
+                lr_mapper["score"] = self.args.head_lr
+                head_parameters = [name for name, _ in opt_model.named_parameters() if "score" in name]
+
+            if len(lr_mapper) > 0:
+                special_lr_parameters = merger_parameters + visual_parameters + head_parameters
+                
+                optimizer_grouped_parameters = [
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n not in special_lr_parameters and p.requires_grad)],
+                        "weight_decay": self.args.weight_decay,
+                    },
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n not in special_lr_parameters and p.requires_grad)],
+                        "weight_decay": 0.0,
+                    },
+                ]
+                
+                if visual_parameters: 
+                    optimizer_grouped_parameters.extend(
+                        [
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n in visual_parameters and p.requires_grad)],
+                                "weight_decay": self.args.weight_decay,
+                                "lr": self.args.vision_lr,
+                                "param_group_name": "visaul_decay"
+                            },
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n in visual_parameters and p.requires_grad)],
+                                "weight_decay": 0.0,
+                                "lr": self.args.vision_lr,
+                                "param_group_name": "visaul_non_decay"
+                            },
+                        ]
+                    )
+                
+                if merger_parameters: 
+                    optimizer_grouped_parameters.extend(
+                        [
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n in merger_parameters and p.requires_grad)],
+                                "weight_decay": self.args.weight_decay,
+                                "lr": self.args.merger_lr,
+                                "param_group_name": "merger_decay",
+                            },
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n in merger_parameters and p.requires_grad)],
+                                "weight_decay": 0.0,
+                                "lr": self.args.merger_lr,
+                                "param_group_name": "merger_non_decay",
+                            },
+                        ]
+                    )
+                if head_parameters:
+                    optimizer_grouped_parameters.extend(
+                        [
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n in head_parameters and p.requires_grad)],
+                                "weight_decay": self.args.weight_decay,
+                                "lr": self.args.head_lr,
+                                "param_group_name": "head_decay",
+                            },
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n in head_parameters and p.requires_grad)],
+                                "weight_decay": 0.0,
+                                "lr": self.args.head_lr,
+                                "param_group_name": "head_non_decay",
+                            },
+                        ]
+                    )
+            else:
+                optimizer_grouped_parameters = [
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and p.requires_grad)],
+                        "weight_decay": self.args.weight_decay,
+                    },
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and p.requires_grad)],
+                        "weight_decay": 0.0,
+                    },
+                ]
+            optimizer_cls, optimizer_kwargs = Trainer.get_optimizer_cls_and_kwargs(self.args)
+
+            self.optimizer = optimizer_cls(optimizer_grouped_parameters, **optimizer_kwargs)
+            if optimizer_cls.__name__ == "Adam8bit":
+                import bitsandbytes
+
+                manager = bitsandbytes.optim.GlobalOptimManager.get_instance()
+
+                skipped = 0
+                for module in opt_model.modules():
+                    if isinstance(module, nn.Embedding):
+                        skipped += sum({p.data_ptr(): p.numel() for p in module.parameters()}.values())
+                        logger.info(f"skipped {module}: {skipped/2**20}M params")
+                        manager.register_module_override(module, "weight", {"optim_bits": 32})
+                        logger.debug(f"bitsandbytes: will optimize {module} in fp32")
+                logger.info(f"skipped: {skipped/2**20}M params")
+
+        return self.optimizer
+    
+    def _save_checkpoint(self, model, trial):
+        # In all cases, including ddp/dp/deepspeed, self.model is always a reference to the model we
+        # want to save except FullyShardedDDP.
+        # assert unwrap_model(model) is self.model, "internal model should be a reference to self.model"
+
+        # Save model checkpoint
+        super()._save_checkpoint(model, trial)
+
+        if not self.args.lora_enable:
+            return
+
+        checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}"
+        run_dir = self._get_output_dir(trial=trial)
+        output_dir = os.path.join(run_dir, checkpoint_folder)
+
+        non_lora = get_peft_state_non_lora_maybe_zero_3(
+            self.model.named_parameters(),
+            require_grad_only=True,
+        )
+
+        if self.args.should_save:
+            torch.save(non_lora, os.path.join(output_dir, "non_lora_state_dict.bin"))
+            self.model.base_model.config.to_json_file(os.path.join(output_dir, "config.json"))
+
+
+    # def training_step(self, model, inputs):
+    #     for name, param in model.named_parameters():
+    #         if 'visual' in name and param.requires_grad:
+    #             print(f"Training parameter {name}")
+    # 
+    #     return super().training_step(model, inputs)

src/trainer/dpo_trainer.py

@@ -0,0 +1,314 @@
+import os
+import torch
+from torch import nn
+from pathlib import Path
+import torch.nn.functional as F
+from typing import Union
+
+from transformers.trainer import (
+    is_sagemaker_mp_enabled,
+    get_parameter_names,
+    TRAINER_STATE_NAME,
+    PREFIX_CHECKPOINT_DIR,
+    logger,
+    ExportableState,
+    SaveStrategy
+)
+from transformers.pytorch_utils import (
+    ALL_LAYERNORM_LAYERS
+)
+from trl import DPOTrainer
+from trl.trainer.utils import pad_to_length, flush_left, selective_log_softmax
+from train.train_utils import get_peft_state_non_lora_maybe_zero_3
+
+def maybe_zero_3(param, ignore_status=False, name=None):
+    from deepspeed import zero
+    from deepspeed.runtime.zero.partition_parameters import ZeroParamStatus
+
+    if hasattr(param, "ds_id"):
+        if param.ds_status == ZeroParamStatus.NOT_AVAILABLE:
+            if not ignore_status:
+                print(name, "no ignore status")
+        with zero.GatheredParameters([param]):
+            param = param.data.detach().cpu().clone()
+    else:
+        param = param.detach().cpu().clone()
+    return param
+
+class QwenDPOTrainer(DPOTrainer):
+
+    def __init__(self, *args, **kwargs):
+        super(QwenDPOTrainer, self).__init__(*args, **kwargs)
+
+    def _prepare_dataset(
+        self,
+        dataset,
+        processing_class,
+        args,
+        dataset_name
+    ):
+        return dataset
+
+    @staticmethod
+    def concatenated_inputs(
+        batch: dict[str, Union[list, torch.LongTensor]], padding_value: int
+    ) -> dict[str, torch.LongTensor]:
+
+        concatenated_batch = {}
+
+        concatenated_batch['prompt_input_ids'] = torch.cat([batch["prompt_input_ids"], batch["prompt_input_ids"]], dim=0)
+        concatenated_batch['prompt_attention_mask'] = torch.cat([batch["prompt_attention_mask"], batch["prompt_attention_mask"]], dim=0)
+
+        if 'pixel_values' in batch:
+            concatenated_batch['pixel_values'] = torch.cat([batch["pixel_values"], batch["pixel_values"]], dim=0)
+            concatenated_batch['image_grid_thw'] = torch.cat([batch["image_grid_thw"], batch["image_grid_thw"]], dim=0)
+
+        if 'pixel_values_videos' in batch:
+            concatenated_batch['pixel_values_videos'] = torch.cat(
+                [batch["pixel_values_videos"], batch["pixel_values_videos"]], dim=0
+            )
+            concatenated_batch['video_grid_thw'] = torch.cat(
+                [batch["video_grid_thw"], batch["video_grid_thw"]], dim=0
+            )
+
+        if 'second_grid_ts' in batch:
+            concatenated_batch['second_grid_ts'] = torch.cat(
+                [batch["second_grid_ts"], batch["second_grid_ts"]], dim=0
+            )
+
+        max_completion_length = max(batch["chosen_input_ids"].shape[1], batch["rejected_input_ids"].shape[1])
+
+        concatenated_batch['completion_input_ids'] = torch.cat(
+            (
+                pad_to_length(batch["chosen_input_ids"], max_completion_length, pad_value=padding_value),
+                pad_to_length(batch["rejected_input_ids"], max_completion_length, pad_value=padding_value),
+            ),
+        )
+
+        concatenated_batch['completion_attention_mask'] = torch.cat(
+            (
+                pad_to_length(batch["chosen_attention_mask"], max_completion_length, pad_value=0),
+                pad_to_length(batch["rejected_attention_mask"], max_completion_length, pad_value=0),
+            ),
+        )
+
+        return concatenated_batch
+    
+
+    def concatenated_forward(self, model, batch, is_ref_model:bool=False):
+
+        num_examples = batch['prompt_input_ids'].shape[0]
+        
+        concatenated_batch = self.concatenated_inputs(batch, padding_value=self.padding_value)
+
+        model_kwargs = {}
+
+        if self.aux_loss_enabled:
+            model_kwargs['output_router_logits'] = True
+
+        # Add image/video values to model kwargs
+        if 'pixel_values' in batch:
+            model_kwargs['pixel_values'] = concatenated_batch['pixel_values']
+            model_kwargs['image_grid_thw'] = concatenated_batch['image_grid_thw']
+        if 'pixel_values_videos' in batch:
+            model_kwargs['pixel_values_videos'] = concatenated_batch['pixel_values_videos']
+            model_kwargs['video_grid_thw'] = concatenated_batch['video_grid_thw']
+        if 'second_grid_ts' in batch:
+            model_kwargs['second_grid_ts'] = concatenated_batch['second_grid_ts']
+
+        prompt_input_ids = concatenated_batch["prompt_input_ids"]
+        prompt_attention_mask = concatenated_batch["prompt_attention_mask"]
+        completion_input_ids = concatenated_batch["completion_input_ids"]
+        completion_attention_mask = concatenated_batch["completion_attention_mask"]
+        
+        input_ids = torch.cat((prompt_input_ids, completion_input_ids), dim=1)
+        attention_mask = torch.cat((prompt_attention_mask, completion_attention_mask), dim=1)
+        loss_mask = torch.cat(
+            (torch.zeros_like(prompt_attention_mask), completion_attention_mask), dim=1
+        )
+
+        # Flush left to reduce the memory usage
+        # [[0, 0, x, x, x, x],  ->  [[x, x, x, x],
+        #  [0, x, x, x, 0, 0]]       [x, x, x, 0]]
+        attention_mask, input_ids, loss_mask = flush_left(attention_mask, input_ids, loss_mask)
+
+        model_kwargs["attention_mask"] = attention_mask
+
+        outputs = model(input_ids, **model_kwargs)
+        logits = outputs.logits
+
+        labels = torch.roll(input_ids, shifts=-1, dims=1)
+        loss_mask = torch.roll(loss_mask, shifts=-1, dims=1).bool()
+
+        if logits.shape[:2] != labels.shape[:2]:
+            # for llava, the returned logits include the image tokens (placed before the text tokens)
+            seq_len = labels.shape[1]
+            logits = logits[:, -seq_len:]
+
+        # Compute the log probabilities of the labels
+        labels[~loss_mask] = 0  # dummy token; we'll ignore the losses on these tokens later
+        per_token_logps = selective_log_softmax(logits, labels)
+        per_token_logps[~loss_mask] = 0
+        per_token_logps = torch.roll(per_token_logps, shifts=1, dims=1)
+
+        all_logps = per_token_logps.sum(-1)
+
+        output = {}
+
+        if self.use_weighting:
+            with torch.no_grad():
+                # Eq (2) of the WPO paper: https://huggingface.co/papers/2406.11827
+                logprobs = F.log_softmax(logits, dim=-1)
+                weights_adjustment_factor = torch.logsumexp(2 * logprobs, dim=-1)  # same as sum(probs**2) in log space
+                per_token_logps_adjusted = per_token_logps - weights_adjustment_factor
+                all_weights = (per_token_logps_adjusted * loss_mask).sum(-1) / loss_mask.sum(-1)
+                chosen_weights = all_weights[:num_examples]
+                rejected_weights = all_weights[num_examples:]
+                output["policy_weights"] = torch.clamp(torch.exp(chosen_weights + rejected_weights), max=1)
+
+        if self.args.rpo_alpha is not None:
+            # Only use the chosen logits for the RPO loss
+            chosen_logits = logits[:num_examples]
+            chosen_labels = labels[:num_examples]
+
+            # Compute the log probabilities of the labels
+            output["nll_loss"] = F.cross_entropy(
+                torch.flatten(chosen_logits, end_dim=1), torch.flatten(chosen_labels, end_dim=1), ignore_index=0
+            )
+
+        if "ipo" in self.loss_type:
+            all_logps = all_logps / loss_mask.sum(-1)
+
+        output["chosen_logps"] = all_logps[:num_examples]
+        output["rejected_logps"] = all_logps[num_examples:]
+        output["mean_chosen_logits"] = logits[:num_examples][loss_mask[:num_examples]].mean()
+        output["mean_rejected_logits"] = logits[num_examples:][loss_mask[num_examples:]].mean()
+
+        if self.aux_loss_enabled:
+            output["aux_loss"] = outputs.aux_loss
+
+        return output
+
+    def create_optimizer(self):
+        """
+        Setup the optimizer.
+        We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the
+        Trainer's init through `optimizers`, or subclass and override this method in a subclass.
+        """
+        if is_sagemaker_mp_enabled():
+            return super().create_optimizer()
+        
+        opt_model = self.model
+
+        if self.optimizer is None:
+            decay_parameters = get_parameter_names(opt_model, ALL_LAYERNORM_LAYERS)
+            decay_parameters = [name for name in decay_parameters if "bias" not in name]
+            lr_mapper = {}
+            visual_parameters = []
+            merger_parameters = []
+
+            if self.args.vision_lr is not None:
+                lr_mapper["visual"] = self.args.vision_lr
+                visual_parameters = [name for name, _ in opt_model.named_parameters() if "visual" in name and "merger" not in name]
+            if self.args.merger_lr is not None:
+                lr_mapper["merger"] = self.args.merger_lr
+                merger_parameters = [name for name, _ in opt_model.named_parameters() if "merger" in name]
+
+            if len(lr_mapper) > 0:
+                special_lr_parameters = merger_parameters + visual_parameters
+                
+                optimizer_grouped_parameters = [
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n not in special_lr_parameters and p.requires_grad)],
+                        "weight_decay": self.args.weight_decay,
+                    },
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n not in special_lr_parameters and p.requires_grad)],
+                        "weight_decay": 0.0,
+                    },
+                ]
+                
+                if visual_parameters: 
+                    optimizer_grouped_parameters.extend(
+                        [
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n in visual_parameters and p.requires_grad)],
+                                "weight_decay": self.args.weight_decay,
+                                "lr": self.args.vision_lr,
+                                "param_group_name": "visaul_decay"
+                            },
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n in visual_parameters and p.requires_grad)],
+                                "weight_decay": 0.0,
+                                "lr": self.args.vision_lr,
+                                "param_group_name": "visaul_non_decay"
+                            },
+                        ]
+                    )
+                
+                if merger_parameters: 
+                    optimizer_grouped_parameters.extend(
+                        [
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n in merger_parameters and p.requires_grad)],
+                                "weight_decay": self.args.weight_decay,
+                                "lr": self.args.merger_lr,
+                                "param_group_name": "merger_decay",
+                            },
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n in merger_parameters and p.requires_grad)],
+                                "weight_decay": 0.0,
+                                "lr": self.args.merger_lr,
+                                "param_group_name": "merger_non_decay",
+                            },
+                        ]
+                    )
+            else:
+                optimizer_grouped_parameters = [
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and p.requires_grad)],
+                        "weight_decay": self.args.weight_decay,
+                    },
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and p.requires_grad)],
+                        "weight_decay": 0.0,
+                    },
+                ]
+            optimizer_cls, optimizer_kwargs = self.get_optimizer_cls_and_kwargs(self.args)
+
+            self.optimizer = optimizer_cls(optimizer_grouped_parameters, **optimizer_kwargs)
+            if optimizer_cls.__name__ == "Adam8bit":
+                import bitsandbytes
+
+                manager = bitsandbytes.optim.GlobalOptimManager.get_instance()
+
+                skipped = 0
+                for module in opt_model.modules():
+                    if isinstance(module, nn.Embedding):
+                        skipped += sum({p.data_ptr(): p.numel() for p in module.parameters()}.values())
+                        logger.info(f"skipped {module}: {skipped/2**20}M params")
+                        manager.register_module_override(module, "weight", {"optim_bits": 32})
+                        logger.debug(f"bitsandbytes: will optimize {module} in fp32")
+                logger.info(f"skipped: {skipped/2**20}M params")
+
+        return self.optimizer
+
+
+    def _save_checkpoint(self, model, trial):
+        super()._save_checkpoint(model, trial)
+
+        if not self.args.lora_enable:
+            return
+
+        checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}"
+        run_dir = self._get_output_dir(trial=trial)
+        output_dir = os.path.join(run_dir, checkpoint_folder)
+
+        non_lora = get_peft_state_non_lora_maybe_zero_3(
+            self.model.named_parameters(),
+            require_grad_only=True,
+        )
+
+        if self.args.should_save:
+            torch.save(non_lora, os.path.join(output_dir, "non_lora_state_dict.bin"))
+            self.model.base_model.config.to_json_file(os.path.join(output_dir, "config.json"))

src/trainer/grpo_trainer.py

@@ -0,0 +1,943 @@
+import os
+import torch
+from pathlib import Path
+import torch.nn as nn
+from typing import Any
+
+from transformers.trainer import (
+    is_sagemaker_mp_enabled,
+    get_parameter_names,
+    TRAINER_STATE_NAME,
+    PREFIX_CHECKPOINT_DIR,
+    logger,
+    ExportableState,
+    SaveStrategy,
+    Trainer,
+)
+from transformers.pytorch_utils import (
+    ALL_LAYERNORM_LAYERS
+)
+from trl import GRPOTrainer
+from trl.data_utils import is_conversational
+from trl.trainer.utils import (
+    pad,
+    nanmax,
+    nanmin,
+    nanstd,
+    selective_log_softmax,
+    entropy_from_logits,
+)
+from trl.extras.profiling import profiling_decorator
+from accelerate.utils import gather_object, is_peft_model
+from src.train.train_utils import get_peft_state_non_lora_maybe_zero_3
+
+
+def _identity_collator(features):
+    """Identity collator that passes data through unchanged."""
+    return features
+
+
+class QwenGRPOTrainer(GRPOTrainer):
+    def __init__(self, *args, **kwargs):
+        super(QwenGRPOTrainer, self).__init__(*args, **kwargs)
+        # Override data_collator to prevent any data processing
+        self.data_collator = _identity_collator
+
+    def _set_signature_columns_if_needed(self):
+        # If `self.args.remove_unused_columns` is True, non-signature columns are removed.
+        # By default, this method sets `self._signature_columns` to the model's expected inputs.
+        # In GRPOTrainer, we preprocess data, so using the model's signature columns doesn't work.
+        # Instead, we set them to the columns expected by the `training_step` method, hence the override.
+        if self._signature_columns is None:
+            self._signature_columns = ["prompt", "assistant", "image", "images", "video", "videos", "video_kwargs"]
+
+    def _generate_single_turn(self, prompts: list):
+        """Override to include images/videos in generation for multimodal models."""
+        from contextlib import nullcontext
+        from trl.models.utils import unwrap_model_for_generation
+        from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+
+        device = self.accelerator.device
+
+        # Get stored images/videos
+        images = getattr(self, '_current_images', None)
+        videos = getattr(self, '_current_videos', None)
+        video_kwargs = getattr(self, '_current_video_kwargs', None)
+
+        model_id = getattr(self.model.config, "_name_or_path", "")
+
+        # Build processor kwargs
+        processor_kwargs = {
+            "text": prompts,
+            "return_tensors": "pt",
+            "padding": True,
+            "padding_side": "left",
+            "max_length": self.max_prompt_length,
+            "truncation": True,
+            "add_special_tokens": False,
+        }
+
+        # Add images if available
+        if images is not None:
+            processor_kwargs["images"] = images
+            processor_kwargs["do_resize"] = False
+
+        # Add videos if available
+        if videos is not None:
+            if "Qwen2.5" in model_id:
+                processor_kwargs["videos"] = videos
+                if video_kwargs and video_kwargs[0] is not None:
+                    processor_kwargs.update(video_kwargs[0])
+            elif "Qwen3" in model_id:
+                batched_video_datas = []
+                batched_video_metadatas = []
+                for sample_videos in videos:
+                    if sample_videos is None:
+                        batched_video_datas.append(None)
+                        batched_video_metadatas.append(None)
+                    else:
+                        datas, metas = zip(*sample_videos)
+                        batched_video_datas.append(list(datas))
+                        batched_video_metadatas.append(list(metas))
+                processor_kwargs["videos"] = batched_video_datas
+                processor_kwargs["video_metadata"] = batched_video_metadatas
+                if video_kwargs and video_kwargs[0] is not None:
+                    processor_kwargs.update(video_kwargs[0])
+            else:
+                processor_kwargs["videos"] = videos
+
+        # Process inputs
+        generate_inputs = self.processing_class(**processor_kwargs)
+        generate_inputs = Trainer._prepare_inputs(self, generate_inputs)
+
+        # Generate completions
+        with (
+            unwrap_model_for_generation(
+                self.model_wrapped, self.accelerator, gather_deepspeed3_params=self.args.ds3_gather_for_generation
+            ) as unwrapped_model,
+            torch.no_grad(),
+            FSDP.summon_full_params(self.model_wrapped, recurse=False) if self.is_fsdp_enabled else nullcontext(),
+        ):
+            prompt_completion_ids = unwrapped_model.generate(
+                **generate_inputs, generation_config=self.generation_config, disable_compile=True
+            )
+
+        # Extract prompt and completion ids
+        prompt_ids, prompt_mask = generate_inputs["input_ids"], generate_inputs["attention_mask"]
+        prompt_length = prompt_ids.size(1)
+        completion_ids = prompt_completion_ids[:, prompt_length:]
+
+        # Mask everything after the first EOS token
+        is_eos = completion_ids == self.eos_token_id
+        eos_idx = torch.full((is_eos.size(0),), is_eos.size(1), dtype=torch.long, device=device)
+        eos_idx[is_eos.any(dim=1)] = is_eos.int().argmax(dim=1)[is_eos.any(dim=1)]
+        sequence_indices = torch.arange(is_eos.size(1), device=device).expand(is_eos.size(0), -1)
+        completion_mask = (sequence_indices <= eos_idx.unsqueeze(1)).int()
+
+        prompt_ids = [p[m].tolist() for p, m in zip(prompt_ids, prompt_mask.bool(), strict=True)]
+        completion_ids = [c[m].tolist() for c, m in zip(completion_ids, completion_mask.bool(), strict=True)]
+
+        return prompt_ids, completion_ids, None, {}
+
+    def _generate_and_score_completions(
+        self, inputs: list[dict[str, torch.Tensor | Any]]
+    ) -> dict[str, torch.Tensor | Any]:
+        device = self.accelerator.device
+        mode = "train" if self.model.training else "eval"
+
+        # Handle different input formats:
+        # 1. List of dicts: [{"prompt": ..., "images": ...}, ...]
+        # 2. Batched dict with "prompt" key: {"prompt": [...], "images": [...]}
+        # 3. Already processed BatchFeature (no "prompt" key): error case
+        if isinstance(inputs, dict):
+            if "prompt" in inputs:
+                # Batched dict format - convert to list of dicts
+                bsz = len(inputs["prompt"])
+                inputs = [
+                    {k: (v[i] if v is not None else None) for k, v in inputs.items()}
+                    for i in range(bsz)
+                ]
+            else:
+                # Already processed BatchFeature - this shouldn't happen in normal flow
+                raise ValueError(
+                    f"Received pre-processed inputs with keys {list(inputs.keys())}. "
+                    "Expected raw inputs with 'prompt' key. This may indicate the data "
+                    "is being processed by the AutoProcessor before reaching the trainer. "
+                    "Ensure you're passing data_collator=identity_collator to the trainer."
+                )
+        elif not isinstance(inputs, list):
+            # Unexpected input type
+            raise TypeError(
+                f"Expected inputs to be list[dict] or dict, got {type(inputs).__name__}. "
+                f"Sample: {str(inputs)[:200]}"
+            )
+
+        prompts = [x["prompt"] for x in inputs]
+
+        if "images" in inputs[0]:
+            images = [example.get("images") for example in inputs]
+        elif "image" in inputs[0]:
+            images = [[example.get("image")] if example.get("image") is not None else None for example in inputs]
+        else:
+            images = None
+        # Transformers requires at least one image in the batch, otherwise it throws an error
+        if images is not None and all(img_list == [] for img_list in images):
+            images = None
+
+        if "videos" in inputs[0]:
+            videos = [example.get("videos") for example in inputs]
+            video_kwargs = [example.get("video_kwargs") for example in inputs]
+        elif "video" in inputs[0]:
+            videos = [[example.get("video")] if example.get("video") is not None else None for example in inputs]
+            video_kwargs = [example.get("video_kwargs") for example in inputs]
+        else:
+            videos = None
+
+        if videos is not None and all(v_list is None or v_list == [] for v_list in videos):
+            videos = None
+
+        # Store images/videos for use in _generate_single_turn
+        self._current_images = images
+        self._current_videos = videos
+        self._current_video_kwargs = video_kwargs if videos is not None else None
+
+        prompt_ids_list, completion_ids_list, num_items_in_batch, sampling_per_token_logps_list, extra_fields = (
+            self._generate(prompts)
+        )
+
+        # Clear stored images/videos
+        self._current_images = None
+        self._current_videos = None
+        self._current_video_kwargs = None
+
+        # Convert lists of token IDs to padded tensors
+        prompt_ids = [torch.tensor(ids, device=device) for ids in prompt_ids_list]
+        prompt_mask = [torch.ones_like(ids, dtype=torch.long) for ids in prompt_ids]
+        prompt_ids = pad(prompt_ids, padding_value=self.pad_token_id, padding_side="left")
+        prompt_mask = pad(prompt_mask, padding_value=0, padding_side="left")
+        completion_ids = [torch.tensor(ids, device=device) for ids in completion_ids_list]
+        completion_mask = [torch.ones_like(ids, dtype=torch.long) for ids in completion_ids]
+        completion_ids = pad(completion_ids, padding_value=self.pad_token_id, padding_side="right")
+        completion_mask = pad(completion_mask, padding_value=0, padding_side="right")
+        if sampling_per_token_logps_list is not None:
+            sampling_per_token_logps = [torch.tensor(logps, device=device) for logps in sampling_per_token_logps_list]
+            sampling_per_token_logps = pad(sampling_per_token_logps, padding_value=0.0, padding_side="right")
+        else:
+            sampling_per_token_logps = None
+
+        # If mask_truncated_completions is enabled, zero out truncated completions in completion_mask
+        if self.mask_truncated_completions:
+            eos_and_pad = [self.eos_token_id, self.pad_token_id]
+            is_truncated = torch.tensor([ids[-1] not in eos_and_pad for ids in completion_ids_list], device=device)
+            completion_mask = completion_mask * (~is_truncated).unsqueeze(1).int()
+
+        # Concatenate prompt_mask with completion_mask for logit computation
+        prompt_completion_ids = torch.cat([prompt_ids, completion_ids], dim=1)  # (B, P+C)
+        attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)  # (B, P+C)
+
+        logits_to_keep = completion_ids.size(1)  # we only need to compute the logits for the completion tokens
+        batch_size = self.args.per_device_train_batch_size if mode == "train" else self.args.per_device_eval_batch_size
+
+        num_images = [len(img_list) for img_list in images] if images is not None else None
+
+        model_id = getattr(self.model.config, "_name_or_path", "")
+
+        # Get forward_kwargs for models with multimodal inputs
+        if images is not None or videos is not None:
+            prompts_text = prompts
+
+            processor_kwargs = dict(
+                text=prompts_text,
+                padding=True,
+                return_tensors="pt",
+                do_resize=False
+            )
+            if images is not None:
+                processor_kwargs["images"] = images
+            if videos is not None:
+                if "Qwen2.5" in model_id:
+                    common_vk = video_kwargs[0] if isinstance(video_kwargs, list) else video_kwargs
+                    processor_kwargs["videos"] = videos
+                    if common_vk is not None:
+                        processor_kwargs.update(common_vk)
+
+                elif "Qwen3" in model_id:
+                    batched_video_datas = []
+                    batched_video_metadatas = []
+                    for sample_videos in videos:
+                        if sample_videos is None:
+                            batched_video_datas.append(None)
+                            batched_video_metadatas.append(None)
+                        else:
+                            datas, metas = zip(*sample_videos)
+                            batched_video_datas.append(list(datas))
+                            batched_video_metadatas.append(list(metas))
+
+                    processor_kwargs["videos"] = batched_video_datas
+                    processor_kwargs["video_metadata"] = batched_video_metadatas
+                    
+                    common_vk = video_kwargs[0] if isinstance(video_kwargs, list) else video_kwargs
+                    if common_vk is not None:
+                        processor_kwargs.update(common_vk)
+
+                else:
+                    processor_kwargs["videos"] = videos
+
+            prompt_inputs = self.processing_class(**processor_kwargs)
+            # Use Trainer._prepare_inputs directly to avoid recursive call through GRPOTrainer._prepare_inputs
+            prompt_inputs = Trainer._prepare_inputs(self, prompt_inputs)
+            forward_kwargs = {k: v for k, v in prompt_inputs.items() if k not in ["input_ids", "attention_mask"]}
+        else:
+            forward_kwargs = {}
+
+        # If token_type_ids are used, extend them with zeros for the completion part
+        if "token_type_ids" in forward_kwargs:
+            token_type_ids = forward_kwargs["token_type_ids"]
+            forward_kwargs["token_type_ids"] = torch.cat(
+                [token_type_ids, token_type_ids.new_zeros(completion_ids.shape)], dim=1
+            )
+
+        with torch.no_grad():
+            # If the generation and optimization steps are misaligned—i.e., if generation does not occur at the end of
+            # a full optimizer step (when gradient_accumulation_steps is not a multiple of generate_every)—then the
+            # samples may come from an earlier version of the model. In that case, we need to track old_per_token_logps
+            # for importance sampling. If the steps are aligned, importance sampling isn't necessary and we set
+            # old_per_token_logps to None.
+            # When using vLLM, we always compute old_per_token_logps for importance sampling, it was shown that the
+            # distribution mismatch between vLLM and the training model can be large and harm the training.
+            generate_every = self.args.steps_per_generation * self.num_iterations  # generation frequency
+            if self.args.gradient_accumulation_steps % generate_every != 0 or (
+                self.use_vllm and self.vllm_importance_sampling_correction
+            ):
+                old_per_token_logps, _ = self._get_per_token_logps_and_entropies(
+                    self.model,
+                    prompt_completion_ids,
+                    attention_mask,
+                    logits_to_keep,
+                    batch_size,
+                    num_images=num_images,
+                    **forward_kwargs,  # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes
+                )
+            else:
+                old_per_token_logps = None
+
+            # Compute the importance sampling ratio when using vLLM, to correct for potential distribution mismatch
+            if self.use_vllm and self.vllm_importance_sampling_correction:
+                importance_sampling_ratio = torch.exp(old_per_token_logps - sampling_per_token_logps)
+                importance_sampling_ratio = torch.clamp(
+                    importance_sampling_ratio, max=self.vllm_importance_sampling_cap
+                )
+
+            # Compute the per-token log probabilities for the reference model
+            if self.beta != 0.0:
+                if self.ref_model is not None:
+                    ref_per_token_logps, _ = self._get_per_token_logps_and_entropies(
+                        self.ref_model,
+                        prompt_completion_ids,
+                        attention_mask,
+                        logits_to_keep,
+                        batch_size=batch_size,
+                        num_images=num_images,
+                        **forward_kwargs,  # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes
+                    )
+                else:
+                    with self.accelerator.unwrap_model(self.model).disable_adapter():
+                        ref_per_token_logps, _ = self._get_per_token_logps_and_entropies(
+                            self.model,
+                            prompt_completion_ids,
+                            attention_mask,
+                            logits_to_keep,
+                            batch_size=batch_size,
+                            num_images=num_images,
+                            **forward_kwargs,  # may contain pixel_values, image_grid_thw, pixel_attention_mask and image_sizes
+                        )
+            else:
+                ref_per_token_logps = None
+
+        # Decode
+        prompts_text = self.processing_class.batch_decode(prompt_ids, skip_special_tokens=True)
+        completions_text = self.processing_class.batch_decode(completion_ids, skip_special_tokens=True)
+        if is_conversational(inputs[0]):
+            completions = []
+            for prompt, completion in zip(prompts, completions_text, strict=True):
+                bootstrap = prompt.pop()["content"] if prompt[-1]["role"] == "assistant" else ""
+                completions.append([{"role": "assistant", "content": bootstrap + completion}])
+        else:
+            completions = completions_text
+
+        # Merge extra_fields from rollout_func into inputs for reward functions
+        if extra_fields:
+            for i, inp in enumerate(inputs):
+                for key, values in extra_fields.items():
+                    if isinstance(values, list) and i < len(values):
+                        inp[key] = values[i]
+                    elif not isinstance(values, list):
+                        inp[key] = values
+
+        # Calculate rewards for each reward function. rewards_per_func aggregates rewards across all processes. This is
+        # important because rewards will be normalized per group, and completions are distributed. We will later slice
+        # rewards_per_func to extract each process's subset.
+        rewards_per_func = self._calculate_rewards(inputs, prompts, completions, completion_ids_list)
+
+        # Apply weights to each reward function's output and sum
+        rewards = (rewards_per_func * self.reward_weights.to(device).unsqueeze(0)).nansum(dim=1)
+
+        # Compute grouped-wise rewards
+        mean_grouped_rewards = rewards.view(-1, self.num_generations).mean(dim=1)
+
+        # Normalize the rewards to compute the advantages
+        mean_grouped_rewards = mean_grouped_rewards.repeat_interleave(self.num_generations, dim=0)
+        advantages = rewards - mean_grouped_rewards
+
+        if self.scale_rewards in ["group", "none"]:
+            # If self.scale_rewards = "none", we'll still log group level std
+            std_rewards = rewards.view(-1, self.num_generations).std(dim=1)
+            std_rewards = std_rewards.repeat_interleave(self.num_generations, dim=0)
+        elif self.scale_rewards == "batch":
+            # Compute global std
+            std_rewards = rewards.std().expand_as(rewards)
+        else:
+            raise ValueError(
+                f"Invalid value for scale_rewards: {self.scale_rewards}. Must be one of 'batch', 'group', or 'none'."
+            )
+
+        is_std_zero = torch.isclose(std_rewards, torch.zeros_like(std_rewards))
+        if self.scale_rewards != "none":
+            advantages = advantages / (std_rewards + 1e-4)
+
+        # Slice to keep only the local part of the data
+        process_slice = slice(
+            self.accelerator.process_index * len(prompts),
+            (self.accelerator.process_index + 1) * len(prompts),
+        )
+        all_process_advantages = advantages.clone()  # keep the aggregated advantages for logging
+        advantages = advantages[process_slice]
+
+        # Calculate mean reward per function, but only for samples where the function was applied (non-NaN values)
+        for i, reward_func_name in enumerate(self.reward_func_names):
+            mean_rewards = torch.nanmean(rewards_per_func[:, i]).item()
+            self._metrics[mode][f"rewards/{reward_func_name}/mean"].append(mean_rewards)
+            std_func_rewards = nanstd(rewards_per_func[:, i]).item()
+            self._metrics[mode][f"rewards/{reward_func_name}/std"].append(std_func_rewards)
+        self._metrics[mode]["reward"].append(mean_grouped_rewards.mean().item())
+        self._metrics[mode]["reward_std"].append(std_rewards.mean().item())
+        self._metrics[mode]["frac_reward_zero_std"].append(is_std_zero.float().mean().item())
+
+        # Log prompt and completion texts
+        self._logs["prompt"].extend(gather_object(prompts_text))
+        self._logs["completion"].extend(gather_object(completions_text))
+        for i, name in enumerate(self.reward_func_names):
+            self._logs["rewards"][name].extend(rewards_per_func[:, i].tolist())
+        self._logs["advantages"].extend(all_process_advantages.tolist())
+
+        if images is not None:
+            self._logs["images"].extend(gather_object(images))
+
+        if self.use_vllm and self.vllm_importance_sampling_correction:
+            delta = torch.abs(old_per_token_logps - sampling_per_token_logps)
+            delta = delta[completion_mask.bool()]
+            mean_delta = torch.mean(delta) if delta.numel() > 0 else torch.tensor(0.0, device=device)
+            max_delta = torch.max(delta) if delta.numel() > 0 else torch.tensor(0.0, device=device)
+            self._metrics[mode]["sampling/sampling_logp_difference/mean"].append(
+                self.accelerator.gather(mean_delta).mean().item()
+            )
+            self._metrics[mode]["sampling/sampling_logp_difference/max"].append(
+                self.accelerator.gather(max_delta).max().item()
+            )
+
+            flat_is_ratio = importance_sampling_ratio[completion_mask.bool()]
+            min_importance_sampling_ratio = (
+                torch.min(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device)
+            )
+            mean_importance_sampling_ratio = (
+                torch.mean(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device)
+            )
+            max_importance_sampling_ratio = (
+                torch.max(flat_is_ratio) if flat_is_ratio.numel() > 0 else torch.tensor(0.0, device=device)
+            )
+            self._metrics[mode]["sampling/importance_sampling_ratio/min"].append(
+                nanmin(self.accelerator.gather(min_importance_sampling_ratio)).item()
+            )
+            self._metrics[mode]["sampling/importance_sampling_ratio/mean"].append(
+                self.accelerator.gather(mean_importance_sampling_ratio).nanmean().item()
+            )
+            self._metrics[mode]["sampling/importance_sampling_ratio/max"].append(
+                nanmax(self.accelerator.gather(max_importance_sampling_ratio)).item()
+            )
+
+        output = {
+            "prompt_ids": prompt_ids,
+            "prompt_mask": prompt_mask,
+            "completion_ids": completion_ids,
+            "completion_mask": completion_mask,
+            "advantages": advantages,
+            "num_items_in_batch": num_items_in_batch,
+        }
+        if old_per_token_logps is not None:
+            output["old_per_token_logps"] = old_per_token_logps
+        if self.use_vllm and self.vllm_importance_sampling_correction:
+            output["importance_sampling_ratio"] = importance_sampling_ratio
+        if ref_per_token_logps is not None:
+            output["ref_per_token_logps"] = ref_per_token_logps
+        if "pixel_values" in forward_kwargs:
+            output["pixel_values"] = forward_kwargs["pixel_values"]
+        if "image_grid_thw" in forward_kwargs:
+            output["image_grid_thw"] = forward_kwargs["image_grid_thw"]
+        if "pixel_attention_mask" in forward_kwargs:
+            output["pixel_attention_mask"] = forward_kwargs["pixel_attention_mask"]
+        if "image_sizes" in forward_kwargs:
+            output["image_sizes"] = forward_kwargs["image_sizes"]
+
+        if "pixel_values_videos" in forward_kwargs:
+            output["pixel_values_videos"] = forward_kwargs["pixel_values_videos"]
+        if "video_grid_thw" in forward_kwargs:
+            output["video_grid_thw"] = forward_kwargs["video_grid_thw"]
+        if "second_per_grid_ts" in forward_kwargs:
+            output["second_per_grid_ts"] = forward_kwargs["second_per_grid_ts"]
+
+        if "token_type_ids" in forward_kwargs:
+            output["token_type_ids"] = forward_kwargs["token_type_ids"]
+        if images is not None:
+            output["num_images"] = num_images
+        return output
+    
+    @profiling_decorator
+    def _get_per_token_logps_and_entropies(
+        self,
+        model,
+        input_ids,
+        attention_mask,
+        logits_to_keep,
+        batch_size=None,
+        compute_entropy=False,
+        pixel_values=None,
+        image_grid_thw=None,
+        num_images=None,
+        pixel_attention_mask=None,
+        image_sizes=None,
+        token_type_ids=None,
+        pixel_values_videos=None,
+        video_grid_thw=None,
+        second_per_grid_ts=None,
+    ) -> dict[str, torch.Tensor | None]:
+        """Compute log-probs and (optionally) entropies for each token."""
+        batch_size = batch_size or input_ids.size(0)  # Chunk inputs into smaller batches to reduce memory peak
+        all_logps = []
+        all_entropies = []
+        for start in range(0, input_ids.size(0), batch_size):
+            input_ids_batch = input_ids[start : start + batch_size]
+            attention_mask_batch = attention_mask[start : start + batch_size]
+
+            # Build model inputs - check if the model supports logits_to_keep (some models and VLMs don't)
+            model_inputs = {"input_ids": input_ids_batch, "attention_mask": attention_mask_batch}
+            if image_grid_thw is not None and pixel_values is not None:
+                rows_per_image = image_grid_thw.prod(dim=-1)
+                rows_per_sample = torch.split(rows_per_image, num_images)
+                rows_per_sample = torch.stack([s.sum() for s in rows_per_sample])
+                cum_rows = torch.cat([torch.tensor([0], device=rows_per_sample.device), rows_per_sample.cumsum(0)])
+                row_start, row_end = cum_rows[start].item(), cum_rows[start + batch_size].item()
+                model_inputs["pixel_values"] = pixel_values[row_start:row_end]
+                cum_imgs = torch.tensor([0] + num_images).cumsum(0)
+                img_start, img_end = cum_imgs[start], cum_imgs[start + batch_size]
+                model_inputs["image_grid_thw"] = image_grid_thw[img_start:img_end]
+            elif pixel_values is not None:
+                model_inputs["pixel_values"] = pixel_values[start : start + batch_size]
+
+            if pixel_values_videos is not None:
+                model_inputs["pixel_values_videos"] = pixel_values_videos[start : start + batch_size]
+            if video_grid_thw is not None:
+                model_inputs["video_grid_thw"] = video_grid_thw[start : start + batch_size]
+            if second_per_grid_ts is not None:
+                model_inputs["second_per_grid_ts"] = second_per_grid_ts[start : start + batch_size]
+
+            if pixel_attention_mask is not None:
+                model_inputs["pixel_attention_mask"] = pixel_attention_mask[start : start + batch_size]
+            if image_sizes is not None:
+                model_inputs["image_sizes"] = image_sizes[start : start + batch_size]
+            if token_type_ids is not None:
+                model_inputs["token_type_ids"] = token_type_ids[start : start + batch_size]
+
+            # Only add logits_to_keep if the model supports it
+            if "logits_to_keep" in self.model_kwarg_keys:
+                # We add 1 to `logits_to_keep` because the last logits of the sequence is later excluded
+                model_inputs["logits_to_keep"] = logits_to_keep + 1
+
+            model_inputs["use_cache"] = False  # only used in generation; set False to suppress warnings
+
+            logits = model(**model_inputs).logits
+            # Exclude the last value: it corresponds to the next token pred
+            logits = logits[:, :-1, :]  # (B, L-1, H)
+            # Only keep the last logits_to_keep. For model that support logits_to_keep, this is a no-op.
+            logits = logits[:, -logits_to_keep:, :]  # (B, logits_to_keep, H)
+            # Divide logits by sampling temperature.
+            # See https://huggingface.co/blog/the_n_implementation_details_of_rlhf_with_ppo#policy-training-implementation-details
+            logits = logits / self.temperature
+            completion_ids = input_ids_batch[:, -logits_to_keep:]
+            logps = selective_log_softmax(logits, completion_ids)  # compute logprobs
+            all_logps.append(logps)
+
+            if compute_entropy:
+                with torch.no_grad():
+                    entropies = entropy_from_logits(logits)
+                all_entropies.append(entropies)
+
+        logps = torch.cat(all_logps, dim=0)
+        entropies = torch.cat(all_entropies, dim=0) if compute_entropy else None
+        return logps, entropies
+    
+    @profiling_decorator
+    def _get_last_hidden_state(
+        self,
+        unwrapped_model,
+        input_ids,
+        attention_mask,
+        logits_to_keep,
+        pixel_values=None,
+        image_grid_thw=None,
+        pixel_attention_mask=None,
+        image_sizes=None,
+        pixel_values_videos=None,
+        video_grid_thw=None,
+        second_per_grid_ts=None,
+    ):
+        if is_peft_model(unwrapped_model):
+            unwrapped_model = unwrapped_model.base_model.model
+
+        # Build model inputs - check if the model supports logits_to_keep (some models and VLMs don't)
+        model_inputs = {"input_ids": input_ids, "attention_mask": attention_mask}
+
+        # For Qwen models:
+        if image_grid_thw is not None and pixel_values is not None:
+            model_inputs["image_grid_thw"] = image_grid_thw
+        # For Gemma, SmolVLM2, LLaVa-Next etc.:
+        if pixel_values is not None:
+            model_inputs["pixel_values"] = pixel_values
+
+        if video_grid_thw is not None and pixel_values_videos is not None:
+            model_inputs["video_grid_thw"] = video_grid_thw
+            model_inputs["pixel_values_videos"] = pixel_values_videos
+        if second_per_grid_ts is not None:
+            model_inputs["second_per_grid_ts"] = second_per_grid_ts
+
+        # For SmolVLM2
+        if pixel_attention_mask is not None:
+            model_inputs["pixel_attention_mask"] = pixel_attention_mask
+        # For LLaVa-Next
+        if image_sizes is not None:
+            model_inputs["image_sizes"] = image_sizes
+
+        # Only add logits_to_keep if the model supports it
+        if "logits_to_keep" in self.model_kwarg_keys:
+            # We add 1 to `logits_to_keep` because the last logits of the sequence is later excluded
+            model_inputs["logits_to_keep"] = logits_to_keep + 1
+
+        model_inputs["use_cache"] = False  # only used in generation; set False to suppress warnings
+
+        last_hidden_state = unwrapped_model.model(**model_inputs).last_hidden_state
+        # Exclude the last value: it corresponds to the next token pred
+        last_hidden_state = last_hidden_state[:, :-1, :]  # (B, L-1, H)
+        # Only keep the last logits_to_keep. For model that support logits_to_keep, this is a no-op.
+        last_hidden_state = last_hidden_state[:, -logits_to_keep:, :]  # (B, logits_to_keep, H)
+        return last_hidden_state
+    
+    def compute_liger_loss(self, unwrapped_model, inputs):
+        # Compute the per-token log probabilities for the model
+        prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"]
+        completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"]
+        input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+        attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+        logits_to_keep = completion_ids.size(1)  # we only need to compute the logits for the completion tokens
+
+        # Get the last hidden state of the model
+        last_hidden_state = self._get_last_hidden_state(
+            unwrapped_model,
+            input_ids,
+            attention_mask,
+            logits_to_keep,
+            inputs.get("pixel_values"),
+            inputs.get("image_grid_thw"),
+            inputs.get("pixel_attention_mask"),
+            inputs.get("image_sizes"),
+            inputs.get("pixel_values_videos"),
+            inputs.get("video_grid_thw"),
+            inputs.get("second_per_grid_ts"),
+        )
+
+        # compute loss and metrics using liger grpo loss
+        loss, metrics = self.liger_grpo_loss(
+            _input=last_hidden_state,
+            lin_weight=unwrapped_model.lm_head.weight,
+            selected_token_ids=completion_ids,
+            attention_mask=completion_mask,
+            advantages=inputs["advantages"],
+            bias=unwrapped_model.lm_head.bias,
+            old_per_token_logps=inputs.get("old_per_token_logps"),
+            ref_per_token_logps=inputs.get("ref_per_token_logps"),
+        )
+        # Extract metrics from the liger_grpo_loss output
+        # KL divergence is the first metric when beta is non-zero
+        mean_kl = metrics[0] if self.beta != 0.0 else None
+        clip_ratio = metrics[-1]
+
+        mode = "train" if self.model.training else "eval"
+        if self.beta != 0.0:
+            self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).mean().item())
+        self._metrics[mode]["clip_ratio"].append(self.accelerator.gather(clip_ratio).mean().item())
+        return loss / self.current_gradient_accumulation_steps
+
+    
+    def _compute_loss(self, model, inputs):
+        # Compute the per-token log probabilities for the model
+        prompt_ids, prompt_mask = inputs["prompt_ids"], inputs["prompt_mask"]
+        completion_ids, completion_mask = inputs["completion_ids"], inputs["completion_mask"]
+        input_ids = torch.cat([prompt_ids, completion_ids], dim=1)
+        attention_mask = torch.cat([prompt_mask, completion_mask], dim=1)
+        logits_to_keep = completion_ids.size(1)  # we only need to compute the logits for the completion tokens
+
+        # Compute the per_token_logps and the entropy at each position in the completion
+        per_token_logps, entropies = self._get_per_token_logps_and_entropies(
+            model,
+            input_ids,
+            attention_mask,
+            logits_to_keep,
+            compute_entropy=True,
+            pixel_values=inputs.get("pixel_values"),
+            image_grid_thw=inputs.get("image_grid_thw"),
+            num_images=inputs.get("num_images"),
+            pixel_attention_mask=inputs.get("pixel_attention_mask"),
+            image_sizes=inputs.get("image_sizes"),
+            token_type_ids=inputs.get("token_type_ids"),
+            pixel_values_videos=inputs.get("pixel_values_videos"),
+            video_grid_thw=inputs.get("video_grid_thw"),
+            second_per_grid_ts=inputs.get("second_per_grid_ts"),
+        )
+
+        if self.top_entropy_quantile < 1.0:
+            entropy_mask = self.get_high_entropy_mask(entropies, completion_mask, 1 - self.top_entropy_quantile)
+        else:
+            entropy_mask = None
+
+        # Compute the KL divergence between the model and the reference model
+        if self.beta != 0.0:
+            ref_per_token_logps = inputs["ref_per_token_logps"]
+            per_token_kl = (
+                torch.exp(ref_per_token_logps - per_token_logps) - (ref_per_token_logps - per_token_logps) - 1
+            )
+
+        # Compute the loss
+        advantages = inputs["advantages"]
+        # When num_iterations == 1 and steps_per_generation <= gradient_accumulation_steps,
+        # old_per_token_logps == per_token_logps. In this case we can skip its computation
+        # (see _generate_and_score_completions) and instead use per_token_logps.detach().
+        # The exception is when using vLLM, where we always compute old_per_token_logps
+        # for importance sampling
+        old_per_token_logps = inputs.get("old_per_token_logps")
+        old_per_token_logps = per_token_logps.detach() if old_per_token_logps is None else old_per_token_logps
+
+        log_ratio = per_token_logps - old_per_token_logps
+        if self.importance_sampling_level == "token":
+            log_importance_weights = log_ratio
+        elif self.importance_sampling_level == "sequence":
+            log_importance_weights = (log_ratio * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0)
+            log_importance_weights = log_importance_weights.unsqueeze(-1)
+        else:
+            raise ValueError(
+                f"Unknown importance sampling level: {self.importance_sampling_level}. Possible values are 'token' "
+                "and 'sequence'."
+            )
+        # From here, log_importance_weights (and all subsequent tensors, coef_1, coef_2, etc.) shape depends on
+        # importance_sampling_level: "token" level: (B, T); "sequence" level: (B, 1)
+
+        coef_1 = torch.exp(log_importance_weights)
+        coef_2 = torch.clamp(coef_1, 1 - self.epsilon_low, 1 + self.epsilon_high)
+
+        # Two-sided clipping
+        if self.args.delta is not None:
+            coef_1 = torch.clamp(coef_1, max=self.args.delta)
+
+        per_token_loss1 = coef_1 * advantages.unsqueeze(1)
+        per_token_loss2 = coef_2 * advantages.unsqueeze(1)
+        per_token_loss = -torch.min(per_token_loss1, per_token_loss2)
+        if entropy_mask is not None:
+            per_token_loss = per_token_loss * entropy_mask
+
+        if self.use_vllm and self.vllm_importance_sampling_correction:
+            per_token_loss = per_token_loss * inputs["importance_sampling_ratio"]
+
+        if self.beta != 0.0:
+            per_token_loss = per_token_loss + self.beta * per_token_kl
+
+        if self.loss_type == "grpo":
+            loss = ((per_token_loss * completion_mask).sum(-1) / completion_mask.sum(-1).clamp(min=1.0)).mean()
+            loss = loss / self.current_gradient_accumulation_steps
+        elif self.loss_type == "bnpo":
+            loss = (per_token_loss * completion_mask).sum() / completion_mask.sum().clamp(min=1.0)
+            loss = loss / self.current_gradient_accumulation_steps
+        elif self.loss_type == "dr_grpo":
+            loss = (per_token_loss * completion_mask).sum() / (per_token_loss.size(0) * self.max_completion_length)
+            loss = loss / self.current_gradient_accumulation_steps
+        elif self.loss_type == "dapo":
+            normalizer = inputs["num_items_in_batch"] / self.accelerator.num_processes
+            loss = (per_token_loss * completion_mask).sum() / normalizer
+        else:
+            raise ValueError(f"Unknown loss type: {self.loss_type}")
+
+        # Log the metrics
+        mode = "train" if self.model.training else "eval"
+
+        completion_token_count = completion_mask.sum().clamp(min=1.0)
+
+        def masked_batch_mean(x):
+            if x.shape[1] == 1:  # when importance_sampling_level == "sequence"
+                return x.mean()
+            else:
+                return (x * completion_mask).sum() / completion_token_count
+
+        if self.beta != 0.0:
+            mean_kl = masked_batch_mean(per_token_kl)
+            self._metrics[mode]["kl"].append(self.accelerator.gather(mean_kl).nanmean().item())
+
+        mean_entropy = masked_batch_mean(entropies)
+        self._metrics[mode]["entropy"].append(self.accelerator.gather(mean_entropy).nanmean().item())
+
+        # Compute the clipped probability ratios
+        is_low_clipped = (coef_1 < 1 - self.epsilon_low) & (advantages.unsqueeze(1) < 0)
+        is_high_clipped = (coef_1 > 1 + self.epsilon_high) & (advantages.unsqueeze(1) > 0)
+        is_region_clipped = is_low_clipped | is_high_clipped
+
+        low_clip = masked_batch_mean(is_low_clipped.float())
+        high_clip = masked_batch_mean(is_high_clipped.float())
+        clip_ratio = masked_batch_mean(is_region_clipped.float())
+
+        gathered_low_clip = self.accelerator.gather(low_clip)
+        self._metrics[mode]["clip_ratio/low_mean"].append(gathered_low_clip.nanmean().item())
+        self._metrics[mode]["clip_ratio/low_min"].append(nanmin(gathered_low_clip).item())
+        gathered_high_clip = self.accelerator.gather(high_clip)
+        self._metrics[mode]["clip_ratio/high_mean"].append(gathered_high_clip.nanmean().item())
+        self._metrics[mode]["clip_ratio/high_max"].append(nanmax(gathered_high_clip).item())
+        gathered_clip_ratio = self.accelerator.gather(clip_ratio)
+        self._metrics[mode]["clip_ratio/region_mean"].append(gathered_clip_ratio.nanmean().item())
+        return loss
+
+    def create_optimizer(self):
+        """
+        Setup the optimizer.
+        We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the
+        Trainer's init through `optimizers`, or subclass and override this method in a subclass.
+        """
+        if is_sagemaker_mp_enabled():
+            return super().create_optimizer()
+        
+        opt_model = self.model
+
+        if self.optimizer is None:
+            decay_parameters = get_parameter_names(opt_model, ALL_LAYERNORM_LAYERS)
+            decay_parameters = [name for name in decay_parameters if "bias" not in name]
+            lr_mapper = {}
+            visual_parameters = []
+            merger_parameters = []
+
+            if self.args.vision_lr is not None:
+                lr_mapper["visual"] = self.args.vision_lr
+                visual_parameters = [name for name, _ in opt_model.named_parameters() if "visual" in name and "merger" not in name]
+            if self.args.merger_lr is not None:
+                lr_mapper["merger"] = self.args.merger_lr
+                merger_parameters = [name for name, _ in opt_model.named_parameters() if "merger" in name]
+
+            if len(lr_mapper) > 0:
+                special_lr_parameters = merger_parameters + visual_parameters
+                
+                optimizer_grouped_parameters = [
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n not in special_lr_parameters and p.requires_grad)],
+                        "weight_decay": self.args.weight_decay,
+                    },
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n not in special_lr_parameters and p.requires_grad)],
+                        "weight_decay": 0.0,
+                    },
+                ]
+                
+                if visual_parameters: 
+                    optimizer_grouped_parameters.extend(
+                        [
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n in visual_parameters and p.requires_grad)],
+                                "weight_decay": self.args.weight_decay,
+                                "lr": self.args.vision_lr,
+                                "param_group_name": "visaul_decay"
+                            },
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n in visual_parameters and p.requires_grad)],
+                                "weight_decay": 0.0,
+                                "lr": self.args.vision_lr,
+                                "param_group_name": "visaul_non_decay"
+                            },
+                        ]
+                    )
+                
+                if merger_parameters: 
+                    optimizer_grouped_parameters.extend(
+                        [
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and n in merger_parameters and p.requires_grad)],
+                                "weight_decay": self.args.weight_decay,
+                                "lr": self.args.merger_lr,
+                                "param_group_name": "merger_decay",
+                            },
+                            {
+                                "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and n in merger_parameters and p.requires_grad)],
+                                "weight_decay": 0.0,
+                                "lr": self.args.merger_lr,
+                                "param_group_name": "merger_non_decay",
+                            },
+                        ]
+                    )
+            else:
+                optimizer_grouped_parameters = [
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n in decay_parameters and p.requires_grad)],
+                        "weight_decay": self.args.weight_decay,
+                    },
+                    {
+                        "params": [p for n, p in opt_model.named_parameters() if (n not in decay_parameters and p.requires_grad)],
+                        "weight_decay": 0.0,
+                    },
+                ]
+            optimizer_cls, optimizer_kwargs = self.get_optimizer_cls_and_kwargs(self.args)
+
+            self.optimizer = optimizer_cls(optimizer_grouped_parameters, **optimizer_kwargs)
+            if optimizer_cls.__name__ == "Adam8bit":
+                import bitsandbytes
+
+                manager = bitsandbytes.optim.GlobalOptimManager.get_instance()
+
+                skipped = 0
+                for module in opt_model.modules():
+                    if isinstance(module, nn.Embedding):
+                        skipped += sum({p.data_ptr(): p.numel() for p in module.parameters()}.values())
+                        logger.info(f"skipped {module}: {skipped/2**20}M params")
+                        manager.register_module_override(module, "weight", {"optim_bits": 32})
+                        logger.debug(f"bitsandbytes: will optimize {module} in fp32")
+                logger.info(f"skipped: {skipped/2**20}M params")
+
+        return self.optimizer
+
+    def _save_checkpoint(self, model, trial):
+        super()._save_checkpoint(model, trial)
+
+        if not self.args.lora_enable:
+            return
+
+        checkpoint_folder = f"{PREFIX_CHECKPOINT_DIR}-{self.state.global_step}"
+        run_dir = self._get_output_dir(trial=trial)
+        output_dir = os.path.join(run_dir, checkpoint_folder)
+
+        non_lora = get_peft_state_non_lora_maybe_zero_3(
+            self.model.named_parameters(),
+            require_grad_only=True,
+        )
+
+        if self.args.should_save:
+            torch.save(non_lora, os.path.join(output_dir, "non_lora_state_dict.bin"))
+            self.model.base_model.config.to_json_file(os.path.join(output_dir, "config.json"))