Delete open-r1-multimodal with huggingface_hub

open-r1-multimodal/.gitignore

@@ -1,178 +0,0 @@
-# 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
-
-# UV
-#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#uv.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/
-
-# PyPI configuration file
-.pypirc
-
-# Temp folders
-data/
-wandb/
-scripts/
-checkpoints/
-.vscode/

open-r1-multimodal/LICENSE

@@ -1,201 +0,0 @@
-                                 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.

open-r1-multimodal/Makefile

@@ -1,20 +0,0 @@
-.PHONY: style quality
-
-# make sure to test the local checkout in scripts and not the pre-installed one (don't use quotes!)
-export PYTHONPATH = src
-
-check_dirs := src
-
-style:
-	black --line-length 119 --target-version py310 $(check_dirs) setup.py
-	isort $(check_dirs) setup.py
-
-quality:
-	black --check --line-length 119 --target-version py310 $(check_dirs) setup.py
-	isort --check-only $(check_dirs) setup.py
-	flake8 --max-line-length 119 $(check_dirs) setup.py
-
-
-# Evaluation
-
-evaluate:

open-r1-multimodal/configs/ddp.yaml

@@ -1,16 +0,0 @@
-compute_environment: LOCAL_MACHINE
-debug: false
-distributed_type: MULTI_GPU
-downcast_bf16: 'no'
-gpu_ids: all
-machine_rank: 0
-main_training_function: main
-mixed_precision: bf16
-num_machines: 1
-num_processes: 8
-rdzv_backend: static
-same_network: true
-tpu_env: []
-tpu_use_cluster: false
-tpu_use_sudo: false
-use_cpu: false

open-r1-multimodal/configs/qwen2vl_sft_config.yaml

@@ -1,42 +0,0 @@
-# Model arguments
-model_name_or_path: /data/shz/ckpt/Qwen2.5-VL-3B-Instruct
-model_revision: main
-torch_dtype: bfloat16
-
-# Data training arguments
-dataset_name: /data/shz/project/vlm-r1/VLM-R1/src/open-r1-multimodal/data_script/rec.yaml
-image_root: /data/shz/dataset/coco
-dataset_configs:
-- all
-preprocessing_num_workers: 8
-
-# SFT trainer config
-bf16: true
-do_eval: true
-eval_strategy: "no"
-gradient_accumulation_steps: 2
-gradient_checkpointing: true
-gradient_checkpointing_kwargs:
-  use_reentrant: false
-hub_model_id: Qwen2.5-VL-3B-Instruct
-hub_strategy: every_save
-learning_rate: 2.0e-05
-log_level: info
-logging_steps: 5
-logging_strategy: steps
-lr_scheduler_type: cosine
-packing: true
-max_seq_length: 4096
-max_steps: -1
-num_train_epochs: 3
-output_dir: /data/shz/project/vlm-r1/VLM-R1/output/Qwen2.5-VL-3B-Instruct-SFT
-overwrite_output_dir: true
-per_device_eval_batch_size: 1
-per_device_train_batch_size: 4
-push_to_hub: false
-report_to:
-- wandb
-save_strategy: "no"
-seed: 42
-data_seed: 42
-warmup_ratio: 0.1

open-r1-multimodal/configs/zero2.yaml

@@ -1,21 +0,0 @@
-compute_environment: LOCAL_MACHINE
-debug: false
-deepspeed_config:
-  deepspeed_multinode_launcher: standard
-  offload_optimizer_device: none
-  offload_param_device: none
-  zero3_init_flag: false
-  zero_stage: 2
-distributed_type: DEEPSPEED
-downcast_bf16: 'no'
-machine_rank: 0
-main_training_function: main
-mixed_precision: bf16
-num_machines: 1
-num_processes: 8
-rdzv_backend: static
-same_network: true
-tpu_env: []
-tpu_use_cluster: false
-tpu_use_sudo: false
-use_cpu: false

open-r1-multimodal/configs/zero3.yaml

@@ -1,22 +0,0 @@
-compute_environment: LOCAL_MACHINE
-debug: false
-deepspeed_config:
-  deepspeed_multinode_launcher: standard
-  offload_optimizer_device: none
-  offload_param_device: none
-  zero3_init_flag: true
-  zero3_save_16bit_model: true
-  zero_stage: 3
-distributed_type: DEEPSPEED
-downcast_bf16: 'no'
-machine_rank: 0
-main_training_function: main
-mixed_precision: bf16
-num_machines: 1
-num_processes: 8
-rdzv_backend: static
-same_network: true
-tpu_env: []
-tpu_use_cluster: false
-tpu_use_sudo: false
-use_cpu: false

open-r1-multimodal/data_config/gui_grounding.yaml

@@ -1,2 +0,0 @@
-datasets:
-    - json_path: /data/vjuicefs_ai_camera_jgroup_research/public_data/11178625/LLaMA-Factory/VLM-R1/data/rec_jsons_processed/showui_desktop_no_position_high_quality_qwen25vl_4028160_attention_0.2_filtered_only_one.json

open-r1-multimodal/data_config/rec.yaml

@@ -1,4 +0,0 @@
-datasets:
-    - json_path: /data/vjuicefs_ai_camera_jgroup_research/public_data/11178625/LLaMA-Factory/VLM-R1/data/rec_jsons_processed/refcoco_train.json
-    - json_path: /data/vjuicefs_ai_camera_jgroup_research/public_data/11178625/LLaMA-Factory/VLM-R1/data/rec_jsons_processed/refcocop_train.json
-    - json_path: /data/vjuicefs_ai_camera_jgroup_research/public_data/11178625/LLaMA-Factory/VLM-R1/data/rec_jsons_processed/refcocog_train.json

open-r1-multimodal/data_config/rec_internvl.yaml

@@ -1,4 +0,0 @@
-datasets:
-    - json_path: /data10/shz/dataset/rec/rec_jsons_internvl/refcoco_train.json
-    - json_path: /data10/shz/dataset/rec/rec_jsons_internvl/refcocop_train.json
-    - json_path: /data10/shz/dataset/rec/rec_jsons_internvl/refcocog_train.json

open-r1-multimodal/data_jsonl/showui_desktop_qwen25vl_absolute_position.json

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

open-r1-multimodal/local_scripts/create_vision_cot_data.py

@@ -1,153 +0,0 @@
-import argparse
-import base64
-import concurrent.futures
-import io
-import json
-import os
-import random
-import re
-import time
-from concurrent.futures import ThreadPoolExecutor
-from functools import partial
-from io import BytesIO
-from typing import Dict, List
-
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-from datasets import Dataset, concatenate_datasets, load_dataset, load_from_disk
-from tqdm import tqdm
-
-import bytedtos
-import seaborn as sns
-import yaml
-from openai import AzureOpenAI
-from PIL import Image
-from pillow_avif import AvifImagePlugin
-
-
-PROMPT_FORMAT = """I will provide you with an image, an original question, and its answer related to the image. Your task is to rewrite the question in such a way that answering it requires step-by-step Chain-of-Thought (CoT) reasoning with numerical or mathematical expressions where applicable. The reasoning process can include expressions like "let me think," "oh, I see," or other natural language thought expressions.
-
-Please make sure your question is to ask for a certain answer with a certain value, do not ask for open-ended answer, and the answer is correct and easy to verify via simple protocol, like "2" or "A".
-
-Please strictly do not include "Answer:" in the question part to avoid confusion and leakage.
-
-Input Format:
-Original Question: {original_question}
-Original Answer: {original_answer}
-
-Output Format:
-Question: [rewrite the question if necessary]
-Answer: [answer with reasoning steps, including calculations where applicable]
-<think>step-by-step reasoning process</think>
-<answer>easy to verify answer</answer>
-"""
-
-
-def get_image_data_url(image_input):
-    if isinstance(image_input, str) and image_input.startswith("data:"):
-        return image_input
-
-    if isinstance(image_input, str) and image_input.startswith("http"):
-        image_input = load_image(image_input)
-
-    if isinstance(image_input, str):
-        image_input = Image.open(image_input)
-
-    if not isinstance(image_input, Image.Image):
-        raise ValueError("Unsupported image input type")
-
-    if image_input.mode != "RGB":
-        image_input = image_input.convert("RGB")
-
-    buffer = BytesIO()
-    image_input.save(buffer, format="JPEG")
-    img_bytes = buffer.getvalue()
-    base64_data = base64.b64encode(img_bytes).decode("utf-8")
-    return f"data:image/jpeg;base64,{base64_data}"
-
-
-def gpt4o_query(image, prompt, max_retries=5, initial_delay=3):
-    if image is None:
-        return None
-
-    data_url_list = [get_image_data_url(image)]
-    client = AzureOpenAI(
-        azure_endpoint="YOUR_AZURE_ENDPOINT",
-        api_version="2023-07-01-preview",
-        api_key="YOUR_API_KEY",
-    )
-
-    for attempt in range(max_retries):
-        try:
-            messages = [
-                {
-                    "role": "system",
-                    "content": "You are an expert to analyze the image and provide useful information for users.",
-                },
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": prompt},
-                    ],
-                },
-            ]
-
-            for data_url in data_url_list:
-                messages[1]["content"].insert(
-                    0, {"type": "image_url", "image_url": {"url": data_url}}
-                )
-
-            response = client.chat.completions.create(
-                model="gpt-4o-2024-08-06",
-                messages=messages,
-                temperature=0.2,
-                max_tokens=8192,
-            )
-            return response.choices[0].message.content
-
-        except Exception as e:
-            if attempt == max_retries - 1:
-                raise Exception(
-                    f"Failed after {max_retries} attempts. Last error: {str(e)}"
-                )
-            delay = initial_delay * (2**attempt) + random.uniform(
-                0, 0.1 * initial_delay * (2**attempt)
-            )
-            time.sleep(delay)
-
-
-def process_single_item(example):
-    try:
-        image_path = example["image_path"]
-        formatted_prompt = PROMPT_FORMAT.format(
-            original_question=example["question"], original_answer=example["answer"]
-        )
-
-        response = gpt4o_query(image_path, formatted_prompt)
-        example["gpt4o_response"] = response
-        return example
-    except Exception as e:
-        print(f"Error processing item: {str(e)}")
-        example["gpt4o_response"] = None
-        return example
-
-
-def main():
-    dataset_path = "path/to/your/dataset"
-    full_dataset = load_from_disk(dataset_path)
-
-    processed_dataset = full_dataset.map(
-        function=partial(process_single_item),
-        num_proc=256,
-        desc="Processing dataset with GPT-4o",
-        keep_in_memory=True,
-    )
-
-    output_path = f"{dataset_path}_processed"
-    processed_dataset.save_to_disk(output_path)
-    print(f"Processed dataset saved to: {output_path}")
-
-
-if __name__ == "__main__":
-    main()

open-r1-multimodal/local_scripts/lmms_eval_qwen2vl.sh

@@ -1,61 +0,0 @@
-export HF_HOME="<CACHE_DIR>"
-export HF_TOKEN="<HF_TOKEN>"
-export HF_HUB_ENABLE_HF_TRANSFER="1"
-
-export API_TYPE="<API_TYPE>"
-export AZURE_ENDPOINT="<AZURE_ENDPOINT>"
-export AZURE_API_KEY="<API_KEY>"
-export API_VERSION="<API_VERSION>"
-export MODEL_VERSION="<MODEL_VERSION>"
-export NAVIT_ATTENTION_IMPLEMENTATION="eager"
-
-# Prompt for installation with 3-second timeout
-read -t 3 -p "Do you want to install dependencies? (YES/no, timeout in 3s): " install_deps || true
-if [ "$install_deps" = "YES" ]; then
-    # Prepare the environment
-    pip3 install --upgrade pip
-    pip3 install -U setuptools
-
-    cd <PROJECT_ROOT>
-    if [ ! -d "maas_engine" ]; then
-        git clone <REPO_URL>
-    else
-        echo "maas_engine directory already exists, skipping clone"
-    fi
-    cd maas_engine
-    git pull
-    git checkout <BRANCH_NAME>
-    pip3 install --no-cache-dir --no-build-isolation -e ".[standalone]"
-
-    current_version=$(pip3 show transformers | grep Version | cut -d' ' -f2)
-    if [ "$current_version" != "4.46.2" ]; then
-        echo "Installing transformers 4.46.2 (current version: $current_version)"
-        pip3 install transformers==4.46.2
-    else
-        echo "transformers 4.46.2 is already installed"
-    fi
-
-    cd <LMMS_EVAL_DIR>
-    rm -rf <TARGET_DIR>
-    pip3 install -e .
-    pip3 install -U pydantic
-    pip3 install Levenshtein
-    pip3 install nltk
-    python3 -c "import nltk; nltk.download('wordnet', quiet=True); nltk.download('punkt', quiet=True)"
-fi
-
-TASKS=mmmu_val,mathvista_testmini,mmmu_pro
-MODEL_BASENAME=qwen2_vl
-
-model_checkpoint="<MODEL_CHECKPOINT_PATH>"
-echo "MODEL_BASENAME: ${MODEL_BASENAME}"
-cd <LMMS_EVAL_DIR>
-
-python3 -m accelerate.commands.launch --num_processes=8 --main_process_port=12345 lmms_eval \
-    --model qwen2_vl \
-    --model_args=pretrained=${model_checkpoint},max_pixels=2359296 \
-    --tasks ${TASKS} \
-    --batch_size 1 \
-    --log_samples \
-    --log_samples_suffix ${MODEL_BASENAME} \
-    --output_path ./logs

open-r1-multimodal/local_scripts/prepare_hf_data.py

@@ -1,166 +0,0 @@
-import matplotlib.pyplot as plt
-import seaborn as sns
-import pandas as pd
-import random
-from typing import List, Dict
-import numpy as np
-from concurrent.futures import ThreadPoolExecutor
-from tqdm import tqdm
-import datasets
-
-import io
-from datasets import load_dataset, load_from_disk, concatenate_datasets
-from PIL import Image
-from tqdm import tqdm
-from functools import partial
-from pillow_avif import AvifImagePlugin
-from datasets import Dataset
-import json
-import yaml
-import os
-import re
-import time
-import random
-import base64
-from openai import AzureOpenAI
-import concurrent.futures
-from typing import List, Dict
-import argparse
-import time
-
-
-def extract_problem_solution(gpt4o_response):
-    # Split the response into parts
-    parts = gpt4o_response.split("<think>")
-
-    # Extract the problem (first part before any <think> tags)
-    problem = parts[0].strip()
-    # Remove "Question:" prefix if it exists
-    problem = re.sub(r"^Question:\s*", "", problem)
-    # Remove "Answer:" at the end of the problem
-    problem = re.sub(r"\s*Answer:\s*$", "", problem).strip()
-
-    # Combine all the reasoning steps into a single <think> block
-    think_parts = [p.split("</think>")[0].strip() for p in parts[1:] if "</think>" in p]
-    solution = f"<think>{' '.join(think_parts)}</think>"
-
-    # Add the final answer if it exists, removing "Answer:" prefix
-    if "<answer>" in gpt4o_response:
-        final_answer = (
-            gpt4o_response.split("<answer>")[-1].split("</answer>")[0].strip()
-        )
-        final_answer = re.sub(r"^Answer:\s*", "", final_answer)
-        solution += f"\n\n<answer>{final_answer}</answer>"
-
-    return problem, solution
-
-
-def load_image_from_path(image_path):
-    try:
-        img = Image.open(image_path)
-        return img
-    except Exception as e:
-        print(f"Error loading image {image_path}: {str(e)}")
-        return None
-
-
-def process_raw_data(raw_data):
-    # Parse the raw data if it's a string
-    if isinstance(raw_data, str):
-        data = json.loads(raw_data)
-    else:
-        data = raw_data
-
-    # Extract problem and solution
-    try:
-        problem, solution = extract_problem_solution(data["gpt4o_response"])
-        image = load_image_from_path(data["image_path"])
-
-        return {
-            "image": image,
-            "problem": problem,
-            "solution": solution,
-            "original_question": data["question"],
-            "original_answer": data["answer"],
-        }
-    except Exception as e:
-        print(f"Error processing data {data}: {str(e)}")
-        return {
-            "image": None,
-            "problem": None,
-            "solution": None,
-            "original_question": None,
-            "original_answer": None,
-        }
-
-
-raw_data_list = [
-    "/path/to/reasoning_data_with_response_90k_verified",
-]
-
-raw_data = concatenate_datasets([load_from_disk(path) for path in raw_data_list])
-
-processed_data = raw_data.map(process_raw_data, num_proc=128).shuffle(seed=42)
-
-hf_dict = {
-    "image": [],
-    "problem": [],
-    "solution": [],
-    "original_question": [],
-    "original_answer": [],
-}
-
-for item in tqdm(processed_data):
-    hf_dict["image"].append(item["image"])
-    hf_dict["problem"].append(item["problem"])
-    hf_dict["solution"].append(item["solution"])
-    hf_dict["original_question"].append(item["original_question"])
-    hf_dict["original_answer"].append(item["original_answer"])
-
-
-features = datasets.Features(
-    {
-        "image": datasets.Image(),
-        "problem": datasets.Value("string"),
-        "solution": datasets.Value("string"),
-        "original_question": datasets.Value("string"),
-        "original_answer": datasets.Value("string"),
-    }
-)
-
-
-def has_empty_tags(text):
-    # Pattern to match empty tags like <tag></tag>
-    pattern = r"<[^>]+></[^>]+>"
-    return bool(re.search(pattern, text))
-
-
-def has_answer_pattern(text):
-    if "Answer:" in text:
-        return True
-    return False
-
-
-def has_valid_image_size(example): # for Qwen2-VL-2B's processor requirement
-    # Assuming the image is in a format that can be checked for dimensions
-    # You might need to adjust this depending on how the image is stored in your dataset
-    try:
-        image = example["image"]  # or however your image is accessed
-        if isinstance(image, dict) and "height" in image and "width" in image:
-            return image["height"] >= 28 and image["width"] >= 28
-        # If image is a PIL Image or similar
-        return image.height >= 28 and image.width >= 28
-    except:
-        return False
-
-
-ds = datasets.Dataset.from_dict(hf_dict, features=features)
-ds = ds.filter(
-    lambda x: not has_empty_tags(x["solution"])
-    and not has_answer_pattern(x["problem"])
-    and has_valid_image_size(x)
-    and x["image"] is not None,
-    num_proc=128,
-)
-# Push to Hugging Face Hub
-ds.push_to_hub("path/to/your/dataset")

