Initial mirror of VectorSpaceLab/EditScore@4609c5d

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/figure_edit_results.png filter=lfs diff=lfs merge=lfs -text
+assets/logo.png filter=lfs diff=lfs merge=lfs -text
+assets/table_editscore_qwen3_vl.png filter=lfs diff=lfs merge=lfs -text
+assets/table_reward_model_results.png filter=lfs diff=lfs merge=lfs -text
+example_images/input.png filter=lfs diff=lfs merge=lfs -text
+example_images/output.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,239 @@
+# Created by https://www.toptal.com/developers/gitignore/api/macos,python
+# Edit at https://www.toptal.com/developers/gitignore?templates=macos,python
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# 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/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/macos,python
+
+local_scripts/
+
+omnigen2/utils/vpn_utils.py
+
+test_tokenizer.py
+save_pipeline.py
+app.sh
+logs/
+results/
+test_jsonl*
+pbs_files/
+convert_ckpt_to_pipeline.py
+inference_test_efficiency.py
+upload_pipeline*
+example_images_resized/
+example_t2i_test_efficiency*.sh
+example_edit_test_efficiency*.sh
+example_in_context_generation_test_efficiency*.sh
+intro*
+resize_example_images.py
+save_pipeline.py
+outputs_gradio/*
+test.py
+
+upload_to_huggingface.py
+upload_to_modelscope.py
+
+editscore.egg-info/
+dist/

FORK_PROVENANCE.md

@@ -0,0 +1,11 @@
+# Fork provenance
+
+- **Upstream:** `VectorSpaceLab/EditScore (github)`
+- **Upstream commit / SHA:** `4609c5d2ebb62fdebf665d3c924686d896ef1f74`
+- **License:** Apache-2.0
+- **Kind:** Code mirror
+- **Workspace consumer:** EditScore-7B (training + inference code)
+- **Forked to:** `chibifire/EditScore-code`
+- **Forked on:** 2026-09-05
+- **Author:** Ernest Lee <ernest.lee@chibifire.com>
+- **Reason:** shipping-surface completeness under our own HF org so a base/source we depend on cannot disappear or relicense out from under us

LICENSE

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

README.md

@@ -0,0 +1,215 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/VectorSpaceLab/EditScore/refs/heads/main/assets/logo.png" width="65%">
+</p>
+
+<p align="center">
+  <a href="https://vectorspacelab.github.io/EditScore"><img src="https://img.shields.io/badge/Project%20Page-EditScore-yellow" alt="project page"></a>
+  <a href="https://arxiv.org/abs/2509.23909"><img src="https://img.shields.io/badge/arXiv%20paper-2509.23909-b31b1b.svg" alt="arxiv"></a>
+  <a href="https://huggingface.co/collections/EditScore/editscore-68d8e27ee676981221db3cfe"><img src="https://img.shields.io/badge/EditScore-🤗-yellow" alt="model"></a>
+  <a href="https://huggingface.co/datasets/EditScore/EditReward-Bench"><img src="https://img.shields.io/badge/EditReward--Bench-🤗-yellow" alt="dataset"></a>
+  <a href="https://huggingface.co/datasets/EditScore/EditScore-Reward-Data"><img src="https://img.shields.io/badge/EditScore--Reward--Data-🤗-yellow" alt="dataset"></a>
+  <a href="https://huggingface.co/datasets/EditScore/EditScore-RL-Data"><img src="https://img.shields.io/badge/EditScore--RL--Data-🤗-yellow" alt="dataset"></a>
+</p>
+
+<h4 align="center">
+    <p>
+        <a href=#-news>News</a> |
+        <a href=#-quick-start>Quick Start</a> |
+        <a href=#-benchmark-your-image-editing-reward-model usage>Benchmark Usage</a> |
+        <a href=#%EF%B8%8F-citing-us>Citation</a>
+    <p>
+</h4>
+
+**EditScore** is a series of state-of-the-art open-source reward models (7B–72B) designed to evaluate and enhance instruction-guided image editing.
+## ✨ Highlights
+- **State-of-the-Art Performance**: Effectively matches the performance of leading proprietary VLMs. With a self-ensembling strategy, **our largest model surpasses even GPT-5** on our comprehensive benchmark, **EditReward-Bench**.
+- **A Reliable Evaluation Standard**: We introduce **EditReward-Bench**, the first public benchmark specifically designed for evaluating reward models in image editing, featuring 13 subtasks, 11 state-of-the-art editing models (*including proprietary models*) and expert human annotations.
+- **Simple and Easy-to-Use**: Get an accurate quality score for your image edits with just a few lines of code.
+- **Versatile Applications**: Ready to use as a best-in-class reranker to improve editing outputs, or as a high-fidelity reward signal for **stable and effective Reinforcement Learning (RL) fine-tuning**.
+
+## 🔥 News
+- **2026-02-01**: Our work has been accepted to ICLR 2026 🎉
+- **2025-11-21**: We're excited to release the training configs for EditScore reward models! 🎯 Built on LLaMA-Factory, we trained EditScore ranging from 4B to 72B parameters with simple YAML configurations. Check out the [EditScore-train guide](examples/EditScore-train/README.md) to get started with training your own reward models.
+- **2025-10-31**: We’re thrilled to announce the **Qwen3-VL** variants of **EditScore**! 🚀 Powered by Qwen3-VL, the new 4B and 8B models achieve outstanding efficiency and performance. Impressively, the 4B model already matches the performance of the original 32B version, while the 8B model delivers results comparable to the original 72B model. The models are now available on [huggingface](https://huggingface.co/EditScore/models), see [Usage Example](#-usage-example) for how to use. Detailed comparisons with Qwen2.5-VL variants are in the [performance table](https://raw.githubusercontent.com/VectorSpaceLab/EditScore/refs/heads/main/assets/table_editscore_qwen3_vl.png).
+- **2025-10-27**: Released [OmniGen2-EditScore7B-v1.1](https://huggingface.co/OmniGen2/OmniGen2-EditScore7B-v1.1), achieving a **7.01 (+0.73) GEdit score** within **700 steps**, by incorporating the **reweighting strategy** from [TempFlow](https://arxiv.org/abs/2508.04324). Additionally, the **JSON repair process** has been enhanced using [json_repair](https://github.com/mangiucugna/json_repair), improving **EditScore’s stability** under various conditions. Upgrade via `pip install -U editscore`.
+- **2025-10-22**: **Introducing Our Reinforcement Learning Training Framework!**
+  We're excited to release our complete RL pipeline, the result of a massive effort to simplify fine-tuning for image editing models. Key features include:
+    - **Ready-to-Use RL Dataset**: Includes the complete dataset used in the EditScore project, along with clear usage guidelines and preparation scripts.
+    - **An Easy-to-Use Reward Model**: Seamlessly integrate **EditScore** as a reward signal.
+    - **A Scalable Reward Server**: Built with native multi-node support for high-throughput training.
+    - **Flexible Training Code**: Supports distributed training, variable image resolutions and mixed tasks (t2i, edit, in-context generation) out-of-the-box.
+  Dive into our comprehensive guide on [RL Fine-Tuning](examples/OmniGen2-RL#application-2-reinforcement-fine-tuning) to get started.
+
+- 2025-10-16: Training datasets [EditScore-Reward-Data](https://huggingface.co/datasets/EditScore/EditScore-Reward-Data) and [EditScore-RL-Data](https://huggingface.co/datasets/EditScore/EditScore-RL-Data) are available.
+- 2025-10-15: **EditScore** is now available on PyPI — install it easily with `pip install editscore`.
+- 2025-10-15: Best-of-N inference scripts for OmniGen2, Flux-dev-Kontext, and Qwen-Image-Edit are now available! See [this](#apply-editscore-to-image-editing) for details.
+- 2025-09-30: We release **OmniGen2-EditScore7B**, unlocking online RL For Image Editing via high-fidelity EditScore. LoRA weights are available at [Hugging Face](https://huggingface.co/OmniGen2/OmniGen2-EditScore7B) and [ModelScope](https://www.modelscope.cn/models/OmniGen2/OmniGen2-EditScore7B).
+- 2025-09-30: We are excited to release **EditScore** and **EditReward-Bench**! Model weights and the benchmark dataset are now publicly available. You can access them on Hugging Face: [Models Collection](https://huggingface.co/collections/EditScore/editscore-68d8e27ee676981221db3cfe) and [Benchmark Dataset](https://huggingface.co/datasets/EditScore/EditReward-Bench), and on ModelScope: [Models Collection](https://www.modelscope.cn/collections/EditScore-8b0d53aa945d4e) and [Benchmark Dataset](https://www.modelscope.cn/datasets/EditScore/EditReward-Bench).
+
+## 📖 Introduction
+While Reinforcement Learning (RL) holds immense potential for this domain, its progress has been severely hindered by the absence of a high-fidelity, efficient reward signal.
+
+To overcome this barrier, we provide a systematic, two-part solution:
+
+- **A Rigorous Evaluation Standard**: We first introduce **EditReward-Bench**, a new public benchmark for the direct and reliable evaluation of reward models. It features 13 diverse subtasks and expert human annotations, establishing a gold standard for measuring reward signal quality.
+
+- **A Powerful & Versatile Tool**: Guided by our benchmark, we developed the **EditScore** model series. Through meticulous data curation and an effective self-ensembling strategy, EditScore sets a new state of the art for open-source reward models, even surpassing the accuracy of leading proprietary VLMs.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/VectorSpaceLab/EditScore/refs/heads/main/assets/table_reward_model_results.png" width="95%">
+  <br>
+  <em>Benchmark results on EditReward-Bench.</em>
+</p>
+
+We demonstrate the practical utility of EditScore through two key applications:
+
+- **As a State-of-the-Art Reranker**: Use EditScore to perform Best-of-*N* selection and instantly improve the output quality of diverse editing models.
+- **As a High-Fidelity Reward for RL**: Use EditScore as a robust reward signal to fine-tune models via RL, enabling stable training and unlocking significant performance gains where general-purpose VLMs fail.
+
+This repository releases both the **EditScore** models and the **EditReward-Bench** dataset to facilitate future research in reward modeling, policy optimization, and AI-driven model improvement.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/VectorSpaceLab/EditScore/refs/heads/main/assets/figure_edit_results.png" width="95%">
+  <br>
+  <em>EditScore as a superior reward signal for image editing.</em>
+</p>
+
+
+## 📌 TODO
+We are actively working on improving EditScore and expanding its capabilities. Here's what's next:
+
+- [x] Qwen3-VL variants of EditScore.
+- [x] Release training data for reward model and online RL.
+- [x] Release RL training code applying EditScore to OmniGen2.
+- [x] Provide Best-of-N inference scripts for OmniGen2, Flux-dev-Kontext, and Qwen-Image-Edit.
+
+## 🚀 Quick Start
+
+### 🛠️ Environment Setup
+We offer two ways to install EditScore. Choose the one that best fits your needs.
+**Method 1: Install from PyPI (Recommended for Users)**: If you want to use EditScore as a library in your own project.
+**Method 2: Install from Source (For Developers)**: If you plan to contribute to the code, modify it, or run the examples in this repository
+
+#### Prerequisites: Installing PyTorch
+Both installation methods require PyTorch to be installed first, as its version is dependent on your system's CUDA setup.
+```bash
+# (Optional) Create a clean Python environment
+conda create -n editscore python=3.12
+conda activate editscore
+
+# Choose the command that matches your CUDA version.
+# This example is for CUDA 12.6.
+pip install torch==2.7.1 torchvision --extra-index-url https://download.pytorch.org/whl/cu126
+````
+
+<details>
+<summary>🌏 For users in Mainland China</summary>
+```bash
+# Install PyTorch from a domestic mirror
+pip install torch==2.7.1 torchvision --index-url https://mirror.sjtu.edu.cn/pytorch-wheels/cu126
+```
+</details>
+
+#### Method 1: Install from PyPI (Recommended for Users)
+```bash
+pip install -U editscore
+```
+
+#### Method 2: Install from Source (For Developers)
+This method gives you a local, editable version of the project.
+1. Clone the repository
+```bash
+git clone https://github.com/VectorSpaceLab/EditScore.git
+cd EditScore
+```
+
+2. Install EditScore in editable mode
+```bash
+pip install -e .
+```
+
+#### ✅ (Recommended) Install Optional High-Performance Dependencies
+For the best performance, especially during inference, we highly recommend installing vllm.
+```bash
+pip install -U vllm
+```
+
+---
+
+### 🧪 Usage Example
+Using EditScore is straightforward. The model will be automatically downloaded from the Hugging Face Hub on its first run.
+```python
+from PIL import Image
+from editscore import EditScore
+
+# Load the EditScore model. It will be downloaded automatically.
+# Replace with the specific model version you want to use.
+model_path = "Qwen/Qwen3-VL-4B-Instruct"
+lora_path = "EditScore/EditScore-Qwen3-VL-4B-Instruct"
+
+scorer = EditScore(
+    backbone="qwen3vl", # set to "qwen3vl_vllm" for faster inference
+    model_name_or_path=model_path,
+    lora_path=lora_path,
+    score_range=25,
+    num_pass=1, # Increase for better performance via self-ensembling
+)
+
+# Below is Qwen2.5-VL version
+
+# model_path = "Qwen/Qwen2.5-VL-7B-Instruct"
+# lora_path = "EditScore/EditScore-7B"
+
+# scorer = EditScore(
+#     backbone="qwen25vl", # set to "qwen25vl_vllm" for faster inference
+#     model_name_or_path=model_path,
+#     lora_path=lora_path,
+#     score_range=25,
+#     num_pass=1, # Increase for better performance via self-ensembling
+# )
+
+input_image = Image.open("example_images/input.png")
+output_image = Image.open("example_images/output.png")
+instruction = "Adjust the background to a glass wall."
+
+result = scorer.evaluate([input_image, output_image], instruction)
+print(f"Edit Score: {result['overall']}")
+# Expected output: A dictionary containing the final score and other details.
+```
+
+---
+
+## 📊 Benchmark Your Image-Editing Reward Model
+#### Install benchmark dependencies
+To use example code for benchmark, run following
+```bash
+pip install -r requirements.txt
+```
+
+We provide an evaluation script to benchmark reward models on **EditReward-Bench**. To evaluate your own custom reward model, simply create a scorer class with a similar interface and update the script.
+```bash
+# This script will evaluate the default EditScore model on the benchmark
+bash evaluate.sh
+
+# Or speed up inference with VLLM
+bash evaluate_vllm.sh
+```
+
+## Apply EditScore to Image Editing
+We offer two example use cases for your exploration:
+- **Best-of-N selection**: Use EditScore to automatically pick the most preferred image among multiple candidates.
+- **Reinforcement fine-tuning**: Use EditScore as a reward model to guide RL-based optimization.
+
+For detailed instructions and examples, please refer to the [documentation](examples/OmniGen2-RL/README.md).
+
+## ❤️ Citing Us
+If you find this repository or our work useful, please consider giving a star ⭐ and citation 🦖, which would be greatly appreciated:
+
+```bibtex
+@article{luo2025editscore,
+  title={EditScore: Unlocking Online RL for Image Editing via High-Fidelity Reward Modeling},
+  author={Xin Luo and Jiahao Wang and Chenyuan Wu and Shitao Xiao and Xiyan Jiang and Defu Lian and Jiajun Zhang and Dong Liu and Zheng Liu},
+  journal={arXiv preprint arXiv:2509.23909},
+  year={2025}
+}
+```

calculate_statistics.py

@@ -0,0 +1,124 @@
+import os
+import glob
+import json
+import numpy as np
+
+import argparse
+
+PROMPT_FOLLOWING = "prompt_following"
+CONSISTENCY = "consistency"
+OVERALL = "overall"
+SCORE_CATEGORIES = [PROMPT_FOLLOWING, CONSISTENCY, OVERALL]
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--result_dir", type=str, required=True)
+    parser.add_argument("--backbone", type=str, default="qwen25vl", choices=["qwen25vl", "openai", "internvl3_5"])
+    return parser.parse_args()
+
+def main(args):
+    task_types = sorted(os.listdir(args.result_dir))
+
+    print(task_types)
+
+    prompt_following_results = dict()
+    consistency_results = dict()
+    overall_results = dict()
+
+    all_prompt_following_scores = []
+    all_consistency_scores = []
+    all_overall_scores = []
+
+    for task_type in task_types:
+        task_type_dir = os.path.join(args.result_dir, task_type)
+        prompt_following_json_file = os.path.join(task_type_dir, f"{PROMPT_FOLLOWING}.jsonl")
+        consistency_json_file = os.path.join(task_type_dir, f"{CONSISTENCY}.jsonl")
+        overall_json_file = os.path.join(task_type_dir, f"{OVERALL}.jsonl")
+
+        total_num = 0
+        correct_num = 0
+        with open(prompt_following_json_file, 'r') as f:
+            for line in f:
+                json_line = json.loads(line)
+                if json_line['score'][0] > json_line['score'][1]:
+                    correct_num += 1
+                total_num += 1
+                all_prompt_following_scores.append(json_line['score'][0])
+                all_prompt_following_scores.append(json_line['score'][1])
+        prompt_following_results[task_type] = correct_num / total_num
+        
+        total_num = 0
+        correct_num = 0
+        with open(consistency_json_file, 'r') as f:
+            for line in f:
+                json_line = json.loads(line)
+                if json_line['score'][0] > json_line['score'][1]:
+                    correct_num += 1
+                total_num += 1
+                all_consistency_scores.append(json_line['score'][0])
+                all_consistency_scores.append(json_line['score'][1])
+        consistency_results[task_type] = correct_num / total_num
+        
+        total_num = 0
+        correct_num = 0
+        with open(overall_json_file, 'r') as f:
+            for line in f:
+                json_line = json.loads(line)
+                if json_line['score'][0] > json_line['score'][1]:
+                    correct_num += 1
+                total_num += 1
+                all_overall_scores.append(json_line['score'][0])
+                all_overall_scores.append(json_line['score'][1])
+        overall_results[task_type] = correct_num / total_num
+
+    prompt_following_results['average'] = sum(prompt_following_results.values()) / len(prompt_following_results)
+    consistency_results['average'] = sum(consistency_results.values()) / len(consistency_results)
+    overall_results['average'] = sum(overall_results.values()) / len(overall_results)
+
+    print(overall_results.keys())
+
+    task_types = [
+        'background_change', 'color_alter', 'style_change', 'subject-add', 'subject-remove', 'subject-replace', 'material_alter',
+        'motion_change', 'ps_human', 'text_change', 'tone_transfer', 'extract', 'compose', 'average'
+    ]
+
+    print(" & ".join(task_types))
+    print("Prompt Following: " + " & ".join([f"{prompt_following_results[task_type]:.3f}" for task_type in task_types]))
+    print("Consistency: " + " & ".join([f"{consistency_results[task_type]:.3f}" for task_type in task_types]))
+    print("Overall: " + " & ".join([f"{overall_results[task_type]:.3f}" for task_type in task_types]))
+    
+    groups = {
+        'object': ['subject-add', 'subject-remove', 'subject-replace'],
+        'appearance': ['color_alter', 'material_alter', 'style_change', 'tone_transfer'],
+        'scene': ['background_change', 'extract'],
+        'advanced': ['ps_human', 'text_change', 'motion_change', 'compose'],
+    }
+
+    print("--------------------------------")
+    print("--------------------------------")
+
+    for group_name, group_task_types in groups.items():
+        print(group_name + ":")
+        print("Prompt Following & Consistency & Overall")
+        prompt_following_mean = np.mean([prompt_following_results[task_type] for task_type in group_task_types])
+        consistency_mean = np.mean([consistency_results[task_type] for task_type in group_task_types])
+        overall_mean = np.mean([overall_results[task_type] for task_type in group_task_types])
+        print(f"{prompt_following_mean:.3f} & {consistency_mean:.3f} & {overall_mean:.3f}")
+    
+    print("Average:")
+    print("Prompt Following & Consistency & Overall")
+    print(f"{prompt_following_results['average']:.3f} & {consistency_results['average']:.3f} & {overall_results['average']:.3f}")
+
+    print("Prompt Following Scores:")
+    print("Min & Max & Mean & Std")
+    print(f"{np.min(all_prompt_following_scores):.3f} & {np.max(all_prompt_following_scores):.3f} & {np.mean(all_prompt_following_scores):.3f} & {np.std(all_prompt_following_scores):.3f}")
+    print("Consistency Scores:")
+    print("Min & Max & Mean & Std")
+    print(f"{np.min(all_consistency_scores):.3f} & {np.max(all_consistency_scores):.3f} & {np.mean(all_consistency_scores):.3f} & {np.std(all_consistency_scores):.3f}")
+    print("Overall Scores:")
+    print("Min & Max & Mean & Std")
+    print(f"{np.min(all_overall_scores):.3f} & {np.max(all_overall_scores):.3f} & {np.mean(all_overall_scores):.3f} & {np.std(all_overall_scores):.3f}")
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)

editscore/__init__.py

@@ -0,0 +1,217 @@
+import sys
+sys.path.insert(0, 'editscore')
+
+from typing import Optional
+from .utils import (
+    mllm_output_to_dict
+)
+import math
+from . import vie_prompts
+import numpy as np
+from .json_parser import parse_vlm_output_to_dict
+
+class EditScore:
+    def __init__(
+        self,
+        backbone="gpt-4.1",
+        openai_url="https://api.openai.com/v1/chat/completions",
+        key=None,
+        model_name_or_path="",
+        score_range: int=25,
+        temperature: float=0.7,
+        tensor_parallel_size: int=1,
+        max_model_len: int=1536,
+        max_num_batched_tokens: int=1536,
+        max_num_seqs: int=32,
+        num_pass: int=1,
+        reduction: str="average_last",
+        seed: int=42,
+        lora_path: Optional[str]=None,
+        cache_dir: Optional[str]=None,
+    ) -> None:
+        self.backbone = backbone
+        self.score_range = score_range
+        self.reduction = reduction
+        self.seed = seed
+        self.num_pass = num_pass
+
+        if self.backbone == 'openai':
+            from .mllm_tools.openai import GPT4o
+            self.model = GPT4o(key, model_name=model_name_or_path, url=openai_url)
+        elif self.backbone == "qwen25vl":
+            from .mllm_tools.qwen25vl import Qwen25VL
+            self.model = Qwen25VL(
+                vlm_model=model_name_or_path,
+                temperature=temperature,
+                seed=seed,
+                lora_path=lora_path,
+            )
+        elif self.backbone == "qwen25vl_vllm":
+            from .mllm_tools.qwen25vl_vllm import Qwen25VL
+            self.model = Qwen25VL(
+                vlm_model=model_name_or_path,
+                tensor_parallel_size=tensor_parallel_size,
+                max_model_len=max_model_len,
+                max_num_seqs=max_num_seqs,
+                max_num_batched_tokens=max_num_batched_tokens,
+                temperature=temperature,
+                seed=seed,
+                lora_path=lora_path,
+                cache_dir=cache_dir,
+            )
+        elif self.backbone == "qwen3vl":
+            from .mllm_tools.qwen3vl import Qwen3VL
+            self.model = Qwen3VL(
+                vlm_model=model_name_or_path,
+                temperature=temperature,
+                seed=seed,
+                lora_path=lora_path,
+            )
+        elif self.backbone == "qwen3vl_vllm":
+            from .mllm_tools.qwen3vl_vllm import Qwen3VL
+            self.model = Qwen3VL(
+                vlm_model=model_name_or_path,
+                tensor_parallel_size=tensor_parallel_size,
+                max_model_len=max_model_len,
+                max_num_seqs=max_num_seqs,
+                max_num_batched_tokens=max_num_batched_tokens,
+                temperature=temperature,
+                seed=seed,
+                lora_path=lora_path,
+                cache_dir=cache_dir,
+            )
+        elif self.backbone == "internvl3_5":
+            from .mllm_tools.internvl35_lmdeploy import InternVL35
+            self.model = InternVL35(model=model_name_or_path, tensor_parallel_size=tensor_parallel_size)
+            
+        self.context = vie_prompts._context_no_delimit_reasoning_first
+    
+        self.SC_prompt = "\n".join([self.context, vie_prompts._prompts_0shot_two_image_edit_rule, vie_prompts._prompts_0shot_tie_rule_SC.replace('10', str(self.score_range))])
+        self.PQ_prompt = "\n".join([self.context, vie_prompts._prompts_0shot_rule_PQ.replace('10', str(self.score_range))])
+
+    def evaluate(self, image_prompts, text_prompt):
+        if not isinstance(image_prompts, list):
+            image_prompts = [image_prompts]
+
+        if self.backbone in ['openai']:
+            self.model.use_encode = False if isinstance(image_prompts[0], str) else True
+            
+        _SC_prompt = self.SC_prompt.replace("<instruction>", text_prompt)
+        
+        SC_prompt_final = self.model.prepare_input(image_prompts, _SC_prompt)
+        PQ_prompt_final = self.model.prepare_input(image_prompts[-1], self.PQ_prompt) # assume the last image is the edited image
+
+        outputs_multi_pass = []
+
+        for i in range(self.num_pass):
+            SC_dict = False
+            PQ_dict = False
+            tries = 0
+            max_tries = 2
+            while SC_dict is False or PQ_dict is False:
+                tries += 1
+                give_up_parsing = True if tries > max_tries else False
+
+                result_SC = self.model.inference(SC_prompt_final, seed=self.seed + i)
+                result_PQ = self.model.inference(PQ_prompt_final, seed=self.seed + i)
+
+                if result_SC in ["I'm sorry, but I can't assist with that request."] or result_PQ in ["I'm sorry, but I can't assist with that request."]:
+                    give_up_parsing = True
+                    
+                SC_dict = mllm_output_to_dict(result_SC, give_up_parsing=give_up_parsing, text_prompt=text_prompt, score_range=self.score_range)
+                PQ_dict = mllm_output_to_dict(result_PQ, give_up_parsing=give_up_parsing, text_prompt=text_prompt, score_range=self.score_range)
+
+            if SC_dict == "rate_limit_exceeded" or PQ_dict == "rate_limit_exceeded":
+                print("rate_limit_exceeded") 
+                raise ValueError("rate_limit_exceeded")
+            
+            try:
+                SC_score = min(SC_dict['score']) / (self.score_range / 10)
+                PQ_score = min(PQ_dict['score']) / (self.score_range / 10)
+                O_score = math.sqrt(SC_score * PQ_score)
+            except Exception as e:
+                print(f"{e=} {SC_dict['score']=} {PQ_dict['score']=}")
+                raise e
+
+            try:
+                outputs_multi_pass.append({
+                    'prompt_following': SC_dict['score'][0] / (self.score_range / 10),
+                    'consistency': SC_dict['score'][1] / (self.score_range / 10),
+                    'perceptual_quality': PQ_score,
+                    'overall': O_score,
+                })
+            except Exception as e:
+                print(f"{e=} {SC_dict['score']=} {PQ_dict['score']=}")
+                raise e
+        
+        output = {
+                    "prompt_following": np.mean([output_per_pass["prompt_following"] for output_per_pass in outputs_multi_pass]),
+                    "consistency": np.mean([output_per_pass["consistency"] for output_per_pass in outputs_multi_pass]),
+                    "perceptual_quality": np.mean([output_per_pass["perceptual_quality"] for output_per_pass in outputs_multi_pass]),
+                    "overall": np.mean([output_per_pass["overall"] for output_per_pass in outputs_multi_pass]),
+                    "SC_reasoning": SC_dict["reasoning"],
+                    "PQ_reasoning": PQ_dict["reasoning"],
+                }
+        if self.reduction == "average_first":
+            output["overall"] = math.sqrt(output["prompt_following"] * output["perceptual_quality"])
+        return output
+
+
+    def batch_evaluate(self, image_prompts, text_prompt):
+        SC_prompt = [self.SC_prompt.replace("<instruction>", _text_prompt) for _text_prompt in text_prompt]
+
+        SC_prompt = [self.model.prepare_input(image_prompt, _SC_prompt) for image_prompt, _SC_prompt in zip(image_prompts, SC_prompt)]
+        PQ_prompt = [self.model.prepare_input(image_prompt, self.PQ_prompt) for image_prompt in image_prompts]
+
+        outputs_multi_pass = [[] for _ in range(len(image_prompts))]
+        for i in range(self.num_pass):
+            results = self.model.batch_inference(SC_prompt + PQ_prompt, seed=self.seed + i)
+
+            SC_evaluations = [parse_vlm_output_to_dict(results[i]) for i in range(len(results) // 2)]
+            PQ_evaluations = [parse_vlm_output_to_dict(results[i]) for i in range(len(results) // 2, len(results))]
+
+            for idx, (SC_evaluation, PQ_evaluation) in enumerate(zip(SC_evaluations, PQ_evaluations)):
+                SC_scores = SC_evaluation["score"]
+                PQ_scores = PQ_evaluation["score"]
+
+                if len(SC_scores) == 0:
+                    SC_scores = [self.score_range / 2]
+                if len(PQ_scores) == 0:
+                    PQ_scores = [self.score_range / 2]
+
+                SC_score = min(SC_scores) / (self.score_range / 10)
+                PQ_score = min(PQ_scores) / (self.score_range / 10)
+                if SC_score < 0 or SC_score > 10:
+                    SC_score = self.score_range / 2
+                if PQ_score < 0 or PQ_score > 10:
+                    PQ_score = self.score_range / 2
+                O_score = math.sqrt(SC_score * PQ_score)
+
+                outputs_multi_pass[idx].append(
+                    {
+                        "SC_score": SC_score,
+                        "PQ_score": PQ_score,
+                        "O_score": O_score,
+                        "SC_score_reasoning": SC_evaluation["reasoning"],
+                        "PQ_score_reasoning": PQ_evaluation["reasoning"],
+                        "SC_raw_output": results[idx],
+                        "PQ_raw_output": results[len(results) // 2 + idx],
+                    }
+                )
+        
+        outputs = []
+        for idx, outputs_per_prompt in enumerate(outputs_multi_pass):
+            outputs.append(
+                {
+                    "SC_score": np.mean([output_per_pass["SC_score"] for output_per_pass in outputs_per_prompt]),
+                    "PQ_score": np.mean([output_per_pass["PQ_score"] for output_per_pass in outputs_per_prompt]),
+                    "O_score": np.mean([output_per_pass["O_score"] for output_per_pass in outputs_per_prompt]),
+                    "SC_score_reasoning": outputs_per_prompt[0]["SC_score_reasoning"],
+                    "PQ_score_reasoning": outputs_per_prompt[0]["PQ_score_reasoning"],
+                    "SC_raw_output": outputs_per_prompt[0]["SC_raw_output"],
+                    "PQ_raw_output": outputs_per_prompt[0]["PQ_raw_output"],
+                }
+            )
+            if self.reduction == "average_first":
+                outputs[-1]["O_score"] = math.sqrt(outputs[-1]["SC_score"] * outputs[-1]["PQ_score"])
+        return outputs

editscore/json_parser.py

@@ -0,0 +1,173 @@
+import json
+import re
+from typing import Dict, Any, List, Optional
+
+# ==============================================================================
+#  HELPER FUNCTIONS (Based on your provided robust fixers)
+# ==============================================================================
+# For clarity, these are named as internal functions (prefixed with an underscore).
+
+def _fix_json_quotes(s: str) -> str:
+    """First-stage repair: handle incorrect quotes and basic structure."""
+    # Replace Python-style booleans/None with JSON standard
+    s = re.sub(r'\bTrue\b', 'true', s)
+    s = re.sub(r'\bFalse\b', 'false', s)
+    s = re.sub(r'\bNone\b', 'null', s)
+    
+    # Attempt to replace single quotes with double quotes (a common VLM error)
+    # This is a high-risk operation that might break the reasoning content, 
+    # but it's worth trying early on.
+    try:
+        temp_s = s.replace("'", '"')
+        json.loads(temp_s)
+        return temp_s
+    except json.JSONDecodeError:
+        # If it's still invalid after replacement, return the original string for the next repair step.
+        pass
+
+    # Add double quotes to keys (e.g., {reasoning: ...} -> {"reasoning": ...})
+    s = re.sub(r'([\{\s,])(\w+)\s*:', r'\1"\2":', s)
+    return s
+
+def _repair_reasoning_field_robust(json_str: str) -> str:
+    """Second-stage repair: specifically fix unescaped double quotes inside the 'reasoning' field."""
+    pattern = re.compile(
+        r'("reasoning"\s*:\s*")'  # --- Group 1: "reasoning" : "
+        r'(.*?)'                  # --- Group 2: The content (non-greedy)
+        r'(?="\s*[,}])',          # --- Lookahead: find " followed by , or }
+        re.DOTALL
+    )
+
+    def replacer(match):
+        prefix = match.group(1)
+        content = match.group(2)
+        # In the content, replace all unescaped " with \"
+        fixed_content = content.replace('"', '\\"')
+        return prefix + fixed_content
+
+    return pattern.sub(replacer, json_str)
+
+def _fallback_extract_and_rebuild(input_str: str) -> str:
+    """Final fallback strategy: abandon repair, directly extract information, and rebuild a valid JSON."""
+    # 1. Extract reasoning
+    # Find all content between "reasoning": and ,"score":
+    reasoning_text = ""
+    reason_match = re.search(r'["\']reasoning["\']\s*:\s*["\']?(.*?)["\']?\s*,\s*["\']score["\']', input_str, re.DOTALL | re.IGNORECASE)
+    if reason_match:
+        reasoning_text = reason_match.group(1).strip()
+        # Clean up any potentially remaining escape characters
+        reasoning_text = reasoning_text.replace('\\"', '"')
+    else:
+        # If not found, assume all text besides the score part is the reasoning.
+        # First, remove the score part.
+        score_part_match = re.search(r'["\']score["\']\s*:.*', input_str, re.IGNORECASE)
+        if score_part_match:
+            reasoning_text = input_str[:score_part_match.start()].strip()
+        else:
+            # If even 'score' cannot be found, assume the entire string is the reasoning.
+            reasoning_text = input_str
+            
+    # 2. Extract scores
+    scores = []
+    # Prioritize searching after the 'score' keyword.
+    score_match = re.search(r'["\']score["\']\s*:\s*(.*)', input_str, re.DOTALL | re.IGNORECASE)
+    search_area = score_match.group(1) if score_match else input_str
+    
+    # Find all integers or floats.
+    numbers = re.findall(r'[-+]?\d*\.?\d+', search_area)
+    if numbers:
+        scores = [float(num) for num in numbers]
+
+    # 3. Rebuild into a standard dictionary and return a JSON string.
+    rebuilt_data = {
+        "reasoning": reasoning_text,
+        "score": scores
+    }
+    return json.dumps(rebuilt_data, ensure_ascii=False)
+
+
+def _format_and_validate_dict(data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Validate and format the parsed dictionary to ensure it meets the final output standard."""
+    if not isinstance(data, dict):
+        return None
+
+    # Extract reasoning, tolerating case and spelling variations.
+    reasoning = ""
+    for key in ["reasoning", "reason", "rationale"]:
+        if key in data and isinstance(data[key], str):
+            reasoning = data[key]
+            break
+
+    # Extract score, and ensure it is a list of floats.
+    scores = []
+    if 'score' in data:
+        score_val = data['score']
+        if isinstance(score_val, list):
+            scores = [float(s) for s in score_val if isinstance(s, (int, float, str))]
+        elif isinstance(score_val, (int, float)):
+            scores = [float(score_val)]
+    
+    # If any field was found, consider it a success.
+    if reasoning or scores:
+        return {"score": scores, "reasoning": reasoning}
+    
+    return None
+
+# ==============================================================================
+#  MAIN PARSING FUNCTION
+# ==============================================================================
+
+def parse_vlm_output_to_dict(input_string: str) -> Dict[str, Any]:
+    """
+    A highly robust function to parse a VLM's output string into a dictionary
+    containing 'score' and 'reasoning'.
+
+    It uses a multi-stage repair pipeline, progressively degrading from standard
+    JSON parsing to a final information extraction fallback.
+    """
+    # --- 0. Preprocessing ---
+    if not input_string or not input_string.strip():
+        return {"score": [], "reasoning": "Input was empty."}
+    
+    # Find the substring enclosed by `{}`, which is often the core of the VLM output.
+    json_match = re.search(r'\{.*\}', input_string, re.DOTALL)
+    target_str = json_match.group(0) if json_match else input_string.strip()
+
+    # --- Repair Pipeline ---
+    # Apply fixers in order, attempting to parse after each one.
+    
+    fixer_pipeline = [
+        lambda s: s,                        # 1. Try the original string.
+        _fix_json_quotes,                   # 2. Fix basic quotes and keywords.
+        _repair_reasoning_field_robust,     # 3. Fix internal quotes in the reasoning field.
+    ]
+
+    for fixer in fixer_pipeline:
+        try:
+            fixed_str = fixer(target_str)
+            data = json.loads(fixed_str)
+            validated_data = _format_and_validate_dict(data)
+            if validated_data is not None:
+                return validated_data
+        except (json.JSONDecodeError, TypeError):
+            # If it fails, continue to the next fixer.
+            continue
+            
+    # --- Final Fallback Strategy ---
+    # If all repair and parsing attempts fail, activate the information extraction mode.
+    try:
+        fallback_str = _fallback_extract_and_rebuild(target_str)
+        # This function guarantees a valid JSON string, so we can load it directly.
+        data = json.loads(fallback_str)
+        # Still run it through the validator to standardize the format.
+        validated_data = _format_and_validate_dict(data)
+        if validated_data:
+            return validated_data
+    except Exception:
+        # If even the final fallback strategy fails, return an error message.
+        pass
+        
+    return {
+        "score": [],
+        "reasoning": f"Failed to parse after all strategies. Original output: '{input_string}'"
+    }

editscore/mllm_tools/internvl35_lmdeploy.py

@@ -0,0 +1,73 @@
+from typing import List
+
+import random
+# import magic
+# import megfile
+
+import numpy as np
+import torch
+
+from lmdeploy import pipeline, PytorchEngineConfig
+from lmdeploy.vl import load_image
+from lmdeploy.vl.constants import IMAGE_TOKEN
+
+
+def set_seed(seed: int):
+    """
+    Args:
+    Helper function for reproducible behavior to set the seed in `random`, `numpy`, `torch`.
+        seed (`int`): The seed to set.
+    """
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def apply_chat_template(prompt, num_images: int = 2):
+    """
+    This is used since the bug of transformers which do not support vision id https://github.com/QwenLM/Qwen2.5-VL/issues/716#issuecomment-2723316100
+    """
+    template = "\n".join([f"Image-{i}: {IMAGE_TOKEN}" for i in range(1, num_images + 1)])
+    template += f"\n{prompt}"
+    return template
+
+class InternVL35():
+    def __init__(self, model, max_model_len: int = 16384, tensor_parallel_size=1, max_num_seqs=32) -> None:
+        # attn_implementation = "flash_attention_2" if is_flash_attn_2_available() else None
+        self.model = pipeline(model, backend_config=PytorchEngineConfig(session_len=max_model_len, tp=tensor_parallel_size))
+        
+    def prepare_input(self, images: List = [], text_prompt: str = ""):
+        if not isinstance(images, list):
+            images = [images]
+        messages = (apply_chat_template(text_prompt, num_images=len(images)), images)
+        return messages
+
+    def inference(self, messages):
+        set_seed(42)
+        # Prepare the inputs
+
+        response = self.model(messages)
+        print(f"{response.text=}", flush=True)
+        return response.text
+
+if __name__ == "__main__":
+    model = InternVL35(
+        vlm_model="OpenGVLab/InternVL3_5-8B",
+        max_model_len=16384,
+        tensor_parallel_size=1,
+        max_num_seqs=32
+    )
+
+    from PIL import Image
+    prompt = model.prepare_input(
+        [Image.open("https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg")], 
+        'Describe the image in detail.'
+    )
+
+    prompt2 = model.prepare_input(
+        [Image.open("https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg")], 
+        'How well it looks? Give a score between 0 and 100.'
+    )
+    res = model.inference([prompt, prompt2])
+    print("result : \n", res)

editscore/mllm_tools/openai.py

@@ -0,0 +1,180 @@
+import base64
+import requests
+from io import BytesIO, StringIO
+from typing import Union, Optional, Tuple, List
+from PIL import Image, ImageOps
+import os
+
+def get_api_key(file_path):
+    # Read the API key from the first line of the file
+    with open(file_path, 'r') as file:
+        return file.readline().strip()
+
+# Function to encode the image
+def encode_image(image_path):
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode('utf-8')
+
+def pick_next_item(current_item, item_list):
+    if current_item not in item_list:
+        raise ValueError("Current item is not in the list")
+    current_index = item_list.index(current_item)
+    next_index = (current_index + 1) % len(item_list)
+
+    return item_list[next_index]
+
+# Function to encode a PIL image
+def encode_pil_image(pil_image):
+    # Create an in-memory binary stream
+    image_stream = BytesIO()
+    
+    # Save the PIL image to the binary stream in JPEG format (you can change the format if needed)
+    pil_image.save(image_stream, format='JPEG')
+    
+    # Get the binary data from the stream and encode it as base64
+    image_data = image_stream.getvalue()
+    base64_image = base64.b64encode(image_data).decode('utf-8')
+    
+    return base64_image
+
+
+def load_image(image: Union[str, Image.Image], format: str = "RGB", size: Optional[Tuple] = None) -> Image.Image:
+    """
+    Load an image from a given path or URL and convert it to a PIL Image.
+
+    Args:
+        image (Union[str, Image.Image]): The image path, URL, or a PIL Image object to be loaded.
+        format (str, optional): Desired color format of the resulting image. Defaults to "RGB".
+        size (Optional[Tuple], optional): Desired size for resizing the image. Defaults to None.
+
+    Returns:
+        Image.Image: A PIL Image in the specified format and size.
+
+    Raises:
+        ValueError: If the provided image format is not recognized.
+    """
+    if isinstance(image, str):
+        if image.startswith("http://") or image.startswith("https://"):
+            image = Image.open(requests.get(image, stream=True).raw)
+        elif os.path.isfile(image):
+            image = Image.open(image)
+        else:
+            raise ValueError(
+                f"Incorrect path or url, URLs must start with `http://` or `https://`, and {image} is not a valid path"
+            )
+    elif isinstance(image, Image.Image):
+        image = image
+    else:
+        raise ValueError(
+            "Incorrect format used for image. Should be an url linking to an image, a local path, or a PIL image."
+        )
+    image = ImageOps.exif_transpose(image)
+    image = image.convert(format)
+    if (size != None):
+        image = image.resize(size, Image.LANCZOS)
+    return image
+
+class GPT4v():
+    def __init__(self, key, url="https://api.openai.com/v1/chat/completions", are_images_encoded=False, model_name="gpt-4-vision-preview"):
+        """OpenAI GPT-4-vision model wrapper
+        Args:
+            api_key_path (str): Path to the API key file. Defaults to 'keys/secret.env'.
+            are_images_encoded (bool): Whether the images are encoded in base64. Defaults to False.
+        """
+        self.multiple_api_keys = False
+        self.current_key_file = None
+        self.api_key = key
+
+        self.url = url
+        self.model_name = model_name
+        self.use_encode = are_images_encoded
+
+    def prepare_input(self, image_links: List = [], text_prompt: str = ""):
+        prompt_content = []
+        text_dict = {
+                    "type": "text",
+                    "text": text_prompt
+                }
+        prompt_content.append(text_dict)
+
+        if not isinstance(image_links, list):
+            image_links = [image_links]
+            
+        for image_link in image_links:
+            image = load_image(image_link)
+            if self.use_encode:
+                visual_dict = {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/jpeg;base64,{encode_pil_image(image)}"}
+                    }
+            else:
+                visual_dict = {
+                        "type": "image_url",
+                        "image_url": {"url": image_link}
+                    }
+            prompt_content.append(visual_dict)
+        return prompt_content
+
+    def inference(self, prompt, seed: Optional[int] = None):
+        payload = {
+            "model": self.model_name,
+            "messages": [
+            {
+                "role": "user",
+                "content": prompt
+            }
+            ],
+            # "max_tokens": 1400
+        }
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+        # try:
+        response = requests.post(self.url, json=payload, headers=headers, timeout=180)  # Set timeout to 5 minutes (300 seconds)
+        # except Exception as e:
+        #     print(f"Error: {e}")
+        #     return ""
+        #return response.text
+        return self.extract_response(response)
+    
+    def extract_response(self, response):
+        try:
+            response = response.json()
+            out = response['choices'][0]['message']['content']
+            return out
+        except Exception as e:
+            print(f"Error: {e}")
+            if response['error']['code'] == 'content_policy_violation':
+                print("Code is content_policy_violation")
+            elif response['error']['code'] in ['rate_limit_exceeded', 'insufficient_quota', 'insufficient_user_quota']:
+                print(f"Code is {response['error']['code']}", flush=True)
+                print(response['error']['message'], flush=True)
+                return "rate_limit_exceeded"
+                if self.multiple_api_keys == True:
+                    new_key = pick_next_item(self.current_key_file, self.key_lists)
+                    self.update_key(new_key)
+                    self.current_key_file = new_key #override key
+                    print("New key is from the file: ", new_key)
+            else:
+                print("Code is different")
+                print(response)
+                print(f"{response['error']['code']=}")
+        return ""
+
+    def update_key(self, key, load_from_file=True):
+        if load_from_file:
+            self.api_key = get_api_key(key)
+        else:
+            self.api_key = key
+
+class GPT4o(GPT4v):
+    def __init__(self, key, url="https://api.openai.com/v1/chat/completions", are_images_encoded=False, model_name="gpt-4o-2024-05-13"):
+        super().__init__(key, url, are_images_encoded, model_name)
+
+if __name__ == "__main__":
+    model = GPT4o('sk-cB6h7HcCSDIp71gs6lFLZxKE0dOYOnJbxzES6kWXe1Wb2VHS', model_name="gpt-4.1")
+    prompt = model.prepare_prompt(['https://chromaica.github.io/Museum/ImagenHub_Text-Guided_IE/DiffEdit/sample_34_1.jpg', 'https://chromaica.github.io/Museum/ImagenHub_Text-Guided_IE/input/sample_34_1.jpg'], 'What is difference between two images?')
+    print("prompt : \n", prompt)
+    res = model.get_parsed_output(prompt)
+    print("result : \n", res)

editscore/mllm_tools/qwen25vl.py

@@ -0,0 +1,97 @@
+from typing import Optional
+import random
+import numpy as np
+import torch
+
+from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
+from qwen_vl_utils import process_vision_info
+from peft import PeftModel
+
+
+def set_seed(seed: int):
+    """
+    Args:
+    Helper function for reproducible behavior to set the seed in `random`, `numpy`, `torch`.
+        seed (`int`): The seed to set.
+    """
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def apply_chat_template(prompt, num_images: int = 2):
+    """
+    This is used since the bug of transformers which do not support vision id https://github.com/QwenLM/Qwen2.5-VL/issues/716#issuecomment-2723316100
+    """
+    template = "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n"
+    template += "".join([f"<img{i}>: <|vision_start|><|image_pad|><|vision_end|>" for i in range(1, num_images + 1)])
+    template += f"{prompt}<|im_end|>\n<|im_start|>assistant\n"
+    return template
+
+
+class Qwen25VL():
+    def __init__(
+        self,
+        vlm_model,
+        temperature: float = 0.7,
+        seed: Optional[int] = None,
+        lora_path: Optional[str] = None,
+    ) -> None:
+        self.model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+            vlm_model, torch_dtype=torch.bfloat16, device_map="auto"
+        )
+        if lora_path:
+            self.model = PeftModel.from_pretrained(self.model, lora_path)
+            self.model = self.model.merge_and_unload()
+
+        self.processor = AutoProcessor.from_pretrained(vlm_model)
+        self.temperature = temperature
+        self.seed = seed
+    
+    def prepare_input(self, images, text_prompt: str = ""):
+        if not isinstance(images, list):
+            images = [images]
+
+        messages = [
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image} for image in images]
+                + [{"type": "text", "text": text_prompt}],
+            }
+        ]
+        text = apply_chat_template(text_prompt, num_images=len(images))
+        image_inputs, video_inputs = process_vision_info(messages)
+
+        inputs = self.processor(
+            text=[text],
+            images=image_inputs,
+            videos=video_inputs,
+            padding=True,
+            return_tensors="pt",
+        )
+        inputs = inputs.to("cuda")
+
+        return inputs
+
+    def inference(self, inputs, seed: Optional[int] = None):
+        seed = self.seed if seed is None else seed
+
+        set_seed(seed)
+        generated_ids = self.model.generate(
+            **inputs,
+            max_new_tokens=512,
+            do_sample=True,
+            temperature=self.temperature,
+            top_p=0.9,
+            top_k=20,
+        )
+        generated_ids_trimmed = [
+            out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+        ]
+        outputs = self.processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+        )
+
+        outputs = [output.strip() for output in outputs]
+        return outputs[0]

editscore/mllm_tools/qwen25vl_vllm.py

@@ -0,0 +1,138 @@
+from typing import Optional
+
+import os
+import hashlib
+import random
+import time
+import numpy as np
+import torch
+
+from vllm import LLM
+from vllm.sampling_params import SamplingParams
+
+from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
+from peft import PeftModel
+
+from qwen_vl_utils import process_vision_info
+
+
+def set_seed(seed: int):
+    """
+    Args:
+    Helper function for reproducible behavior to set the seed in `random`, `numpy`, `torch`.
+        seed (`int`): The seed to set.
+    """
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def apply_chat_template(prompt, num_images: int = 2):
+    """
+    This is used since the bug of transformers which do not support vision id https://github.com/QwenLM/Qwen2.5-VL/issues/716#issuecomment-2723316100
+    """
+    template = "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n"
+    template += "".join([f"<img{i}>: <|vision_start|><|image_pad|><|vision_end|>" for i in range(1, num_images + 1)])
+    template += f"{prompt}<|im_end|>\n<|im_start|>assistant\n"
+    return template
+
+
+class Qwen25VL():
+    def __init__(
+        self,
+        vlm_model,
+        max_model_len: int = 1536,
+        tensor_parallel_size=1,
+        max_num_seqs=32,
+        max_num_batched_tokens=1536,
+        temperature: float = 0.7,
+        seed: Optional[int] = None,
+        lora_path: Optional[str] = None,
+        cache_dir: Optional[str] = None,
+    ) -> None:
+        if lora_path:
+            if cache_dir is None:
+                root_dir = torch.hub.get_dir() # default: ~/.cache/torch/hub
+
+                lora_filename = os.path.splitext(os.path.basename(lora_path))[0]
+                lora_hash = hashlib.md5(lora_path.encode()).hexdigest()[:8]
+                lora_identifier = f"{lora_filename}_{lora_hash}"
+
+                cache_dir = os.path.join(root_dir, "EditScore", f"{os.path.basename(vlm_model)}_merged_lora_{lora_identifier}")
+
+            if not os.path.exists(cache_dir):
+                print(f"Merging LORA to {vlm_model} and saving to {cache_dir}", flush=True)
+                start_time = time.time()
+                model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+                    vlm_model, torch_dtype=torch.bfloat16, device_map="cpu"
+                )
+                model = PeftModel.from_pretrained(model, lora_path)
+                model = model.merge_and_unload()
+                model.save_pretrained(cache_dir)
+
+                processor = AutoProcessor.from_pretrained(vlm_model)
+                processor.save_pretrained(cache_dir)
+
+                print(f"Merging LORA to {vlm_model} and saving to {cache_dir} took {time.time() - start_time} seconds", flush=True)
+            else:
+                print(f"Skipping merging LORA, as merged model already exists in {cache_dir}", flush=True)
+
+            vlm_model = cache_dir
+
+        self.model = LLM(
+            model=vlm_model,
+            max_model_len=max_model_len,
+            tensor_parallel_size=tensor_parallel_size,
+            max_num_seqs=max_num_seqs,
+            max_num_batched_tokens=max_num_batched_tokens,
+            limit_mm_per_prompt={"image": 2},
+            enable_prefix_caching=True,
+        )
+        self.temperature = temperature
+        self.seed = seed
+    
+    def prepare_input(self, images, text_prompt: str = ""):
+        if not isinstance(images, list):
+            images = [images]
+
+        messages = [
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image} for image in images]
+                + [{"type": "text", "text": text_prompt}],
+            }
+        ]
+        text = apply_chat_template(text_prompt, num_images=len(images))
+        image_inputs, _ = process_vision_info(messages)
+
+        messages = {
+            "prompt": text,
+            "multi_modal_data": {"image": image_inputs},
+        }
+        return messages
+
+    def inference(self, messages, seed: Optional[int] = None):
+        seed = self.seed if seed is None else seed
+        sampling_params = SamplingParams(max_tokens=512, temperature=self.temperature, top_p=0.9, top_k=20, seed=seed)
+        outputs = self.model.generate(messages, sampling_params, use_tqdm=False)
+
+        responses = []
+        for output in outputs:
+            instruction = output.outputs[0].text.strip()
+            responses.append(instruction)
+
+        return responses[0]
+
+
+    def batch_inference(self, messages, seed: Optional[int] = None):
+        seed = self.seed if seed is None else seed
+        sampling_params = SamplingParams(max_tokens=512, temperature=self.temperature, top_p=0.9, top_k=20, seed=seed)
+        outputs = self.model.generate(messages, sampling_params, use_tqdm=False)
+
+        responses = []
+        for output in outputs:
+            instruction = output.outputs[0].text.strip()
+            responses.append(instruction)
+
+        return responses

editscore/mllm_tools/qwen3vl.py

@@ -0,0 +1,95 @@
+from typing import Optional
+import random
+import numpy as np
+import torch
+
+from transformers import Qwen3VLForConditionalGeneration, AutoProcessor
+from peft import PeftModel
+
+
+def set_seed(seed: int):
+    """
+    Args:
+    Helper function for reproducible behavior to set the seed in `random`, `numpy`, `torch`.
+        seed (`int`): The seed to set.
+    """
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def apply_chat_template(prompt, num_images: int = 2):
+    """
+    This is used since the bug of transformers which do not support vision id https://github.com/QwenLM/Qwen2.5-VL/issues/716#issuecomment-2723316100
+    """
+    template = "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n"
+    template += "".join([f"<img{i}>: <|vision_start|><|image_pad|><|vision_end|>" for i in range(1, num_images + 1)])
+    template += f"{prompt}<|im_end|>\n<|im_start|>assistant\n"
+    return template
+
+
+class Qwen3VL():
+    def __init__(
+        self,
+        vlm_model,
+        temperature: float = 0.7,
+        seed: Optional[int] = None,
+        lora_path: Optional[str] = None,
+    ) -> None:
+        self.model = Qwen3VLForConditionalGeneration.from_pretrained(
+            vlm_model, torch_dtype=torch.bfloat16, device_map="auto"
+        )
+        if lora_path:
+            self.model = PeftModel.from_pretrained(self.model, lora_path)
+            self.model = self.model.merge_and_unload()
+
+        self.processor = AutoProcessor.from_pretrained(vlm_model)
+        self.temperature = temperature
+        self.seed = seed
+    
+    def prepare_input(self, images, text_prompt: str = ""):
+        if not isinstance(images, list):
+            images = [images]
+
+        messages = [
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image} for image in images]
+                + [{"type": "text", "text": text_prompt}],
+            }
+        ]
+
+        inputs = self.processor.apply_chat_template(
+            messages,
+            tokenize=True,
+            add_generation_prompt=True,
+            return_dict=True,
+            return_tensors="pt"
+        )
+
+        inputs = inputs.to("cuda")
+
+        return inputs
+
+    def inference(self, inputs, seed: Optional[int] = None):
+        seed = self.seed if seed is None else seed
+
+        set_seed(seed)
+        generated_ids = self.model.generate(
+            **inputs,
+            max_new_tokens=512,
+            do_sample=True,
+            temperature=self.temperature,
+            top_p=0.9,
+            top_k=20,
+        )
+        generated_ids_trimmed = [
+            out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+        ]
+        outputs = self.processor.batch_decode(
+            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+        )
+
+        outputs = [output.strip() for output in outputs]
+        return outputs[0]

editscore/mllm_tools/qwen3vl_vllm.py

@@ -0,0 +1,141 @@
+from typing import Optional
+
+import os
+import hashlib
+import random
+import time
+import numpy as np
+import torch
+
+from vllm import LLM
+from vllm.sampling_params import SamplingParams
+
+from transformers import Qwen3VLForConditionalGeneration, AutoProcessor
+from peft import PeftModel
+
+from qwen_vl_utils import process_vision_info
+
+
+def set_seed(seed: int):
+    """
+    Args:
+    Helper function for reproducible behavior to set the seed in `random`, `numpy`, `torch`.
+        seed (`int`): The seed to set.
+    """
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def apply_chat_template(prompt, num_images: int = 2):
+    """
+    This is used since the bug of transformers which do not support vision id https://github.com/QwenLM/Qwen2.5-VL/issues/716#issuecomment-2723316100
+    """
+    template = "<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n"
+    template += "".join([f"<img{i}>: <|vision_start|><|image_pad|><|vision_end|>" for i in range(1, num_images + 1)])
+    template += f"{prompt}<|im_end|>\n<|im_start|>assistant\n"
+    return template
+
+
+class Qwen3VL():
+    def __init__(
+        self,
+        vlm_model,
+        max_model_len: int = 1536,
+        tensor_parallel_size=1,
+        max_num_seqs=32,
+        max_num_batched_tokens=1536,
+        temperature: float = 0.7,
+        seed: Optional[int] = None,
+        lora_path: Optional[str] = None,
+        cache_dir: Optional[str] = None,
+    ) -> None:
+        if lora_path:
+            if cache_dir is None:
+                root_dir = torch.hub.get_dir() # default: ~/.cache/torch/hub
+
+                lora_filename = os.path.splitext(os.path.basename(lora_path))[0]
+                lora_hash = hashlib.md5(lora_path.encode()).hexdigest()[:8]
+                lora_identifier = f"{lora_filename}_{lora_hash}"
+
+                cache_dir = os.path.join(root_dir, "EditScore", f"{os.path.basename(vlm_model)}_merged_lora_{lora_identifier}")
+
+            if not os.path.exists(cache_dir):
+                print(f"Merging LORA to {vlm_model} and saving to {cache_dir}", flush=True)
+                start_time = time.time()
+                model = Qwen3VLForConditionalGeneration.from_pretrained(
+                    vlm_model, torch_dtype=torch.bfloat16, device_map="cpu"
+                )
+                model = PeftModel.from_pretrained(model, lora_path)
+                model = model.merge_and_unload()
+                model.save_pretrained(cache_dir)
+
+                processor = AutoProcessor.from_pretrained(vlm_model)
+                processor.save_pretrained(cache_dir)
+
+                print(f"Merging LORA to {vlm_model} and saving to {cache_dir} took {time.time() - start_time} seconds", flush=True)
+            else:
+                print(f"Skipping merging LORA, as merged model already exists in {cache_dir}", flush=True)
+
+            vlm_model = cache_dir
+
+        self.model = LLM(
+            model=vlm_model,
+            max_model_len=max_model_len,
+            tensor_parallel_size=tensor_parallel_size,
+            max_num_seqs=max_num_seqs,
+            max_num_batched_tokens=max_num_batched_tokens,
+            limit_mm_per_prompt={"image": 2},
+            enable_prefix_caching=True,
+        )
+
+        self.processor = AutoProcessor.from_pretrained(vlm_model)
+        self.temperature = temperature
+        self.seed = seed
+    
+    def prepare_input(self, images, text_prompt: str = ""):
+        if not isinstance(images, list):
+            images = [images]
+
+        messages = [
+            {
+                "role": "user",
+                "content": [{"type": "image", "image": image} for image in images]
+                + [{"type": "text", "text": text_prompt}],
+            }
+        ]
+        # text = apply_chat_template(text_prompt, num_images=len(images))
+        text = self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        image_inputs, _ = process_vision_info(messages)
+
+        messages = {
+            "prompt": text,
+            "multi_modal_data": {"image": image_inputs},
+        }
+        return messages
+
+    def inference(self, messages, seed: Optional[int] = None):
+        seed = self.seed if seed is None else seed
+        sampling_params = SamplingParams(max_tokens=512, temperature=self.temperature, top_p=0.9, top_k=20, seed=seed)
+        outputs = self.model.generate(messages, sampling_params, use_tqdm=False)
+
+        responses = []
+        for output in outputs:
+            instruction = output.outputs[0].text.strip()
+            responses.append(instruction)
+
+        return responses[0]
+
+
+    def batch_inference(self, messages, seed: Optional[int] = None):
+        seed = self.seed if seed is None else seed
+        sampling_params = SamplingParams(max_tokens=512, temperature=self.temperature, top_p=0.9, top_k=20, seed=seed)
+        outputs = self.model.generate(messages, sampling_params, use_tqdm=False)
+
+        responses = []
+        for output in outputs:
+            instruction = output.outputs[0].text.strip()
+            responses.append(instruction)
+
+        return responses

editscore/mllm_tools/utils.py

@@ -0,0 +1,65 @@
+from typing import List
+import base64
+from io import BytesIO
+from PIL import Image
+import requests
+
+def pil_image_to_base64(pil_image, format="PNG"):
+    buffered = BytesIO()
+    pil_image.save(buffered, format=format)  # Save image to the buffer in the specified format
+    img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')  # Encode the buffer's content to base64
+    return img_str
+
+def load_image(image_file):
+    if image_file.startswith("http"):
+        response = requests.get(image_file)
+        image = Image.open(BytesIO(response.content)).convert("RGB")
+    else:
+        import os
+        image = Image.open(image_file).convert("RGB")
+    return image
+
+
+def load_images(image_files):
+    out = []
+    for image_file in image_files:
+        image = load_image(image_file)
+        out.append(image)
+    return out
+
+def merge_images(image_links: List = []):
+        """Merge multiple images into one image
+
+        Args:
+            image_links (List, optional): List of image links. Defaults to [].
+
+        Returns:
+            [type]: [description]
+        """
+        if len(image_links) == 0:
+            return None
+        images = load_images(image_links)
+        if len(images) == 1:
+            return images[0]
+        widths, heights = zip(*(i.size for i in images))
+        average_height = sum(heights) // len(heights)
+        for i, im in enumerate(images):
+            # scale in proportion
+            images[i] = im.resize((int(im.size[0] * average_height / im.size[1]), average_height))
+        widths, heights = zip(*(i.size for i in images))
+        total_width = sum(widths)
+        max_height = max(heights)
+        new_im = Image.new("RGB", (total_width + 10 * (len(images) - 1), max_height))
+        x_offset = 0
+        for i, im in enumerate(images):
+            if i > 0:
+                # past a column of 1 pixel starting from x_offset width being black, 8 pixels being white, and 1 pixel being black
+                new_im.paste(Image.new("RGB", (1, max_height), (0, 0, 0)), (x_offset, 0))
+                x_offset += 1
+                new_im.paste(Image.new("RGB", (8, max_height), (255, 255, 255)), (x_offset, 0))
+                x_offset += 8
+                new_im.paste(Image.new("RGB", (1, max_height), (0, 0, 0)), (x_offset, 0))
+                x_offset += 1
+            new_im.paste(im, (x_offset, 0))
+            x_offset += im.size[0]
+        return new_im

editscore/utils.py

@@ -0,0 +1,534 @@
+import os
+from typing import Union, List, Optional
+import json
+import regex as re
+import ast
+import random
+import json_repair
+
+def fix_json(input_str):
+    # Add double quotes around keys using regex
+    fixed_str = re.sub(r'(\w+):', r'"\1":', input_str)
+    
+    # Add double quotes around string values if necessary and wrap int/float values in []
+    def format_value(match):
+        key, value, comma = match.groups()
+        value = value.strip()
+        # Check if value is an integer or float
+        if re.match(r'^-?\d+(\.\d+)?$', value):
+            value = f'[{value}]'
+        # Check if value is a boolean or null
+        elif re.match(r'^(true|false|null)$', value, re.IGNORECASE):
+            pass  # leave as is
+        else:
+            # Add quotes around string values
+            value = f'"{value}"'
+        return f'{key}: {value}{comma}'
+    
+    fixed_str = re.sub(r'(".*?"):(.*?)(,|})', format_value, fixed_str)
+    
+    return fixed_str
+
+def repair_reasoning_field_robust(json_str: str) -> str:
+    """
+    Robustly repair unescaped double quotes inside the "reasoning" field of a JSON string.
+    This function uses regular expressions and a lookahead assertion to locate
+    the end of the "reasoning" value, even if it is not the last field in the JSON.
+
+    Args:
+        json_str (str): A possibly malformed JSON string that may contain
+                        unescaped quotes within the "reasoning" field.
+
+    Returns:
+        str: A repaired JSON string with properly escaped quotes inside "reasoning".
+    """
+    # 1. Define a regex pattern that locates the reasoning value using a lookahead.
+    # The re.DOTALL flag allows '.' to match newline characters.
+    pattern = re.compile(
+        # --- Group 1: prefix part including the "reasoning" key and opening quote ---
+        r'("reasoning"\s*:\s*")'
+        
+        # --- Group 2: content inside the reasoning string (non-greedy) ---
+        r'(.*?)'
+        
+        # --- Lookahead assertion ---
+        # Match the ending quote of the "reasoning" value,
+        # but only if it is followed by a comma or closing brace.
+        r'(?="\s*[,}])',
+        
+        re.DOTALL
+    )
+
+    # 2. Define a replacement function to escape quotes inside the "reasoning" content.
+    def replacer(match):
+        prefix = match.group(1)   # e.g., '"reasoning": "'
+        content = match.group(2)  # e.g., 'Overall building...'
+
+        # Escape all unescaped double quotes inside the reasoning text.
+        fixed_content = content.replace('"', '\\"')
+
+        # Reassemble the full matched segment. The suffix is not consumed by the pattern,
+        # so we just return the prefix + repaired content.
+        return prefix + fixed_content
+
+    # 3. Apply the regex substitution across the entire JSON string.
+    repaired_str = pattern.sub(replacer, json_str)
+
+    return repaired_str
+
+def fallback_repair_json(input_str: str) -> str:
+    """
+    Last-resort JSON repair that tries to preserve the 'reasoning' text
+    even when it contains unescaped quotes or other corruption.
+
+    Target output:
+      {"reasoning": "<text>", "score": [float, float]}
+
+    Approach:
+      1. Locate 'reasoning' key position and 'score' key position.
+      2. Extract the raw substring between them (reasoning_raw).
+      3. Clean only the outer noise (leading/trailing quotes, commas, braces),
+         but preserve internal punctuation.
+      4. Unescape common escape sequences and normalize quotes.
+      5. Extract numeric scores robustly.
+      6. Return a valid JSON string.
+    """
+
+    s = input_str
+
+    # Normalize whitespace for easier searching (but keep original for slicing)
+    lowered = s.lower()
+
+    # 1) find the start of reasoning key (case-insensitive)
+    m_reason = re.search(r'"?reasoning"?\s*[:：]', lowered)
+    m_score = re.search(r'"?score"?\s*[:：]', lowered)
+
+    reasoning_text = ""
+    scores = []
+
+    if m_reason and m_score:
+        # compute the real indices in the original string
+        start_idx = m_reason.end()  # right after colon in 'reasoning:'
+        score_start_idx = m_score.start()
+
+        # 2) slice the original string between reasoning value start and score key start
+        reasoning_raw = s[start_idx:score_start_idx]
+
+        # 3) clean outer noise but preserve inner content:
+        #    - strip whitespace and outer commas/braces
+        reasoning_raw = reasoning_raw.strip()
+        # remove leading commas/braces/colons
+        reasoning_raw = re.sub(r'^[\s,{\[]+', '', reasoning_raw)
+        # remove trailing commas/braces/colons (but keep inner punctuation)
+        reasoning_raw = re.sub(r'[\s,}\]]+$', '', reasoning_raw)
+
+        # If the reasoning starts with a quote char, drop it (we'll re-escape later).
+        if reasoning_raw.startswith(("'", '"')):
+            reasoning_raw = reasoning_raw[1:]
+        # If it ends with a quote char (common), drop it.
+        if reasoning_raw.endswith(("'", '"')):
+            reasoning_raw = reasoning_raw[:-1]
+
+        # 4) normalize escapes:
+        # Replace common escaped sequences (\" -> "), but avoid creating unbalanced quotes.
+        reasoning_raw = reasoning_raw.replace('\\"', '"').replace("\\'", "'")
+        # Replace fancy quotes with straight quotes (optional)
+        reasoning_raw = re.sub(r'[“”]', '"', reasoning_raw)
+        reasoning_raw = re.sub(r"[‘’]", "'", reasoning_raw)
+
+        # Trim again
+        reasoning_text = reasoning_raw.strip()
+    else:
+        # If we couldn't find both keys, try a looser regex capturing 'reasoning' value
+        m_loose = re.search(r'"?reasoning"?\s*[:：]\s*["\']?(.*?)["\']?\s*(,|$)', s, re.DOTALL | re.IGNORECASE)
+        if m_loose:
+            reasoning_text = m_loose.group(1).strip()
+            # normalize escapes as above
+            reasoning_text = reasoning_text.replace('\\"', '"').replace("\\'", "'")
+            reasoning_text = re.sub(r'[“”]', '"', reasoning_text)
+            reasoning_text = re.sub(r"[‘’]", "'", reasoning_text)
+
+    # 5) Extract two numeric scores anywhere after the 'score' key (robust)
+    if m_score:
+        # slice from score key to the end
+        score_slice = s[m_score.end():]
+        # find numbers (integers or floats)
+        nums = re.findall(r'-?\d+(?:\.\d+)?', score_slice)
+        try:
+            scores = [float(n) for n in nums[:2]]
+        except Exception:
+            scores = []
+    else:
+        # fallback: try to find any two numbers in the whole string
+        nums = re.findall(r'-?\d+(?:\.\d+)?', s)
+        try:
+            scores = [float(n) for n in nums[:2]]
+        except Exception:
+            scores = []
+
+    # Ensure we always return two floats
+    if len(scores) < 2:
+        scores += [0.0] * (2 - len(scores))
+
+    # 6) Construct final object. Let json.dumps handle escaping inside the reasoning.
+    repaired_obj = {
+        "reasoning": reasoning_text,
+        "score": scores
+    }
+
+    return json.dumps(repaired_obj, ensure_ascii=False)
+
+def robust_json_fix(s: str):
+    try:
+        return json_repair.loads(s)
+    except Exception:
+        pass
+    
+    for fixer in [fix_json, repair_reasoning_field_robust]:
+        s = fixer(s)
+        try:
+            return json_repair.loads(s)
+        except Exception:
+            print(f"Error: Cannot fix {fixer.__name__} {s=}")
+            continue
+
+    try:
+        repaired_str = fallback_repair_json(s)
+        return json_repair.loads(repaired_str)
+    except Exception as e:
+        print(f"Error: Cannot fix fallback_repair_json {s=} {e=}")
+        return False
+        
+def read_file_to_string(file_path):
+    """
+    Reads the contents of a text file and returns it as a string.
+
+    :param file_path: The path to the text file.
+    :return: A string containing the contents of the file.
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            return file.read()
+    except FileNotFoundError:
+        print(f"The file {file_path} was not found.")
+        return None
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None
+
+def read_files_to_string(file_paths):
+    """
+    Reads the contents of multiple text files and returns them as a single string,
+    with each file's contents separated by a newline.
+
+    :param file_paths: A list of paths to text files.
+    :return: A string containing the concatenated contents of the files.
+    """
+    all_contents = []  # List to hold the contents of each file
+
+    for file_path in file_paths:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as file:
+                all_contents.append(file.read())
+        except FileNotFoundError:
+            print(f"The file {file_path} was not found.")
+        except Exception as e:
+            print(f"An error occurred while reading {file_path}: {e}")
+
+    # Join all the contents with a newline character
+    return "\n".join(all_contents)
+
+def get_file_path(filename: Union[str, os.PathLike], search_from: Union[str, os.PathLike] = "."):
+    """
+    Search for a file across a directory and return its absolute path.
+
+    Args:
+        filename (Union[str, os.PathLike]): The name of the file to search for.
+        search_from (Union[str, os.PathLike], optional): The directory from which to start the search. Defaults to ".".
+
+    Returns:
+        str: Absolute path to the found file.
+
+    Raises:
+        FileNotFoundError: If the file is not found.
+    """
+    for root, dirs, files in os.walk(search_from):
+        for name in files:
+            if name == filename:
+                return os.path.abspath(os.path.join(root, name))
+    raise FileNotFoundError(filename, "not found.")
+
+
+
+#+=========================================================================================
+def verify(s, target_sequence):
+    # Count the occurrences of the target sequence
+    count = s.count(target_sequence)
+
+    # Check if the target sequence appears exactly twice
+    return count == 2
+
+
+def is_int_between_0_and_10(s):
+    try:
+        num = int(s)
+        return 0 <= num <= 10
+    except ValueError:
+        return False
+    
+def is_str_a_list_of_ints_0_to_10(s):
+    try:
+        # Attempt to parse the string as a Python literal (list, dict, etc.)
+        parsed = ast.literal_eval(s)
+
+        # Check if the parsed object is a list
+        if not isinstance(parsed, list):
+            return False
+
+        # Check if all elements are integers and between 0 to 10
+        return all(isinstance(item, int) and 0 <= item <= 10 for item in parsed)
+
+    except (ValueError, SyntaxError):
+        # If parsing fails or any other error occurs
+        return False
+    
+def is_str_valid_score_format_brackets(s):
+    try:
+        # Removing brackets and splitting the string by commas
+        content = s.strip("[]").split(',')
+
+        length = len(content)
+
+        # Parsing each element and checking the format and range
+        scores = {}
+        for item in content:
+            key, value = item.split(':')
+            key = key.strip()
+            value = int(value.strip())
+
+            # Check if the key starts with 'score' and the value is in the correct range
+            if not key.startswith("score") or not 0 <= value <= 10:
+                return False
+
+            scores[key] = value
+
+        fetch_words = [f"score{i+1}" for i in range(length)]
+        # Check if at least 'score1' and 'score2' are present
+        return all(key in scores for key in fetch_words)
+
+    except (ValueError, SyntaxError):
+        # If any parsing error occurs
+        return False
+
+def normalize_quotes(s: str) -> str:
+    """
+    Replace curly/smart quotes with normal ASCII quotes.
+    """
+    # 常见的几种智能引号 U+201C U+201D U+2018 U+2019
+    return s.replace("“", '"').replace("”", '"').replace("‘", "'").replace("’", "'")
+
+
+#+=========================================================================================
+def mllm_output_to_dict(input_string, give_up_parsing=False, text_prompt=None, score_range: int = 10):
+    """
+    Args:
+        input_string (str): actually the output of the mllm model to be parsed
+        output_file_name (str): The name of the output file.
+    """
+    # Catch for gpt4v rate_limit_exceeded error
+    if input_string == "rate_limit_exceeded":
+        return "rate_limit_exceeded"
+
+    if give_up_parsing:
+        guessed_value = random.randint(0, score_range)
+        json_content = {'score': [guessed_value, guessed_value], "reasoning": f"guess_if_cannot_parse | {input_string}"}
+        return json_content
+    
+    # Define the delimiters
+    delimiter = '||V^=^V||'
+
+    if input_string.count(delimiter) == 2:
+        if not verify(input_string, delimiter):
+            print("The required delimiters were not found correctly in the string.", flush=True)
+            return False
+        # Extract the content between the delimiters
+        start_index = input_string.find(delimiter) + len(delimiter)
+        end_index = input_string.rfind(delimiter)
+    else:
+        # find the json mannually
+        # some mllm tends not to output the delimiters, but it does output the json contents
+        # so we will find the json content mannually
+        start_index = input_string.find('{')
+        end_index = input_string.rfind('}') + 1
+        if start_index == -1 or end_index == 0:
+            # json not found
+            # some mllm tends to output only a list of scores like [6, 0], 
+            # this time we will just get the scores and ignore the reasoning (other part of the json)
+            start_index = input_string.find('[')
+            end_index = input_string.rfind(']') + 1
+            if re.match(r'^\[\d+, ?\d+\]$', input_string[start_index:end_index]):
+                scores = json.loads(input_string[start_index:end_index])
+                if not isinstance(scores, list):
+                    scores = [scores]
+                json_content = {'score': scores, "reasoning": "System: output is simply a list of scores"}
+                json_str = json.dumps(json_content)
+                input_string = json_str
+                start_index = 0
+                end_index = len(json_str)
+            elif is_int_between_0_and_10(input_string): # if output is simply a number
+                scores = [int(input_string)]
+                json_content = {'score': scores, "reasoning": "System: output is simply a number"}
+                json_str = json.dumps(json_content)
+                input_string = json_str
+                start_index = 0
+                end_index = len(json_str)
+            else:
+                print(f"22 222 Failed to find the json content in the string. {text_prompt=} {input_string=}", flush=True)
+                return False
+    
+    # Check if we found two delimiters
+    if start_index != -1 and end_index != -1 and start_index != end_index:
+        # Extract the JSON string
+        json_str = input_string[start_index:end_index].strip()
+        json_str = json_str.replace("\n", "")
+        # Parse the JSON string into a dictionary
+        try:
+            json_str = normalize_quotes(json_str)
+            new_data = json.loads(json_str)
+            if not isinstance(new_data['score'], list):
+                new_data['score'] = [new_data['score']]
+        except Exception as e1:
+            print(f"Now fixing: {e1=} {json_str=}")
+            
+            new_data = robust_json_fix(json_str)
+        return new_data
+    else:
+        print("The required delimiters were not found correctly in the string.")
+        return False
+
+def write_entry_to_json_file(input_string, uid, prompt_input, vision_input, output_file_name, give_up_parsing=False):
+    """
+    Args:
+        input_string (str): actually the output of the mllm model to be parsed
+        uid (str): The unique identifier for the each item in the test data
+        prompt_input (str): The prompt input for the entry. text prompt.
+        vision_input (str): The vision input for the entry. image links.
+        output_file_name (str): The name of the output file.
+    """
+    # Catch for gpt4v rate_limit_exceeded error
+    if input_string == "rate_limit_exceeded":
+        return "rate_limit_exceeded"
+
+    # Define the delimiters
+    delimiter = '||V^=^V||'
+
+    if input_string.count(delimiter) == 2:
+        if not verify(input_string, delimiter):
+            print("The required delimiters were not found correctly in the string.")
+            return False
+        # Extract the content between the delimiters
+        start_index = input_string.find(delimiter) + len(delimiter)
+        end_index = input_string.rfind(delimiter)
+    else:
+        # find the json mannually
+        # some mllm tends not to output the delimiters, but it does output the json contents
+        # so we will find the json content mannually
+        start_index = input_string.find('{')
+        end_index = input_string.rfind('}') + 1
+        if start_index == -1 or end_index == 0:
+            # json not found
+            # some mllm tends to output only a list of scores like [6, 0], 
+            # this time we will just get the scores and ignore the reasoning (other part of the json)
+            start_index = input_string.find('[')
+            end_index = input_string.rfind(']') + 1
+            if give_up_parsing: # if we want to give up parsing
+                guessed_value = random.randint(0, 10)
+                print(f"Failed to find the json content in the string. Guess a value : {guessed_value}.")
+                json_content = {'score': [guessed_value], "reasoning": f"guess_if_cannot_parse | {input_string}"}
+                json_str = json.dumps(json_content)
+                input_string = json_str
+                start_index = 0
+                end_index = len(json_str)
+            elif re.match(r'^\[\d+, ?\d+\]$', input_string[start_index:end_index]):
+                scores = json.loads(input_string[start_index:end_index])
+                json_content = {'score': scores, "reasoning": None}
+                json_str = json.dumps(json_content)
+                input_string = json_str
+                start_index = 0
+                end_index = len(json_str)
+            elif is_int_between_0_and_10(input_string): # if output is simply a number
+                scores = [int(input_string)]
+                json_content = {'score': scores, "reasoning": None}
+                json_str = json.dumps(json_content)
+                input_string = json_str
+                start_index = 0
+                end_index = len(json_str)
+            else:
+                print("Failed to find the json content in the string.")
+                return False
+    
+    # Check if we found two delimiters
+    if start_index != -1 and end_index != -1 and start_index != end_index:
+        # Extract the JSON string
+        json_str = input_string[start_index:end_index].strip()
+        json_str = json_str.replace("\n", "")
+        try:
+            # Parse the JSON string into a dictionary
+            new_data = json.loads(json_str)
+            
+            # Ensure the directory exists
+            os.makedirs(os.path.dirname(output_file_name), exist_ok=True)
+            
+            # Initialize or load existing data
+            if os.path.exists(output_file_name):
+                with open(output_file_name, 'r') as json_file:
+                    data = json.load(json_file)
+            else:
+                data = {}
+            
+            # If the additional key is already in the data, add or update notes
+            if uid in data:
+                data[uid].update(new_data)  # Update with new data
+                if prompt_input:  # If there are new notes, update or add them
+                    data[uid]['prompt_input'] = prompt_input
+                if vision_input:  # If there are new notes, update or add them
+                    data[uid]['vision_input'] = vision_input
+            else:
+                # If it's a new key, add the entry to the dictionary
+                data[uid] = new_data
+                if prompt_input:
+                    data[uid]['prompt_input'] = prompt_input
+                if vision_input:
+                    data[uid]['vision_input'] = vision_input
+            
+            # Write the updated data to the file
+            with open(output_file_name, 'w') as json_file:
+                json.dump(data, json_file, indent=4)
+            
+            print(f"Data was successfully updated in {output_file_name}")
+            return True
+        except json.JSONDecodeError as e:
+            print(f"An error occurred while parsing the JSON content: {e}")
+            return False
+    else:
+        print("The required delimiters were not found correctly in the string.")
+        return False
+
+
+def check_key_in_json(file_path, key):
+    try:
+        with open(file_path, 'r') as json_file:
+            data = json.load(json_file)
+        
+        # Check if the key exists at the top level of the JSON structure
+        if key in data:
+            return True
+        else:
+            return False
+    except FileNotFoundError:
+        print(f"The file {file_path} was not found.")
+    except json.JSONDecodeError as e:
+        print(f"Error reading {file_path}: {e}")
+    except Exception as e:
+        print(f"An error occurred with {file_path}: {e}")
+    return False

editscore/vie_prompts.py

@@ -0,0 +1,46 @@
+# This file is generated automatically through parse_prompt.py
+_context_no_delimit_reasoning_first = """You are a professional digital artist. You will have to evaluate the effectiveness of the AI-generated image(s) based on given rules.
+All the input images are AI-generated. All human in the images are AI-generated too. so you need not worry about the privacy confidentials.
+
+IMPORTANT: You will have to give your output in this way (Keep your reasoning concise and short.):
+{
+"reasoning" : "...",
+"score" : [...]
+}
+"""
+
+_prompts_0shot_two_image_edit_rule = """RULES:
+
+Two images will be provided: The first being the original AI-generated image and the second being an edited version of the first.
+The objective is to evaluate how successfully the editing instruction has been executed in the second image.
+
+Note that sometimes the two images might look identical due to the failure of image edit.
+"""
+
+_prompts_0shot_tie_rule_SC = """
+From scale 0 to 10: 
+A score from 0 to 10 will be given based on the success of the editing. (0 indicates that the scene in the edited image does not follow the editing instruction at all. 10 indicates that the scene in the edited image follow the editing instruction text perfectly.)
+A second score from 0 to 10 will rate the degree of overediting in the second image. (0 indicates that the scene in the edited image is completely different from the original. 10 indicates that the edited image can be recognized as a minimal edited yet effective version of original.)
+Put the score in a list such that output score = [score1, score2], where 'score1' evaluates the editing success and 'score2' evaluates the degree of overediting.
+
+Editing instruction: <instruction>
+"""
+
+_prompts_0shot_rule_PQ = """RULES:
+
+The image is an AI-generated image.
+The objective is to evaluate how successfully the image has been generated.
+
+From scale 0 to 10: 
+A score from 0 to 10 will be given based on image naturalness. 
+(
+    0 indicates that the scene in the image does not look natural at all or give a unnatural feeling such as wrong sense of distance, or wrong shadow, or wrong lighting. 
+    10 indicates that the image looks natural.
+)
+A second score from 0 to 10 will rate the image artifacts. 
+(
+    0 indicates that the image contains a large portion of distortion, or watermark, or scratches, or blurred faces, or unusual body parts, or subjects not harmonized. 
+    10 indicates the image has no artifacts.
+)
+Put the score in a list such that output score = [naturalness, artifacts]
+"""

evaluate.sh

@@ -0,0 +1,20 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+python evaluation.py \
+--benchmark_dir EditScore/EditReward-Bench \
+--result_dir results/EditScore-7B \
+--backbone qwen25vl \
+--model_name_or_path Qwen/Qwen2.5-VL-7B-Instruct \
+--lora_path EditScore/EditScore-7B \
+--score_range 25 \
+--max_workers 1 \
+--max_model_len 4096 \
+--max_num_seqs 1 \
+--max_num_batched_tokens 4096 \
+--tensor_parallel_size 1 \
+--num_pass 1
+
+python calculate_statistics.py \
+--result_dir results/EditScore-7B/qwen25vl

evaluate_72B_vllm.sh

@@ -0,0 +1,20 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+python evaluation.py \
+--benchmark_dir EditScore/EditReward-Bench \
+--result_dir results/EditScore-72B \
+--backbone qwen25vl_vllm \
+--model_name_or_path Qwen/Qwen2.5-VL-72B-Instruct \
+--lora_path EditScore/EditScore-72B \
+--score_range 25 \
+--max_workers 1 \
+--max_model_len 4096 \
+--max_num_seqs 1 \
+--max_num_batched_tokens 4096 \
+--tensor_parallel_size 4 \
+--num_pass 1
+
+python calculate_statistics.py \
+--result_dir results/EditScore-72B/qwen25vl_vllm

evaluate_qwen3_vl_32B.sh

@@ -0,0 +1,20 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+python evaluation.py \
+--benchmark_dir EditScore/EditReward-Bench \
+--result_dir results/EditScore-Qwen3-VL-32B \
+--backbone qwen3vl \
+--model_name_or_path Qwen/Qwen3-VL-32B-Instruct \
+--lora_path EditScore/EditScore-Qwen3-VL-32B-Instruct \
+--score_range 25 \
+--max_workers 1 \
+--max_model_len 4096 \
+--max_num_seqs 1 \
+--max_num_batched_tokens 4096 \
+--tensor_parallel_size 1 \
+--num_pass 1
+
+python calculate_statistics.py \
+--result_dir results/EditScore-Qwen3-VL-32B/qwen3vl

evaluate_qwen3_vl_32B_avg4.sh

@@ -0,0 +1,20 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+python evaluation.py \
+--benchmark_dir EditScore/EditReward-Bench \
+--result_dir results/EditScore-Qwen3-VL-32B-avg4 \
+--backbone qwen3vl \
+--model_name_or_path Qwen/Qwen3-VL-32B-Instruct \
+--lora_path EditScore/EditScore-Qwen3-VL-32B-Instruct \
+--score_range 25 \
+--max_workers 1 \
+--max_model_len 4096 \
+--max_num_seqs 1 \
+--max_num_batched_tokens 4096 \
+--tensor_parallel_size 1 \
+--num_pass 4
+
+python calculate_statistics.py \
+--result_dir results/EditScore-Qwen3-VL-32B-avg4/qwen3vl

evaluate_qwen3_vl_4B.sh

@@ -0,0 +1,20 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+python evaluation.py \
+--benchmark_dir EditScore/EditReward-Bench \
+--result_dir results/EditScore-Qwen3-VL-4B \
+--backbone qwen3vl \
+--model_name_or_path Qwen/Qwen3-VL-4B-Instruct \
+--lora_path EditScore/EditScore-Qwen3-VL-4B-Instruct \
+--score_range 25 \
+--max_workers 1 \
+--max_model_len 4096 \
+--max_num_seqs 1 \
+--max_num_batched_tokens 4096 \
+--tensor_parallel_size 1 \
+--num_pass 1
+
+python calculate_statistics.py \
+--result_dir results/EditScore-Qwen3-VL-4B/qwen3vl

evaluate_qwen3_vl_4B_avg4.sh

@@ -0,0 +1,20 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+python evaluation.py \
+--benchmark_dir EditScore/EditReward-Bench \
+--result_dir results/EditScore-Qwen3-VL-4B-avg4 \
+--backbone qwen3vl \
+--model_name_or_path Qwen/Qwen3-VL-4B-Instruct \
+--lora_path EditScore/EditScore-Qwen3-VL-4B-Instruct \
+--score_range 25 \
+--max_workers 1 \
+--max_model_len 4096 \
+--max_num_seqs 1 \
+--max_num_batched_tokens 4096 \
+--tensor_parallel_size 1 \
+--num_pass 4
+
+python calculate_statistics.py \
+--result_dir results/EditScore-Qwen3-VL-4B-avg4/qwen3vl

evaluate_qwen3_vl_4B_vllm.sh

@@ -0,0 +1,20 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+python evaluation.py \
+--benchmark_dir EditScore/EditReward-Bench \
+--result_dir results/EditScore-Qwen3-VL-4B \
+--backbone qwen3vl_vllm \
+--model_name_or_path Qwen/Qwen3-VL-4B-Instruct \
+--lora_path EditScore/EditScore-Qwen3-VL-4B-Instruct \
+--score_range 25 \
+--max_workers 1 \
+--max_model_len 4096 \
+--max_num_seqs 1 \
+--max_num_batched_tokens 4096 \
+--tensor_parallel_size 1 \
+--num_pass 1
+
+python calculate_statistics.py \
+--result_dir results/EditScore-Qwen3-VL-4B/qwen3vl_vllm

evaluate_qwen3_vl_8B.sh

@@ -0,0 +1,20 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+python evaluation.py \
+--benchmark_dir EditScore/EditReward-Bench \
+--result_dir results/EditScore-Qwen3-VL-8B \
+--backbone qwen3vl \
+--model_name_or_path Qwen/Qwen3-VL-8B-Instruct \
+--lora_path EditScore/EditScore-Qwen3-VL-8B-Instruct \
+--score_range 25 \
+--max_workers 1 \
+--max_model_len 4096 \
+--max_num_seqs 1 \
+--max_num_batched_tokens 4096 \
+--tensor_parallel_size 1 \
+--num_pass 1
+
+python calculate_statistics.py \
+--result_dir results/EditScore-Qwen3-VL-8B/qwen3vl

evaluate_qwen3_vl_8B_avg4.sh

@@ -0,0 +1,20 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+python evaluation.py \
+--benchmark_dir EditScore/EditReward-Bench \
+--result_dir results/EditScore-Qwen3-VL-8B-avg4 \
+--backbone qwen3vl \
+--model_name_or_path Qwen/Qwen3-VL-8B-Instruct \
+--lora_path EditScore/EditScore-Qwen3-VL-8B-Instruct \
+--score_range 25 \
+--max_workers 1 \
+--max_model_len 4096 \
+--max_num_seqs 1 \
+--max_num_batched_tokens 4096 \
+--tensor_parallel_size 1 \
+--num_pass 4
+
+python calculate_statistics.py \
+--result_dir results/EditScore-Qwen3-VL-8B-avg4/qwen3vl

evaluate_vllm.sh

@@ -0,0 +1,20 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+python evaluation.py \
+--benchmark_dir EditScore/EditReward-Bench \
+--result_dir results/EditScore-7B \
+--backbone qwen25vl_vllm \
+--model_name_or_path Qwen/Qwen2.5-VL-7B-Instruct \
+--lora_path EditScore/EditScore-7B \
+--score_range 25 \
+--max_workers 1 \
+--max_model_len 4096 \
+--max_num_seqs 1 \
+--max_num_batched_tokens 4096 \
+--tensor_parallel_size 1 \
+--num_pass 1
+
+python calculate_statistics.py \
+--result_dir results/EditScore-7B/qwen25vl_vllm

evaluation.py

@@ -0,0 +1,272 @@
+import dotenv
+
+dotenv.load_dotenv(override=True)
+
+import argparse
+import glob
+import hashlib
+import json
+import logging
+import os
+import time
+import threading
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, as_completed
+from typing import List, Tuple, Dict, Any, Optional
+
+import dotenv
+from PIL import Image
+from tqdm import tqdm
+from datasets import Dataset, load_dataset
+
+from editscore import EditScore
+
+PROMPT_FOLLOWING = "prompt_following"
+CONSISTENCY = "consistency"
+OVERALL = "overall"
+SCORE_CATEGORIES = [PROMPT_FOLLOWING, CONSISTENCY, OVERALL]
+
+
+class CacheManager:
+    def __init__(self, cache_file: str):
+        self.cache_file = cache_file
+        self.lock = threading.Lock()
+        self.cache = self._load()
+
+    def _load(self) -> Dict[str, Any]:
+        cache = {}
+        if not os.path.exists(self.cache_file):
+            print(
+                f"Cache file not found at {self.cache_file}. A new one will be created."
+            )
+            return cache
+
+        with open(self.cache_file, "r", encoding="utf-8") as f:
+            for i, line in enumerate(f):
+                try:
+                    data = json.loads(line)
+                    cache[data["key"]] = data["result"]
+                except json.JSONDecodeError:
+                    logging.warning(
+                        f"Skipping corrupted line {i + 1} in cache file: {line.strip()}"
+                    )
+        print(f"Loaded {len(cache)} items from {self.cache_file}.")
+        return cache
+
+    def get(self, key: str) -> Optional[Any]:
+        return self.cache.get(key)
+
+    def append(self, key: str, result: Any):
+        with self.lock:
+            self.cache[key] = result
+            with open(self.cache_file, "a", encoding="utf-8") as f:
+                f.write(
+                    json.dumps({"key": key, "result": result}, ensure_ascii=False)
+                    + "\n"
+                )
+
+def generate_cache_key(pair_key):
+    return hashlib.sha256(pair_key.encode("utf-8")).hexdigest()
+
+def load_pairs_dataset(dataset: Dataset) -> Dict[str, Tuple[str, Image.Image, Image.Image]]:
+    pairs = {}
+    for data in dataset:
+        key1, key2 = data["key"]
+        instruction = data["instruction"]
+        input_image = data["input_image"].convert("RGB")
+
+        pairs[key1] = (instruction, input_image, data["output_images"][0].convert("RGB"))
+        pairs[key2] = (instruction, input_image, data["output_images"][1].convert("RGB"))
+    return pairs
+
+def _load_item(data: dict) -> list[tuple[str, tuple[str, Image.Image, Image.Image]]]:
+    key1, key2 = data["key"]
+    instruction = data["instruction"]
+    
+    input_image = data["input_image"].convert("RGB")
+    output_image1 = data["output_images"][0].convert("RGB")
+    output_image2 = data["output_images"][1].convert("RGB")
+
+    return [
+        (key1, (instruction, input_image, output_image1)),
+        (key2, (instruction, input_image, output_image2)),
+    ]
+
+def load_pairs_dataset_multithreaded(dataset: Dataset, max_workers: int = None) -> Dict[str, Tuple[str, Image.Image, Image.Image]]:
+    if max_workers is None:
+        # max_workers = min(32, (os.cpu_count() or 1) * 5)  
+        max_workers = os.cpu_count() or 1
+
+    pairs = {}
+    
+    print(f"Processing dataset (length: {len(dataset)}) with {max_workers} threads", flush=True)
+    
+    with ProcessPoolExecutor(max_workers=max_workers) as executor:
+        results_iterator = tqdm(
+            executor.map(_load_item, dataset), 
+            total=len(dataset), 
+            desc="Processing dataset with multiple threads"
+        )
+        
+        for result_pairs in results_iterator:
+            pairs.update(result_pairs)
+            
+    return pairs
+
+
+def process_single_item(key, item, scorer):
+    instruction = item[0]
+    input_image = item[1]
+    output_image = item[2]
+    
+    output_image = output_image.resize((input_image.size[0], input_image.size[1]))
+
+    score = scorer.evaluate([input_image, output_image], instruction)
+    return key, score
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--benchmark_dir", type=str, default="EditScore/EditReward-Bench"
+    )
+    parser.add_argument("--result_dir", type=str, required=True)
+    parser.add_argument(
+        "--backbone",
+        type=str,
+        default="openai",
+        choices=["openai", "qwen25vl", "qwen25vl_vllm", "internvl3_5", "qwen3vl", "qwen3vl_vllm"],
+    )
+    parser.add_argument("--model_name_or_path", type=str, default="gpt-4.1")
+    parser.add_argument(
+        "--openai_url", type=str, default="https://api.openai.com/v1/chat/completions"
+    )
+    parser.add_argument("--key", type=str, default="PUT YOUR API KEY HERE")
+    parser.add_argument("--num_pass", type=int, default=1)
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--max_workers", type=int, default=20)
+    parser.add_argument("--score_range", type=int, default=25)
+    parser.add_argument("--tensor_parallel_size", type=int, default=1)
+    parser.add_argument("--max_model_len", type=int, default=1536)
+    parser.add_argument("--max_num_seqs", type=int, default=32)
+    parser.add_argument("--max_num_batched_tokens", type=int, default=1536)
+    parser.add_argument("--lora_path", type=str, default="EditScore/EditScore-7B")
+    parser.add_argument("--cache_dir", type=str, default=None)
+    return parser.parse_args()
+
+
+def main(args):
+    start_time = time.time()
+    scorer = EditScore(
+        backbone=args.backbone,
+        key=args.key,
+        openai_url=args.openai_url,
+        model_name_or_path=args.model_name_or_path,
+        score_range=args.score_range,
+        temperature=args.temperature,
+        tensor_parallel_size=args.tensor_parallel_size,
+        max_model_len=args.max_model_len,
+        max_num_seqs=args.max_num_seqs,
+        max_num_batched_tokens=args.max_num_batched_tokens,
+        num_pass=args.num_pass,
+        lora_path=args.lora_path,
+        cache_dir=args.cache_dir,
+    )
+    print(f"Scorer initialized in {time.time() - start_time} seconds", flush=True)
+
+    cache_dir = os.path.join(args.result_dir, ".cache")
+    os.makedirs(cache_dir, exist_ok=True)
+    cache_file = os.path.join(
+        cache_dir, f"{args.backbone}_{args.model_name_or_path.replace('/', '_')}.jsonl"
+    )
+    cache_manager = CacheManager(cache_file)
+
+    start_time = time.time()
+    dataset = load_dataset(args.benchmark_dir, split="train")
+    print(f"Dataset loaded in {time.time() - start_time} seconds", flush=True)
+
+    start_time = time.time()
+    unique_pairs = load_pairs_dataset_multithreaded(dataset)
+    print(f"Pairs loaded in {time.time() - start_time} seconds", flush=True)
+
+    all_scores = {}
+    pairs_to_process = [
+        pair_key
+        for pair_key in unique_pairs.keys()
+        if cache_manager.get(generate_cache_key(pair_key)) is None
+    ]
+
+    for pair_key in unique_pairs.keys():
+        if pair_key not in pairs_to_process:
+            all_scores[pair_key] = cache_manager.get(generate_cache_key(pair_key))
+
+    print(
+        f"{len(unique_pairs) - len(pairs_to_process)} pairs found in cache. Processing {len(pairs_to_process)} new pairs.",
+        flush=True
+    )
+
+    if pairs_to_process:
+        with ThreadPoolExecutor(max_workers=args.max_workers) as executor:
+            futures = [
+                executor.submit(process_single_item, pair_key, unique_pairs[pair_key], scorer)
+                for pair_key in pairs_to_process
+            ]
+
+            for future in tqdm(
+                as_completed(futures),
+                total=len(futures),
+                unit="pair",
+                desc="Processing",
+            ):
+                pair_key, result = future.result()
+                if result:
+                    all_scores[pair_key] = result
+                    cache_manager.append(generate_cache_key(pair_key), result)
+
+    print("Writing results...", flush=True)
+
+    start_time = time.time()
+    # dataset = dataset.remove_columns(["input_image", "output_images"])
+    for idx, data in enumerate(dataset):
+        key1, key2 = data["key"]
+        task_type = data["task_type"]
+        dimension = data["dimension"]
+
+        score1 = all_scores[key1][dimension]
+        score2 = all_scores[key2][dimension]
+        data["score"] = [score1, score2]
+        
+        input_image_path = os.path.join(args.result_dir, "images", f"{key1}_input.png")
+        output_image_path1 = os.path.join(args.result_dir, "images", f"{key1}.png")
+        output_image_path2 = os.path.join(args.result_dir, "images", f"{key2}.png")
+
+        os.makedirs(os.path.dirname(input_image_path), exist_ok=True)
+
+        data['input_image'].save(input_image_path)
+        data['output_images'][0].save(output_image_path1)
+        data['output_images'][1].save(output_image_path2)
+
+        json_line = {
+            "key": (key1, key2),
+            "idx": idx,
+            "score": [score1, score2],
+            "SC_reasoning": [all_scores[key1]["SC_reasoning"], all_scores[key2]["SC_reasoning"]],
+            "PQ_reasoning": [all_scores[key1]["PQ_reasoning"], all_scores[key2]["PQ_reasoning"]],
+            "input_image": input_image_path,
+            "output_images": [output_image_path1, output_image_path2],
+        }
+
+        save_file = os.path.join(
+            args.result_dir, args.backbone, task_type, f"{dimension}.jsonl"
+        )
+        os.makedirs(os.path.dirname(save_file), exist_ok=True)
+
+        with open(save_file, "a", encoding="utf-8") as f:
+            f.write(json.dumps(json_line, ensure_ascii=False) + "\n")
+
+    print(f"Results written in {time.time() - start_time} seconds", flush=True)
+    print("--- Completed! ---", flush=True)
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)

examples/EditScore-train/README.md

@@ -0,0 +1,101 @@
+# EditScore Reward Model Training Guide
+
+This guide explains how to train EditScore reward models using LLaMA-Factory.
+
+## 1. Environment Setup
+
+### Clone LLaMA-Factory and Configure Virtual Environment
+
+```bash
+git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git
+cd LLaMA-Factory
+conda create -n llama-factory python=3.10
+conda activate llama-factory
+pip install -e ".[torch,metrics]" --no-build-isolation
+```
+
+## 2. Directory Structure Configuration
+
+Create necessary folders and files in the LLaMA-Factory root directory:
+
+```bash
+# Create log and output directories
+mkdir -p logs
+mkdir -p output
+
+# Create training configuration directory
+mkdir -p examples/train_editscore
+
+# Copy training configuration files
+cp EditScore/examples/EditScore-train/config/*.yaml examples/train_editscore/
+
+# Copy training script
+cp EditScore/examples/EditScore-train/train.sh .
+```
+
+## 3. Dataset Registration
+
+Register the EditScore-Reward-Data dataset in `LLaMA-Factory/data/dataset_info.json`:
+
+```json
+"EditScore-Reward-Data": {
+  "file_name": "/path/to/your/reward.json",
+  "formatting": "sharegpt",
+  "columns": {
+    "messages": "conversations",
+    "images": "images"
+  }
+}
+```
+
+## 4. Training Configuration Description
+
+### Single-Machine Training Configuration
+- `editscore_7B.yaml` - Train EditScore-7B model (single machine)
+- `editscore_qwen3_vl_4B_instruct.yaml` - Train EditScore_Qwen3_Vl_4B_Instruct model (single machine)
+- `editscore_qwen3_vl_8B_instruct.yaml` - Train EditScore_Qwen3_Vl_8B_Instruct model (single machine)
+
+### Multi-Machine Training Configuration
+- `editscore_32B.yaml` - Train EditScore-32B model (two machines)
+- `editscore_72B.yaml` - Train EditScore-72B model (two machines)
+
+## 5. Start Training
+
+### Single-Machine Training
+
+```bash
+# Modify experiment_name in train.sh to the corresponding configuration file name
+# For example: name=editscore_7B
+bash train.sh
+```
+
+### Multi-Machine Training
+
+**Master node (rank=0):**
+```bash
+bash train.sh --rank=0 --world_size=2 --master_addr=MASTER_NODE_IP --master_port=29500
+```
+
+**Worker node (rank=1):**
+```bash
+bash train.sh --rank=1 --world_size=2 --master_addr=MASTER_NODE_IP --master_port=29500
+```
+
+## 6. Parameter Configuration
+
+Users can modify the following parameters in the YAML configuration files as needed:
+
+- `per_device_train_batch_size`: Batch size per device
+- `gradient_accumulation_steps`: Gradient accumulation steps
+- `learning_rate`: Learning rate
+- `num_train_epochs`: Number of training epochs
+- `max_samples`: Maximum number of samples
+- `output_dir`: Output directory
+
+## 7. Output Files
+
+After training completion, model files will be saved in the corresponding output directories:
+- Single-machine training: `LLaMA-Factory/output/model_name/`
+- Log files: `LLaMA-Factory/logs/experiment_name_rank.log`
+
+

examples/EditScore-train/config/editscore_32B.yaml

@@ -0,0 +1,42 @@
+model_name_or_path: Qwen/Qwen2.5-VL-32B-Instruct
+image_max_pixels: 262144
+video_max_pixels: 16384
+trust_remote_code: true
+
+### method
+stage: sft
+do_train: true
+finetuning_type: lora
+lora_rank: 32
+lora_target: all
+
+deepspeed: LLaMA-Factory/examples/deepspeed/ds_z2_config.json
+### dataset
+dataset: EditScore-Reward-Data  
+template: qwen2_vl
+cutoff_len: 8192
+max_samples: 100000
+overwrite_cache: true
+preprocessing_num_workers: 16
+dataloader_num_workers: 4
+
+### output
+output_dir: LLaMA-Factory/output/editscore_32B/
+logging_steps: 1
+save_steps: 250
+plot_loss: true
+overwrite_output_dir: true
+save_only_model: false
+report_to: none  # choices: [none, wandb, tensorboard, swanlab, mlflow]
+
+### train
+per_device_train_batch_size: 1
+gradient_accumulation_steps: 8
+learning_rate: 1.0e-4
+num_train_epochs: 3.0
+lr_scheduler_type: cosine
+warmup_ratio: 0.1
+bf16: true
+ddp_timeout: 180000000
+resume_from_checkpoint: null
+

examples/EditScore-train/config/editscore_72B.yaml

@@ -0,0 +1,42 @@
+model_name_or_path: Qwen/Qwen2.5-VL-72B-Instruct
+image_max_pixels: 262144
+video_max_pixels: 16384
+trust_remote_code: true
+
+### method
+stage: sft
+do_train: true
+finetuning_type: lora
+lora_rank: 32
+lora_target: all
+
+deepspeed: LLaMA-Factory/examples/deepspeed/ds_z3_config.json
+### dataset
+dataset: EditScore-Reward-Data  
+template: qwen2_vl
+cutoff_len: 8192
+max_samples: 100000
+overwrite_cache: true
+preprocessing_num_workers: 16
+dataloader_num_workers: 4
+
+### output
+output_dir: LLaMA-Factory/output/editscore_72B/
+logging_steps: 1
+save_steps: 250
+plot_loss: true
+overwrite_output_dir: true
+save_only_model: false
+report_to: none  # choices: [none, wandb, tensorboard, swanlab, mlflow]
+
+### train
+per_device_train_batch_size: 1
+gradient_accumulation_steps: 8
+learning_rate: 1.0e-4
+num_train_epochs: 3.0
+lr_scheduler_type: cosine
+warmup_ratio: 0.1
+bf16: true
+ddp_timeout: 180000000
+resume_from_checkpoint: null
+

examples/EditScore-train/config/editscore_7B.yaml

@@ -0,0 +1,41 @@
+model_name_or_path: Qwen/Qwen2.5-VL-7B-Instruct
+image_max_pixels: 262144
+video_max_pixels: 16384
+trust_remote_code: true
+
+### method
+stage: sft
+do_train: true
+finetuning_type: lora
+lora_rank: 32
+lora_target: all
+
+### dataset
+dataset: EditScore-Reward-Data  
+template: qwen2_vl
+cutoff_len: 8192
+max_samples: 100000
+overwrite_cache: true
+preprocessing_num_workers: 16
+dataloader_num_workers: 4
+
+### output
+output_dir: LLaMA-Factory/output/editscore_7B/
+logging_steps: 1
+save_steps: 250
+plot_loss: true
+overwrite_output_dir: true
+save_only_model: false
+report_to: none  # choices: [none, wandb, tensorboard, swanlab, mlflow]
+
+### train
+per_device_train_batch_size: 1
+gradient_accumulation_steps: 16
+learning_rate: 1.0e-4
+num_train_epochs: 3.0
+lr_scheduler_type: cosine
+warmup_ratio: 0.1
+bf16: true
+ddp_timeout: 180000000
+resume_from_checkpoint: null
+

examples/EditScore-train/config/editscore_qwen3_vl_4B_instruct.yaml

@@ -0,0 +1,41 @@
+model_name_or_path: Qwen/Qwen3-VL-4B-Instruct
+image_max_pixels: 262144
+video_max_pixels: 16384
+trust_remote_code: true
+
+### method
+stage: sft
+do_train: true
+finetuning_type: lora
+lora_rank: 32
+lora_target: all
+
+### dataset
+dataset: EditScore-Reward-Data  
+template: qwen3_vl
+cutoff_len: 8192
+max_samples: 500000
+overwrite_cache: true
+preprocessing_num_workers: 16
+dataloader_num_workers: 4
+
+### output
+output_dir: LLaMA-Factory/output/editscore_qwen3_vl_4B_instruct/
+logging_steps: 1
+save_steps: 250
+plot_loss: true
+overwrite_output_dir: true
+save_only_model: false
+report_to: none  # choices: [none, wandb, tensorboard, swanlab, mlflow]
+
+### train
+per_device_train_batch_size: 1
+gradient_accumulation_steps: 16
+learning_rate: 1.0e-4
+num_train_epochs: 3.0
+lr_scheduler_type: cosine
+warmup_ratio: 0.1
+bf16: true
+ddp_timeout: 180000000
+resume_from_checkpoint: null
+

examples/EditScore-train/config/editscore_qwen3_vl_8B_instruct.yaml

@@ -0,0 +1,41 @@
+model_name_or_path: Qwen/Qwen3-VL-8B-Instruct
+image_max_pixels: 262144
+video_max_pixels: 16384
+trust_remote_code: true
+
+### method
+stage: sft
+do_train: true
+finetuning_type: lora
+lora_rank: 32
+lora_target: all
+
+### dataset
+dataset: EditScore-Reward-Data  
+template: qwen3_vl
+cutoff_len: 8192
+max_samples: 500000
+overwrite_cache: true
+preprocessing_num_workers: 16
+dataloader_num_workers: 4
+
+### output
+output_dir: LLaMA-Factory/output/editscore_qwen3_vl_8B_instruct/
+logging_steps: 1
+save_steps: 250
+plot_loss: true
+overwrite_output_dir: true
+save_only_model: false
+report_to: none  # choices: [none, wandb, tensorboard, swanlab, mlflow]
+
+### train
+per_device_train_batch_size: 1
+gradient_accumulation_steps: 16
+learning_rate: 1.0e-4
+num_train_epochs: 3.0
+lr_scheduler_type: cosine
+warmup_ratio: 0.1
+bf16: true
+ddp_timeout: 180000000
+resume_from_checkpoint: null
+

examples/EditScore-train/train.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $SHELL_FOLDER
+
+# Activate conda environment of LLaMA-Factory
+conda activate llama-factory
+
+
+RANK=0
+WORLD_SIZE=1
+MASTER_ADDR="localhost"
+MASTER_PORT=29500
+
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --rank=*)
+            RANK="${1#*=}"
+            shift
+            ;;
+        --world_size=*)
+            WORLD_SIZE="${1#*=}"
+            shift
+            ;;
+        --master_addr=*)
+            MASTER_ADDR="${1#*=}"
+            shift
+            ;;
+        --master_port=*)
+            MASTER_PORT="${1#*=}"
+            shift
+            ;;
+        *)
+            echo "Unknown parameter: $1"
+            exit 1
+            ;;
+    esac
+done
+
+name=experiment_name
+log_dir="LLaMA-Factory/logs"
+
+log_file="${log_dir}/${name}_${RANK}.log"
+
+
+CONFIG_YAML="LLaMA-Factory/examples/train_editscore/${name}.yaml"
+FORCE_TORCHRUN=1 \
+NNODES=${WORLD_SIZE} \
+NODE_RANK=${RANK} \
+MASTER_ADDR=${MASTER_ADDR} \
+MASTER_PORT=${MASTER_PORT} \
+llamafactory-cli train ${CONFIG_YAML} 2>&1 | tee ${log_file}

examples/OmniGen2-RL/.gitignore

@@ -0,0 +1,233 @@
+# Created by https://www.toptal.com/developers/gitignore/api/macos,python
+# Edit at https://www.toptal.com/developers/gitignore?templates=macos,python
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# 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/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/macos,python
+
+local_scripts/
+
+omnigen2/utils/vpn_utils.py
+
+test_tokenizer.py
+save_pipeline.py
+app.sh
+logs/
+results/
+test_jsonl*
+pbs_files/
+convert_ckpt_to_pipeline.py
+inference_test_efficiency.py
+upload_pipeline*
+example_images_resized/
+example_t2i_test_efficiency*.sh
+example_edit_test_efficiency*.sh
+example_in_context_generation_test_efficiency*.sh
+intro*
+resize_example_images.py
+save_pipeline.py
+outputs_gradio/*
+test.py

examples/OmniGen2-RL/LICENSE

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

examples/OmniGen2-RL/README.md

@@ -0,0 +1,189 @@
+# 🚀 Advanced Applications of EditScore
+
+Welcome to the examples directory! Here, we demonstrate how to leverage **EditScore** not just as an evaluation metric, but as a powerful component to actively *improve image editing models*.
+
+This guide covers two primary downstream applications:
+1. **Best-of-N selection**: A simple, training-free method to instantly boost the output quality of any image editing model.
+2. **Reinforcement Learning (RL) Fine-Tuning**: Using EditScore as a high-fidelity reward signal to train models for significantly better performance.
+
+## 🛠️ Setup for Examples
+The examples require libraries for RL, data handling, and potentially experiment tracking.
+```bash
+# Navigate to this directory if you are in the root
+cd examples/OmniGen2-RL
+
+# Install the required packages
+pip install -r requirements.txt
+```
+
+## Application 1: Best-of-N for Superior Outputs
+Best-of-N is an elegant and powerful technique. Instead of generating a single output for a given instruction, you generate multiple (N) candidates and then use a highly accurate evaluator—**EditScore**—to select the best one.
+
+This acts as a powerful "reranker" that filters out suboptimal results, significantly improving the perceived quality of the model without any extra training.
+
+### How to Use
+We provide ready-to-use scripts to perform a full Best-of-N workflow on the GEdit-Bench benchmark. The following instructions use **OmniGen2** as the base model, but we provide similar scripts for **FLUX-Kontext** and **Qwen-Image-Edit** in the `evaluation/GEdit-Bench/` directory.
+
+**1. Generate Candidates**
+```bash
+bash evaluation/GEdit-Bench/omnigen2_16samples.sh # default using 8 GPUs
+```
+
+> **⚠️ Important Note on Resource Usage**
+>
+> This process is computationally expensive and slow due to the large number of generations (16 samples per instruction). For reference, completing this step for OmniGen2 takes approximately **3 hours using 64 H100 GPUs**.
+
+<details>
+<summary><strong>👉 Click here for tips on the usage of the script</strong></summary>
+
+- **Distributed Inference**: Our scripts natively support multi-machine and multi-GPU execution. To run inference across 4 machines, for example, execute the following commands on each respective machine:
+```bash
+# On the first machine (rank 0)
+bash evaluation/GEdit-Bench/omnigen2_16samples.sh --world_size 4 --rank 0
+
+# On the second machine (rank 1)
+bash evaluation/GEdit-Bench/omnigen2_16samples.sh --world_size 4 --rank 1
+
+# ...and so on for ranks 2 and 3.
+```
+
+- **Monitoring Progress**: The scripts utilize nohup for background execution. We recommend monitoring the file (specified in the script file) to track the status and progress of the generation process.
+</details>
+
+**2. Score and Select**
+Next, use EditScore to evaluate all N candidates and identify the one with the highest score.
+
+```bash
+bash evaluation/GEdit-Bench/omnigen2_16samples_select_best_editscore_pass1.sh # EditScore-7B, single pass
+bash evaluation/GEdit-Bench/omnigen2_16samples_select_best_editscore_pass4.sh # EditScore-7B, Avg@4
+```
+
+**3. Evaluate the Final Selections**
+Finally, evaluate the performance of the images selected by EditScore on GEdit-Bench to quantify the improvement.
+```bash
+bash evaluation/GEdit-Bench/omnigen2_16samples_select_best_editscore_pass1_eval.sh
+bash evaluation/GEdit-Bench/omnigen2_16samples_select_best_editscore_pass4_eval.sh
+```
+
+By comparing these results to the baseline performance of the original model, you will see the benefits of applying EditScore as a reranker.
+
+## Application 2: Reinforcement Fine-Tuning
+Beyond evaluation, **EditScore** can be used as a high-quality reward signal to fine-tune your image editing models using Reinforcement Learning (RL), leading to significantly improved performance.
+
+We employ the **FlowGRPO** algorithm, combining its strengths with EditScore's accurate, real-time feedback to create a powerful end-to-end fine-tuning pipeline. This process effectively guides the model toward generating better edits.
+
+### 1. Prepare Training Data
+First, set up the dataset for RL fine-tuning.
+1. Download the Data
+Downlaod the official RL training data from [EditScore-RL-Data](https://huggingface.co/datasets/EditScore/EditScore-RL-Data).
+2. Create Meta File
+The uploaded dataset uses relative image paths. Run the following script to convert them to absolute paths based on your local environment:
+```bash
+# Then
+python scripts/data/process_jsonl.py --input /path/to/EditScore-RL-Data/rl.jsonl --output /path/to/EditScore-RL-Data/rl_abs.jsonl --base-path /path/to/EditScore-RL-Data
+
+# Due to the limitation of base model (OmniGen2), we discard text change and portrait beautification, as these tasks harm RL training.
+python scripts/data/extract_9_tasks.py --input_path /path/to/EditScore-RL-Data/rl_abs.jsonl --output_path /path/to/EditScore-RL-Data/rl_abs_9tasks.jsonl
+```
+3. Configure the Data Path
+Specify the path to your processed `.jsonl` file in the data configuration located at `data_configs/train/example/edit/all.yml`.
+For example:
+```yaml
+ratio_type: inside_ratio
+
+data:
+  - 
+    path: '/path/to/EditScore-RL-Data/rl_abs_9tasks.jsonl' # <-- Ensure this path is correct
+    type: 'edit'
+    ratio: !!float 1
+```
+
+### 2. Prepare the Base Model (OmniGen2)
+```bash
+python scripts/misc/extract_bin_from_pipe.py
+```
+
+### 3. Launch the Reward Server
+RL training requires a live reward signal. Before starting the training process, you must launch the **EditScore Reward Server**. This server will provide real-time scores for the generated images during training.
+
+Our reward server is built with two components: a **proxy** and one or more **reward servers**. The proxy receives requests from the training node, distributes them to the individual reward servers for computation, and then collects the results to send back. This architecture allows for easy scaling across multiple machines.
+
+We provide a convenient script to launch the entire server stack across multiple machines, assuming you have `ssh` access to all reward server nodes.
+
+```bash
+# Launch EditScore-7B Reward Server
+bash reward_server/start_multi_machines.sh --model_name=editscore_7B --config_path=reward_server/server_configs/editscore_7B.yml
+
+# Launch EditScore-7B (Avg@4) Reward Server
+bash reward_server/start_multi_machines.sh --model_name=editscore_7B_pass4 --config_path=reward_server/server_configs/editscore_7B_pass4.yml
+
+# Launch EditScore-72B Reward Server
+bash reward_server/start_multi_machines.sh --model_name=editscore_72B --config_path=reward_server/server_configs/editscore_72B.yml
+```
+
+> **⚠️ Important Notes**
+>
+> *   Before running the script, you **must** specify the IP addresses of your reward server machines in the corresponding `.yml` configuration file.
+> *   If you cannot use `ssh` to control the nodes, please refer to the logic in `reward_server/start_multi_machines.sh` to manually start the proxy and server processes on each machine.
+> *   You can monitor the status of the proxy and servers by checking the log files in the `reward_server/logs/` directory.
+
+## 3.5 (Optional) Reward Server Sanity Check
+To ensure the reward server is configured correctly and running as expected, we provide a sanity check script.
+```bash
+python reward_server/scripts/utils/reward_server_sanity_check.py --config_path=reward_server/server_configs/editscore_7B.yml
+```
+Once these steps are complete, your environment is ready to begin the reinforcement learning fine-tuning process.
+
+### 4. Start RL Fine-Tuning
+
+**Configure Training Parameters**
+Before launching, you may need to adjust key parameters in the configuration file: `options/omnigen2_edit_rl_4machine_editscore7b_avg4.yml`.
+
+Here are some important settings:
+- `train.global_batch_size`: The total number of images generated across all GPUs in a single sampling phase before the policy is updated. It is calculated as `num_unique_prompts_per_sampling * num_images_per_prompt`.
+- `train.batch_size`: Batch size per GPU (`batch_size_per_forward * gradient_accumulation_steps * num_update_steps_per_sampling`)
+- `train.rl.num_images_per_prompt`: The number of candidate images to generate for each unique prompt.
+- `train.rl.num_unique_prompts_per_sampling`: The number of unique prompts in a global batch
+- `train.rl.num_update_steps_per_sampling`: The number of gradient updates to perform in each sampling phase. Set this to `> 1` to enable off-policy RL, which improves sample efficiency.
+- `train.rl.batch_size_per_forward`: Batch size for each forward pass. Together with `num_update_steps_per_sampling`, it defines the total number of samples processed per policy update.
+
+**Launch Distributed Training**
+We provide scripts for both single and multi-machine distributed training based on **FSDP**.
+```bash
+# Single-machine training (8 GPUs) using EditScore-7B as the reward model
+bash scripts/train/omnigen2_edit_rl_single_machine_editscore7b.sh
+
+# Multi-machine training (e.g., 4 machines with 8 GPUs each) using EditScore-7B (Avg@4)
+bash scripts/train/omnigen2_edit_rl_4machine_editscore7b_avg4.sh
+```
+
+### 4. Training Outputs and Monitoring
+All training artifacts, including logs and model checkpoints, are saved to the `experiments/` directory.
+For transparency and to ensure full reproducibility, we provide the training curves of **OmniGen2-EditScore7B-v1.1** on [Weights & Biases (wandb)](https://wandb.ai/omnigen-rl/OmniGen2-RL/reports/Training-Curves-of-OmniGen2-EditScore7B-v1-1---VmlldzoxNDg2MTI2NQ?accessToken=467cbc4jupu1maluk00pan7z611m6xxmnwviwk8nblml3ydoy3j9fu92el6c0s8i).
+
+
+### 5. Evaluate your RL Fine-Tuned Model
+After training, you must convert the FSDP-saved checkpoint (`.bin`) into the standard Hugging Face format before you can use it for inference.
+
+#### Step 1: Convert the Checkpoint
+We provide a script to automatically handle the conversion from the distributed FSDP format to the standard Hugging Face format (`.bin`).
+Run the following command, replacing the arguments with your experiment's details:
+
+```shell
+bash scripts/misc/convert_dist_ckpt_to_hf_format.sh [EXPERIMENT_NAME] [STEP_NUMBER]
+```
+- [EXPERIMENT_NAME]: The name of your training experiment (e.g., omnigen2_edit_rl_single_machine_editscore7b).
+- [STEP_NUMBER]: The specific training step of the checkpoint you wish to evaluate (e.g., 500).
+
+This will create a new directory containing the converted model weights in the standard format, ready for inference.
+
+#### Step 2: Run Evaluation on GEdit-Bench
+Once the checkpoint is converted, you can benchmark its performance. We provide evaluation scripts tailored for GEdit-Bench.
+
+You can use our example scripts as a template. Simply copy one and modify the internal paths to point to your newly converted model checkpoint.
+```shell
+# Run evaluation for the converted model from step 500
+bash evaluation/GEdit-Bench/omnigen2.sh --experiment_name=omnigen2_edit_rl_4machine_editscore7b_avg4 --step=500
+bash evaluation/GEdit-Bench/omnigen2_eval.sh --experiment_name=omnigen2_edit_rl_4machine_editscore7b_avg4 --step=500
+```
+By comparing the results to the baseline model's performance, you can quantify the improvements achieved through RL fine-tuning with EditScore.

examples/OmniGen2-RL/data_configs/train/example/edit/all.yml

@@ -0,0 +1,7 @@
+ratio_type: inside_ratio
+
+data:
+  - 
+    path: '/path/to/EditScore-RL-Data/rl_abs_9tasks.jsonl'
+    type: 'edit'
+    ratio: !!float 1

examples/OmniGen2-RL/data_configs/train/example/train.yml

@@ -0,0 +1,5 @@
+data:
+  - 
+    path: 'data_configs/train/example/edit/all.yml'
+    type: 'edit'
+    ratio: !!float 1

examples/OmniGen2-RL/docs/README.md

@@ -0,0 +1,2 @@
+## Apply EditScore to Image Editing
+### Best-of-N selection**

examples/OmniGen2-RL/evaluation/GEdit-Bench/calculate_statistics.py

@@ -0,0 +1,223 @@
+import os
+import pandas as pd
+from collections import defaultdict
+import sys
+import numpy as np
+import math
+
+GROUPS = [
+    "background_change",
+    "color_alter",
+    "style_change",
+    "subject-add",
+    "subject-remove",
+    "subject-replace",
+    "material_alter",
+    "motion_change",
+    "ps_human",
+    "text_change",
+    "tone_transfer",
+]
+
+GROUPS2 = [
+    "background_change",
+    "color_alter",
+    "material_alter",
+    "motion_change",
+    "ps_human",
+    "style_change",
+    "subject-add",
+    "subject-remove",
+    "subject-replace",
+    "text_change",
+    "tone_transfer",
+]
+
+def analyze_scores(result_dir, language, num_samples):    # 这些 group_scores 字典用于存储每个 group 的最终平均分
+    group_scores_semantics = {}
+    group_scores_quality = {}
+    group_scores_overall = {}
+    group_scores_semantics_intersection = {}
+    group_scores_quality_intersection = {}
+    group_scores_overall_intersection = {}
+    
+    # 外部循环，处理每一个 group
+    for group_name in GROUPS:
+        data_point_samples = defaultdict(list)
+        
+        # 循环读取 num_samples 个评分文件
+        for turn in range(num_samples):
+            csv_path = os.path.join(result_dir, f"{group_name}_gpt_score{'_sample' + str(turn) if turn > 0 else ''}.csv")
+            if not os.path.exists(csv_path):
+                print(f"Warning: File not found, skipping: {csv_path}")
+                continue
+
+            with open(csv_path, 'r') as f:
+                df = pd.read_csv(f)
+                
+                for _, row in df.iterrows():
+                    # 过滤语言
+                    if row['instruction_language'] != language:
+                        continue
+                    
+                    # 定义唯一标识符
+                    unique_key = os.path.basename(row['source_image']).split('_SRCIMG')[0]
+                    
+                    # 计算 overall_score
+                    semantics_score = row['sementics_score']
+                    quality_score = row['quality_score']
+                    overall_score = math.sqrt(semantics_score * quality_score)
+                    
+                    # 将当前样本的分数信息存入字典
+                    sample_data = {
+                        'semantics_score': semantics_score,
+                        'quality_score': quality_score,
+                        'overall_score': overall_score,
+                        'intersection_exist': row['intersection_exist']
+                    }
+                    
+                    # 按唯一标识符聚合所有样本
+                    data_point_samples[unique_key].append(sample_data)
+
+        # --- 核心改动部分：第二阶段 - 筛选与计算 ---
+        # 现在 data_point_samples 已经收集了所有测试项的所有样本数据。
+        # 我们需要遍历它，为每个测试项找到最佳样本，然后将最佳分数存入最终列表。
+        
+        best_semantics_scores = []
+        best_quality_scores = []
+        best_overall_scores = []
+            
+        for unique_key, samples in data_point_samples.items():
+            if not samples:
+                continue
+
+            # 从当前测试项的所有样本中，找到 overall_score 最高的那个
+            # max() 函数的 key 参数可以让我们指定按字典中的哪个值来比较
+            best_sample = max(samples, key=lambda s: s['overall_score'])
+            
+            # 将这个最佳样本的分数添加到最终列表中
+            best_semantics_scores.append(best_sample['semantics_score'])
+            best_quality_scores.append(best_sample['quality_score'])
+            best_overall_scores.append(best_sample['overall_score'])
+            
+        
+        group_scores_semantics[group_name] = np.mean(best_semantics_scores)
+        group_scores_quality[group_name] = np.mean(best_quality_scores)
+        group_scores_overall[group_name] = np.mean(best_overall_scores)
+
+    print("\n--- Overall Model Averages ---")
+
+    print("\nSemantics:")
+    model_scores = [group_scores_semantics[group] for group in GROUPS]
+    model_avg = np.mean(model_scores)
+    group_scores_semantics["avg_semantics"] = model_avg
+
+    # print("\nSemantics Valid Num:")
+    # model_scores = [group_scores_semantics_valid_num[group] for group in GROUPS]
+    # model_avg = np.mean(model_scores)
+    # group_scores_semantics_valid_num["avg_semantics_valid_num"] = model_avg
+
+    # print("\nSemantics Intersection:")
+    # model_scores = [group_scores_semantics_intersection[group] for group in GROUPS]
+    # model_avg = np.mean(model_scores)
+    # group_scores_semantics_intersection["avg_semantics"] = model_avg
+
+    # print("\nSemantics Valid Num Intersection:")
+    # model_scores = [group_scores_semantics_valid_num_intersection[group] for group in GROUPS]
+    # model_avg = np.mean(model_scores)
+    # group_scores_semantics_valid_num_intersection["avg_semantics_valid_num"] = model_avg
+
+    print("\nQuality:")
+    model_scores = [group_scores_quality[group] for group in GROUPS]
+    model_avg = np.mean(model_scores)
+    group_scores_quality["avg_quality"] = model_avg
+
+    # print("\nQuality Valid Num:")
+    # model_scores = [group_scores_quality_valid_num[group] for group in GROUPS]
+    # model_avg = np.mean(model_scores)
+    # group_scores_quality_valid_num["avg_quality_valid_num"] = model_avg
+
+    # print("\nQuality Intersection:")
+    # model_scores = [group_scores_quality_intersection[group] for group in GROUPS]
+    # model_avg = np.mean(model_scores)
+    # group_scores_quality_intersection["avg_quality"] = model_avg
+
+    # print("\nQuality Valid Num Intersection:")
+    # model_scores = [group_scores_quality_valid_num_intersection[group] for group in GROUPS]
+    # model_avg = np.mean(model_scores)
+    # group_scores_quality_valid_num_intersection["avg_quality_valid_num"] = model_avg
+
+    print("\nOverall:")
+    model_scores = [group_scores_overall[group] for group in GROUPS]
+    model_avg = np.mean(model_scores)
+    group_scores_overall["avg_overall"] = model_avg
+
+    # print("\nOverall Valid Num:")
+    # model_scores = [group_scores_overall_valid_num[group] for group in GROUPS]
+    # model_avg = np.mean(model_scores)
+    # group_scores_overall_valid_num["avg_overall_valid_num"] = model_avg
+
+
+    return (
+        group_scores_semantics,
+        group_scores_quality,
+        group_scores_overall,
+        # group_scores_semantics_valid_num,
+        # group_scores_quality_valid_num,
+        # group_scores_overall_valid_num
+    )
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--result_dir", type=str, default="/results/")
+    parser.add_argument("--language", type=str, default="en", choices=["en", "cn"])
+    parser.add_argument("--num_samples", type=int, default=1)
+    parser.add_argument("--groups", type=str, default="GROUPS", choices=["GROUPS", "GROUPS2"])
+    args = parser.parse_args()
+    result_dir = args.result_dir
+
+    # result_dir = os.path.join(result_dir, "viescore")
+
+    print("\nOverall:")
+
+    (
+        group_scores_semantics,
+        group_scores_quality,
+        group_scores_overall,
+        # group_scores_semantics_valid_num,
+        # group_scores_quality_valid_num,
+        # group_scores_overall_valid_num
+    ) = analyze_scores(result_dir, language=args.language, num_samples=args.num_samples)
+    
+    if args.groups == "GROUPS":
+        groups = GROUPS
+    else:
+        groups = GROUPS2
+
+    for group_name in groups:
+        print(f"{group_name}: {group_scores_semantics[group_name]:.2f}, {group_scores_quality[group_name]:.2f}, {group_scores_overall[group_name]:.2f}")
+
+    print(f"Average: {group_scores_semantics['avg_semantics']:.2f}, {group_scores_quality['avg_quality']:.2f}, {group_scores_overall['avg_overall']:.2f}")
+
+    print("Semantics: " + " & ".join([f"{group_scores_semantics[group_name]:.2f}" for group_name in groups] + [f"{group_scores_semantics['avg_semantics']:.2f}"]))
+    print("Quality: " + " & ".join([f"{group_scores_quality[group_name]:.2f}" for group_name in groups] + [f"{group_scores_quality['avg_quality']:.2f}"]))
+    print("Overall: " + " & ".join([f"{group_scores_overall[group_name]:.2f}" for group_name in groups] + [f"{group_scores_overall['avg_overall']:.2f}"]))
+
+    # print("\nValid Num:")
+    # for group_name in GROUPS:
+    #     print(f"{group_name}: {group_scores_semantics_valid_num[group_name]:.2f}, {group_scores_quality_valid_num[group_name]:.2f}, {group_scores_overall_valid_num[group_name]:.2f}")
+
+    # print(f"Average Valid Num: {group_scores_semantics_valid_num['avg_semantics_valid_num']:.2f}, {group_scores_quality_valid_num['avg_quality_valid_num']:.2f}, {group_scores_overall_valid_num['avg_overall_valid_num']:.2f}")
+
+    # print("\nIntersection:")
+    # for group_name in GROUPS:
+    #     print(f"{group_name}: {group_scores_semantics_intersection[group_name]:.2f}, {group_scores_quality_intersection[group_name]:.2f}, {group_scores_overall_intersection[group_name]:.2f}")
+
+    # print(f"Average Intersection: {group_scores_semantics_intersection['avg_semantics']:.2f}, {group_scores_quality_intersection['avg_quality']:.2f}, {group_scores_overall_intersection['avg_overall']:.2f}")
+
+    # print("\nValid Num Intersection:")
+    # for group_name in GROUPS:
+    #     print(f"{group_name}: {group_scores_semantics_valid_num_intersection[group_name]:.2f}, {group_scores_quality_valid_num_intersection[group_name]:.2f}, {group_scores_overall_valid_num_intersection[group_name]:.2f}")
+
+    # print(f"Average Valid Num Intersection: {group_scores_semantics_valid_num_intersection['avg_semantics_valid_num']:.2f}, {group_scores_quality_valid_num_intersection['avg_quality_valid_num']:.2f}, {group_scores_overall_valid_num_intersection['avg_overall_valid_num']:.2f}")

examples/OmniGen2-RL/evaluation/GEdit-Bench/flux_kontext_dev_16samples.sh

@@ -0,0 +1,83 @@
+# !/bin/bash
+SHELL_FOLDER=$(cd "$(dirname "$0")";pwd)
+cd $(dirname $SHELL_FOLDER)
+cd ../
+
+RANK=0
+MASTER_ADDR=1
+MASTER_PORT=29500
+WORLD_SIZE=1
+
+# 处理命名参数
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --rank=*)
+            RANK="${1#*=}"
+            shift
+            ;;
+        --master_addr=*)
+            MASTER_ADDR="${1#*=}"
+            shift
+            ;;
+        --master_port=*)
+            MASTER_PORT="${1#*=}"
+            shift
+            ;;
+        --world_size=*)
+            WORLD_SIZE="${1#*=}"
+            shift
+            ;;
+        *)
+            echo "未知参数: $1"
+            shift
+            ;;
+    esac
+done
+
+# 输出配置
+echo "RANK: $RANK"
+echo "MASTER_ADDR: $MASTER_ADDR"
+echo "MASTER_PORT: $MASTER_PORT"
+echo "WORLD_SIZE: $WORLD_SIZE"
+
+global_shift_index=0
+total_num_images=606
+
+num_gpus_per_machine=$(python -c "import torch; print(torch.cuda.device_count())")
+# Calculate images per machine, rounding up to ensure all data is covered
+num_images_per_machine=$(( (total_num_images + WORLD_SIZE - 1) / WORLD_SIZE ))
+shift_index=$((RANK * num_images_per_machine))
+
+if [ $((total_num_images - shift_index)) -lt $num_images_per_machine ]; then
+    num_images_per_machine=$((total_num_images - shift_index))
+fi
+
+# Calculate base number of images per GPU (for first 7 GPUs)
+num_images_per_gpu=$(( (num_images_per_machine + num_gpus_per_machine - 1) / num_gpus_per_machine ))
+
+guidance_scale=2.5
+
+for ((i=0; i<num_gpus_per_machine; i++)); do
+    if [ $i -lt $((num_gpus_per_machine - 1)) ]; then
+        # First 7 GPUs process equal amounts
+        start_idx=$((global_shift_index + i * num_images_per_gpu + shift_index))
+        end_idx=$((start_idx + num_images_per_gpu))
+    else
+        # Last GPU processes remaining data
+        start_idx=$((global_shift_index + (num_gpus_per_machine - 1) * num_images_per_gpu + shift_index))
+        end_idx=$((global_shift_index + shift_index + num_images_per_machine))
+    fi
+    echo ${start_idx} ${end_idx}
+    
+    CUDA_VISIBLE_DEVICES=${i} WORLD_SIZE=1 nohup accelerate launch --num_processes 1 --num_machines 1 \
+    evaluation/GEdit-Bench/inference_flux_kontext_dev.py \
+    --pipeline_path black-forest-labs/FLUX.1-Kontext-dev \
+    --num_inference_step 28 \
+    --height 1024 \
+    --width 1024 \
+    --guidance_scale ${guidance_scale} \
+    --result_dir evaluation/GEdit-Bench/results/FLUX-Kontext-dev/results_gs${guidance_scale}_16samples \
+    --start_index ${start_idx} --end_index ${end_idx} \
+    --num_samples 16 \
+    > logs/gedit_FLUX-Kontext-dev_gs${guidance_scale}_16samples_${start_idx}_${end_idx}.log 2>&1 &
+done