open-r1-multimodal/local_scripts/train_aria_moe.sh

@@ -1,68 +0,0 @@
-#!/bin/bash
-
-export NCCL_BLOCKING_WAIT=0
-export TOKENIZERS_PARALLELISM=false
-export OMP_NUM_THREADS=8
-export NCCL_IB_DISABLE=0
-export NCCL_IB_GID_INDEX=3
-export NCCL_SOCKET_IFNAME=eth0
-export NCCL_DEBUG=INFO
-
-# CONFIG Huggingface
-# export HF_TOKEN="<PLACEHOLDER_HF_TOKEN_1>"
-export HF_TOKEN="<PLACEHOLDER_HF_TOKEN_2>"
-export HF_HOME="$HOME/.cache/huggingface"
-export HF_HUB_ENABLE_HF_TRANSFER="1"
-
-export NCCL_DEBUG=INFO
-
-GPUS="0,1,2,3,4,5,6,7"
-
-# 取 worker0 第一个 port
-ports=($(echo $METIS_WORKER_0_PORT | tr ',' ' '))
-port=${ports[0]}
-port_in_cmd="$(echo "${METIS_WORKER_0_PORT:-2000}" | awk -F',' '{print $1}')"
-
-echo "total workers: ${ARNOLD_WORKER_NUM}"
-echo "cur worker id: ${ARNOLD_ID}"
-echo "gpus per worker: ${ARNOLD_WORKER_GPU}"
-echo "master ip: ${METIS_WORKER_0_HOST}"
-echo "master port: ${port}"
-echo "master port in cmd: ${port_in_cmd}"
-
-# export WANDB_BASE_URL=https://api.wandb.ai
-# export WANDB_API_KEY="<PLACEHOLDER_WANDB_KEY_1>"
-# wandb login $WANDB_API_KEY
-
-export WANDB_BASE_URL=https://api.wandb.ai
-export WANDB_PROJECT=vision-reasoning
-export WANDB_API_KEY="<PLACEHOLDER_WANDB_KEY_2>"
-export WANDB_RUN_NAME=Qwen-VL-2B-GRPO-$(date +%Y-%m-%d-%H-%M-%S)
-wandb login $WANDB_API_KEY
-
-cd /home/tiger/multimodal-open-r1
-# pip3 install vllm==0.6.6.post1
-pip3 install -e ".[dev]"
-pip3 install wandb==0.18.3
-
-torchrun --nproc_per_node="${ARNOLD_WORKER_GPU}" \
-    --nnodes="${ARNOLD_WORKER_NUM}" \
-    --node_rank="${ARNOLD_ID}" \
-    --master_addr="${METIS_WORKER_0_HOST}" \
-    --master_port="${port_in_cmd}" \
-    src/open_r1/grpo.py \
-    --deepspeed scripts/zero3.json \
-    --output_dir Aria-GRPO-mini_cot_80k \
-    --model_name_or_path rhymes-ai/Aria \
-    --dataset_name luodian/mini_cot_80k \
-    --max_prompt_length 8192 \
-    --per_device_train_batch_size 1 \
-    --gradient_accumulation_steps 1 \
-    --logging_steps 1 \
-    --bf16 \
-    --report_to wandb \
-    --gradient_checkpointing true \
-    --attn_implementation eager \
-    --save_total_limit 8 \
-    --num_train_epochs 1 \
-    --run_name $WANDB_RUN_NAME

open-r1-multimodal/local_scripts/train_qwen2_vl.sh

@@ -1,61 +0,0 @@
-#!/bin/bash
-
-export NCCL_BLOCKING_WAIT=0
-export TOKENIZERS_PARALLELISM=false
-export OMP_NUM_THREADS=8
-export NCCL_IB_DISABLE=0
-export NCCL_IB_GID_INDEX=3
-export NCCL_SOCKET_IFNAME=eth0
-export NCCL_DEBUG=INFO
-
-GPUS="0,1,2,3,4,5,6,7"
-
-# 取 worker0 第一个 port
-ports=($(echo $METIS_WORKER_0_PORT | tr ',' ' '))
-port=${ports[0]}
-port_in_cmd="$(echo "${METIS_WORKER_0_PORT:-2000}" | awk -F',' '{print $1}')"
-
-echo "total workers: ${ARNOLD_WORKER_NUM}"
-echo "cur worker id: ${ARNOLD_ID}"
-echo "gpus per worker: ${ARNOLD_WORKER_GPU}"
-echo "master ip: ${METIS_WORKER_0_HOST}"
-echo "master port: ${port}"
-echo "master port in cmd: ${port_in_cmd}"
-
-# export WANDB_BASE_URL=https://api.wandb.ai
-# export WANDB_API_KEY="<PLACEHOLDER_WANDB_KEY_1>"
-# wandb login $WANDB_API_KEY
-
-export WANDB_BASE_URL=https://api.wandb.ai
-export WANDB_PROJECT=vision-reasoning
-export WANDB_API_KEY="<PLACEHOLDER_WANDB_KEY_2>"
-export WANDB_RUN_NAME=Qwen-VL-2B-GRPO-$(date +%Y-%m-%d-%H-%M-%S)
-wandb login $WANDB_API_KEY
-
-cd /home/tiger/multimodal-open-r1
-# pip3 install vllm==0.6.6.post1
-pip3 install -e ".[dev]"
-pip3 install wandb==0.18.3
-
-torchrun --nproc_per_node="${ARNOLD_WORKER_GPU}" \
-    --nnodes="${ARNOLD_WORKER_NUM}" \
-    --node_rank="${ARNOLD_ID}" \
-    --master_addr="${METIS_WORKER_0_HOST}" \
-    --master_port="${port_in_cmd}" \
-    src/open_r1/grpo.py \
-    --deepspeed scripts/zero3.json \
-    --output_dir checkpoints/${WANDB_RUN_NAME} \
-    --model_name_or_path Qwen/Qwen2-VL-2B-Instruct \
-    --dataset_name luodian/${DATASET_NAME} \
-    --max_prompt_length 8192 \
-    --per_device_train_batch_size 1 \
-    --gradient_accumulation_steps 1 \
-    --logging_steps 1 \
-    --bf16 \
-    --report_to wandb \
-    --gradient_checkpointing true \
-    --attn_implementation flash_attention_2 \
-    --max_pixels 2359296 \
-    --save_total_limit 8 \
-    --num_train_epochs 1 \
-    --run_name $WANDB_RUN_NAME

open-r1-multimodal/local_scripts/zero2.json

@@ -1,41 +0,0 @@
-{
-    "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": 2,
-        "offload_optimizer": {
-            "device": "none",
-            "pin_memory": true
-        },
-        "allgather_partitions": true,
-        "allgather_bucket_size": 2e8,
-        "overlap_comm": false,
-        "reduce_scatter": true,
-        "reduce_bucket_size": 2e8,
-        "contiguous_gradients": true
-    },
-    "gradient_accumulation_steps": "auto",
-    "gradient_clipping": "auto",
-    "steps_per_print": 100,
-    "train_batch_size": "auto",
-    "train_micro_batch_size_per_gpu": "auto",
-    "wall_clock_breakdown": false
-}

open-r1-multimodal/local_scripts/zero3.json

@@ -1,41 +0,0 @@
-{
-    "fp16": {
-        "enabled": "auto",
-        "loss_scale": 0,
-        "loss_scale_window": 1000,
-        "initial_scale_power": 16,
-        "hysteresis": 2,
-        "min_loss_scale": 1
-    },
-    "bf16": {
-        "enabled": "auto"
-    },
-
-    "zero_optimization": {
-        "stage": 3,
-        "offload_optimizer": {
-            "device": "none",
-            "pin_memory": true
-        },
-        "offload_param": {
-            "device": "none",
-            "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,
-        "stage3_gather_16bit_weights_on_model_save": true
-    },
-
-    "gradient_accumulation_steps": "auto",
-    "gradient_clipping": "auto",
-    "steps_per_print": 100,
-    "train_batch_size": "auto",
-    "train_micro_batch_size_per_gpu": "auto",
-    "wall_clock_breakdown": false
-}

open-r1-multimodal/local_scripts/zero3.yaml

@@ -1,22 +0,0 @@
-compute_environment: LOCAL_MACHINE
-debug: false
-deepspeed_config:
-  deepspeed_multinode_launcher: standard
-  offload_optimizer_device: none
-  offload_param_device: none
-  zero3_init_flag: true
-  zero3_save_16bit_model: true
-  zero_stage: 3
-distributed_type: DEEPSPEED
-downcast_bf16: 'no'
-machine_rank: 0
-main_training_function: main
-mixed_precision: bf16
-num_machines: 1
-num_processes: 8
-rdzv_backend: static
-same_network: true
-tpu_env: []
-tpu_use_cluster: false
-tpu_use_sudo: false
-use_cpu: false

open-r1-multimodal/local_scripts/zero3_offload.json

@@ -1,48 +0,0 @@
-{
-    "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
-}

open-r1-multimodal/run_scripts/multinode_training_args.yaml

@@ -1,21 +0,0 @@
-output_dir: /path/to/output/runs/Qwen2.5-VL-3B-Idefics-V3-RSN-ai2d-500steps
-model_name_or_path: /path/to/models/Qwen2.5-VL-3B-Instruct
-dataset_name: Idefics-ai2d
-data_file_paths: /path/to/data/ai2d.jsonl
-image_folders: /path/to/images
-max_prompt_length: 1024
-per_device_train_batch_size: 1
-gradient_accumulation_steps: 2
-logging_steps: 1
-bf16: true
-report_to: wandb
-gradient_checkpointing: false
-deepspeed: /path/to/config/zero3.json
-attn_implementation: flash_attention_2
-max_pixels: 401408
-max_steps: 500
-run_name: Qwen2.5-VL-3B-Idefics-V3-RSN-ai2d-500steps-multinode
-save_steps: 100
-save_total_limit: 3
-save_only_model: true
-num_generations: 8

open-r1-multimodal/run_scripts/multinode_training_demo.sh

@@ -1,145 +0,0 @@
-#!/bin/bash
-
-RUN_NAME=multinode_training # assume there is a ${RUN_NAME}_args.yaml file in the current directory
-
-declare -A node2ip_map
-node2ip_map=(
-    ["node1"]="192.168.1.101"
-    ["node2"]="192.168.1.102"
-    ["node3"]="192.168.1.103"
-    ["node4"]="192.168.1.104"
-)
-
-# Default nodes if no arguments provided
-DEFAULT_NODES=("node1" "node2")
-
-# Local codebase path in file system
-LOCAL_CODEBASE_PATH="/path/to/your/codebase"
-
-# Use provided nodes or default nodes
-if [ "$#" -ge 1 ]; then
-    NODES=("$@")
-else
-    NODES=("${DEFAULT_NODES[@]}")
-    echo "Using default nodes: ${NODES[*]}"
-fi
-
-# Add this debug line
-echo "All nodes in order: ${NODES[@]}"
-
-TOTAL_NODES=${#NODES[@]}
-MASTER_NODE=${NODES[0]}
-MASTER_PORT=12345
-
-# Get project root directory (using the directory where this script is located)
-PROJECT_ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-echo "Project root directory: $PROJECT_ROOT"
-
-# Get master node IP address
-echo "MASTER_NODE: $MASTER_NODE"
-MASTER_IP="${node2ip_map[$MASTER_NODE]}"
-echo "Master node IP: $MASTER_IP"
-
-# Create log directory for each node
-LOG_DIR="path/to/your/log/dir"
-mkdir -p $LOG_DIR
-
-# Generate docker-compose.yml
-echo "Generating docker-compose.yml..."
-cat > docker-compose.yml << EOL
-version: '3.8'
-
-services:
-  trainer:
-    image: your/training-image:tag
-    deploy:
-      resources:
-        reservations:
-          devices:
-            - driver: nvidia
-              count: all
-              capabilities: [gpu]
-    shm_size: '8gb'
-    volumes:
-      - /path/to/data:/data
-      - $LOCAL_CODEBASE_PATH/src:/workspace/src
-    environment:
-      - MASTER_ADDR=\${MASTER_ADDR:-$MASTER_IP}
-      - MASTER_PORT=\${MASTER_PORT:-12345}
-      - NODE_RANK=\${NODE_RANK:-0}
-      - WORLD_SIZE=\${WORLD_SIZE:-4}
-      - DEBUG_MODE=true
-      - LOG_PATH=${LOG_DIR}/debug_log.txt
-      - WANDB_API_KEY=your_wandb_api_key  # Optional: for logging with weights & biases
-      - WANDB_PROJECT=your_project_name
-      - WANDB_RUN_NAME=${RUN_NAME}-$(date +%Y-%m-%d-%H-%M-%S)
-      - PYTHONPATH=/workspace/src
-    network_mode: "host"
-    command: /bin/bash
-    working_dir: /workspace
-EOL
-
-# Function to build training arguments from yaml
-build_train_args() {
-    args=""
-    while IFS=": " read -r key value; do
-        [[ -z "$key" || "$key" =~ ^[[:space:]]*# ]] && continue
-        value=$(echo "$value" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' -e 's/^"//' -e 's/"$//')
-        if [[ "$value" == "true" ]]; then
-            args="$args --$key"
-        elif [[ "$value" == "false" ]]; then
-            continue
-        else
-            args="$args --$key $value"
-        fi
-    done < ${RUN_NAME}_args.yaml
-    echo "$args"
-}
-
-# Get training arguments
-TRAIN_ARGS=$(build_train_args)
-echo "TRAIN_ARGS: $TRAIN_ARGS"
-
-# Launch containers on each node
-NODE_RANK=0
-for host in "${NODES[@]}"; do
-    LOG_FILE="$LOG_DIR/${host}_rank${NODE_RANK}.log"
-    if [ "$host" = "$MASTER_NODE" ]; then
-        echo "Launching on master $host with rank $NODE_RANK, logging to $LOG_FILE"
-        ssh $host "cd $PROJECT_ROOT && \
-            MASTER_ADDR=$MASTER_IP \
-            NODE_RANK=$NODE_RANK \
-            WORLD_SIZE=$TOTAL_NODES \
-            sudo -E docker-compose -f docker-compose.yml run --rm trainer \
-            torchrun --nproc_per_node=8 \
-            --nnodes=$TOTAL_NODES \
-            --node_rank=$NODE_RANK \
-            --master_addr=$MASTER_IP \
-            --master_port=$MASTER_PORT \
-            src/train.py \
-            $TRAIN_ARGS" > "$LOG_FILE" 2>&1 &
-    else
-        echo "Launching on $host with rank $NODE_RANK, logging to $LOG_FILE"
-        ssh $host "cd $PROJECT_ROOT && \
-            MASTER_ADDR=$MASTER_IP \
-            NODE_RANK=$NODE_RANK \
-            WORLD_SIZE=$TOTAL_NODES \
-            sudo -E docker-compose -f docker-compose.yml run --rm trainer \
-            torchrun --nproc_per_node=8 \
-            --nnodes=$TOTAL_NODES \
-            --node_rank=$NODE_RANK \
-            --master_addr=$MASTER_IP \
-            --master_port=$MASTER_PORT \
-            src/train.py \
-            $TRAIN_ARGS" > "$LOG_FILE" 2>&1 &
-    fi
-    
-    NODE_RANK=$((NODE_RANK + 1))
-done
-
-echo "Jobs launched. To monitor the logs, you can:"
-echo "1. Use 'tail -f $LOG_DIR/*.log' to watch all logs"
-echo "2. Use 'tail -f $LOG_DIR/<node_name>_rank<N>.log' to watch a specific node"
-
-# Wait for all background processes to complete
-wait 

open-r1-multimodal/run_scripts/run_grpo_gui.sh

@@ -1,34 +0,0 @@
-cd src/open-r1-multimodal
-export DEBUG_MODE="true"
-# export CUDA_VISIBLE_DEVICES=4,5,6,7
-RUN_NAME="Qwen2.5-VL-3B-GRPO-GUI_multi-image"
-export LOG_PATH="./debug_log_$RUN_NAME.txt"
-
-torchrun --nproc_per_node="8" \
-    --nnodes="1" \
-    --node_rank="0" \
-    --master_addr="127.0.0.1" \
-    --master_port="12346" \
-    src/open_r1/grpo_jsonl.py \
-    --deepspeed local_scripts/zero3.json \
-    --output_dir output/$RUN_NAME \
-    --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
-    --dataset_name none \
-    --image_folders /path/to/images/ \
-    --data_file_paths data_jsonl/gui_multi-image.jsonl \
-    --freeze_vision_modules true \
-    --max_prompt_length 1024 \
-    --num_generations 8 \
-    --per_device_train_batch_size 8 \
-    --gradient_accumulation_steps 2 \
-    --logging_steps 1 \
-    --bf16 \
-    --torch_dtype bfloat16 \
-    --data_seed 42 \
-    --report_to wandb \
-    --gradient_checkpointing true \
-    --attn_implementation flash_attention_2 \
-    --num_train_epochs 2 \
-    --run_name $RUN_NAME \
-    --save_steps 100 \
-    --save_only_model true

open-r1-multimodal/run_scripts/run_grpo_gui_grounding.sh

@@ -1,34 +0,0 @@
-cd src/open-r1-multimodal
-export DEBUG_MODE="true"
-# export CUDA_VISIBLE_DEVICES=4,5,6,7
-
-RUN_NAME="Qwen2.5-VL-3B-GRPO-GUI-Grounding_showui_desktop_high_quality_attention_0.2_filtered_continual_dense_reward_quadratic_decay_0.5_format_bs16_kl0.004_nothink_10e_max_pixel_4028160"
-export LOG_PATH="./debug_log_$RUN_NAME.txt"
-
-torchrun --nproc_per_node="8" \
-    --nnodes="1" \
-    --node_rank="0" \
-    --master_addr="127.0.0.1" \
-    --master_port="12346" \
-    src/open_r1/grpo_gui_grounding.py \
-    --deepspeed local_scripts/zero3.json \
-    --output_dir output/$RUN_NAME \
-    --model_name_or_path /data/vjuicefs_ai_camera_jgroup_research/public_data/11178625/LLaMA-Factory/Qwen2.5-VL-3B-Instruct \
-    --dataset_name data_config/gui_grounding.yaml \
-    --image_root /data/vjuicefs_ai_camera_jgroup_research/public_data/11178625/LLaMA-Factory/VLM-R1/data  \
-    --max_prompt_length 4096 \
-    --max_completion_length 1400 \
-    --num_generations 8 \
-    --per_device_train_batch_size 1 \
-    --gradient_accumulation_steps 2 \
-    --logging_steps 1 \
-    --bf16 \
-    --torch_dtype bfloat16 \
-    --data_seed 42 \
-    --report_to wandb \
-    --gradient_checkpointing false \
-    --attn_implementation flash_attention_2 \
-    --num_train_epochs 10 \
-    --run_name $RUN_NAME \
-    --save_steps 100 \
-    --save_only_model true 

open-r1-multimodal/run_scripts/run_grpo_rec.sh

@@ -1,33 +0,0 @@
-cd src/open-r1-multimodal
-export DEBUG_MODE="true"
-# export CUDA_VISIBLE_DEVICES=4,5,6,7
-
-RUN_NAME="Qwen2.5-VL-7B-GRPO-REC"
-export LOG_PATH="./debug_log_$RUN_NAME.txt"
-
-torchrun --nproc_per_node="8" \
-    --nnodes="1" \
-    --node_rank="0" \
-    --master_addr="127.0.0.1" \
-    --master_port="12346" \
-    src/open_r1/grpo_rec.py \
-    --deepspeed local_scripts/zero3.json \
-    --output_dir output/$RUN_NAME \
-    --model_name_or_path /data/vjuicefs_ai_camera_jgroup_research/public_data/11178625/LLaMA-Factory/Qwen2.5-VL-3B-Instruct \
-    --dataset_name data_config/rec.yaml \
-    --image_root /data/vjuicefs_ai_camera_jgroup_research/public_data/11178625/LLaMA-Factory/VLM-R1/data  \
-    --max_prompt_length 1024 \
-    --num_generations 8 \
-    --per_device_train_batch_size 4 \
-    --gradient_accumulation_steps 4 \
-    --logging_steps 1 \
-    --bf16 \
-    --torch_dtype bfloat16 \
-    --data_seed 42 \
-    --report_to wandb \
-    --gradient_checkpointing false \
-    --attn_implementation flash_attention_2 \
-    --num_train_epochs 2 \
-    --run_name $RUN_NAME \
-    --save_steps 100 \
-    --save_only_model true

open-r1-multimodal/run_scripts/run_grpo_rec_internvl.sh

@@ -1,36 +0,0 @@
-cd src/open-r1-multimodal
-
-export DEBUG_MODE="true"
-# export CUDA_VISIBLE_DEVICES=4,5,6,7
-
-RUN_NAME="InternVL-4B-GRPO-REC"
-export LOG_PATH="./debug_log_$RUN_NAME.txt"
-
-torchrun --nproc_per_node="8" \
-    --nnodes="1" \
-    --node_rank="0" \
-    --master_addr="127.0.0.1" \
-    --master_port="12346" \
-    src/open_r1/grpo_rec.py \
-    --deepspeed local_scripts/zero_stage2_config.json \
-    --output_dir output/$RUN_NAME \
-    --model_name_or_path /data10/shz/ckpt/vlm-r1-related/InternVL2_5-4B \
-    --dataset_name data_config/rec_internvl.yaml \
-    --image_root /data10/shz/dataset/coco \
-    --freeze_vision_modules true \
-    --max_anyres_num 6 \
-    --max_prompt_length 1024 \
-    --num_generations 8 \
-    --per_device_train_batch_size 8 \
-    --gradient_accumulation_steps 2 \
-    --logging_steps 1 \
-    --bf16 \
-    --torch_dtype bfloat16 \
-    --data_seed 42 \
-    --report_to wandb \
-    --gradient_checkpointing true \
-    --attn_implementation flash_attention_2 \
-    --num_train_epochs 2 \
-    --run_name $RUN_NAME \
-    --save_steps 100 \
-    --save_only_model true

open-r1-multimodal/run_scripts/run_grpo_rec_lora.sh

@@ -1,43 +0,0 @@
-cd src/open-r1-multimodal
-
-export DEBUG_MODE="true"
-# export CUDA_VISIBLE_DEVICES=4,5,6,7
-
-RUN_NAME="Qwen2.5-VL-7B-GRPO-REC-lora"
-export LOG_PATH="./debug_log_$RUN_NAME.txt"
-
-torchrun --nproc_per_node="8" \
-    --nnodes="1" \
-    --node_rank="0" \
-    --master_addr="127.0.0.1" \
-    --master_port="12346" \
-    src/open_r1/grpo_rec.py \
-    --deepspeed local_scripts/zero2.json \
-    --output_dir output/$RUN_NAME \
-    --model_name_or_path Qwen/Qwen2.5-VL-7B-Instruct \
-    --dataset_name data_config/rec.yaml \
-    --image_root <your_image_root> \
-    --max_prompt_length 1024 \
-    --num_generations 8 \
-    --per_device_train_batch_size 1 \
-    --gradient_accumulation_steps 2 \
-    --logging_steps 1 \
-    --bf16 \
-    --torch_dtype bfloat16 \
-    --data_seed 42 \
-    --report_to wandb \
-    --gradient_checkpointing true \
-    --attn_implementation flash_attention_2 \
-    --num_train_epochs 2 \
-    --run_name $RUN_NAME \
-    --save_steps 100 \
-    --save_only_model true \
-    --learning_rate 1e-5 \
-    --use_peft true \
-    --lora_r 64 \
-    --lora_alpha 128 \
-    --lora_dropout 0.05 \
-    --lora_task_type CAUSAL_LM \
-    --freeze_vision_modules true
-
-

open-r1-multimodal/setup.cfg

@@ -1,41 +0,0 @@
-[isort]
-default_section = FIRSTPARTY
-ensure_newline_before_comments = True
-force_grid_wrap = 0
-include_trailing_comma = True
-known_first_party = open_r1
-known_third_party =
-    transformers
-    datasets
-    fugashi
-    git
-    h5py
-    matplotlib
-    nltk
-    numpy
-    packaging
-    pandas
-    psutil
-    pytest
-    rouge_score
-    sacrebleu
-    seqeval
-    sklearn
-    streamlit
-    torch
-    tqdm
-
-line_length = 119
-lines_after_imports = 2
-multi_line_output = 3
-use_parentheses = True
-
-[flake8]
-ignore = E203, E501, E741, W503, W605
-max-line-length = 119
-per-file-ignores =
-    # imported but unused
-    __init__.py: F401
-
-[tool:pytest]
-doctest_optionflags=NUMBER NORMALIZE_WHITESPACE ELLIPSIS

open-r1-multimodal/setup.py

@@ -1,137 +0,0 @@
-# Copyright 2025 The HuggingFace Team. All rights reserved.
-#
-# 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.
-#
-# Adapted from huggingface/transformers: https://github.com/huggingface/transformers/blob/21a2d900eceeded7be9edc445b56877b95eda4ca/setup.py
-
-
-import re
-import shutil
-from pathlib import Path
-
-from setuptools import find_packages, setup
-
-
-# Remove stale open_r1.egg-info directory to avoid https://github.com/pypa/pip/issues/5466
-stale_egg_info = Path(__file__).parent / "open_r1.egg-info"
-if stale_egg_info.exists():
-    print(
-        (
-            "Warning: {} exists.\n\n"
-            "If you recently updated open_r1, this is expected,\n"
-            "but it may prevent open_r1 from installing in editable mode.\n\n"
-            "This directory is automatically generated by Python's packaging tools.\n"
-            "I will remove it now.\n\n"
-            "See https://github.com/pypa/pip/issues/5466 for details.\n"
-        ).format(stale_egg_info)
-    )
-    shutil.rmtree(stale_egg_info)
-
-
-# IMPORTANT: all dependencies should be listed here with their version requirements, if any.
-#   * If a dependency is fast-moving (e.g. transformers), pin to the exact version
-_deps = [
-    "accelerate>=1.2.1",
-    "bitsandbytes>=0.43.0",
-    "black>=24.4.2",
-    "datasets>=3.2.0",
-    "deepspeed==0.15.4",
-    "distilabel[vllm,ray,openai]>=1.5.2",
-    "einops>=0.8.0",
-    "flake8>=6.0.0",
-    "hf_transfer>=0.1.4",
-    "huggingface-hub[cli]>=0.19.2,<1.0",
-    "isort>=5.12.0",
-    "liger_kernel==0.5.2",
-    # "lighteval @ git+https://github.com/huggingface/lighteval.git@4f381b352c0e467b5870a97d41cb66b487a2c503#egg=lighteval[math]",
-    "math-verify",  # Used for math verification in grpo
-    "packaging>=23.0",
-    "parameterized>=0.9.0",
-    "pytest",
-    "safetensors>=0.3.3",
-    "sentencepiece>=0.1.99",
-    "torch>=2.5.1",
-    "transformers>=4.49.0",
-    "trl @ git+https://github.com/huggingface/trl.git@main",
-    "vllm==0.6.6.post1",
-    "wandb>=0.19.1",
-    "pillow",
-]
-
-# this is a lookup table with items like:
-#
-# tokenizers: "tokenizers==0.9.4"
-# packaging: "packaging"
-#
-# some of the values are versioned whereas others aren't.
-deps = {b: a for a, b in (re.findall(r"^(([^!=<>~ \[\]]+)(?:\[[^\]]+\])?(?:[!=<>~ ].*)?$)", x)[0] for x in _deps)}
-
-
-def deps_list(*pkgs):
-    return [deps[pkg] for pkg in pkgs]
-
-
-extras = {}
-extras["tests"] = deps_list("pytest", "parameterized")
-extras["torch"] = deps_list("torch")
-extras["quality"] = deps_list("black", "isort", "flake8")
-# extras["eval"] = deps_list("lighteval", "math-verify")
-extras["eval"] = deps_list("math-verify")
-extras["dev"] = extras["quality"] + extras["tests"] + extras["eval"]
-
-# core dependencies shared across the whole project - keep this to a bare minimum :)
-install_requires = [
-    deps["accelerate"],
-    deps["bitsandbytes"],
-    deps["einops"],
-    deps["datasets"],
-    deps["deepspeed"],
-    deps["hf_transfer"],
-    deps["huggingface-hub"],
-    deps["liger_kernel"],
-    deps["packaging"],  # utilities from PyPA to e.g., compare versions
-    deps["safetensors"],
-    deps["sentencepiece"],
-    deps["transformers"],
-    deps["trl"],
-]
-
-setup(
-    name="open-r1",
-    version="0.1.0.dev0",  # expected format is one of x.y.z.dev0, or x.y.z.rc1 or x.y.z (no to dashes, yes to dots)
-    author="The Hugging Face team (past and future)",
-    author_email="lewis@huggingface.co",
-    description="Open R1",
-    # long_description=open("README.md", "r", encoding="utf-8").read(),
-    long_description_content_type="text/markdown",
-    keywords="llm inference-time compute reasoning",
-    license="Apache",
-    url="https://github.com/huggingface/open-r1",
-    package_dir={"": "src"},
-    packages=find_packages("src"),
-    zip_safe=False,
-    extras_require=extras,
-    python_requires=">=3.10.9",
-    install_requires=install_requires,
-    classifiers=[
-        "Development Status :: 3 - Alpha",
-        "Intended Audience :: Developers",
-        "Intended Audience :: Education",
-        "Intended Audience :: Science/Research",
-        "License :: OSI Approved :: Apache Software License",
-        "Operating System :: OS Independent",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.10",
-        "Topic :: Scientific/Engineering :: Artificial Intelligence",
-    ],
-)

open-r1-multimodal/src/open_r1.egg-info/PKG-INFO

@@ -1,63 +0,0 @@
-Metadata-Version: 2.2
-Name: open-r1
-Version: 0.1.0.dev0
-Summary: Open R1
-Home-page: https://github.com/huggingface/open-r1
-Author: The Hugging Face team (past and future)
-Author-email: lewis@huggingface.co
-License: Apache
-Keywords: llm inference-time compute reasoning
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.10.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: accelerate>=1.2.1
-Requires-Dist: bitsandbytes>=0.43.0
-Requires-Dist: einops>=0.8.0
-Requires-Dist: datasets>=3.2.0
-Requires-Dist: deepspeed==0.15.4
-Requires-Dist: hf_transfer>=0.1.4
-Requires-Dist: huggingface-hub[cli]<1.0,>=0.19.2
-Requires-Dist: liger_kernel==0.5.2
-Requires-Dist: packaging>=23.0
-Requires-Dist: safetensors>=0.3.3
-Requires-Dist: sentencepiece>=0.1.99
-Requires-Dist: transformers>=4.49.0
-Requires-Dist: trl@ git+https://github.com/huggingface/trl.git@main
-Provides-Extra: tests
-Requires-Dist: pytest; extra == "tests"
-Requires-Dist: parameterized>=0.9.0; extra == "tests"
-Provides-Extra: torch
-Requires-Dist: torch>=2.5.1; extra == "torch"
-Provides-Extra: quality
-Requires-Dist: black>=24.4.2; extra == "quality"
-Requires-Dist: isort>=5.12.0; extra == "quality"
-Requires-Dist: flake8>=6.0.0; extra == "quality"
-Provides-Extra: eval
-Requires-Dist: math-verify; extra == "eval"
-Provides-Extra: dev
-Requires-Dist: black>=24.4.2; extra == "dev"
-Requires-Dist: isort>=5.12.0; extra == "dev"
-Requires-Dist: flake8>=6.0.0; extra == "dev"
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: parameterized>=0.9.0; extra == "dev"
-Requires-Dist: math-verify; extra == "dev"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary

open-r1-multimodal/src/open_r1.egg-info/SOURCES.txt

@@ -1,32 +0,0 @@
-LICENSE
-setup.cfg
-setup.py
-src/open_r1/__init__.py
-src/open_r1/configs.py
-src/open_r1/evaluate.py
-src/open_r1/generate.py
-src/open_r1/grpo.py
-src/open_r1/grpo_gui_grounding.py
-src/open_r1/grpo_jsonl.py
-src/open_r1/grpo_rec.py
-src/open_r1/sft.py
-src/open_r1.egg-info/PKG-INFO
-src/open_r1.egg-info/SOURCES.txt
-src/open_r1.egg-info/dependency_links.txt
-src/open_r1.egg-info/not-zip-safe
-src/open_r1.egg-info/requires.txt
-src/open_r1.egg-info/top_level.txt
-src/open_r1/trainer/__init__.py
-src/open_r1/trainer/grpo_config.py
-src/open_r1/trainer/grpo_trainer.py
-src/open_r1/trainer/qwen_grpo_trainer.py
-src/open_r1/trainer/vllm_grpo_trainer.py
-src/open_r1/utils/__init__.py
-src/open_r1/utils/callbacks.py
-src/open_r1/utils/evaluation.py
-src/open_r1/utils/hub.py
-src/open_r1/utils/math.py
-src/open_r1/vlm_modules/__init__.py
-src/open_r1/vlm_modules/internvl_module.py
-src/open_r1/vlm_modules/qwen_module.py
-src/open_r1/vlm_modules/vlm_module.py

open-r1-multimodal/src/open_r1.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

open-r1-multimodal/src/open_r1.egg-info/not-zip-safe

@@ -1 +0,0 @@
-

open-r1-multimodal/src/open_r1.egg-info/requires.txt

@@ -1,36 +0,0 @@
-accelerate>=1.2.1
-bitsandbytes>=0.43.0
-einops>=0.8.0
-datasets>=3.2.0
-deepspeed==0.15.4
-hf_transfer>=0.1.4
-huggingface-hub[cli]<1.0,>=0.19.2
-liger_kernel==0.5.2
-packaging>=23.0
-safetensors>=0.3.3
-sentencepiece>=0.1.99
-transformers>=4.49.0
-trl@ git+https://github.com/huggingface/trl.git@main
-
-[dev]
-black>=24.4.2
-isort>=5.12.0
-flake8>=6.0.0
-pytest
-parameterized>=0.9.0
-math-verify
-
-[eval]
-math-verify
-
-[quality]
-black>=24.4.2
-isort>=5.12.0
-flake8>=6.0.0
-
-[tests]
-pytest
-parameterized>=0.9.0
-
-[torch]
-torch>=2.5.1

open-r1-multimodal/src/open_r1.egg-info/top_level.txt

@@ -1 +0,0 @@
-open_r1

open-r1-multimodal/src/open_r1/configs.py

@@ -1,82 +0,0 @@
-# coding=utf-8
-# Copyright 2025 The HuggingFace Team. All rights reserved.
-#
-# 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.
-
-from dataclasses import dataclass, field
-from typing import Optional
-
-import trl
-
-
-# TODO: add the shared options with a mixin to reduce code duplication
-@dataclass
-class GRPOConfig(trl.GRPOConfig):
-    """
-    args for callbacks, benchmarks etc
-    """
-
-    benchmarks: list[str] = field(
-        default_factory=lambda: [], metadata={"help": "The benchmarks to run after training."}
-    )
-    callbacks: list[str] = field(
-        default_factory=lambda: [], metadata={"help": "The callbacks to run during training."}
-    )
-    system_prompt: Optional[str] = field(
-        default=None, metadata={"help": "The optional system prompt to use for benchmarking."}
-    )
-    hub_model_revision: Optional[str] = field(
-        default="main", metadata={"help": "The Hub model branch to push the model to."}
-    )
-    overwrite_hub_revision: bool = field(default=False, metadata={"help": "Whether to overwrite the Hub revision."})
-    push_to_hub_revision: bool = field(default=False, metadata={"help": "Whether to push to a Hub revision/branch."})
-    wandb_entity: Optional[str] = field(
-        default=None,
-        metadata={"help": ("The entity to store runs under.")},
-    )
-    wandb_project: Optional[str] = field(
-        default=None,
-        metadata={"help": ("The project to store runs under.")},
-    )
-
-
-@dataclass
-class SFTConfig(trl.SFTConfig):
-    """
-    args for callbacks, benchmarks etc
-    """
-
-    benchmarks: list[str] = field(
-        default_factory=lambda: [], metadata={"help": "The benchmarks to run after training."}
-    )
-    callbacks: list[str] = field(
-        default_factory=lambda: [], metadata={"help": "The callbacks to run during training."}
-    )
-    system_prompt: Optional[str] = field(
-        default=None,
-        metadata={"help": "The optional system prompt to use for benchmarking."},
-    )
-    hub_model_revision: Optional[str] = field(
-        default="main",
-        metadata={"help": "The Hub model branch to push the model to."},
-    )
-    overwrite_hub_revision: bool = field(default=False, metadata={"help": "Whether to overwrite the Hub revision."})
-    push_to_hub_revision: bool = field(default=False, metadata={"help": "Whether to push to a Hub revision/branch."})
-    wandb_entity: Optional[str] = field(
-        default=None,
-        metadata={"help": ("The entity to store runs under.")},
-    )
-    wandb_project: Optional[str] = field(
-        default=None,
-        metadata={"help": ("The project to store runs under.")},
-    )

open-r1-multimodal/src/open_r1/evaluate.py

@@ -1,85 +0,0 @@
-# Copyright 2025 The HuggingFace Team. All rights reserved.
-#
-# 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.
-
-"""Custom evaluation tasks for LightEval."""
-
-from lighteval.metrics.dynamic_metrics import (
-    ExprExtractionConfig,
-    LatexExtractionConfig,
-    multilingual_extractive_match_metric,
-)
-from lighteval.tasks.lighteval_task import LightevalTaskConfig
-from lighteval.tasks.requests import Doc
-from lighteval.utils.language import Language
-
-
-metric = multilingual_extractive_match_metric(
-    language=Language.ENGLISH,
-    fallback_mode="first_match",
-    precision=5,
-    gold_extraction_target=(LatexExtractionConfig(),),
-    pred_extraction_target=(ExprExtractionConfig(), LatexExtractionConfig()),
-    aggregation_function=max,
-)
-
-
-def prompt_fn(line, task_name: str = None):
-    """Assumes the model is either prompted to emit \\boxed{answer} or does so automatically"""
-    return Doc(
-        task_name=task_name,
-        query=line["problem"],
-        choices=[line["solution"]],
-        gold_index=0,
-    )
-
-
-# Define tasks
-aime24 = LightevalTaskConfig(
-    name="aime24",
-    suite=["custom"],
-    prompt_function=prompt_fn,
-    hf_repo="HuggingFaceH4/aime_2024",
-    hf_subset="default",
-    hf_avail_splits=["train"],
-    evaluation_splits=["train"],
-    few_shots_split=None,
-    few_shots_select=None,
-    generation_size=32768,
-    metric=[metric],
-    version=1,
-)
-math_500 = LightevalTaskConfig(
-    name="math_500",
-    suite=["custom"],
-    prompt_function=prompt_fn,
-    hf_repo="HuggingFaceH4/MATH-500",
-    hf_subset="default",
-    hf_avail_splits=["test"],
-    evaluation_splits=["test"],
-    few_shots_split=None,
-    few_shots_select=None,
-    generation_size=32768,
-    metric=[metric],
-    version=1,
-)
-
-# Add tasks to the table
-TASKS_TABLE = []
-TASKS_TABLE.append(aime24)
-TASKS_TABLE.append(math_500)
-
-# MODULE LOGIC
-if __name__ == "__main__":
-    print([t["name"] for t in TASKS_TABLE])
-    print(len(TASKS_TABLE))

open-r1-multimodal/src/open_r1/generate.py

@@ -1,156 +0,0 @@
-# Copyright 2025 The HuggingFace Team. All rights reserved.
-#
-# 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.
-
-from typing import Optional
-
-from distilabel.llms import OpenAILLM
-from distilabel.pipeline import Pipeline
-from distilabel.steps.tasks import TextGeneration
-
-
-def build_distilabel_pipeline(
-    model: str,
-    base_url: str = "http://localhost:8000/v1",
-    prompt_column: Optional[str] = None,
-    temperature: Optional[float] = None,
-    top_p: Optional[float] = None,
-    max_new_tokens: int = 8192,
-    num_generations: int = 1,
-) -> Pipeline:
-    generation_kwargs = {"max_new_tokens": max_new_tokens}
-
-    if temperature is not None:
-        generation_kwargs["temperature"] = temperature
-
-    if top_p is not None:
-        generation_kwargs["top_p"] = top_p
-
-    with Pipeline().ray() as pipeline:
-        TextGeneration(
-            llm=OpenAILLM(
-                base_url=base_url,
-                api_key="something",
-                model=model,
-                # thinking can take some time...
-                timeout=10 * 60,
-                generation_kwargs=generation_kwargs,
-            ),
-            input_mappings={"instruction": prompt_column} if prompt_column is not None else {},
-            input_batch_size=64,  # on 4 nodes bs ~60+ leads to preemption due to KV cache exhaustion
-            num_generations=num_generations,
-        )
-
-    return pipeline
-
-
-if __name__ == "__main__":
-    import argparse
-
-    from datasets import load_dataset
-
-    parser = argparse.ArgumentParser(description="Run distilabel pipeline for generating responses with DeepSeek R1")
-    parser.add_argument(
-        "--hf-dataset",
-        type=str,
-        required=True,
-        help="HuggingFace dataset to load",
-    )
-    parser.add_argument(
-        "--hf-dataset-config",
-        type=str,
-        required=False,
-        help="Dataset config to use",
-    )
-    parser.add_argument(
-        "--hf-dataset-split",
-        type=str,
-        default="train",
-        help="Dataset split to use",
-    )
-    parser.add_argument("--prompt-column", type=str, default="prompt")
-    parser.add_argument(
-        "--model",
-        type=str,
-        required=True,
-        help="Model name to use for generation",
-    )
-    parser.add_argument(
-        "--vllm-server-url",
-        type=str,
-        default="http://localhost:8000/v1",
-        help="URL of the vLLM server",
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        help="Temperature for generation",
-    )
-    parser.add_argument(
-        "--top-p",
-        type=float,
-        help="Top-p value for generation",
-    )
-    parser.add_argument(
-        "--max-new-tokens",
-        type=int,
-        default=8192,
-        help="Maximum number of new tokens to generate",
-    )
-    parser.add_argument(
-        "--num-generations",
-        type=int,
-        default=1,
-        help="Number of generations per problem",
-    )
-    parser.add_argument(
-        "--hf-output-dataset",
-        type=str,
-        required=False,
-        help="HuggingFace repo to push results to",
-    )
-    parser.add_argument(
-        "--private",
-        action="store_true",
-        help="Whether to make the output dataset private when pushing to HF Hub",
-    )
-
-    args = parser.parse_args()
-
-    print("\nRunning with arguments:")
-    for arg, value in vars(args).items():
-        print(f"  {arg}: {value}")
-    print()
-
-    print(f"Loading '{args.hf_dataset}' (config: {args.hf_dataset_config}, split: {args.hf_dataset_split}) dataset...")
-    dataset = load_dataset(args.hf_dataset, split=args.hf_dataset_split)
-    print("Dataset loaded!")
-
-    pipeline = build_distilabel_pipeline(
-        model=args.model,
-        base_url=args.vllm_server_url,
-        prompt_column=args.prompt_column,
-        temperature=args.temperature,
-        top_p=args.top_p,
-        max_new_tokens=args.max_new_tokens,
-        num_generations=args.num_generations,
-    )
-
-    print("Running generation pipeline...")
-    distiset = pipeline.run(dataset=dataset, use_cache=False)
-    print("Generation pipeline finished!")
-
-    if args.hf_output_dataset:
-        print(f"Pushing resulting dataset to '{args.hf_output_dataset}'...")
-        distiset.push_to_hub(args.hf_output_dataset, private=args.private)
-        print("Dataset pushed!")

open-r1-multimodal/src/open_r1/grpo.py

@@ -1,214 +0,0 @@
-# Copyright 2025 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# import debugpy
-# try:
-#     # 5678 is the default attach port in the VS Code debug configurations. Unless a host and port are specified, host defaults to 127.0.0.1
-#     debugpy.listen(("localhost", 9501))
-#     print("Waiting for debugger attach")
-#     debugpy.wait_for_client()
-# except Exception as e:
-#     pass
-
-import os
-import re
-from datetime import datetime
-from dataclasses import dataclass, field
-from typing import Optional
-
-from datasets import load_dataset, load_from_disk
-from transformers import Qwen2VLForConditionalGeneration
-
-from math_verify import parse, verify
-from open_r1.trainer import VLMGRPOTrainer
-from trl import GRPOConfig, GRPOTrainer, ModelConfig, ScriptArguments, TrlParser, get_peft_config
-
-
-@dataclass
-class GRPOScriptArguments(ScriptArguments):
-    """
-    Script arguments for the GRPO training script.
-
-    Args:
-        reward_funcs (`list[str]`):
-            List of reward functions. Possible values: 'accuracy', 'format'.
-    """
-
-    reward_funcs: list[str] = field(
-        default_factory=lambda: ["accuracy", "format"],
-        metadata={"help": "List of reward functions. Possible values: 'accuracy', 'format'"},
-    )
-    max_pixels: Optional[int] = field(
-        default=12845056,
-        metadata={"help": "Maximum number of pixels for the image"},
-    )
-    min_pixels: Optional[int] = field(
-        default=3136,
-        metadata={"help": "Minimum number of pixels for the image"},
-    )
-
-
-def accuracy_reward(completions, solution, **kwargs):
-    """Reward function that checks if the completion is correct using either symbolic verification or exact string matching."""
-    contents = [completion[0]["content"] for completion in completions]
-    rewards = []
-    current_time = datetime.now().strftime("%d-%H-%M-%S-%f")
-    for content, sol in zip(contents, solution):
-        reward = 0.0
-        # Try symbolic verification first
-        try:
-            answer = parse(content)
-            if float(verify(answer, parse(sol))) > 0:
-                reward = 1.0
-        except Exception:
-            pass  # Continue to next verification method if this fails
-
-        # If symbolic verification failed, try string matching
-        if reward == 0.0:
-            try:
-                # Extract answer from solution if it has think/answer tags
-                sol_match = re.search(r'<answer>(.*?)</answer>', sol)
-                ground_truth = sol_match.group(1).strip() if sol_match else sol.strip()
-                
-                # Extract answer from content if it has think/answer tags
-                content_match = re.search(r'<answer>(.*?)</answer>', content)
-                student_answer = content_match.group(1).strip() if content_match else content.strip()
-                
-                # Compare the extracted answers
-                if student_answer == ground_truth:
-                    reward = 1.0
-            except Exception:
-                pass  # Keep reward as 0.0 if both methods fail
-                
-        rewards.append(reward)
-        if os.getenv("DEBUG_MODE") == "true":
-            log_path = os.getenv("LOG_PATH")
-            # local_rank = int(os.getenv("LOCAL_RANK", 0))
-            with open(log_path, "a") as f:
-                f.write(f"------------- {current_time} Accuracy reward: {reward} -------------\n")
-                f.write(f"Content: {content}\n")
-                f.write(f"Solution: {sol}\n")
-    return rewards
-
-
-def format_reward(completions, **kwargs):
-    """Reward function that checks if the completion has a specific format."""
-    pattern = r"<think>.*?</think>\s*<answer>.*?</answer>"
-    completion_contents = [completion[0]["content"] for completion in completions]
-    matches = [re.match(pattern, content) for content in completion_contents]
-    return [1.0 if match else 0.0 for match in matches]
-
-
-reward_funcs_registry = {
-    "accuracy": accuracy_reward,
-    "format": format_reward,
-}
-
-SYSTEM_PROMPT = (
-    "A conversation between User and Assistant. The user asks a question, and the Assistant solves it. The assistant "
-    "first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning "
-    "process and answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., "
-    "<think> reasoning process here </think><answer> answer here </answer>"
-)
-
-
-def main(script_args, training_args, model_args):
-    # Get reward functions
-    reward_funcs = [reward_funcs_registry[func] for func in script_args.reward_funcs]
-    print("reward_funcs:", reward_funcs)
-
-    # Load the dataset
-    dataset = load_dataset(script_args.dataset_name, name=script_args.dataset_config)
-
-
-    # Format into conversation
-    def make_conversation(example):
-        return {
-            "prompt": [
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": example["problem"]},
-            ],
-        }
-
-    # def make_conversation_image(example):
-    #     return {
-    #         "prompt": [
-    #             {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]},
-    #             {
-    #                 "role": "user",
-    #                 "content": [
-    #                     {"type": "image"},
-    #                     {"type": "text", "text": example["problem"]},
-    #                 ],
-    #             },
-    #         ],
-    #     }
-
-    QUESTION_TEMPLATE = "{Question}  Output the thinking process in <think> </think> and final answer (number) in <answer> </answer> tags."
-
-    def make_conversation_image(example):
-        return {
-            "prompt": [
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "image"},
-                        {"type": "text", "text": QUESTION_TEMPLATE.format(Question=example["problem"])},
-                    ],
-                },
-            ],
-        }
-
-
-    if "image" in dataset[script_args.dataset_train_split].features:
-        print("has image in dataset")
-        dataset = dataset.map(make_conversation_image)  # Utilize multiprocessing for faster mapping
-        # dataset = dataset.remove_columns(["original_question", "original_answer"])
-
-    else:
-        print("no image in dataset")
-        dataset = dataset.map(make_conversation)
-        dataset = dataset.remove_columns("messages")
-
-    
-    trainer_cls = VLMGRPOTrainer
-
-
-    # Initialize the GRPO trainer
-    trainer = trainer_cls(
-        model=model_args.model_name_or_path,
-        reward_funcs=reward_funcs,
-        args=training_args,
-        train_dataset=dataset[script_args.dataset_train_split],
-        eval_dataset=dataset[script_args.dataset_test_split] if training_args.eval_strategy != "no" else None,
-        peft_config=get_peft_config(model_args),
-        attn_implementation=model_args.attn_implementation,
-        max_pixels=script_args.max_pixels,
-        min_pixels=script_args.min_pixels,
-        torch_dtype=model_args.torch_dtype,
-    )
-
-    # Train and push the model to the Hub
-    trainer.train()
-
-    # Save and push to hub
-    trainer.save_model(training_args.output_dir)
-    if training_args.push_to_hub:
-        trainer.push_to_hub(dataset_name=script_args.dataset_name)
-
-
-if __name__ == "__main__":
-    parser = TrlParser((GRPOScriptArguments, GRPOConfig, ModelConfig))
-    script_args, training_args, model_args = parser.parse_args_and_config()
-    main(script_args, training_args, model_args)

open-r1-multimodal/src/open_r1/grpo_gui_grounding.py

@@ -1,357 +0,0 @@
-# Copyright 2025 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# import debugpy
-# try:
-#     # 5678 is the default attach port in the VS Code debug configurations. Unless a host and port are specified, host defaults to 127.0.0.1
-#     debugpy.listen(("localhost", 9501))
-#     print("Waiting for debugger attach")
-#     debugpy.wait_for_client()
-# except Exception as e:
-#     pass
-
-import os
-import re
-from datetime import datetime
-from dataclasses import dataclass, field
-from typing import Optional
-
-from PIL import Image
-from torch.utils.data import Dataset
-from transformers import Qwen2VLForConditionalGeneration
-
-from math_verify import parse, verify
-from open_r1.trainer import VLMGRPOTrainer, GRPOConfig, Qwen2VLGRPOVLLMTrainer,Qwen2VLGRPOTrainer
-from open_r1.vlm_modules import *
-from trl import ModelConfig, ScriptArguments, TrlParser, get_peft_config
-from transformers import TrainingArguments
-import yaml
-import json
-import random
-import math
-
-# ----------------------- Fix the flash attention bug in the current version of transformers -----------------------
-from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import Qwen2_5_VLVisionFlashAttention2, apply_rotary_pos_emb_flashatt, flash_attn_varlen_func
-import torch
-from typing import Tuple
-def custom_forward(
-        self,
-        hidden_states: torch.Tensor,
-        cu_seqlens: torch.Tensor,
-        rotary_pos_emb: Optional[torch.Tensor] = None,
-        position_embeddings: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
-    ) -> torch.Tensor:
-        seq_length = hidden_states.shape[0]
-        q, k, v = self.qkv(hidden_states).reshape(seq_length, 3, self.num_heads, -1).permute(1, 0, 2, 3).unbind(0)
-        # print(111, 222, 333, 444, 555, 666, 777, 888, 999)
-        if position_embeddings is None:
-            logger.warning_once(
-                "The attention layers in this model are transitioning from computing the RoPE embeddings internally "
-                "through `rotary_pos_emb` (2D tensor of RoPE theta values), to using externally computed "
-                "`position_embeddings` (Tuple of tensors, containing cos and sin). In v4.54 `rotary_pos_emb` will be "
-                "removed and `position_embeddings` will be mandatory."
-            )
-            emb = torch.cat((rotary_pos_emb, rotary_pos_emb), dim=-1)
-            cos = emb.cos().float()
-            sin = emb.sin().float()
-        else:
-            cos, sin = position_embeddings
-            # Add this
-            cos = cos.to(torch.float)
-            sin = sin.to(torch.float)
-        q, k = apply_rotary_pos_emb_flashatt(q.unsqueeze(0), k.unsqueeze(0), cos, sin)
-        q = q.squeeze(0)
-        k = k.squeeze(0)
-
-        max_seqlen = (cu_seqlens[1:] - cu_seqlens[:-1]).max().item()
-        attn_output = flash_attn_varlen_func(q, k, v, cu_seqlens, cu_seqlens, max_seqlen, max_seqlen).reshape(
-            seq_length, -1
-        )
-        attn_output = self.proj(attn_output)
-        return attn_output
-
-def smart_resize(
-    height: int, width: int, factor: int = 28, min_pixels: int = 56 * 56, max_pixels: int = 4028160
-):
-    """Rescales the image so that the following conditions are met:
-
-    1. Both dimensions (height and width) are divisible by 'factor'.
-
-    2. The total number of pixels is within the range ['min_pixels', 'max_pixels'].
-
-    3. The aspect ratio of the image is maintained as closely as possible.
-
-    """
-    if height < factor or width < factor:
-        raise ValueError(f"height:{height} or width:{width} must be larger than factor:{factor}")
-    elif max(height, width) / min(height, width) > 200:
-        raise ValueError(
-            f"absolute aspect ratio must be smaller than 200, got {max(height, width) / min(height, width)}"
-        )
-    h_bar = round(height / factor) * factor
-    w_bar = round(width / factor) * factor
-    if h_bar * w_bar > max_pixels:
-        beta = math.sqrt((height * width) / max_pixels)
-        h_bar = math.floor(height / beta / factor) * factor
-        w_bar = math.floor(width / beta / factor) * factor
-    elif h_bar * w_bar < min_pixels:
-        beta = math.sqrt(min_pixels / (height * width))
-        h_bar = math.ceil(height * beta / factor) * factor
-        w_bar = math.ceil(width * beta / factor) * factor
-    return h_bar, w_bar
-
-
-Qwen2_5_VLVisionFlashAttention2.forward = custom_forward
-
-
-# ----------------------- Main Script -----------------------
-@dataclass
-class GRPOScriptArguments(ScriptArguments):
-    """
-    Script arguments for the GRPO training script.
-
-    Args:
-        reward_funcs (`list[str]`):
-            List of reward functions. Possible values: 'accuracy', 'format'.
-    """
-
-    reward_funcs: list[str] = field(
-        default_factory=lambda: ["accuracy","format"],
-        metadata={"help": "List of reward functions. Possible values: 'accuracy', 'format'"},
-    )
-    max_pixels: Optional[int] = field(
-        default=4028160,
-        metadata={"help": "Maximum number of pixels for the image (for QwenVL)"},
-    )
-    min_pixels: Optional[int] = field(
-        default=3136,
-        metadata={"help": "Minimum number of pixels for the image (for QwenVL)"},
-    )
-    max_anyres_num: Optional[int] = field(
-        default=12,
-        metadata={"help": "Maximum number of anyres blocks for the image (for InternVL)"},
-    )
-    image_root: Optional[str] = field(
-        default=None,
-        metadata={"help": "Root directory of the image"},
-    )
-
-@dataclass
-class GRPOModelConfig(ModelConfig):
-    freeze_vision_modules: bool = False
-
-
-SYSTEM_PROMPT = (
-    "A conversation between User and Assistant. The user asks a question, and the Assistant solves it. The assistant "
-    "first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning "
-    "process and answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., "
-    "<think> reasoning process here </think><answer> answer here </answer>"
-)
-
-import json
-import os
-import random
-from PIL import Image
-import yaml
-from torch.utils.data import Dataset
-
-class LazySupervisedDataset(Dataset):
-    """A dataset class to process conversations with system, human, and GPT messages, including images."""
-    def __init__(self, data_path: str, script_args, question_template: str = None):
-        """
-        Initialize the dataset.
-
-        Args:
-            data_path (str): Path to the data file (.json or .yaml).
-            script_args: Arguments containing image_root and other configurations.
-            question_template (str, optional): Kept for compatibility, not used here.
-        """
-        super(LazySupervisedDataset, self).__init__()
-        self.script_args = script_args
-        self.list_data_dict = []
-        self.question_template = question_template  # Unused but kept for compatibility
-
-        # Load data based on file type
-        if data_path.endswith(".json"):
-            # Direct JSON file containing conversations
-            with open(data_path, "r") as json_file:
-                self.list_data_dict = json.load(json_file)
-            print(f"Loaded {len(self.list_data_dict)} samples from {data_path}")
-        elif data_path.endswith(".yaml"):
-            # Original YAML-based loading (for backward compatibility)
-            with open(data_path, "r") as file:
-                yaml_data = yaml.safe_load(file)
-                datasets = yaml_data.get("datasets", [])
-                for data in datasets:
-                    json_path = data.get("json_path")
-                    if json_path.endswith(".jsonl"):
-                        cur_data_dict = [json.loads(line.strip()) for line in open(json_path, "r")]
-                    elif json_path.endswith(".json"):
-                        with open(json_path, "r") as json_file:
-                            cur_data_dict = json.load(json_file)
-                    else:
-                        raise ValueError(f"Unsupported file type: {json_path}")
-                    self.list_data_dict.extend(cur_data_dict)
-            print(f"Loaded {len(self.list_data_dict)} samples from YAML config")
-        else:
-            raise ValueError(f"Unsupported file type: {data_path}")
-
-    def __len__(self):
-        """Return the number of samples in the dataset."""
-        return len(self.list_data_dict)
-
-    def __getitem__(self, i):
-        """
-        Retrieve a processed sample by index.
-
-        Args:
-            i (int): Index of the sample.
-
-        Returns:
-            dict: Contains 'image', 'prompt', and 'solution'.
-        """
-        example = self.list_data_dict[i]
-        conversations = example["conversations"]
-        images = example.get("images", [])
-        bbox = example.get("bbox", [])
-
-        # Extract messages (assuming one of each role)
-        try:
-            system_message = next(msg["value"] for msg in conversations if msg["from"] == "system")
-            human_message = next(msg["value"] for msg in conversations if msg["from"] == "human")
-            gpt_message = next(msg["value"] for msg in conversations if msg["from"] == "gpt")
-        except StopIteration:
-            raise ValueError("Conversation missing required system, human, or gpt message.")
-
-        # Handle image if present
-        image = None
-        image_root = self.script_args.image_root
-        if "<image>" in human_message and images:
-            image_path = os.path.join(image_root, images[0])
-            # Fallback: try another sample if image is missing
-            tries = 0
-            max_tries = 10
-            while tries < max_tries and not os.path.exists(image_path):
-                print(f"Warning: Image {image_path} not found, selecting another sample")
-                i = random.randint(0, len(self.list_data_dict) - 1)
-                example = self.list_data_dict[i]
-                conversations = example["conversations"]
-                images = example.get("images", [])
-                try:
-                    system_message = next(msg["value"] for msg in conversations if msg["from"] == "system")
-                    human_message = next(msg["value"] for msg in conversations if msg["from"] == "human")
-                    gpt_message = next(msg["value"] for msg in conversations if msg["from"] == "gpt")
-                    
-                except StopIteration:
-                    tries += 1
-                    continue
-                if "<image>" not in human_message or not images:
-                    image_path = None
-                    break
-                image_path = os.path.join(image_root, images[0])
-                tries += 1
-            if image_path and os.path.exists(image_path):
-                image = Image.open(image_path).convert("RGB")
-            elif tries >= max_tries:
-                print("Warning: No valid image found after max tries, proceeding without image")
-                image = None
-        height,width = image.size if image else (0, 0)
-        resized_height, resized_width = smart_resize(height, width)
-        image = image.resize((resized_height, resized_width))
-        print(f"Image size: {image.size}")
-        # Construct user content with image if applicable
-        if image and "<image>" in human_message:
-            # Split human message around <image> placeholder
-            parts = human_message.split("<image>", 1)
-            user_content = []
-            if parts[0]:  # Text before <image>
-                user_content.append({"type": "text", "text": parts[0]})
-            user_content.append({"type": "image"})  # Image placeholder
-            if len(parts) > 1 and parts[1]:  # Text after <image>
-                user_content.append({"type": "text", "text": parts[1]})
-        else:
-            user_content = human_message  # Plain text if no image
-
-        # Build the prompt
-        prompt = [
-            {"role": "system", "content": system_message},
-            {"role": "user", "content": user_content}
-        ]
-
-        # Return processed sample
-        return {
-            "image": image,        # PIL Image or None
-            "prompt": prompt,      # List of messages for the model
-            "solution": bbox  # GPT response (e.g., tool call)
-        }
-
-
-def get_vlm_module(model_name_or_path):
-    if "qwen" in model_name_or_path.lower():
-        return Qwen2VLModule
-    elif "internvl" in model_name_or_path.lower():
-        return InvernVLModule
-    else:
-        raise ValueError(f"Unsupported model: {model_name_or_path}")
-
-def main(script_args, training_args, model_args):
-    # Load the VLM module
-    vlm_module_cls = get_vlm_module(model_args.model_name_or_path)
-    # print("Module file:", vlm_module_cls.__module__)
-    # print("available attributes:",dir(vlm_module_cls))
-    # print("using vlm module:", vlm_module_cls.__name__)
-
-    # Load the reward functions
-    reward_funcs_registry = {
-        "accuracy": vlm_module_cls.point_reward,
-        # "accuracy_v2": vlm_module_cls.point_reward_v2,
-        "format": vlm_module_cls.format_reward_rec,
-    }
-    reward_funcs = [reward_funcs_registry[func] for func in script_args.reward_funcs]
-    print("reward_funcs:", reward_funcs)
-
-    # Load the dataset
-    dataset = LazySupervisedDataset(script_args.dataset_name, script_args, question_template=vlm_module_cls.get_question_template(task_type="rec"))
-
-    trainer_cls = Qwen2VLGRPOTrainer
-    print('-'*100)
-    print(script_args.max_pixels)
-    print(script_args.min_pixels)
-    print('-'*100)
-    # Initialize the GRPO trainer
-    trainer = trainer_cls(
-        model=model_args.model_name_or_path,
-        reward_funcs=reward_funcs,
-        args=training_args,
-        train_dataset=dataset,
-        eval_dataset=None,
-        peft_config=get_peft_config(model_args),
-        max_pixels=script_args.max_pixels,
-        min_pixels=script_args.min_pixels,
-        attn_implementation=model_args.attn_implementation,
-    )
-
-    # Train and push the model to the Hub
-    trainer.train()
-
-    # Save and push to hub
-    trainer.save_model(training_args.output_dir)
-    if training_args.push_to_hub:
-        trainer.push_to_hub(dataset_name=script_args.dataset_name)
-
-
-if __name__ == "__main__":
-    parser = TrlParser((GRPOScriptArguments, GRPOConfig, GRPOModelConfig))
-    script_args, training_args, model_args = parser.parse_args_and_config()
-    main(script_args, training_args, model_args)

open-r1-multimodal/src/open_r1/grpo_jsonl.py

@@ -1,649 +0,0 @@
-# Copyright 2025 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import re
-import pathlib
-from datetime import datetime
-from dataclasses import dataclass, field
-from typing import Optional
-from babel.numbers import parse_decimal
-from utils.math import compute_score
-from datasets import load_dataset, load_from_disk
-from transformers import Qwen2VLForConditionalGeneration
-
-from math_verify import parse, verify
-from open_r1.trainer import VLMGRPOTrainer, GRPOConfig
-from trl import ModelConfig, ScriptArguments, TrlParser, get_peft_config
-import PIL
-from Levenshtein import ratio
-from open_r1.utils.pycocotools.coco import COCO
-from open_r1.utils.pycocotools.cocoeval import COCOeval
-import json
-
-from open_r1.vlm_modules import *
-
-# ----------------------- Fix the flash attention bug in the current version of transformers -----------------------
-from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import Qwen2_5_VLVisionFlashAttention2, apply_rotary_pos_emb_flashatt, flash_attn_varlen_func
-import torch
-from typing import Tuple
-from transformers.utils import logging
-
-from openai import OpenAI
-
-logger = logging.get_logger(__name__)
-
-client = OpenAI(
-    api_key=os.getenv("OPENAI_API_KEY", "sk-proj-1234567890"),
-    base_url=os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1")
-)
-
-def custom_forward(
-        self,
-        hidden_states: torch.Tensor,
-        cu_seqlens: torch.Tensor,
-        rotary_pos_emb: Optional[torch.Tensor] = None,
-        position_embeddings: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
-    ) -> torch.Tensor:
-        seq_length = hidden_states.shape[0]
-        q, k, v = self.qkv(hidden_states).reshape(seq_length, 3, self.num_heads, -1).permute(1, 0, 2, 3).unbind(0)
-        # print(111, 222, 333, 444, 555, 666, 777, 888, 999)
-        if position_embeddings is None:
-            logger.warning_once(
-                "The attention layers in this model are transitioning from computing the RoPE embeddings internally "
-                "through `rotary_pos_emb` (2D tensor of RoPE theta values), to using externally computed "
-                "`position_embeddings` (Tuple of tensors, containing cos and sin). In v4.54 `rotary_pos_emb` will be "
-                "removed and `position_embeddings` will be mandatory."
-            )
-            emb = torch.cat((rotary_pos_emb, rotary_pos_emb), dim=-1)
-            cos = emb.cos().float()
-            sin = emb.sin().float()
-        else:
-            cos, sin = position_embeddings
-            # Add this
-            cos = cos.to(torch.float)
-            sin = sin.to(torch.float)
-        q, k = apply_rotary_pos_emb_flashatt(q.unsqueeze(0), k.unsqueeze(0), cos, sin)
-        q = q.squeeze(0)
-        k = k.squeeze(0)
-
-        max_seqlen = (cu_seqlens[1:] - cu_seqlens[:-1]).max().item()
-        attn_output = flash_attn_varlen_func(q, k, v, cu_seqlens, cu_seqlens, max_seqlen, max_seqlen).reshape(
-            seq_length, -1
-        )
-        attn_output = self.proj(attn_output)
-        return attn_output
-
-Qwen2_5_VLVisionFlashAttention2.forward = custom_forward
-
-@dataclass
-class GRPOScriptArguments(ScriptArguments):
-    """
-    Script arguments for the GRPO training script.
-    """
-    data_file_paths: str = field(
-        default=None,
-        metadata={"help": "Paths to data files, separated by ':'"},
-    )
-    image_folders: str = field(
-        default=None,
-        metadata={"help": "Paths to image folders, separated by ':'"},
-    )
-    arrow_cache_dir: str = field(
-        default=None,
-        metadata={"help": "Path to arrow cache directory"},
-    )
-    val_split_ratio: float = field(
-        default=0.0,
-        metadata={"help": "Ratio of validation split, default 0.0"},
-    )
-    reward_funcs: list[str] = field(
-        default_factory=lambda: ["accuracy", "format"],
-        metadata={"help": "List of reward functions. Possible values: 'accuracy', 'format'"},
-    )
-    max_pixels: Optional[int] = field(
-        default=12845056,
-        metadata={"help": "Maximum number of pixels for the image (for QwenVL)"},
-    )
-    min_pixels: Optional[int] = field(
-        default=3136,
-        metadata={"help": "Minimum number of pixels for the image (for QwenVL)"},
-    )
-    max_anyres_num: Optional[int] = field(
-        default=12,
-        metadata={"help": "Maximum number of anyres blocks for the image (for InternVL)"},
-    )
-    reward_method: Optional[str] = field(
-        default=None,
-        metadata={
-            "help": "Choose reward method: 'default', 'mcp', ..."
-        },
-    )
-
-def extract_choice(text):
-    # 1. Clean and normalize text
-    text = text.upper()  # Convert to uppercase
-    text = re.sub(r'\s+', ' ', text)  # Normalize spaces
-
-    # 2. Choice should not have uppercase letters before or after
-    choices = re.findall(r'(?<![A-Z])([A-Z])(?=[\.\,\?\!\:\;]|$)', text)
-
-    if not choices:
-        return None
-
-    # 3. If only one choice, return it directly
-    if len(choices) == 1:
-        return choices[0]
-
-    # 4. If multiple choices, use heuristic rules
-    choice_scores = {choice: 0 for choice in choices}
-
-    # 4.1 Keywords around choices get points
-    keywords = [
-        '答案', '选择', '正确', '是', '对',
-        'answer', 'correct', 'choose', 'select', 'right',
-        '认为', '应该', '觉得', 'think', 'believe', 'should'
-    ]
-
-    # Get context for each choice (20 chars before and after)
-    for choice in choices:
-        pos = text.find(choice)
-        context = text[max(0, pos-20):min(len(text), pos+20)]
-
-        # Add points for keywords
-        for keyword in keywords:
-            if keyword.upper() in context:
-                choice_scores[choice] += 1
-
-        # Add points if choice is near the end (usually final answer)
-        if pos > len(text) * 0.7:  # In last 30% of text
-            choice_scores[choice] += 2
-
-        # Add points if followed by punctuation
-        if pos < len(text) - 1 and text[pos+1] in '。.!！,，':
-            choice_scores[choice] += 1
-
-    # Return highest scoring choice
-    return max(choice_scores.items(), key=lambda x: x[1])[0]
-
-def evaluate_answer_similarity(student_answer, ground_truth):
-    """Use llm to evaluate answer similarity."""
-    try:
-        response = client.chat.completions.create(
-            model="qwen2.5:7b",
-            messages=[
-                {
-                    "role": "user",
-                    "content": "You are a evaluation expert. First, analyze the student's response to identify and extract their final answer. Then, compare the extracted answer with the correct solution. Output ONLY '1.0' if the extracted answer matches the correct solution in meaning, or '0.0' if the student's response does not contain a clear or correct answer. No other output is allowed."
-                },
-                {
-                    "role": "user",
-                    "content": f"Student's response: {student_answer}\nCorrect solution: {ground_truth}\nOutput only 1.0 or 0.0:"
-                }
-            ],
-            temperature=0
-        )
-        result = response.choices[0].message.content.strip()
-        return float(result)
-    
-    except Exception as e:
-        print(f"Error in GPT evaluation: {e}")
-        # If API call fails, fall back to simple text matching
-        return 1.0 if student_answer ==ground_truth else 0.0
-
-def llm_reward(content, sol, **kwargs):
-    # Extract answer from content if it has think/answer tags
-    sol_match = re.search(r'<answer>(.*?)</answer>', sol)
-    ground_truth = sol_match.group(1).strip() if sol_match else sol.strip()
-    
-    # Extract answer from content if it has think/answer tags
-    content_matches = re.findall(r'<answer>(.*?)</answer>', content, re.DOTALL)
-    student_answer = content_matches[-1].strip() if content_matches else content.strip()
-    return evaluate_answer_similarity(student_answer, ground_truth)
-
-def mcq_reward(content, sol, **kwargs):
-    # For multiple choice, extract and compare choices
-    has_choices = extract_choice(sol)
-    correct_choice = has_choices.upper() if has_choices else sol.strip()
-
-    # Extract answer from content if it has think/answer tags
-    content_match = re.search(r'<answer>(.*?)</answer>', content, re.DOTALL)
-    student_answer = content_match.group(1).strip() if content_match else content.strip()
-    student_choice = extract_choice(student_answer)
-    if student_choice:
-        reward = 1.0 if student_choice == correct_choice else 0.0
-    else:
-        reward = 0.0
-
-    return reward
-
-
-def yes_no_reward(content, sol, **kwargs):
-    content = content.lower()
-    sol = sol.lower()
-
-    # Extract answer from solution if it has think/answer tags
-    sol_match = re.search(r'<answer>(.*?)</answer>', sol)
-    ground_truth = sol_match.group(1).strip() if sol_match else sol.strip()
-
-    # Extract answer from content if it has think/answer tags
-    content_match = re.search(r'<answer>(.*?)</answer>', content, re.DOTALL)
-    student_answer = content_match.group(1).strip() if content_match else content.strip()
-
-    ground_yes_no = re.search(r'(yes|no)', ground_truth)
-    ground_yes_no = ground_yes_no.group(1) if ground_yes_no else ''
-    student_yes_no = re.search(r'(yes|no)', student_answer)
-    student_yes_no = student_yes_no.group(1) if student_yes_no else ''
-
-    reward = 1.0 if ground_yes_no == student_yes_no else 0.0
-
-    return reward
-
-def calculate_map(pred_bbox_list, gt_bbox_list):
-    # Calculate mAP
-
-    # Initialize COCO object for ground truth
-    gt_json = {"annotations": [], "images": [], "categories": []}
-    gt_json["images"] = [{
-        "id": 0,
-        "width": 2048,
-        "height": 2048,
-        "file_name": "image_0.jpg"
-    }]
-
-    gt_json["categories"] = []
-
-    cats2id = {}
-    cat_count = 0
-    for idx, gt_bbox in enumerate(gt_bbox_list):
-        if gt_bbox["label"] not in cats2id:
-            cats2id[gt_bbox["label"]] = cat_count
-            gt_json["categories"].append({
-                "id": cat_count,
-                "name": gt_bbox["label"]
-            })
-            cat_count += 1
-        
-        gt_json["annotations"].append({
-            "id": idx+1,
-            "image_id": 0,
-            "category_id": cats2id[gt_bbox["label"]],
-            "bbox": [gt_bbox["bbox_2d"][0], gt_bbox["bbox_2d"][1], gt_bbox["bbox_2d"][2] - gt_bbox["bbox_2d"][0], gt_bbox["bbox_2d"][3] - gt_bbox["bbox_2d"][1]],
-            "area": (gt_bbox["bbox_2d"][2] - gt_bbox["bbox_2d"][0]) * (gt_bbox["bbox_2d"][3] - gt_bbox["bbox_2d"][1]),
-            "iscrowd": 0
-        })
-    coco_gt = COCO(gt_json)
-
-    dt_json = []
-    for idx, pred_bbox in enumerate(pred_bbox_list):
-        try:
-            dt_json.append({
-                "image_id": 0,
-                "category_id": cats2id[pred_bbox["label"]],
-                "bbox": [pred_bbox["bbox_2d"][0], pred_bbox["bbox_2d"][1], pred_bbox["bbox_2d"][2] - pred_bbox["bbox_2d"][0], pred_bbox["bbox_2d"][3] - pred_bbox["bbox_2d"][1]],
-                "score": 1.0,
-                "area": (pred_bbox["bbox_2d"][2] - pred_bbox["bbox_2d"][0]) * (pred_bbox["bbox_2d"][3] - pred_bbox["bbox_2d"][1])
-            })
-        except:
-            pass
-    
-    if len(dt_json) == 0:
-        return 0.0
-    
-    coco_dt = coco_gt.loadRes(dt_json)
-    coco_eval = COCOeval(coco_gt, coco_dt, "bbox")
-
-    coco_eval.evaluate()
-    coco_eval.accumulate()
-    coco_eval.summarize()
-    return coco_eval.stats[1]
-
-def map_reward(content, sol, **kwargs):
-    """
-    Calculate mean average precision (mAP) reward between predicted and ground truth bounding boxes
-    
-    Args:
-        content: String containing predicted bounding boxes in JSON format
-        sol: String containing ground truth bounding boxes in JSON format
-        
-    Returns:
-        float: mAP reward score between 0 and 1
-    """
-    # Extract JSON content between ```json tags
-    pattern = r'```json(.*?)```'
-    json_match = re.search(pattern, sol, re.DOTALL)
-    bbox_json = json_match.group(1).strip() if json_match else None
-
-    # Parse ground truth JSON to get bbox list
-    gt_bbox_list = []
-    if bbox_json:
-        bbox_data = json.loads(bbox_json)
-        gt_bbox_list = [item for item in bbox_data]
-    
-    # Parse predicted JSON to get bbox list
-    pred_bbox_list = []
-    json_match = re.search(pattern, content, re.DOTALL)
-    if json_match:
-        try:
-            bbox_data = json.loads(json_match.group(1).strip())
-            pred_bbox_list = [item for item in bbox_data]
-        except:
-            # Return empty list if JSON parsing fails
-            pred_bbox_list = []
-
-    # Calculate mAP if both prediction and ground truth exist
-    if len(pred_bbox_list) > 0 and len(gt_bbox_list) > 0:
-        bbox_reward = calculate_map(pred_bbox_list, gt_bbox_list)
-    else:
-        bbox_reward = 0.0
-    
-    return bbox_reward
-
-
-def numeric_reward(content, sol, **kwargs):
-    content = clean_text(content)
-    sol = clean_text(sol)
-    try:
-        content, sol = float(content), float(sol)
-        return 1.0 if content == sol else 0.0
-    except:
-        return None
-def math_reward(content, sol, **kwargs):
-    content = clean_text(content)
-    sol = clean_text(sol)
-    return compute_score(content, sol)
-def clean_text(text, exclue_chars=['\n', '\r']):
-    # Extract content between <answer> and </answer> if present
-    answer_matches = re.findall(r'<answer>(.*?)</answer>', text, re.DOTALL)
-    if answer_matches:
-        # Use the last match
-        text = answer_matches[-1]
-    
-    for char in exclue_chars:
-        if char in ['\n', '\r']:
-            # If there is a space before the newline, remove the newline
-            text = re.sub(r'(?<=\s)' + re.escape(char), '', text)
-            # If there is no space before the newline, replace it with a space
-            text = re.sub(r'(?<!\s)' + re.escape(char), ' ', text)
-        else:
-            text = text.replace(char, ' ')
-    
-    # Remove leading and trailing spaces and convert to lowercase
-    return text.strip().rstrip('.').lower()
-
-def default_accuracy_reward(content, sol, **kwargs):
-    reward = 0.0
-        # Extract answer from solution if it has think/answer tags
-    sol_match = re.search(r'<answer>(.*?)</answer>', sol)
-    ground_truth = sol_match.group(1).strip() if sol_match else sol.strip()
-    
-    # Extract answer from content if it has think/answer tags
-    content_matches = re.findall(r'<answer>(.*?)</answer>', content, re.DOTALL)
-    student_answer = content_matches[-1].strip() if content_matches else content.strip()
-    
-    # Try symbolic verification first for numeric answers
-    try:
-        answer = parse(student_answer)
-        if float(verify(answer, parse(ground_truth))) > 0:
-            reward = 1.0
-    except Exception:
-        pass  # Continue to next verification method if this fails
-
-    # If symbolic verification failed, try string matching or fuzzy matching
-    if reward == 0.0:
-        try: 
-            # Check if ground truth contains numbers
-            has_numbers = bool(re.search(r'\d', ground_truth))
-            # Check if it's a multiple choice question
-            has_choices = extract_choice(ground_truth)
-            
-            if has_numbers:
-                # For numeric answers, use exact matching
-                reward = numeric_reward(student_answer, ground_truth)
-                if reward is None:
-                    reward = ratio(clean_text(student_answer), clean_text(ground_truth))
-            elif has_choices:
-                # For multiple choice, extract and compare choices
-                correct_choice = has_choices.upper()
-                student_choice = extract_choice(student_answer)
-                if student_choice:
-                    reward = 1.0 if student_choice == correct_choice else 0.0
-            else:
-                # For text answers, use fuzzy matching
-                reward = ratio(clean_text(student_answer), clean_text(ground_truth))
-        except Exception:
-            pass  # Keep reward as 0.0 if all methods fail
-
-    return reward
-
-def accuracy_reward(completions, solution, **kwargs):
-    """Reward function that checks if the completion is correct using symbolic verification, exact string matching, or fuzzy matching."""
-    contents = [completion[0]["content"] for completion in completions]
-    rewards = []
-    for content, sol, accu_reward_method in zip(contents, solution, kwargs.get("accu_reward_method")):
-        # if accu_reward_method is defined, use the corresponding reward function, otherwise use the default reward function
-        if accu_reward_method == "mcq":
-            reward = mcq_reward(content, sol)
-        elif accu_reward_method == 'yes_no':
-            reward = yes_no_reward(content, sol)
-        elif accu_reward_method == 'llm':
-            reward = llm_reward(content, sol)
-        elif accu_reward_method == 'map':
-            reward = map_reward(content, sol)
-        elif accu_reward_method == 'math':
-            reward = math_reward(content, sol)
-        else:
-            reward = default_accuracy_reward(content, sol)  
-        rewards.append(reward)
-        
-        if os.getenv("DEBUG_MODE") == "true":
-            log_path = os.getenv("LOG_PATH")
-            current_time = datetime.now().strftime("%d-%H-%M-%S-%f")
-            image_path = kwargs.get("image_path")[0] if "image_path" in kwargs else None
-            problem = kwargs.get("problem")[0]
-            if reward <= 1.0:  # this condition can be changed for debug
-                with open(log_path, "a", encoding='utf-8') as f:
-                    f.write(f"------------- {current_time} Accuracy reward: {reward} -------------\n")
-                    f.write(f"accu_reward_method: {accu_reward_method}\n")
-                    f.write(f"image_path: {image_path}\n")
-                    f.write(f"problem: {problem}\n")
-                    f.write(f"Content: {content}\n")
-                    f.write(f"Solution: {sol}\n")     
-
-        
-    return rewards
-
-
-def format_reward(completions, **kwargs):
-    """Reward function that checks if the completion has a specific format."""
-    pattern = r"<think>.*?</think>\s*<answer>.*?</answer>"
-    completion_contents = [completion[0]["content"] for completion in completions]
-    matches = [re.fullmatch(pattern, content, re.DOTALL) for content in completion_contents]
-
-    current_time = datetime.now().strftime("%d-%H-%M-%S-%f")
-    if os.getenv("DEBUG_MODE") == "true":
-        log_path = os.getenv("LOG_PATH")
-        with open(log_path.replace(".txt", "_format.txt"), "a", encoding='utf-8') as f:
-            f.write(f"------------- {current_time} Format reward -------------\n")
-            for content, match in zip(completion_contents, matches):
-                f.write(f"Content: {content}\n")
-                f.write(f"Has format: {bool(match)}\n")
-
-    return [1.0 if match else 0.0 for match in matches]
-
-
-reward_funcs_registry = {
-    "accuracy": accuracy_reward,
-    "format": format_reward,
-}
-
-@dataclass
-class GRPOModelConfig(ModelConfig):
-    freeze_vision_modules: bool = False
-
-SYSTEM_PROMPT = (
-    "A conversation between User and Assistant. The user asks a question, and the Assistant solves it. The assistant "
-    "first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning "
-    "process and answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., "
-    "<think> reasoning process here </think><answer> answer here </answer>"
-)
-
-
-def get_vlm_module(model_name_or_path):
-    if "qwen" in model_name_or_path.lower():
-        return Qwen2VLModule
-    elif "internvl" in model_name_or_path.lower():
-        return InvernVLModule
-    else:
-        raise ValueError(f"Unsupported model: {model_name_or_path}")
-
-def main(script_args, training_args, model_args):
-    # Load the VLM module
-    vlm_module_cls = get_vlm_module(model_args.model_name_or_path)
-    print("using vlm module:", vlm_module_cls.__name__)
-    question_prompt = vlm_module_cls.get_question_template(task_type="default")
-
-    # Get reward functions
-    reward_funcs = [reward_funcs_registry[func] for func in script_args.reward_funcs]
-    print("reward_funcs:", reward_funcs)
-
-    # Load the JSONL datasets
-    import json
-    from datasets import Dataset
-    
-    data_files = script_args.data_file_paths.split(":")
-    image_folders = script_args.image_folders.split(":")
-    
-    if len(data_files) != len(image_folders):
-        raise ValueError("Number of data files must match number of image folders")
-    
-    if script_args.reward_method is None:
-        accu_reward_methods = ["default"] * len(data_files)
-    else:
-        accu_reward_methods = script_args.reward_method.split(":")
-        assert len(accu_reward_methods) == len(data_files), f"Number of reward methods must match number of data files: {len(accu_reward_methods)} != {len(data_files)}"
-
-    
-    if len(data_files) != len(image_folders):
-        raise ValueError("Number of data files must match number of image folders")
-    
-    all_data = []
-    for data_file, image_folder, accu_reward_method in zip(data_files, image_folders, accu_reward_methods):
-        with open(data_file, 'r') as f:
-            for line in f:
-                item = json.loads(line)
-                if 'image' in item:
-                    if isinstance(item['image'], str):
-                        # Store image path instead of loading the image
-                        item['image_path'] = [os.path.join(image_folder, item['image'])]
-                        del item['image'] # remove the image column so that it can be loaded later
-                    elif isinstance(item['image'], list):
-                        # if the image is a list, then it is a list of images (for multi-image input)
-                        item['image_path'] = [os.path.join(image_folder, image) for image in item['image']]
-                        del item['image'] # remove the image column so that it can be loaded later
-                    else:
-                        raise ValueError(f"Unsupported image type: {type(item['image'])}")
-                # Remove immediate image loading
-                item['problem'] = item['conversations'][0]['value'].replace('<image>', '')
-                
-                # Handle solution that could be a float or string
-                solution_value = item['conversations'][1]['value']
-                if isinstance(solution_value, str):
-                    item['solution'] = solution_value.replace('<answer>', '').replace('</answer>', '').strip()
-                else:
-                    # If it's a float or other non-string type, keep it as is
-                    item['solution'] = str(solution_value)
-                
-                del item['conversations']
-                item['accu_reward_method'] = item.get('accu_reward_method', accu_reward_method) # if accu_reward_method is in the data jsonl, use the value in the data jsonl, otherwise use the defined value
-                all_data.append(item)
-
-    dataset = Dataset.from_list(all_data)
-
-    def make_conversation_from_jsonl(example):
-        if 'image_path' in example and example['image_path'] is not None:
-            # Don't load image here, just store the path
-            return {
-                'image_path': [p for p in example['image_path']],  # Store path instead of loaded image
-                'problem': example['problem'],
-                'solution': f"<answer> {example['solution']} </answer>",
-                'accu_reward_method': example['accu_reward_method'],
-                'prompt': [{
-                    'role': 'user',
-                    'content': [
-                        *({'type': 'image', 'text': None} for _ in range(len(example['image_path']))),
-                        {'type': 'text', 'text': question_prompt.format(Question=example['problem'])}
-                    ]
-                }]
-            }
-        else:
-            return {
-                'problem': example['problem'],
-                'solution': f"<answer> {example['solution']} </answer>",
-                'accu_reward_method': example['accu_reward_method'],
-                'prompt': [{
-                    'role': 'user',
-                    'content': [
-                        {'type': 'text', 'text': question_prompt.format(Question=example['problem'])}
-                    ]
-                }]
-            }
-
-    # Map the conversations
-    dataset = dataset.map(make_conversation_from_jsonl, num_proc=8)
-
-    # Split dataset for validation if requested
-    splits = {'train': dataset}
-    if script_args.val_split_ratio > 0:
-        train_val_split = dataset.train_test_split(
-            test_size=script_args.val_split_ratio
-        )
-        splits['train'] = train_val_split['train']
-        splits['validation'] = train_val_split['test']
-
-    # Select trainer class based on vlm_trainer argument
-    trainer_cls = VLMGRPOTrainer
-    print("using trainer:", trainer_cls.__name__)
-
-    # Initialize the GRPO trainer
-    trainer = trainer_cls(
-        model=model_args.model_name_or_path,
-        reward_funcs=reward_funcs,
-        args=training_args,
-        vlm_module=vlm_module_cls(),
-        train_dataset=splits['train'],
-        eval_dataset=splits.get('validation') if training_args.eval_strategy != "no" else None,
-        peft_config=get_peft_config(model_args),
-        freeze_vision_modules=model_args.freeze_vision_modules,
-        attn_implementation=model_args.attn_implementation,
-        max_pixels=script_args.max_pixels,
-        min_pixels=script_args.min_pixels,
-    )
-
-    # Train and push the model to the Hub
-    if list(pathlib.Path(training_args.output_dir).glob("checkpoint-*")):
-        trainer.train(resume_from_checkpoint=True)
-    else:
-        trainer.train()
-
-    # Save and push to hub
-    trainer.save_model(training_args.output_dir)
-    if training_args.push_to_hub:
-        trainer.push_to_hub()
-
-
-if __name__ == "__main__":
-    parser = TrlParser((GRPOScriptArguments, GRPOConfig, GRPOModelConfig))
-    script_args, training_args, model_args = parser.parse_args_and_config()
-    main(script_args, training_args, model_args)

open-r1-multimodal/src/open_r1/grpo_rec.py

@@ -1,291 +0,0 @@
-# Copyright 2025 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# import debugpy
-# try:
-#     # 5678 is the default attach port in the VS Code debug configurations. Unless a host and port are specified, host defaults to 127.0.0.1
-#     debugpy.listen(("localhost", 9501))
-#     print("Waiting for debugger attach")
-#     debugpy.wait_for_client()
-# except Exception as e:
-#     pass
-
-import os
-import re
-from datetime import datetime
-from dataclasses import dataclass, field
-from typing import Optional
-
-from PIL import Image
-from torch.utils.data import Dataset
-from transformers import Qwen2VLForConditionalGeneration
-
-from math_verify import parse, verify
-from open_r1.trainer import VLMGRPOTrainer, GRPOConfig
-from open_r1.vlm_modules import *
-from trl import ModelConfig, ScriptArguments, TrlParser, get_peft_config
-from transformers import TrainingArguments
-import yaml
-import json
-import random
-import math
-
-# ----------------------- Fix the flash attention bug in the current version of transformers -----------------------
-from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import Qwen2_5_VLVisionFlashAttention2, apply_rotary_pos_emb_flashatt, flash_attn_varlen_func
-import torch
-from typing import Tuple
-def custom_forward(
-        self,
-        hidden_states: torch.Tensor,
-        cu_seqlens: torch.Tensor,
-        rotary_pos_emb: Optional[torch.Tensor] = None,
-        position_embeddings: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
-    ) -> torch.Tensor:
-        seq_length = hidden_states.shape[0]
-        q, k, v = self.qkv(hidden_states).reshape(seq_length, 3, self.num_heads, -1).permute(1, 0, 2, 3).unbind(0)
-        # print(111, 222, 333, 444, 555, 666, 777, 888, 999)
-        if position_embeddings is None:
-            logger.warning_once(
-                "The attention layers in this model are transitioning from computing the RoPE embeddings internally "
-                "through `rotary_pos_emb` (2D tensor of RoPE theta values), to using externally computed "
-                "`position_embeddings` (Tuple of tensors, containing cos and sin). In v4.54 `rotary_pos_emb` will be "
-                "removed and `position_embeddings` will be mandatory."
-            )
-            emb = torch.cat((rotary_pos_emb, rotary_pos_emb), dim=-1)
-            cos = emb.cos().float()
-            sin = emb.sin().float()
-        else:
-            cos, sin = position_embeddings
-            # Add this
-            cos = cos.to(torch.float)
-            sin = sin.to(torch.float)
-        q, k = apply_rotary_pos_emb_flashatt(q.unsqueeze(0), k.unsqueeze(0), cos, sin)
-        q = q.squeeze(0)
-        k = k.squeeze(0)
-
-        max_seqlen = (cu_seqlens[1:] - cu_seqlens[:-1]).max().item()
-        attn_output = flash_attn_varlen_func(q, k, v, cu_seqlens, cu_seqlens, max_seqlen, max_seqlen).reshape(
-            seq_length, -1
-        )
-        attn_output = self.proj(attn_output)
-        return attn_output
-
-Qwen2_5_VLVisionFlashAttention2.forward = custom_forward
-
-
-# ----------------------- Main Script -----------------------
-@dataclass
-class GRPOScriptArguments(ScriptArguments):
-    """
-    Script arguments for the GRPO training script.
-
-    Args:
-        reward_funcs (`list[str]`):
-            List of reward functions. Possible values: 'accuracy', 'format'.
-    """
-
-    reward_funcs: list[str] = field(
-        default_factory=lambda: ["accuracy", "format"],
-        metadata={"help": "List of reward functions. Possible values: 'accuracy', 'format'"},
-    )
-    max_pixels: Optional[int] = field(
-        default=3512320,
-        metadata={"help": "Maximum number of pixels for the image (for QwenVL)"},
-    )
-    min_pixels: Optional[int] = field(
-        default=3136,
-        metadata={"help": "Minimum number of pixels for the image (for QwenVL)"},
-    )
-    max_anyres_num: Optional[int] = field(
-        default=12,
-        metadata={"help": "Maximum number of anyres blocks for the image (for InternVL)"},
-    )
-    image_root: Optional[str] = field(
-        default=None,
-        metadata={"help": "Root directory of the image"},
-    )
-
-@dataclass
-class GRPOModelConfig(ModelConfig):
-    freeze_vision_modules: bool = False
-
-
-SYSTEM_PROMPT = (
-    "A conversation between User and Assistant. The user asks a question, and the Assistant solves it. The assistant "
-    "first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning "
-    "process and answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., "
-    "<think> reasoning process here </think><answer> answer here </answer>"
-)
-
-class LazySupervisedDataset(Dataset):
-    def __init__(self, data_path: str, script_args: GRPOScriptArguments, question_template: str):
-        super(LazySupervisedDataset, self).__init__()
-        self.script_args = script_args
-        self.list_data_dict = []
-        self.question_template = question_template
-
-        if data_path.endswith(".yaml"):
-            with open(data_path, "r") as file:
-                yaml_data = yaml.safe_load(file)
-                datasets = yaml_data.get("datasets")
-                # file should be in the format of:
-                # datasets:
-                #   - json_path: xxxx1.json
-                #     sampling_strategy: first:1000
-                #   - json_path: xxxx2.json
-                #     sampling_strategy: end:3000
-                #   - json_path: xxxx3.json
-                #     sampling_strategy: random:999
-
-                for data in datasets:
-                    json_path = data.get("json_path")
-                    sampling_strategy = data.get("sampling_strategy", "all")
-                    sampling_number = None
-
-                    if json_path.endswith(".jsonl"):
-                        cur_data_dict = []
-                        with open(json_path, "r") as json_file:
-                            for line in json_file:
-                                cur_data_dict.append(json.loads(line.strip()))
-                    elif json_path.endswith(".json"):
-                        with open(json_path, "r") as json_file:
-                            cur_data_dict = json.load(json_file)
-                    else:
-                        raise ValueError(f"Unsupported file type: {json_path}")
-
-                    if ":" in sampling_strategy:
-                        sampling_strategy, sampling_number = sampling_strategy.split(":")
-                        if "%" in sampling_number:
-                            sampling_number = math.ceil(int(sampling_number.split("%")[0]) * len(cur_data_dict) / 100)
-                        else:
-                            sampling_number = int(sampling_number)
-
-                    # Apply the sampling strategy
-                    if sampling_strategy == "first" and sampling_number is not None:
-                        cur_data_dict = cur_data_dict[:sampling_number]
-                    elif sampling_strategy == "end" and sampling_number is not None:
-                        cur_data_dict = cur_data_dict[-sampling_number:]
-                    elif sampling_strategy == "random" and sampling_number is not None:
-                        random.shuffle(cur_data_dict)
-                        cur_data_dict = cur_data_dict[:sampling_number]
-                    print(f"Loaded {len(cur_data_dict)} samples from {json_path}")
-                    self.list_data_dict.extend(cur_data_dict)
-        else:
-            raise ValueError(f"Unsupported file type: {data_path}")
-
-    def __len__(self):
-        return len(self.list_data_dict)
-
-    def __getitem__(self, i):
-        # Format into conversation
-        def make_conversation(example):
-            return {
-                "prompt": [
-                    {"role": "system", "content": SYSTEM_PROMPT},
-                    {"role": "user", "content": example["problem"]},
-                ],
-            }
-        QUESTION_TEMPLATE = self.question_template
-        def make_conversation_image(example):
-            return {
-                "prompt": [
-                    # {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]},
-                    {
-                        "role": "user",
-                        "content": [
-                            {"type": "image"},
-                            {"type": "text", "text": QUESTION_TEMPLATE.format(Question=example["problem"])},
-                        ],
-                    },
-                ],
-            }
-
-        example = self.list_data_dict[i]
-        image_root = self.script_args.image_root
-        if 'image' in example:
-            image_path = os.path.join(image_root, example['image'])
-            # In case the image is not found
-            while not os.path.exists(image_path):
-                print(f"Warning: Image {image_path} not found, randomly selecting another image")
-                new_index = random.randint(0, len(self.list_data_dict)-1)
-                example = self.list_data_dict[new_index]
-                image_path = os.path.join(image_root, example['image'])
-            image = Image.open(image_path).convert("RGB")
-        else:
-            image = None
-        
-
-        return {
-            'image': image,
-            'problem': example['problem'],
-            'solution': example['solution'],
-            'prompt': make_conversation_image(example)['prompt'] if 'image' in example else make_conversation(example)['prompt'],
-        }
-
-
-def get_vlm_module(model_name_or_path):
-    if "qwen" in model_name_or_path.lower():
-        return Qwen2VLModule
-    elif "internvl" in model_name_or_path.lower():
-        return InvernVLModule
-    else:
-        raise ValueError(f"Unsupported model: {model_name_or_path}")
-
-def main(script_args, training_args, model_args):
-    # Load the VLM module
-    vlm_module_cls = get_vlm_module(model_args.model_name_or_path)
-    print("using vlm module:", vlm_module_cls.__name__)
-
-    # Load the reward functions
-    reward_funcs_registry = {
-        "accuracy": vlm_module_cls.iou_reward,
-        "format": vlm_module_cls.format_reward_rec,
-    }
-    reward_funcs = [reward_funcs_registry[func] for func in script_args.reward_funcs]
-    print("reward_funcs:", reward_funcs)
-
-    # Load the dataset
-    dataset = LazySupervisedDataset(script_args.dataset_name, script_args, question_template=vlm_module_cls.get_question_template(task_type="rec"))
-
-    trainer_cls = VLMGRPOTrainer
-    # Initialize the GRPO trainer
-    trainer = trainer_cls(
-        model=model_args.model_name_or_path,
-        reward_funcs=reward_funcs,
-        args=training_args,
-        vlm_module=vlm_module_cls(),
-        train_dataset=dataset,
-        eval_dataset=None,
-        peft_config=get_peft_config(model_args),
-        freeze_vision_modules=model_args.freeze_vision_modules,
-        attn_implementation=model_args.attn_implementation,
-        max_pixels=script_args.max_pixels,
-        min_pixels=script_args.min_pixels,
-        max_anyres_num=script_args.max_anyres_num,
-        torch_dtype=model_args.torch_dtype,
-    )
-
-    # Train and push the model to the Hub
-    trainer.train()
-
-    # Save and push to hub
-    trainer.save_model(training_args.output_dir)
-    if training_args.push_to_hub:
-        trainer.push_to_hub(dataset_name=script_args.dataset_name)
-
-
-if __name__ == "__main__":
-    parser = TrlParser((GRPOScriptArguments, GRPOConfig, GRPOModelConfig))
-    script_args, training_args, model_args = parser.parse_args_and_config()
-    main(script_args, training_args, model_args)

open-r1-multimodal/src/open_r1/sft.py

@@ -1,346 +0,0 @@
-# Copyright 2025 The HuggingFace Team. All rights reserved.
-#
-# 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.
-
-"""
-Supervised fine-tuning script for decoder language models.
-
-Usage:
-
-# One 1 node of 8 x H100s
-accelerate launch --config_file=configs/zero3.yaml src/open_r1/sft.py \
-    --model_name_or_path Qwen/Qwen2.5-1.5B-Instruct \
-    --dataset_name HuggingFaceH4/Bespoke-Stratos-17k \
-    --learning_rate 2.0e-5 \
-    --num_train_epochs 1 \
-    --packing \
-    --max_seq_length 4096 \
-    --per_device_train_batch_size 4 \
-    --gradient_accumulation_steps 4 \
-    --gradient_checkpointing \
-    --bf16 \
-    --logging_steps 5 \
-    --eval_strategy steps \
-    --eval_steps 100 \
-    --output_dir data/Qwen2.5-1.5B-Open-R1-Distill
-"""
-
-import logging
-import os
-import sys
-
-import datasets
-import torch
-from torch.utils.data import Dataset
-import transformers
-from datasets import load_dataset
-from transformers import AutoTokenizer, set_seed, AutoProcessor
-from transformers.trainer_utils import get_last_checkpoint
-from open_r1.configs import SFTConfig
-from open_r1.utils.callbacks import get_callbacks
-import yaml
-import json
-import math
-import random
-from PIL import Image
-
-from trl import (
-    ModelConfig,
-    ScriptArguments,
-    SFTTrainer,
-    TrlParser,
-    get_kbit_device_map,
-    get_peft_config,
-    get_quantization_config,
-)
-from dataclasses import field
-from qwen_vl_utils import process_vision_info
-logger = logging.getLogger(__name__)
-from dataclasses import dataclass
-
-@dataclass
-class SFTScriptArguments(ScriptArguments):
-    image_root: str = field(default=None, metadata={"help": "The root directory of the image."})
-
-
-processor = None
-
-class LazySupervisedDataset(Dataset):
-    def __init__(self, data_path: str, script_args: ScriptArguments):
-        super(LazySupervisedDataset, self).__init__()
-        self.script_args = script_args
-        self.list_data_dict = []
-
-        if data_path.endswith(".yaml"):
-            with open(data_path, "r") as file:
-                yaml_data = yaml.safe_load(file)
-                datasets = yaml_data.get("datasets")
-                # file should be in the format of:
-                # datasets:
-                #   - json_path: xxxx1.json
-                #     sampling_strategy: first:1000
-                #   - json_path: xxxx2.json
-                #     sampling_strategy: end:3000
-                #   - json_path: xxxx3.json
-                #     sampling_strategy: random:999
-
-                for data in datasets:
-                    json_path = data.get("json_path")
-                    sampling_strategy = data.get("sampling_strategy", "all")
-                    sampling_number = None
-
-                    if json_path.endswith(".jsonl"):
-                        cur_data_dict = []
-                        with open(json_path, "r") as json_file:
-                            for line in json_file:
-                                cur_data_dict.append(json.loads(line.strip()))
-                    elif json_path.endswith(".json"):
-                        with open(json_path, "r") as json_file:
-                            cur_data_dict = json.load(json_file)
-                    else:
-                        raise ValueError(f"Unsupported file type: {json_path}")
-
-                    if ":" in sampling_strategy:
-                        sampling_strategy, sampling_number = sampling_strategy.split(":")
-                        if "%" in sampling_number:
-                            sampling_number = math.ceil(int(sampling_number.split("%")[0]) * len(cur_data_dict) / 100)
-                        else:
-                            sampling_number = int(sampling_number)
-
-                    # Apply the sampling strategy
-                    if sampling_strategy == "first" and sampling_number is not None:
-                        cur_data_dict = cur_data_dict[:sampling_number]
-                    elif sampling_strategy == "end" and sampling_number is not None:
-                        cur_data_dict = cur_data_dict[-sampling_number:]
-                    elif sampling_strategy == "random" and sampling_number is not None:
-                        random.shuffle(cur_data_dict)
-                        cur_data_dict = cur_data_dict[:sampling_number]
-                    print(f"Loaded {len(cur_data_dict)} samples from {json_path}")
-                    self.list_data_dict.extend(cur_data_dict)
-        else:
-            raise ValueError(f"Unsupported file type: {data_path}")
-
-    def __len__(self):
-        return len(self.list_data_dict)
-
-    def __getitem__(self, i):
-        # Format into conversation
-        def make_conversation_image(example):
-            image_root = self.script_args.image_root
-            # print(111, image_root)
-            # print(222, example['image'])
-            image_path = os.path.join(image_root, example['image'])
-            x1, y1, x2, y2 = example["solution"]
-            normal_caption = example["normal_caption"]
-            return  [
-                    {
-                        "role": "user",
-                        "content": [
-                            {"type": "image", "image": f"file://{image_path}"},
-                            {"type": "text", "text": example["problem"]},
-                        ],
-                    },
-                    {
-                        "role": "assistant",
-                        "content": f'```json\n[\n\t{{"bbox_2d": [{int(x1)}, {int(y1)}, {int(x2)}, {int(y2)}], "label": "{normal_caption}"}}\n]\n```',
-                    }
-                ]
-
-        example = self.list_data_dict[i]
-        example["messages"] = make_conversation_image(example)
-        return example
-
-
-
-def collate_fn(examples):
-    texts = [
-        processor.apply_chat_template(example["messages"], tokenize=False, add_generation_prompt=True)
-        for example in examples
-    ]
-    image_inputs = []
-    for example in examples:
-        imgs, vids = process_vision_info(example["messages"])
-        image_inputs.append(imgs)
-    batch = processor(
-        text=texts,
-        images=image_inputs,
-        return_tensors="pt",
-        padding=True,
-    )
-    labels = batch["input_ids"].clone()
-    labels[labels == processor.tokenizer.pad_token_id] = -100
-    image_token_id = processor.tokenizer.convert_tokens_to_ids(processor.image_token)
-    labels[labels == image_token_id] = -100
-    batch["labels"] = labels
-
-    return batch
-
-
-def main(script_args, training_args, model_args):
-    # Set seed for reproducibility
-    set_seed(training_args.seed)
-
-    ###############
-    # Setup logging
-    ###############
-    logging.basicConfig(
-        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
-        handlers=[logging.StreamHandler(sys.stdout)],
-    )
-    log_level = training_args.get_process_log_level()
-    logger.setLevel(log_level)
-    datasets.utils.logging.set_verbosity(log_level)
-    transformers.utils.logging.set_verbosity(log_level)
-    transformers.utils.logging.enable_default_handler()
-    transformers.utils.logging.enable_explicit_format()
-
-    # Log on each process a small summary
-    logger.warning(
-        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
-        + f" distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
-    )
-    logger.info(f"Model parameters {model_args}")
-    logger.info(f"Script parameters {script_args}")
-    logger.info(f"Data parameters {training_args}")
-
-    # Check for last checkpoint
-    last_checkpoint = None
-    if os.path.isdir(training_args.output_dir):
-        last_checkpoint = get_last_checkpoint(training_args.output_dir)
-    if last_checkpoint is not None and training_args.resume_from_checkpoint is None:
-        logger.info(f"Checkpoint detected, resuming training at {last_checkpoint=}.")
-
-    ################
-    # Load datasets
-    ################
-
-    dataset = LazySupervisedDataset(script_args.dataset_name, script_args)
-
-    ################
-    # Load tokenizer
-    ################
-    global processor
-    if "vl" in model_args.model_name_or_path.lower():
-        processor = AutoProcessor.from_pretrained(
-            model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code
-        )
-        logger.info("Using AutoProcessor for vision-language model.")
-    else:
-        processor = AutoTokenizer.from_pretrained(
-            model_args.model_name_or_path, trust_remote_code=model_args.trust_remote_code, use_fast=True
-        )
-        logger.info("Using AutoTokenizer for text-only model.")
-    if hasattr(processor, "pad_token") and processor.pad_token is None:
-        processor.pad_token = processor.eos_token
-    elif hasattr(processor.tokenizer, "pad_token") and processor.tokenizer.pad_token is None:
-        processor.tokenizer.pad_token = processor.tokenizer.eos_token
-    
-    ###################
-    # Model init kwargs
-    ###################
-    logger.info("*** Initializing model kwargs ***")
-    torch_dtype = (
-        model_args.torch_dtype if model_args.torch_dtype in ["auto", None] else getattr(torch, model_args.torch_dtype)
-    )
-    quantization_config = get_quantization_config(model_args)
-    model_kwargs = dict(
-        revision=model_args.model_revision,
-        trust_remote_code=model_args.trust_remote_code,
-        attn_implementation=model_args.attn_implementation,
-        torch_dtype=torch_dtype,
-        use_cache=False if training_args.gradient_checkpointing else True,
-        device_map=get_kbit_device_map() if quantization_config is not None else None,
-        quantization_config=quantization_config,
-    )
-    # training_args.model_init_kwargs = model_kwargs
-    from transformers import Qwen2VLForConditionalGeneration, Qwen2_5_VLForConditionalGeneration
-    if "Qwen2-VL" in model_args.model_name_or_path:
-        model = Qwen2VLForConditionalGeneration.from_pretrained(
-            model_args.model_name_or_path, **model_kwargs
-        )
-    elif "Qwen2.5-VL" in model_args.model_name_or_path:
-        model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
-            model_args.model_name_or_path, **model_kwargs
-        )
-    else:
-        raise ValueError(f"Unsupported model: {model_args.model_name_or_path}")
-    ############################
-    # Initialize the SFT Trainer
-    ############################
-    training_args.dataset_kwargs = {
-        "skip_prepare_dataset": True,
-    }
-    training_args.remove_unused_columns = False
-    trainer = SFTTrainer(
-        model=model,
-        args=training_args,
-        train_dataset=dataset,
-        eval_dataset=None,
-        processing_class=processor.tokenizer,
-        data_collator=collate_fn,
-        peft_config=get_peft_config(model_args),
-        callbacks=get_callbacks(training_args, model_args),
-    )
-
-    ###############
-    # Training loop
-    ###############
-    logger.info("*** Train ***")
-    checkpoint = None
-    if training_args.resume_from_checkpoint is not None:
-        checkpoint = training_args.resume_from_checkpoint
-    elif last_checkpoint is not None:
-        checkpoint = last_checkpoint
-    train_result = trainer.train(resume_from_checkpoint=checkpoint)
-    metrics = train_result.metrics
-    metrics["train_samples"] = len(dataset[script_args.dataset_train_split])
-    trainer.log_metrics("train", metrics)
-    trainer.save_metrics("train", metrics)
-    trainer.save_state()
-
-    ##################################
-    # Save model and create model card
-    ##################################
-    logger.info("*** Save model ***")
-    trainer.save_model(training_args.output_dir)
-    logger.info(f"Model saved to {training_args.output_dir}")
-
-    # Save everything else on main process
-    kwargs = {
-        "finetuned_from": model_args.model_name_or_path,
-        "dataset": list(script_args.dataset_name),
-        "dataset_tags": list(script_args.dataset_name),
-        "tags": ["open-r1"],
-    }
-    if trainer.accelerator.is_main_process:
-        trainer.create_model_card(**kwargs)
-        # Restore k,v cache for fast inference
-        trainer.model.config.use_cache = True
-        trainer.model.config.save_pretrained(training_args.output_dir)
-    #############
-    # push to hub
-    #############
-
-    if training_args.push_to_hub:
-        logger.info("Pushing to hub...")
-        trainer.push_to_hub(**kwargs)
-
-
-
-
-if __name__ == "__main__":
-    parser = TrlParser((SFTScriptArguments, SFTConfig, ModelConfig))
-    script_args, training_args, model_args = parser.parse_args_and_config()
-    print(script_args)
-    main(script_args, training_args, model_args)

open-r1-multimodal/src/open_r1/trainer/__init__.py

@@ -1,5 +0,0 @@
-from .grpo_trainer import VLMGRPOTrainer
-from .grpo_config import GRPOConfig
-from .vllm_grpo_trainer import Qwen2VLGRPOVLLMTrainer
-from .qwen_grpo_trainer import Qwen2VLGRPOTrainer
-__all__ = ["VLMGRPOTrainer",'Qwen2VLGRPOVLLMTrainer', "Qwen2VLGRPOTrainer"]