Add files using upload-large-folder tool

README.md

@@ -0,0 +1,139 @@
+<div align="center">
+  
+# LLaVA-UHD-v3 Pilot Experiment
+
+**PROGRESSIVE VISUAL COMPRESSION FOR EFFICIENT NAIVE-RESOLUTION ENCODING IN MLLMS**
+
+[📄 OpenReview](https://openreview.net/pdf/3bd376fce3e8ff071bfd2f7b509f651553e2cb38.pdf) | [💻 Github](https://github.com/Sishxo/LLaVA-UHD-v3/tree/master?tab=readme-ov-file)
+</div>
+
+Here, we will introduce several benchmarks used in the preliminary experiments of LLaVA-UHD-v3 (ShapeGrid, Sudoku, and Sudoku in the Appendix), along with the related plotting code, preliminary experiment model inference code, and the model inference results.
+
+## Summary of Preliminary Experiments
+
+The pilot experiment is designed to systematically compare the performance of Global Naive-Resolution Encoding ([GNE](https://huggingface.co/ZzzHelloWorld/llava-uhd-final/tree/main)) against Slice-Based Encoding ([SBE](https://huggingface.co/ZzzHelloWorld/llava_uhd_resampler_query_49)) in multimodal models. Through controlled experiments on general benchmarks and a synthetic dataset (ShapeGrid) created specifically to test spatial perception, the study finds that GNE significantly outperforms SBE in both semantic understanding and spatial reasoning. To further investigate the advantages of GNE, the experiment introduced the ShapeGrid-Sudoku dataset. By querying the model on the position of patterns in a 3x3 grid relative to a central pentagram, it revealed that the SBE method exhibits a systematic "cross-shaped" directional bias stemming from its slicing mechanism. The root cause is that image partitioning disrupts the spatial continuity of attention. This conclusion strongly demonstrates the advantage of global encoding in preserving visual holism and highlights the necessity of developing a novel visual encoding method that is both efficient and global.
+
+## 🔥ShapeGrid benchmark
+The `ShapeGrid` benchmark includes questions about distance, area, location, and count involving various random shapes, aiming to specifically evaluate the model’s spatial perception ability.
+
+<p align="center">
+  <img src="figs/ShapeGrid.png" width="400" height="320">
+</p>
+
+Performance comparison between global naive-resolution encoding (GNE) and slice-based encoding (SBE) across different general benchmarks and ShapeGrid subsets.It can be seen that GNE outperforms all others by a large margin, both on the general benchmarks and the ShapeGrid subsets.
+
+<div align="center">
+
+<table style="color:black;">
+  <thead>
+    <tr style="background-color:#D0E8E2">
+      <th>Model</th>
+      <th>Distance</th>
+      <th>Count</th>
+      <th>Location</th>
+      <th>Area</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr style="background-color:#EDF3F1">
+      <td>GNE</td>
+      <td>60.4</td>
+      <td>71.2</td>
+      <td>73.5</td>
+      <td>89.2</td>
+    </tr>
+    <tr style="background-color:#EDF3F1">
+      <td>SBE</td>
+      <td>51.3</td>
+      <td>55.7</td>
+      <td>64.7</td>
+      <td>78.7</td>
+    </tr>
+  </tbody>
+</table>
+
+</div>
+
+<div align="center">
+
+<table style="color:black;">
+  <thead>
+    <tr style="background-color:#C2CAF0">
+      <th>Model</th>
+      <th>MMStar</th>
+      <th>SEED</th>
+      <th>MMBench</th>
+      <th>MME</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr style="background-color:#EFF1FB">
+      <td>GNE</td>
+      <td>51.0</td>
+      <td>74.0</td>
+      <td>74.8</td>
+      <td>78.6</td>
+    </tr>
+    <tr style="background-color:#EFF1FB">
+      <td>SBE</td>
+      <td>47.7</td>
+      <td>72.4</td>
+      <td>72.8</td>
+      <td>77.3</td>
+    </tr>
+  </tbody>
+</table>
+
+</div>
+
+## 🔥ShapeGrid-Sudoku benchmark
+To precisely evaluate spatial directional awareness, the pilot experiment introduced a "`Sudoku`-style" dataset. Each image consists of a 3x3 grid with a fixed central anchor surrounded by random objects. The model is tasked with identifying the direction of a target object relative to the center, a design that isolates directional localization for a clear and independent assessment.
+
+<p align="center">
+  <img src="figs/Sudoku.png" width="270" height="200">
+</p>
+The results revealed a stark contrast between the methods. Global Naive-Resolution Encoding (GNE) achieved high, balanced accuracy across all directions, indicating unbiased spatial understanding. In contrast, Slice-Based Encoding (SBE) exhibited a systematic "cross-shaped" bias, with significantly lower accuracy for objects directly above, below, left, and right of the center. This flaw was attributed to SBE's slicing mechanism disrupting spatial continuity and leading to uneven attention, strongly validating the critical advantage of global encoding in preserving visual holism.
+
+<p align="center">
+  <img src="figs/sudoku_result.png" width="450" height="250">
+</p>
+
+## 🔥Appendix-Sudoku benchmark
+To verify whether the performance of global naive-resolution visual encoding and slice-based en-coding on the Sudoku subset exhibits consistent patterns observed in the pilot experiment, we further evaluate the widely discussed approaches, like Qwen2.5-VL representing GNE and MiniCPM-o 2.6 representing SBE on the Sudoku subset. Since the widely discussed approaches show stronger performance, we adopted the more challenging ShapeGrid-Sudoku subset.
+
+<p align="center">
+  <img src="figs/appendix_sudoku.png" width="270" height="200">
+</p>
+
+It can be seen that Qwen2.5-VL achieves con-sistently high accuracy across all positions in the Sudoku subset, whereas MiniCPM-o 2.6 exhibits lower accuracy in the top and right positions. 
+
+<p align="center">
+  <img src="figs/appendix_sudoku_result.png" width="450" height="250">
+</p>
+
+## Other Sections
+If you want to reproduce the results of the pilot experiment, you need to first download the checkpoints of [GNE](https://huggingface.co/ZzzHelloWorld/llava-uhd-final) and [SBE](https://huggingface.co/ZzzHelloWorld/llava_uhd_resampler_query_49).Evaluation script is in `VLMEvalkit-sudoku`, you need to add the corresponding files to the official VLMEvalkit project for testing.For details of data organization, please refer to [here](https://github.com/open-compass/VLMEvalKit) for help. 
+We provide the same script to complete the testing.
+
+You can start the inference by performing the following steps.
+```bash
+cd ./VLMEvalKit-sudoku
+bash eval.sh
+```
+
+We also provide code for plotting the heatmaps of model answer accuracy, where the Sudoku results are generated using `heatmap.py`, and the Appendix-Sudoku results are generated using `heatmap_appendix.py`.The inference results of GNE, SBE, MiniCPM-o 2.6, and Qwen2.5-VL can be found in `eval_results`.
+
+## Citation
+
+If you find LLaVA-UHD-v3 useful for your research and applications, please cite using this BibTeX:
+```bibtex
+@inproceedings{anonymous2025llavauhd,
+  title={{LL}a{VA}-{UHD} v3: Progressive Visual Compression for Efficient Naive-Resolution Encoding in {MLLM}s},
+  author={Anonymous},
+  booktitle={Submitted to The Fourteenth International Conference on Learning Representations},
+  year={2025},
+  url={https://openreview.net/forum?id=T4pK6ByRit},
+  note={under review}
+}
+```
+

VLMEvalKit-sudoku/.env

@@ -0,0 +1,31 @@
+# # .env 文件，将其放置在 $VLMEvalKit 下
+# # 专有 VLMs 的 API 密钥
+# # QwenVL APIs
+# DASHSCOPE_API_KEY=
+# # Gemini w. Google Cloud Backends
+# GOOGLE_API_KEY=
+# # OpenAI API
+# # OPENAI_API_KEY=sk-PXKqPaLdZiIOZxeK81D94cC7E27f4d85Aa48Ec458f72A981
+# # OPENAI_API_BASE=https://yeysai.com/v1
+# OPENAI_API_KEY=
+# OPENAI_API_BASE=
+# # StepAI API
+# STEPAI_API_KEY=
+# # REKA API
+# REKA_API_KEY=
+# # GLMV API
+# GLMV_API_KEY=
+# # CongRong API
+# CW_API_BASE=
+# CW_API_KEY=
+# # SenseChat-V API
+# SENSECHAT_AK=
+# SENSECHAT_SK=
+# # Hunyuan-Vision API
+# HUNYUAN_SECRET_KEY=
+# HUNYUAN_SECRET_ID=
+# # LMDeploy API
+# LMDEPLOY_API_BASE=
+# # 你可以设置一个评估时代理，评估阶段产生的 API 调用将通过这个代理进行
+# EVAL_PROXY=
+LMUData=/root/LMUData

VLMEvalKit-sudoku/.pre-commit-config.yaml

@@ -0,0 +1,43 @@
+exclude: |
+  (?x)^(
+      scripts/|
+      assets/|
+      vlmeval/config.py |
+      vlmeval/dataset/utils/wemath.py |
+      vlmeval/dataset/OmniDocBench/ |
+      vlmeval/dataset/utils/megabench/ |
+      vlmeval/dataset/utils/vgrpbench/ |
+      vlmeval/dataset/utils/chartmimic/ |
+      vlmeval/vlm/ola/ |
+      vlmeval/vlm/ursa/ |
+      vlmeval/vlm/ovis/ |
+      vlmeval/dataset/utils/mme_reasoning.py
+  )
+repos:
+  - repo: https://github.com/PyCQA/flake8
+    rev: 6.1.0
+    hooks:
+      - id: flake8
+        args:
+          [
+            "--max-line-length=120",
+            "--ignore=F401,F403,F405,E402,E722,E741,W503,E231,E702",
+          ]
+        exclude: ^configs/
+  - repo: https://github.com/pre-commit/mirrors-yapf
+    rev: v0.30.0
+    hooks:
+      - id: yapf
+        args: ["--style={column_limit=120}"]
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.1.0
+    hooks:
+      - id: trailing-whitespace
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: requirements-txt-fixer
+      - id: check-merge-conflict
+      - id: fix-encoding-pragma
+        args: ["--remove"]
+      - id: mixed-line-ending
+        args: ["--fix=lf"]

VLMEvalKit-sudoku/LICENSE

@@ -0,0 +1,203 @@
+Copyright 2023 VLMEvalKit Authors. All rights reserved.
+
+                                 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 2023 VLMEvalKit Authors.
+
+   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.

VLMEvalKit-sudoku/README.md

@@ -0,0 +1,155 @@
+![LOGO](http://opencompass.openxlab.space/utils/MMLB.jpg)
+
+<b>A Toolkit for Evaluating Large Vision-Language Models. </b>
+
+[![][github-contributors-shield]][github-contributors-link] • [![][github-forks-shield]][github-forks-link] • [![][github-stars-shield]][github-stars-link] • [![][github-issues-shield]][github-issues-link] • [![][github-license-shield]][github-license-link]
+
+English | [简体中文](/docs/zh-CN/README_zh-CN.md) | [日本語](/docs/ja/README_ja.md)
+
+<a href="https://rank.opencompass.org.cn/leaderboard-multimodal">🏆 OC Learderboard </a> •
+<a href="#%EF%B8%8F-quickstart">🏗️Quickstart </a> •
+<a href="#-datasets-models-and-evaluation-results">📊Datasets & Models </a> •
+<a href="#%EF%B8%8F-development-guide">🛠️Development </a>
+
+<a href="https://huggingface.co/spaces/opencompass/open_vlm_leaderboard">🤗 HF Leaderboard</a> •
+<a href="https://huggingface.co/datasets/VLMEval/OpenVLMRecords">🤗 Evaluation Records</a> •
+<a href="https://huggingface.co/spaces/opencompass/openvlm_video_leaderboard">🤗 HF Video Leaderboard</a> •
+
+<a href="https://discord.gg/evDT4GZmxN">🔊 Discord</a> •
+<a href="https://www.arxiv.org/abs/2407.11691">📝 Report</a> •
+<a href="#-the-goal-of-vlmevalkit">🎯Goal </a> •
+<a href="#%EF%B8%8F-citation">🖊️Citation </a>
+</div>
+
+**VLMEvalKit** (the python package name is **vlmeval**) is an **open-source evaluation toolkit** of **large vision-language models (LVLMs)**. It enables **one-command evaluation** of LVLMs on various benchmarks, without the heavy workload of data preparation under multiple repositories. In VLMEvalKit, we adopt **generation-based evaluation** for all LVLMs, and provide the evaluation results obtained with both **exact matching** and **LLM-based answer extraction**.
+
+## Recent Codebase Changes
+- **[2025-09-12]** **Major Update: Improved Handling for Models with Thinking Mode**
+
+    A new feature in [PR 1229](https://github.com/open-compass/VLMEvalKit/pull/1175) that improves support for models with thinking mode. VLMEvalKit now allows for the use of a custom `split_thinking` function. **We strongly recommend this for models with thinking mode to ensure the accuracy of evaluation**.  To use this new functionality, please enable the following settings: `SPLIT_THINK=True`. By default, the function will parse content within `<think>...</think>` tags and store it in the `thinking` key of the output. For more advanced customization, you can also create a `split_think` function for model. Please see the InternVL implementation for an example.
+- **[2025-09-12]** **Major Update: Improved Handling for Long Response(More than 16k/32k)**
+
+    A new feature in [PR 1229](https://github.com/open-compass/VLMEvalKit/pull/1175) that improves support for models with long response outputs. VLMEvalKit can now save prediction files in TSV format. **Since individual cells in an `.xlsx` file are limited to 32,767 characters, we strongly recommend using this feature for models that generate long responses (e.g., exceeding 16k or 32k tokens) to prevent data truncation.**. To use this new functionality, please enable the following settings: `PRED_FORMAT=tsv`.
+- **[2025-08-04]** In [PR 1175](https://github.com/open-compass/VLMEvalKit/pull/1175), we refine the `can_infer_option` and `can_infer_text`, which increasingly route the evaluation to LLM choice extractors and empirically leads to slight performance improvement for MCQ benchmarks.
+
+## 🆕 News
+- **[2025-07-07]** Supported [**SeePhys**](https://seephys.github.io/), which is a ​full spectrum multimodal benchmark for evaluating physics reasoning across different knowledge levels. thanks to [**Quinn777**](https://github.com/Quinn777) 🔥🔥🔥
+- **[2025-07-02]** Supported [**OvisU1**](https://huggingface.co/AIDC-AI/Ovis-U1-3B), thanks to [**liyang-7**](https://github.com/liyang-7) 🔥🔥🔥
+- **[2025-06-16]** Supported [**PhyX**](https://phyx-bench.github.io/), a benchmark aiming to assess capacity for physics-grounded reasoning in visual scenarios. 🔥🔥🔥
+- **[2025-05-24]** To facilitate faster evaluations for large-scale or thinking models, **VLMEvalKit supports multi-node distributed inference** using **LMDeploy**  (supports *InternVL Series, QwenVL Series, LLaMa4*) or **VLLM**(supports *QwenVL Series, LLaMa4*). You can activate this feature by adding the ```use_lmdeploy``` or ```use_vllm``` flag to your custom model configuration in [config.py](vlmeval/config.py) . Leverage these tools to significantly speed up your evaluation workflows 🔥🔥🔥
+- **[2025-05-24]** Supported Models: **InternVL3 Series, Gemini-2.5-Pro, Kimi-VL, LLaMA4, NVILA, Qwen2.5-Omni, Phi4, SmolVLM2, Grok, SAIL-VL-1.5, WeThink-Qwen2.5VL-7B, Bailingmm, VLM-R1, Taichu-VLR**. Supported Benchmarks: **HLE-Bench, MMVP, MM-AlignBench, Creation-MMBench, MM-IFEval, OmniDocBench, OCR-Reasoning, EMMA, ChaXiv，MedXpertQA, Physics, MSEarthMCQ, MicroBench, MMSci, VGRP-Bench, wildDoc, TDBench, VisuLogic, CVBench, LEGO-Puzzles, Video-MMLU, QBench-Video, MME-CoT, VLM2Bench, VMCBench, MOAT, Spatial457 Benchmark**. Please refer to [**VLMEvalKit Features**](https://aicarrier.feishu.cn/wiki/Qp7wwSzQ9iK1Y6kNUJVcr6zTnPe?table=tblsdEpLieDoCxtb) for more details. Thanks to all contributors 🔥🔥🔥
+- **[2025-02-20]** Supported Models: **InternVL2.5 Series, Qwen2.5VL Series, QVQ-72B, Doubao-VL, Janus-Pro-7B, MiniCPM-o-2.6, InternVL2-MPO, LLaVA-CoT, Hunyuan-Standard-Vision, Ovis2, Valley, SAIL-VL, Ross, Long-VITA, EMU3, SmolVLM**. Supported Benchmarks: **MMMU-Pro, WeMath, 3DSRBench, LogicVista, VL-RewardBench, CC-OCR, CG-Bench, CMMMU, WorldSense**. Thanks to all contributors 🔥🔥🔥
+- **[2024-12-11]** Supported [**NaturalBench**](https://huggingface.co/datasets/BaiqiL/NaturalBench), a vision-centric VQA benchmark (NeurIPS'24) that challenges vision-language models with simple questions about natural imagery.
+- **[2024-12-02]** Supported [**VisOnlyQA**](https://github.com/psunlpgroup/VisOnlyQA/), a benchmark for evaluating the visual perception capabilities 🔥🔥🔥
+- **[2024-11-26]** Supported [**Ovis1.6-Gemma2-27B**](https://huggingface.co/AIDC-AI/Ovis1.6-Gemma2-27B), thanks to [**runninglsy**](https://github.com/runninglsy) 🔥🔥🔥
+- **[2024-11-25]** Create a new flag `VLMEVALKIT_USE_MODELSCOPE`. By setting this environment variable, you can download the video benchmarks supported from [**modelscope**](https://www.modelscope.cn) 🔥🔥🔥
+
+## 🏗️ QuickStart
+
+See [[QuickStart](/docs/en/Quickstart.md) | [快速开始](/docs/zh-CN/Quickstart.md)] for a quick start guide.
+
+## 📊 Datasets, Models, and Evaluation Results
+
+### Evaluation Results
+
+**The performance numbers on our official multi-modal leaderboards can be downloaded from here!**
+
+[**OpenVLM Leaderboard**](https://huggingface.co/spaces/opencompass/open_vlm_leaderboard): [**Download All DETAILED Results**](http://opencompass.openxlab.space/assets/OpenVLM.json).
+
+Check **Supported Benchmarks** Tab in [**VLMEvalKit Features**](https://aicarrier.feishu.cn/wiki/Qp7wwSzQ9iK1Y6kNUJVcr6zTnPe?table=tblsdEpLieDoCxtb) to view all supported image & video benchmarks (70+).
+
+Check **Supported LMMs** Tab in [**VLMEvalKit Features**](https://aicarrier.feishu.cn/wiki/Qp7wwSzQ9iK1Y6kNUJVcr6zTnPe?table=tblsdEpLieDoCxtb) to view all supported LMMs, including commercial APIs, open-source models, and more (200+).
+
+**Transformers Version Recommendation:**
+
+Note that some VLMs may not be able to run under certain transformer versions, we recommend the following settings to evaluate each VLM:
+
+- **Please use** `transformers==4.33.0` **for**: `Qwen series`, `Monkey series`, `InternLM-XComposer Series`, `mPLUG-Owl2`, `OpenFlamingo v2`, `IDEFICS series`, `VisualGLM`, `MMAlaya`, `ShareCaptioner`, `MiniGPT-4 series`, `InstructBLIP series`, `PandaGPT`, `VXVERSE`.
+- **Please use** `transformers==4.36.2` **for**: `Moondream1`.
+- **Please use** `transformers==4.37.0` **for**: `LLaVA series`, `ShareGPT4V series`, `TransCore-M`, `LLaVA (XTuner)`, `CogVLM Series`, `EMU2 Series`, `Yi-VL Series`, `MiniCPM-[V1/V2]`, `OmniLMM-12B`, `DeepSeek-VL series`, `InternVL series`, `Cambrian Series`, `VILA Series`, `Llama-3-MixSenseV1_1`, `Parrot-7B`, `PLLaVA Series`.
+- **Please use** `transformers==4.40.0` **for**: `IDEFICS2`, `Bunny-Llama3`, `MiniCPM-Llama3-V2.5`, `360VL-70B`, `Phi-3-Vision`, `WeMM`.
+- **Please use** `transformers==4.42.0` **for**: `AKI`.
+- **Please use** `transformers==4.44.0` **for**: `Moondream2`, `H2OVL series`.
+- **Please use** `transformers==4.45.0` **for**: `Aria`.
+- **Please use** `transformers==latest` **for**: `LLaVA-Next series`, `PaliGemma-3B`, `Chameleon series`, `Video-LLaVA-7B-HF`, `Ovis series`, `Mantis series`, `MiniCPM-V2.6`, `OmChat-v2.0-13B-sinlge-beta`, `Idefics-3`, `GLM-4v-9B`, `VideoChat2-HD`, `RBDash_72b`, `Llama-3.2 series`, `Kosmos series`.
+
+**Torchvision Version Recommendation:**
+
+Note that some VLMs may not be able to run under certain torchvision versions, we recommend the following settings to evaluate each VLM:
+
+- **Please use** `torchvision>=0.16` **for**: `Moondream series` and `Aria`
+
+**Flash-attn Version Recommendation:**
+
+Note that some VLMs may not be able to run under certain flash-attention versions, we recommend the following settings to evaluate each VLM:
+
+- **Please use** `pip install flash-attn --no-build-isolation` **for**: `Aria`
+
+```python
+# Demo
+from vlmeval.config import supported_VLM
+model = supported_VLM['idefics_9b_instruct']()
+# Forward Single Image
+ret = model.generate(['assets/apple.jpg', 'What is in this image?'])
+print(ret)  # The image features a red apple with a leaf on it.
+# Forward Multiple Images
+ret = model.generate(['assets/apple.jpg', 'assets/apple.jpg', 'How many apples are there in the provided images? '])
+print(ret)  # There are two apples in the provided images.
+```
+
+## 🛠️ Development Guide
+
+To develop custom benchmarks, VLMs, or simply contribute other codes to **VLMEvalKit**, please refer to [[Development_Guide](/docs/en/Development.md) | [开发指南](/docs/zh-CN/Development.md)].
+
+**Call for contributions**
+
+To promote the contribution from the community and share the corresponding credit (in the next report update):
+
+- All Contributions will be acknowledged in the report.
+- Contributors with 3 or more major contributions (implementing an MLLM, benchmark, or major feature) can join the author list of [VLMEvalKit Technical Report](https://www.arxiv.org/abs/2407.11691) on ArXiv. Eligible contributors can create an issue or dm kennyutc in [VLMEvalKit Discord Channel](https://discord.com/invite/evDT4GZmxN).
+
+Here is a [contributor list](/docs/en/Contributors.md) we curated based on the records.
+
+## 🎯 The Goal of VLMEvalKit
+
+**The codebase is designed to:**
+
+1. Provide an **easy-to-use**, **opensource evaluation toolkit** to make it convenient for researchers & developers to evaluate existing LVLMs and make evaluation results **easy to reproduce**.
+2. Make it easy for VLM developers to evaluate their own models. To evaluate the VLM on multiple supported benchmarks, one just need to **implement a single `generate_inner()` function**, all other workloads (data downloading, data preprocessing, prediction inference, metric calculation) are handled by the codebase.
+
+**The codebase is not designed to:**
+
+1. Reproduce the exact accuracy number reported in the original papers of all **3rd party benchmarks**. The reason can be two-fold:
+   1. VLMEvalKit uses **generation-based evaluation** for all VLMs (and optionally with **LLM-based answer extraction**). Meanwhile, some benchmarks may use different approaches (SEEDBench uses PPL-based evaluation, *eg.*). For those benchmarks, we compare both scores in the corresponding result. We encourage developers to support other evaluation paradigms in the codebase.
+   2. By default, we use the same prompt template for all VLMs to evaluate on a benchmark. Meanwhile, **some VLMs may have their specific prompt templates** (some may not covered by the codebase at this time). We encourage VLM developers to implement their own prompt template in VLMEvalKit, if that is not covered currently. That will help to improve the reproducibility.
+
+## 🖊️ Citation
+
+If you find this work helpful, please consider to **star🌟** this repo. Thanks for your support!
+
+[![Stargazers repo roster for @open-compass/VLMEvalKit](https://reporoster.com/stars/open-compass/VLMEvalKit)](https://github.com/open-compass/VLMEvalKit/stargazers)
+
+If you use VLMEvalKit in your research or wish to refer to published OpenSource evaluation results, please use the following BibTeX entry and the BibTex entry corresponding to the specific VLM / benchmark you used.
+
+```bib
+@inproceedings{duan2024vlmevalkit,
+  title={Vlmevalkit: An open-source toolkit for evaluating large multi-modality models},
+  author={Duan, Haodong and Yang, Junming and Qiao, Yuxuan and Fang, Xinyu and Chen, Lin and Liu, Yuan and Dong, Xiaoyi and Zang, Yuhang and Zhang, Pan and Wang, Jiaqi and others},
+  booktitle={Proceedings of the 32nd ACM International Conference on Multimedia},
+  pages={11198--11201},
+  year={2024}
+}
+```
+
+<p align="right"><a href="#top">🔝Back to top</a></p>
+
+[github-contributors-link]: https://github.com/open-compass/VLMEvalKit/graphs/contributors
+[github-contributors-shield]: https://img.shields.io/github/contributors/open-compass/VLMEvalKit?color=c4f042&labelColor=black&style=flat-square
+[github-forks-link]: https://github.com/open-compass/VLMEvalKit/network/members
+[github-forks-shield]: https://img.shields.io/github/forks/open-compass/VLMEvalKit?color=8ae8ff&labelColor=black&style=flat-square
+[github-issues-link]: https://github.com/open-compass/VLMEvalKit/issues
+[github-issues-shield]: https://img.shields.io/github/issues/open-compass/VLMEvalKit?color=ff80eb&labelColor=black&style=flat-square
+[github-license-link]: https://github.com/open-compass/VLMEvalKit/blob/main/LICENSE
+[github-license-shield]: https://img.shields.io/github/license/open-compass/VLMEvalKit?color=white&labelColor=black&style=flat-square
+[github-stars-link]: https://github.com/open-compass/VLMEvalKit/stargazers
+[github-stars-shield]: https://img.shields.io/github/stars/open-compass/VLMEvalKit?color=ffcb47&labelColor=black&style=flat-square

VLMEvalKit-sudoku/eval.sh

@@ -0,0 +1,7 @@
+#全图
+export HF_ENDPOINT=https://hf-mirror.com
+python run.py --data ShapeGrid_sudoku --model llava_uhd_final
+
+# #切片
+# export HF_ENDPOINT=https://hf-mirror.com
+# python run.py --data ShapeGrid_sudoku --model llava_uhd_resampler_query_49

VLMEvalKit-sudoku/requirements.txt

@@ -0,0 +1,40 @@
+accelerate
+dotenv
+einops
+# for gemini api
+google-genai
+gradio
+huggingface_hub
+imageio
+ipdb
+json_repair
+matplotlib
+nltk
+numpy
+omegaconf
+openai
+opencv-python>=4.7.0.72
+openpyxl
+pandas
+pillow
+portalocker
+protobuf
+python-dotenv
+qwen_vl_utils
+requests
+rich
+sentencepiece
+setuptools
+sty
+sympy
+tabulate
+tiktoken
+timeout-decorator
+timm
+torch
+torchvision
+tqdm
+transformers
+typing_extensions
+validators
+xlsxwriter

VLMEvalKit-sudoku/vlmeval/dataset/CGAVCounting/requirements.txt

@@ -0,0 +1,2 @@
+scipy
+word2number

VLMEvalKit-sudoku/vlmeval/dataset/EgoExoBench/__init__.py

@@ -0,0 +1 @@
+from .egoexobench import EgoExoBench_MCQ

VLMEvalKit-sudoku/vlmeval/dataset/GUI/screenspot_v2.py

@@ -0,0 +1,208 @@
+import os
+import re
+import tempfile
+from functools import partial
+
+import pandas as pd
+import ast
+
+from ..image_base import img_root_map
+from .screenspot import ScreenSpot
+from ..utils import build_judge, DEBUG_MESSAGE
+from ...smp import *
+from ...utils import track_progress_rich
+from ipdb import set_trace as st
+
+logger = get_logger("RUN")
+
+"""
+{
+    "img_filename": "web_3b0ad239-da6b-4f6f-8f12-f674dc90ff33.png",
+    "bbox": [42, 1102, 197, 70],
+    "instruction": "view the details of the item",
+    "data_type": "text",
+    "data_source": "shop"
+},
+{
+    "img_filename": "web_3b0ad239-da6b-4f6f-8f12-f674dc90ff33.png",
+    "bbox": [93, 74, 86, 132],
+    "instruction": "view the previous photo",
+    "data_type": "icon",
+    "data_source": "shop"
+}
+"""
+
+SYSTEM_PROMPT = """You are a GUI agent. You are given a task and a screenshot of the screen. You need to perform pyautogui click/moveTo action to complete the task. The answer format is `pyautogui.click(x=?, y=?), x and y is necessary`"""  # noqa: E501
+
+USER_INSTRUCTION = """Please complete the following tasks by clicking using `pyautogui.click`:\n{instruction}"""  # noqa: E501
+
+SYSTEM_PROMPT_V2 = """You are a GUI agent. You are given a screenshot of the screen and the description of a target element. You need to click the target element using `pyautogui.click`. The answer format is `pyautogui.click(x=?, y=?), x and y is necessary`"""  # noqa: E501
+USER_INSTRUCTION_V2 = """Please click the following target element using `pyautogui.click`:\n{description}"""
+
+
+def parse_bbox_aguvis(response):
+    match = re.search(r"x=([\d.]+), y=([\d.]+)", response)
+    if match:
+        click_point = [float(match.group(1)), float(match.group(2))]
+    else:
+        click_point = [0.0, 0.0]
+    return click_point
+
+
+def compute_iou(box1, box2):
+    """
+    Compute the Intersection over Union (IoU) of two bounding boxes.
+
+    Parameters:
+    - box1 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - box2 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+
+    Returns:
+    - float: IoU of box1 and box2.
+    """
+    # Determine the coordinates of the intersection rectangle
+    x_left = max(box1[0], box2[0])
+    y_top = max(box1[1], box2[1])
+    x_right = min(box1[2], box2[2])
+    y_bottom = min(box1[3], box2[3])
+
+    # Compute the area of intersection
+    intersection_area = max(0, x_right - x_left) * max(0, y_bottom - y_top)
+
+    # Compute the area of both bounding boxes
+    box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
+
+    # Compute the area of the union
+    union_area = box1_area + box2_area - intersection_area
+
+    # Compute the Intersection over Union
+    iou = intersection_area / union_area
+
+    return iou
+
+
+def compute_accuracy(box1, box2, threshold=0.5):
+    """
+    Compute the accuracy of two bounding boxes based on a specified threshold.
+
+    Parameters:
+    - box1 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - box2 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - threshold (float): Threshold for the IoU to consider the prediction correct.
+
+    Returns:
+    - float: Accuracy of the prediction based on the IoU threshold.
+    """
+    iou = compute_iou(box1, box2)
+    return iou >= threshold
+
+
+def compute_center_accuracy(box1, box2):
+    """
+    Compute if the center point of box 2 is within box 1.
+
+    Parameters:
+    - box1 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+    - box2 (list of float): Bounding box [x_min, y_min, x_max, y_max].
+
+    Returns:
+    - bool: True if the center point of box 2 is within box 1, False otherwise.
+    """
+    # Compute the center point of box 2
+    center_x = (box2[0] + box2[2]) / 2
+    center_y = (box2[1] + box2[3]) / 2
+
+    # Check if the center point is within box 1
+    return box1[0] <= center_x <= box1[2] and box1[1] <= center_y <= box1[3]
+
+
+def convert_bbox(bbox, image_path):
+    new_bbox = bbox if isinstance(bbox, list) else ast.literal_eval(bbox)
+    new_bbox = [
+        new_bbox[0],
+        new_bbox[1],
+        new_bbox[0] + new_bbox[2],
+        new_bbox[1] + new_bbox[3],
+    ]
+    image = Image.open(image_path)
+    img_size = image.size
+    new_bbox = [
+        new_bbox[0] / img_size[0],
+        new_bbox[1] / img_size[1],
+        new_bbox[2] / img_size[0],
+        new_bbox[3] / img_size[1],
+    ]
+    return new_bbox
+
+
+class ScreenSpotV2(ScreenSpot):
+    MODALITY = "IMAGE"
+    TYPE = "GUI"
+    DATASET_URL = {
+        "ScreenSpot_v2_Mobile": "ScreenSpot_v2_Mobile.tsv",
+        "ScreenSpot_v2_Desktop": "ScreenSpot_v2_Desktop.tsv",
+        "ScreenSpot_v2_Web": "ScreenSpot_v2_Web.tsv",
+    }  # path
+    DATASET_MD5 = {}
+    EVAL_TYPE = "point"  # point or rectangle
+    RE_TYPE = "functional"  # type of referring expressions: functional or composite
+
+    def __init__(
+        self,
+        dataset="ScreenSpot_Mobile",
+        skip_noimg=True,
+        skeleton=False,
+        re_type="functional",
+    ):
+        # st()
+        ROOT = LMUDataRoot()
+        # You can override this variable to save image files to a different directory
+        self.dataset_name = dataset
+        self.img_root = osp.join(ROOT, "ScreenSpot_v2", "screenspotv2_image")
+        self.RE_TYPE = re_type
+        if skeleton:
+            return
+
+        data = self.load_data(dataset)
+        self.skip_noimg = skip_noimg
+        if skip_noimg and "image" in data:
+            data = data[~pd.isna(data["image"])]
+
+        data["index"] = [str(idx + 1) for idx, x in enumerate(data["bbox"])]
+
+        self.meta_only = True
+        self.parse_response_func = parse_bbox_aguvis  # TODO: parse function can be specified through kwargs when initializing the dataset # noqa: E501
+
+        # The image field can store the base64 encoded image or another question index (for saving space)
+        if "image" in data:
+            data["image"] = [str(x) for x in data["image"]]
+            image_map = {x: y for x, y in zip(data["index"], data["image"])}
+            for k in image_map:
+                if len(image_map[k]) <= 64:
+                    idx = image_map[k]
+                    assert idx in image_map and len(image_map[idx]) > 64
+                    image_map[k] = image_map[idx]
+
+            images = [toliststr(image_map[k]) for k in data["index"]]
+            data["image"] = [x[0] if len(x) == 1 else x for x in images]
+            self.meta_only = False
+
+        if "img_filename" in data:
+            paths = [toliststr(x) for x in data["img_filename"]]
+            data["image_path"] = [x[0] if len(x) == 1 else x for x in paths]
+
+        # if np.all([istype(x, int) for x in data["index"]]):
+        #     data["index"] = [int(x) for x in data["index"]]
+
+        self.data = data
+        self.post_build(dataset)
+
+    def prepare_tsv(self, url, file_md5=None):
+        # st()
+        if self.RE_TYPE == "functional":
+            data_root = LMUDataRoot()
+            data_path = osp.join(data_root, "ScreenSpot_v2", url)
+        else:
+            data_path = self.DATASET_URL_V2[self.dataset_name]
+        return pd.DataFrame(load(data_path))

VLMEvalKit-sudoku/vlmeval/dataset/OmniDocBench/metrics.py

@@ -0,0 +1,486 @@
+import json
+import time
+import Levenshtein
+import evaluate
+import random
+import pdb
+import copy
+import pandas as pd
+
+from .utils import save_paired_result,normalized_table
+from collections import defaultdict
+from apted.helpers import Tree
+from apted import APTED, Config
+from lxml import etree, html
+from collections import deque
+from tqdm import tqdm
+from collections import defaultdict
+from tabulate import tabulate
+
+def show_result(results):
+    for metric_name in results.keys():
+        print(f'{metric_name}:')
+        score_table = [[k,v] for k,v in results[metric_name].items()]
+        print(tabulate(score_table))
+        print('='*100)
+
+def sort_nested_dict(d):
+    # If it's a dictionary, recursively sort it
+    if isinstance(d, dict):
+        # Sort the current dictionary
+        sorted_dict = {k: sort_nested_dict(v) for k, v in sorted(d.items())}
+        return sorted_dict
+    # If not a dictionary, return directly
+    return d
+
+def get_full_labels_results(samples:dict):
+    if not samples:
+        return {}
+    label_group_dict = defaultdict(lambda: defaultdict(list))
+    for sample in samples:
+        label_list = []
+        if not sample.get("gt_attribute"):
+            continue
+        for anno in sample["gt_attribute"]:
+            for k,v in anno.items():
+                label_list.append(k+": "+str(v))
+        for label_name in list(set(label_list)):  # Currently if there are merged cases, calculate based on the set of all labels involved after merging
+            for metric, score in sample['metric'].items():
+                label_group_dict[label_name][metric].append(score)
+
+    print('----Anno Attribute---------------')
+    result = {}
+    result['sample_count'] = {}
+    for attribute in label_group_dict.keys():
+        for metric, scores in label_group_dict[attribute].items():
+            mean_score = sum(scores) / len(scores)
+            if not result.get(metric):
+                result[metric] = {}
+            result[metric][attribute] = mean_score
+            result['sample_count'][attribute] = len(scores)
+    result = sort_nested_dict(result)
+    show_result(result)
+    return result
+
+
+def get_page_split(samples, page_info):   # Page level metric
+    if not page_info:
+        return {}
+    result_list = defaultdict(list)
+
+
+    for sample in samples:
+        img_name = sample['img_id'] if sample['img_id'].endswith('.jpg') else '_'.join(sample['img_id'].split('_')[:-1])
+        page_info_s = page_info[img_name]
+        if not sample.get('metric'):
+            continue
+        for metric, score in sample['metric'].items():
+            gt = sample['norm_gt'] if sample.get('norm_gt') else sample['gt']
+            pred = sample['norm_pred'] if sample.get('norm_pred') else sample['pred']
+            result_list[metric].append({
+                'image_name': img_name,
+                'metric': metric,
+                'attribute': 'ALL',
+                'score': score,
+                'upper_len': max(len(gt), len(pred))
+            })
+            for k,v in page_info_s.items():
+                if isinstance(v, list): # special issue
+                    for special_issue in v:
+                        if 'table' not in special_issue:  # Table-related special fields have duplicates
+                            result_list[metric].append({
+                                'image_name': img_name,
+                                'metric': metric,
+                                'attribute': special_issue,
+                                'score': score,
+                                'upper_len': max(len(gt), len(pred))
+                            })
+                else:
+                    result_list[metric].append({
+                        'image_name': img_name,
+                        'metric': metric,
+                        'attribute': k+": "+str(v),
+                        'score': score,
+                        'upper_len': max(len(gt), len(pred))
+                    })
+
+    # Page level logic, accumulation is only done within pages, and mean operation is performed between pages
+    result = {}
+    if result_list.get('Edit_dist'):
+        df = pd.DataFrame(result_list['Edit_dist'])
+        up_total_avg = df.groupby(["image_name", "attribute"]).apply(lambda x: (x["score"]*x['upper_len']).sum() / x['upper_len'].sum()).groupby('attribute').mean()  # At page level, accumulate edits, denominator is sum of max(gt, pred) from each sample
+        result['Edit_dist'] = up_total_avg.to_dict()
+    for metric in result_list.keys():
+        if metric == 'Edit_dist':
+            continue
+        df = pd.DataFrame(result_list[metric])
+        page_avg = df.groupby(["image_name", "attribute"]).apply(lambda x: x["score"].mean()).groupby('attribute').mean()
+        result[metric] = page_avg.to_dict()
+
+    result = sort_nested_dict(result)
+    # print('----Page Attribute---------------')
+    show_result(result)
+    return result
+
+
+def get_groups(samples, group_info):
+    group_samples = defaultdict(list)
+    for sample in samples:
+        group_samples['all'].append(sample)
+        for group in group_info:
+            select_flag = True
+            for k, v in group.items():
+                for gt_attribute in sample['gt_attribute']:   # gt_attribute is a list containing all merged gt attributes
+                    if not gt_attribute:   # if no GT attributes, don't include in calculation
+                        select_flag = False
+                    elif gt_attribute[k] != v:  # if any gt attribute doesn't meet criteria, don't select
+                        select_flag = False
+            if select_flag:
+                group_samples[str(group)].append(sample)
+    return group_samples
+
+
+class Registry:
+    def __init__(self):
+        self._registry = {}
+    def register(self, name):
+        def decorator(item):
+            if name in self._registry:
+                raise ValueError(f"Item {name} already registered.")
+            self._registry[name] = item
+            return item
+        return decorator
+    def get(self, name):
+        if name not in self._registry:
+            raise ValueError(f"Item {name} not found in registry.")
+        return self._registry[name]
+    def list_items(self):
+        return list(self._registry.keys())
+
+METRIC_REGISTRY = Registry()
+
+
+@METRIC_REGISTRY.register("TEDS")
+class call_TEDS():
+    def __init__(self, samples):
+        self.samples = samples
+    def evaluate(self, group_info=[], save_name='default'):
+        teds = TEDS(structure_only=False)
+        teds_structure_only = TEDS(structure_only=True)
+
+        group_scores = defaultdict(list)
+        group_scores_structure_only = defaultdict(list)
+
+        samples = self.samples
+        for sample in samples:
+            gt = sample['norm_gt'] if sample.get('norm_gt') else sample['gt']
+            pred = sample['norm_pred'] if sample.get('norm_pred') else sample['pred']
+
+            score = teds.evaluate(pred, gt)
+            score_structure_only = teds_structure_only.evaluate(pred, gt)
+            # print('TEDS score:', score)
+            group_scores['all'].append(score)
+            group_scores_structure_only['all'].append(score_structure_only)
+
+            if not sample.get('metric'):
+                sample['metric'] = {}
+            sample['metric']['TEDS'] = score
+            sample['metric']['TEDS_structure_only'] = score_structure_only
+
+            for group in group_info:
+                select_flag = True
+                for k, v in group.items():
+                    for gt_attribute in sample['gt_attribute']:   # gt_attribute is a list containing all merged gt attributes
+                        if not gt_attribute:   # if no GT attributes, don't include in calculation
+                            select_flag = False
+                        elif gt_attribute[k] != v:  # if any gt attribute doesn't meet criteria, don't select
+                            select_flag = False
+                if select_flag:
+                    group_scores[str(group)].append(score)
+
+        result = {}
+        for group_name, scores in group_scores.items():
+            if len(scores) > 0:
+                result[group_name] = sum(scores) / len(scores)    # average of normalized scores at sample level
+            else:
+                result[group_name] = 'NaN'
+                print(f'Warning: Empyty matched samples for {group_name}.')
+
+        structure_only_result = {}
+        for group_name, scores in group_scores_structure_only.items():
+            if len(scores) > 0:
+                structure_only_result[group_name] = sum(scores) / len(scores)    # average of normalized scores at sample level
+            else:
+                structure_only_result[group_name] = 'NaN'
+                print(f'Warning: Empyty matched samples for {group_name}.')
+
+        return samples,{'TEDS': result, 'TEDS_structure_only': structure_only_result}
+
+
+@METRIC_REGISTRY.register("BLEU")
+class call_BLEU():
+    def __init__(self, samples):
+        self.samples = samples
+    def evaluate(self, group_info=[], save_name='default'):
+        group_samples = get_groups(self.samples, group_info)
+        result = {}
+        bleu = evaluate.load("bleu", keep_in_memory=True, experiment_id=random.randint(1,1e8))
+
+        for group_name, samples in group_samples.items():
+            predictions, references = [], []
+            for sample in samples:
+                gt = sample['norm_gt'] if sample.get('norm_gt') else sample['gt']
+                pred = sample['norm_pred'] if sample.get('norm_pred') else sample['pred']
+                predictions.append(pred)
+                references.append(gt)
+
+        if not predictions or not any(predictions) or not references or not any(references):
+            bleu_score = 0
+        else:
+            try:
+                bleu_results = bleu.compute(predictions=predictions, references=references)
+                bleu_score = bleu_results["bleu"]
+            except ZeroDivisionError:
+                bleu_score = 0
+
+        result[group_name] = bleu_score
+
+        return self.samples,{'BLEU': result}
+
+@METRIC_REGISTRY.register("METEOR")
+class call_METEOR():
+    def __init__(self, samples):
+        self.samples = samples
+    def evaluate(self, group_info=[], save_name='default'):
+        group_samples = get_groups(self.samples, group_info)
+        result = {}
+        for group_name, samples in group_samples.items():
+            predictions, references = [], []
+            for sample in samples:
+                gt = sample['norm_gt'] if sample.get('norm_gt') else sample['gt']
+                pred = sample['norm_pred'] if sample.get('norm_pred') else sample['pred']
+                predictions.append(gt)
+                references.append(pred)
+            meteor = evaluate.load('meteor', keep_in_memory=True, experiment_id=random.randint(1,1e8))
+            meteor_results = meteor.compute(predictions=predictions, references=references)
+            result[group_name] = meteor_results['meteor']
+
+        return self.samples,{'METEOR': result}
+
+
+@METRIC_REGISTRY.register("Edit_dist")
+class call_Edit_dist():
+    def __init__(self, samples):
+        self.samples = samples
+    def evaluate(self, group_info=[], save_name='default'):
+        samples = self.samples
+        for sample in samples:
+            img_name = sample['img_id'] if sample['img_id'].endswith('.jpg') else '_'.join(sample['img_id'].split('_')[:-1])
+            sample['image_name'] = img_name
+            gt = sample['norm_gt'] if sample.get('norm_gt') else sample['gt']
+            pred = sample['norm_pred'] if sample.get('norm_pred') else sample['pred']
+            upper_len = max(len(pred), len(gt))
+            sample['upper_len'] = upper_len
+            if len(pred) > 0 or len(gt) > 0:
+                edit_dist = Levenshtein.distance(pred, gt)
+                if not sample.get('metric'):
+                    sample['metric'] = {}
+                sample['metric']['Edit_dist'] = edit_dist / upper_len
+                sample['Edit_num'] = edit_dist
+
+        if isinstance(samples, list):
+            saved_samples = samples
+        else:
+            saved_samples = samples.samples
+
+        if not saved_samples:
+            return {'Edit_dist': {'ALL_page_avg': 'NaN'}}
+
+        df = pd.DataFrame(saved_samples)
+        up_total_avg = df.groupby("image_name").apply(lambda x: x['Edit_num'].sum() / x['upper_len'].sum()) # page level, sum of edits divided by sum of max(gt,pred) lengths for each sample
+        per_img_score = up_total_avg.to_dict()
+
+        return samples,{'Edit_dist': {'ALL_page_avg': up_total_avg.mean()}}
+
+
+@METRIC_REGISTRY.register("CDM")
+class call_CDM():
+    def __init__(self, samples):
+        self.samples = samples
+    def evaluate(self, group_info=[], save_name='default'):
+        if isinstance(self.samples, list):
+            cdm_samples = copy.deepcopy(self.samples)
+        else:
+            cdm_samples = copy.deepcopy(self.samples.samples)
+        for idx, sample in enumerate(cdm_samples):
+            sample['img_name'] = sample['img_id']
+            sample['img_id'] = str(idx)
+            sample['gt'] = sample['gt'].lstrip("$$").rstrip("$$").strip()
+            sample['pred'] = sample['pred'].split("```latex")[-1].split("```")[0]
+            sample['pred'] = sample['pred'].lstrip("$$").rstrip("$$").strip()
+
+        return  self.samples,False
+
+
+class TEDS(object):
+    ''' Tree Edit Distance basead Similarity
+    '''
+    def __init__(self, structure_only=False, n_jobs=1, ignore_nodes=None):
+        assert isinstance(n_jobs, int) and (n_jobs >= 1), 'n_jobs must be an integer greather than 1'
+        self.structure_only = structure_only
+        self.n_jobs = n_jobs
+        self.ignore_nodes = ignore_nodes
+        self.__tokens__ = []
+
+    def tokenize(self, node):
+        ''' Tokenizes table cells
+        '''
+        self.__tokens__.append('<%s>' % node.tag)
+        if node.text is not None:
+            self.__tokens__ += list(node.text)
+        for n in node.getchildren():
+            self.tokenize(n)
+        if node.tag != 'unk':
+            self.__tokens__.append('</%s>' % node.tag)
+        if node.tag != 'td' and node.tail is not None:
+            self.__tokens__ += list(node.tail)
+
+    def load_html_tree(self, node, parent=None):
+        ''' Converts HTML tree to the format required by apted
+        '''
+        global __tokens__
+        if node.tag == 'td':
+            if self.structure_only:
+                cell = []
+            else:
+                self.__tokens__ = []
+                self.tokenize(node)
+                cell = self.__tokens__[1:-1].copy()
+            new_node = TableTree(node.tag,
+                                 int(node.attrib.get('colspan', '1')),
+                                 int(node.attrib.get('rowspan', '1')),
+                                 cell, *deque())
+        else:
+            new_node = TableTree(node.tag, None, None, None, *deque())
+        if parent is not None:
+            parent.children.append(new_node)
+        if node.tag != 'td':
+            for n in node.getchildren():
+                self.load_html_tree(n, new_node)
+        if parent is None:
+            return new_node
+
+    def evaluate(self, pred, true):
+        ''' Computes TEDS score between the prediction and the ground truth of a
+            given sample
+        '''
+        if (not pred) or (not true):
+            return 0.0
+        parser = html.HTMLParser(remove_comments=True, encoding='utf-8')
+        pred = html.fromstring(pred, parser=parser)
+        true = html.fromstring(true, parser=parser)
+        if pred.xpath('body/table') and true.xpath('body/table'):
+            pred = pred.xpath('body/table')[0]
+            true = true.xpath('body/table')[0]
+            if self.ignore_nodes:
+                etree.strip_tags(pred, *self.ignore_nodes)
+                etree.strip_tags(true, *self.ignore_nodes)
+            n_nodes_pred = len(pred.xpath(".//*"))
+            n_nodes_true = len(true.xpath(".//*"))
+            n_nodes = max(n_nodes_pred, n_nodes_true)
+            tree_pred = self.load_html_tree(pred)
+            tree_true = self.load_html_tree(true)
+            distance = APTED(tree_pred, tree_true, CustomConfig()).compute_edit_distance()
+            return 1.0 - (float(distance) / n_nodes)
+        else:
+            return 0.0
+
+    def batch_evaluate(self, pred_json, true_json):
+        ''' Computes TEDS score between the prediction and the ground truth of
+            a batch of samples
+            @params pred_json: {'FILENAME': 'HTML CODE', ...}
+            @params true_json: {'FILENAME': {'html': 'HTML CODE'}, ...}
+            @output: {'FILENAME': 'TEDS SCORE', ...}
+        '''
+        samples = true_json.keys()
+        # if self.n_jobs == 1:
+        scores = [self.evaluate(pred_json.get(filename, ''), true_json[filename]['html']) for filename in tqdm(samples)]
+        # else:
+        #     inputs = [{'pred': pred_json.get(filename, ''), 'true': true_json[filename]['html']} for filename in samples]
+        #     scores = parallel_process(inputs, self.evaluate, use_kwargs=True, n_jobs=self.n_jobs, front_num=1)
+        scores = dict(zip(samples, scores))
+        return scores
+
+
+class CustomConfig(Config):
+    @staticmethod
+    def maximum(*sequences):
+        """Get maximum possible value
+        """
+        return max(map(len, sequences))
+
+    def normalized_distance(self, *sequences):
+        """Get distance from 0 to 1
+        """
+        return float(Levenshtein.distance(*sequences)) / self.maximum(*sequences)
+
+    def rename(self, node1, node2):
+        """Compares attributes of trees"""
+        if (node1.tag != node2.tag) or (node1.colspan != node2.colspan) or (node1.rowspan != node2.rowspan):
+            return 1.
+        if node1.tag == 'td':
+            if node1.content or node2.content:
+                return self.normalized_distance(node1.content, node2.content)
+        return 0.
+
+
+class TableTree(Tree):
+    def __init__(self, tag, colspan=None, rowspan=None, content=None, *children):
+        self.tag = tag
+        self.colspan = colspan
+        self.rowspan = rowspan
+        self.content = content
+        self.children = list(children)
+
+    def bracket(self):
+        """Show tree using brackets notation"""
+        if self.tag == 'td':
+            result = '"tag": %s, "colspan": %d, "rowspan": %d, "text": %s' % \
+                     (self.tag, self.colspan, self.rowspan, self.content)
+        else:
+            result = '"tag": %s' % self.tag
+        for child in self.children:
+            result += child.bracket()
+        return "{{{}}}".format(result)
+
+
+class recogition_end2end_base_dataset():
+    def __init__(self, samples):
+        img_id = 0
+        for sample in samples:
+            if not sample.get('img_id'):
+                sample['img_id'] = img_id
+            img_id += 1
+        self.samples = samples
+    def __getitem__(self, idx):
+        return self.samples[idx]
+
+
+class recogition_end2end_table_dataset(recogition_end2end_base_dataset):
+    def __init__(self, samples, table_format):
+        self.pred_table_format = table_format
+        self.samples = self.normalize_data(samples)
+
+    def normalize_data(self, samples):
+        img_id = 0
+        for sample in samples:
+            p = sample['pred']
+            r = sample['gt']
+            p = normalized_table(p, self.pred_table_format)
+            r = normalized_table(r)
+            sample['norm_gt'] = r
+            sample['norm_pred'] = p
+            sample['img_id'] = sample['img_id'] if sample.get('img_id') else img_id
+            img_id += 1
+
+        return samples

VLMEvalKit-sudoku/vlmeval/dataset/OmniDocBench/omnidocbench.py

@@ -0,0 +1,551 @@
+import json
+import os
+import copy
+import pandas as pd
+import tempfile
+import base64
+import numpy as np
+from tqdm import tqdm
+import torch.distributed as dist
+from ..image_base import ImageBaseDataset
+from ...smp import *
+# from ..utils import get_intermediate_file_path, load, dump
+
+
+class OmniDocBench(ImageBaseDataset):
+
+    MODALITY = 'IMAGE'
+    TYPE = 'QA'
+
+    DATASET_URL = {'OmniDocBench':'https://huggingface.co/datasets/ouyanglinke/OmniDocBench_tsv/resolve/main/OmniDocBench.tsv'}
+    DATASET_MD5 = {'OmniDocBench': '0fa5ccf31e682e219cb9ca83da741a59'}
+
+
+    system_prompt = r'''You are an AI assistant specialized in converting PDF images to Markdown format. Please follow these instructions for the conversion:
+
+    1. Text Processing:
+    - Accurately recognize all text content in the PDF image without guessing or inferring.
+    - Convert the recognized text into Markdown format.
+    - Maintain the original document structure, including headings, paragraphs, lists, etc.
+
+    2. Mathematical Formula Processing:
+    - Convert all mathematical formulas to LaTeX format.
+    # - Enclose inline formulas with \( \). For example: This is an inline formula \( E = mc^2 \)
+    - Enclose block formulas with \\[ \\]. For example: \[ \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} \]
+
+    3. Table Processing:
+    - Convert tables to HTML format.
+    - Wrap the entire table with <table> and </table>.
+
+    4. Figure Handling:
+    - Ignore figures content in the PDF image. Do not attempt to describe or convert images.
+
+    5. Output Format:
+    - Ensure the output Markdown document has a clear structure with appropriate line breaks between elements.
+    - For complex layouts, try to maintain the original document's structure and format as closely as possible.
+
+    Please strictly follow these guidelines to ensure accuracy and consistency in the conversion. Your task is to accurately convert the content of the PDF image into Markdown format without adding any extra explanations or comments.
+    '''
+
+    def __init__(self,dataset='OmniDocBench',**kwargs):
+        super().__init__(dataset,**kwargs)
+        print(f'self.img_root:{self.img_root}')
+
+    def build_prompt(self, line):
+
+        image_path = self.dump_image(line)[0]
+        msg = [
+            dict(type='image', value=image_path),
+            dict(type='text', value=self.system_prompt)
+        ]
+        return msg
+
+    def evaluate(self, eval_file, **judge_kwargs):
+        tsv_path=self.data_path
+        End2end_evaluator=end2end_evaluator(eval_file,tsv_path)
+        Table_evalutor=table_evalutor(eval_file,tsv_path)
+
+        metrics_all=End2end_evaluator.score()
+        metircs_table=Table_evalutor.score()
+
+        return metrics_all
+
+
+class end2end_evaluator():
+    def __init__(self,
+                 eval_file,
+                 tsv_path,
+                 match_method:str='quick_match',
+                 filter_types:dict=None):
+        self.eval_file=eval_file
+        self.match_method=match_method
+        self.references=[]
+        self.predictions = load(eval_file)['prediction'].tolist()
+        self.dafault_metircs_dict={
+            'text_block':
+                {'metric': ['Edit_dist', 'BLEU', 'METEOR']},
+            'display_formula':
+                {'metric': ['Edit_dist', 'CDM']},
+            'table':
+                {'metric': ['TEDS', 'Edit_dist']},
+            'reading_order':
+                {'metric': ['Edit_dist']}
+            }
+
+        references = load(tsv_path)['answer'].tolist()
+
+        load_success,load_fail=0,0
+        for i,ans in tqdm(enumerate(references),desc='Loading data'):
+            try:
+                ans = json.loads(ans)
+                load_success+=1
+                self.references.append(ans) #[{},{}]
+            except json.JSONDecodeError as e:
+                load_fail+=1
+                continue
+        print(f'load_success:{load_success},load_fail:{load_fail}')
+
+        filtered_gt_samples = []
+        if filter_types:
+            for gt_sample in self.references:
+                select_flag = True
+                for k, v in filter_types.items():
+                    if gt_sample["page_info"]["page_attribute"][k] != v:
+                        select_flag = False
+                if select_flag:
+                    filtered_gt_samples.append(gt_sample)
+        else:
+            filtered_gt_samples = self.references #[{},{},{}]
+        self.references=filtered_gt_samples
+
+
+    def score(self)->dict:
+        samples=self.get_matched_elements(self.references,self.predictions)
+        metrics=self.process_generated_metric_results(samples)
+        return metrics
+
+    def get_page_elements(self, selected_annos):
+        saved_element_dict = defaultdict(list)
+        related_truncated = []
+        truncated_all = {}
+        for relation in selected_annos["extra"]["relation"]:   # Handle truncated text issues
+            if relation["relation_type"] == 'truncated':
+                truncated_all[relation["source_anno_id"]] = ""
+                truncated_all[relation["target_anno_id"]] = ""
+                exist_flag = False
+                for merge_list in related_truncated:
+                    if relation["source_anno_id"] in merge_list or relation["target_anno_id"] in merge_list:  # Consider cases where three text blocks may need to be merged
+                        merge_list.append(relation["source_anno_id"])
+                        merge_list.append(relation["target_anno_id"])
+                        exist_flag = True
+                if not exist_flag:
+                    related_truncated.append([relation["source_anno_id"], relation["target_anno_id"]])
+
+        for item in selected_annos['layout_dets']:
+            if item['anno_id'] not in truncated_all.keys():
+                saved_element_dict[item["category_type"]].append(item)
+            else:
+                truncated_all[item['anno_id']] = item
+
+        for merge_list in related_truncated:
+            text_block_list = [truncated_all[key] for key in merge_list]
+            sorted_block = sorted(text_block_list, key=lambda x: x['order'])
+            text = ""
+            for block in sorted_block:
+                text += block['text']
+            merged_block = {
+                "category_type": sorted_block[0]["category_type"], # Directly use information from the first block
+                "order": sorted_block[0]["order"],
+                "anno_id": sorted_block[0]["anno_id"],
+                "text": text,
+                "merge_list": sorted_block
+            }
+            saved_element_dict[sorted_block[0]["category_type"]].append(merged_block)
+
+        return saved_element_dict
+
+    def get_page_elements_list(self, gt_page_elements, category_list):
+        element_list = []
+        for category_type in category_list:
+            if gt_page_elements.get(category_type):
+                element_list.extend(gt_page_elements[category_type])
+        return element_list
+
+    def get_sorted_text_list(self, selected_annos):
+        # txt_type: text, latex, html
+        text_list = []
+        for item in selected_annos:
+            if item.get('order'):
+                order = item['order']
+            else:
+                order = 0
+            # 【txt_type,selecte_annos]
+            text_list.append((order, item))
+        sorted_text_list = sorted(text_list, key=lambda x: x[0])
+        return [_[1] for _ in sorted_text_list]
+
+    def filtered_out_ignore(self, items, ignore_category_list):
+        filted_items = []
+        for item in items:
+            if item['gt_category_type'] not in ignore_category_list:
+                filted_items.append(item)
+        return filted_items
+
+    def get_order_paired(self, order_match_s, img_name):
+        matched = [(item['gt_position'], item['pred_position']) for item in order_match_s if (item['gt_position'] != [""] and item['pred_position'] != "")]
+        gt_idx_all = [item['gt_position'] for item in order_match_s if (item['gt_position'] != [""])]
+        read_order_pred = [i[0] for i in sorted(matched, key=lambda x: x[1])]
+        read_order_gt = sum(gt_idx_all, []) # Convert to one-dimensional list
+        read_order_gt = [x for x in read_order_gt if x]
+        gt = sorted(read_order_gt)
+        pred = sum(read_order_pred, [])
+        pred = [x for x in pred if x]
+        if len(pred) > 0 or len(gt) > 0:
+            import Levenshtein
+            edit = Levenshtein.distance(gt, pred)/ max(len(pred), len(gt))
+            return {
+                'gt': gt,
+                'pred': pred,
+                'img_id': img_name,
+                'edit': edit
+            }
+        else:
+            return {}  # If both GT and pred are empty for the page, return empty
+
+    def formula_format(self, formula_matches, img_name):
+        # formated_list = []
+        for i, item in enumerate(formula_matches):
+            item["img_id"] = img_name + '_' + str(i)
+        return formula_matches
+
+    def get_matched_elements(self,references:list,predictions:list)->dict:
+        from .metrics import recogition_end2end_base_dataset, recogition_end2end_table_dataset
+
+        plain_text_match = []
+        display_formula_match = []
+        html_table_match = []
+        latex_table_match = []
+        order_match = []
+
+
+        for i,sample in enumerate(references):
+            img_name = os.path.basename(sample["page_info"]["image_path"])
+            pred_content = predictions[i]
+            result = self.process_get_matched_elements(sample, pred_content, img_name)
+            [plain_text_match_clean, formated_display_formula, latex_table_match_s, html_table_match_s, order_match_single] = result
+
+            if order_match_single:
+                order_match.append(order_match_single)
+            if plain_text_match_clean:
+                plain_text_match.extend(plain_text_match_clean)
+            if formated_display_formula:
+                display_formula_match.extend(formated_display_formula)
+            if latex_table_match_s:
+                latex_table_match.extend(latex_table_match_s)
+            if html_table_match_s:
+                html_table_match.extend(html_table_match_s)
+
+        if len(latex_table_match) > len(html_table_match):
+            table_match = latex_table_match
+            table_format = 'latex'
+        else:
+            table_match = html_table_match
+            table_format = 'html'
+
+        matched_samples_all = {
+            "text_block": recogition_end2end_base_dataset(plain_text_match),
+            "display_formula": recogition_end2end_base_dataset(display_formula_match),
+            "table": recogition_end2end_table_dataset(table_match, table_format),
+            "reading_order": recogition_end2end_base_dataset(order_match)
+        }
+
+        return matched_samples_all
+
+    def process_get_matched_elements(self, sample, pred_content, img_name):
+        from .utils import match_gt2pred_simple, match_gt2pred_no_split, match_gt2pred_quick, md_tex_filter
+        from func_timeout import FunctionTimedOut, func_timeout
+
+        if self.match_method == 'simple_match':   # add match choice
+            match_gt2pred = match_gt2pred_simple
+        elif self.match_method == 'quick_match':
+            match_gt2pred = match_gt2pred_quick
+        elif self.match_method == 'no_split':
+            match_gt2pred = match_gt2pred_no_split
+        else:
+            # print('Invalid match method name. The quick_match will be used.')
+            match_gt2pred = match_gt2pred_quick
+
+        pred_dataset = md_tex_filter(pred_content)
+        gt_page_elements = self.get_page_elements(sample)
+
+        text_all = self.get_page_elements_list(gt_page_elements, ['text_block', 'title', 'code_txt', 'code_txt_caption', 'reference', 'equation_caption',
+                                                'figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption',
+                                                'header', 'footer', 'page_footnote', 'page_number'])
+
+
+        display_formula_match_s = []
+        plain_text_match_clean = []
+        latex_table_match_s = []
+        html_table_match_s = []
+        order_match_single = []
+        if text_all:
+            gt_text_list = self.get_sorted_text_list(text_all)
+            try:
+                plain_text_match_s = func_timeout(
+                    30, match_gt2pred, args=(gt_text_list, pred_dataset['text_all'], 'text', img_name)
+                )
+            except FunctionTimedOut as e1:
+                print(f'Time out for plain text match of {img_name}, match_gt2pred_simple will be used.')
+                plain_text_match_s = match_gt2pred_simple(gt_text_list, pred_dataset['text_all'], 'text', img_name)
+            except Exception as e:
+                print(str(e))
+                sys.exit()
+
+            if not plain_text_match_s:
+                print(f'No text match of {img_name}. The plain text match will be empty.')
+            else:
+                plain_text_match_clean = self.filtered_out_ignore(plain_text_match_s, ['figure_caption', 'figure_footnote', 'table_caption', 'table_footnote', 'code_algorithm', 'code_algorithm_caption', 'header', 'footer', 'page_footnote', 'page_number', 'equation_caption'])
+
+
+        if gt_page_elements.get('equation_isolated'):
+            gt_display_list = self.get_sorted_text_list(gt_page_elements['equation_isolated'])
+            display_formula_match_s = match_gt2pred(gt_display_list, pred_dataset['equation_isolated'], 'formula', img_name)
+            display_formula_match_s = [x for x in display_formula_match_s if x['gt_idx'] != [""]]
+            if not display_formula_match_s:
+                print(f'No display_formula_match of {img_name}. The display_formula_match will be empty.')
+
+        if gt_page_elements.get('table'):
+            gt_table_list = self.get_sorted_text_list(gt_page_elements['table'])
+            if pred_dataset['latex_table']:
+                latex_table_match_s = match_gt2pred_simple(gt_table_list, pred_dataset['latex_table'], 'latex_table', img_name)
+                latex_table_match_s = [x for x in latex_table_match_s if x['gt_idx'] != [""]]
+            if pred_dataset['html_table']:
+                html_table_match_s = match_gt2pred_simple(gt_table_list, pred_dataset['html_table'], 'html_table', img_name)
+                html_table_match_s = [x for x in html_table_match_s if x['gt_idx'] != [""]]
+            else:
+                html_table_match_s = match_gt2pred_simple(gt_table_list, [], 'html_table', img_name)
+                html_table_match_s = [x for x in html_table_match_s if x['gt_idx'] != [""]]
+
+
+        order_match_s = plain_text_match_clean
+        if order_match_s:
+            order_match_single = self.get_order_paired(order_match_s, img_name)
+
+        return [plain_text_match_clean, display_formula_match_s, latex_table_match_s, html_table_match_s, order_match_single]
+
+    def process_generated_metric_results(self,samples,save_name:str='end2end_quick_match'):
+        from .metrics import show_result, get_full_labels_results, get_page_split, METRIC_REGISTRY
+
+        result_all={}
+        page_info={}
+        metircs_dict=self.dafault_metircs_dict
+        pages=self.references #gt_samples list
+
+        for page in pages:
+                img_path=os.path.basename(page['page_info']['image_path'])
+                page_info[img_path]=page['page_info']['page_attribute']
+
+        for element in metircs_dict.keys():
+
+            result={}
+            group_info=metircs_dict[element].get('group',[])
+            # samples = samples.get(element) ##
+            cur_samples = samples[element]
+
+            for metric in metircs_dict[element]['metric']:
+                metric_val = METRIC_REGISTRY.get(metric)
+
+                cur_samples,result_s = metric_val(cur_samples).evaluate(group_info, f"{save_name}_{element}")
+                if result_s:
+                    result.update(result_s)
+
+            if result:
+                print(f"{element}")
+                show_result(result)
+            result_all[element]={}
+
+
+            group_result=get_full_labels_results(cur_samples)
+            page_result=get_page_split(cur_samples,page_info)
+
+            result_all[element]={
+                'all':result,
+                'group':group_result,
+                'page':page_result
+            }
+            if isinstance(cur_samples,list):
+                saved_samples=cur_samples
+            else:
+                saved_samples=cur_samples.samples
+            # NOTE: The original code has a bug here, it will overwrite the result file in each iteration.
+            # I will fix it by adding element to the filename.
+            # NOTE: Fixed typo .josn -> .json
+            result_file = get_intermediate_file_path(self.eval_file, f'_{save_name}_{element}_result', 'json')
+            dump(saved_samples, result_file)
+
+        metric_result_file = get_intermediate_file_path(self.eval_file, f'_{save_name}_metric_result', 'json')
+        dump(result_all, metric_result_file)
+
+        dict_list = []
+        save_dict={}
+        en_overall=[]
+        ch_overall=[]
+        for category_type, metric in [("text_block", "Edit_dist"), ("display_formula", "Edit_dist"), ("display_formula", "CDM"), ("table", "TEDS"), ("table", "Edit_dist"), ("reading_order", "Edit_dist")]:
+            if metric == 'CDM':
+                save_dict[category_type+'_'+metric+'_EN'] = '-'
+                save_dict[category_type+'_'+metric+'_CH'] = '-'
+            elif metric == "TEDS":
+                save_dict[category_type+'_'+metric+'_EN'] = result_all[category_type]["page"][metric]["language: english"] * 100
+                save_dict[category_type+'_'+metric+'_CH'] = result_all[category_type]["page"][metric]["language: simplified_chinese"] * 100
+            else:
+                save_dict[category_type+'_'+metric+'_EN'] = result_all[category_type]["page"][metric].get("language: english", np.nan)
+                save_dict[category_type+'_'+metric+'_CH'] = result_all[category_type]["page"][metric].get("language: simplified_chinese",np.nan)
+            if metric == "Edit_dist":
+                en_overall.append(result_all[category_type]["page"][metric].get("language: english", np.nan))
+                ch_overall.append(result_all[category_type]["page"][metric].get("language: simplified_chinese",np.nan))
+
+        save_dict['overall_EN'] = sum(en_overall) / len(en_overall)
+        save_dict['overall_CH'] = sum(ch_overall) / len(ch_overall)
+        dict_list.append(save_dict)
+        df = pd.DataFrame(dict_list,index=['end2end',]).round(3)
+
+        e2e_eval_file = get_intermediate_file_path(self.eval_file, '_End2End_Evaluation', 'json')
+        dump(result_all, e2e_eval_file)
+        
+        overall_file = get_intermediate_file_path(self.eval_file, '_overall')
+        dump(df, overall_file)
+
+        print(f"The save path of End2End_Evaluation is: {e2e_eval_file}")
+        print(f"The save path of overall metrics is: {overall_file}")
+        return df
+
+
+class table_evalutor():
+    def __init__(self,eval_file,tsv_path):
+        self.eval_file = eval_file
+        gt_key='html'
+        pred_key='pred'
+        self.category_filter='table'
+        self.category_type='table'
+        self.metircs_list=['TEDS','Edit_dist']
+        self.gt_samples,self.table_samples=self.load_data(eval_file,tsv_path,pred_key,gt_key)
+
+    def load_data(self,eval_file,gt_file,pred_key,gt_key):
+        from .data_preprocess import clean_string, normalized_formula, textblock2unicode, normalized_table
+        samples=[]
+        preds=[]
+        predictions=load(eval_file)['prediction'].tolist()
+        gt_samples=load(gt_file)['answer'].tolist()
+        load_success,load_fail=0,0
+        for i,gt_sample in tqdm(enumerate(gt_samples),desc='Loading data'):
+            try:
+                ans=json.loads(gt_sample)
+                for item in ans['layout_dets']:
+                    if item['category_type']=="table":
+                        item['pred']=predictions[i]
+                        load_success+=1
+                        preds.append(ans)
+
+            except json.JSONDecodeError as e:
+                load_fail+=1
+                continue
+        print(f'load_table_success:{load_success},load_table_fail:{load_fail}')
+
+        count=0
+        for pred in preds:
+            img_name = os.path.basename(pred['page_info']['image_path'])
+            for i, ann in enumerate(pred['layout_dets']):
+                if not ann.get(gt_key):
+                    continue
+                if self.category_filter:
+                    if ann['category_type'] not in self.category_filter:
+                        continue
+                if not ann.get(pred_key):
+                    # print(f'Cannot find pred for {img_name}. ann is {ann}')
+                    # pdb.set_trace()
+                    count += 1
+                    continue
+                else:
+                    gt_text = ann[gt_key]
+                    norm_gt = gt_text
+                    pred_text = ann[pred_key]
+                    norm_pred = pred_text
+                    if self.category_type:
+                        if self.category_type == 'text':
+                            norm_gt = clean_string(textblock2unicode(ann[gt_key]))
+                            norm_pred = clean_string(textblock2unicode(ann[pred_key]))
+                        elif self.category_type == 'formula':
+                            norm_gt = normalized_formula(ann[gt_key])
+                            norm_pred = normalized_formula(ann[pred_key])
+                        elif self.category_type == 'table':
+                            norm_gt = normalized_table(ann[gt_key], gt_key)
+                            norm_pred = normalized_table(ann[pred_key], gt_key)
+                        else:
+                            raise ValueError(f'Invalid category type: {self.category_type}')
+
+                samples.append({
+                    "gt": gt_text,
+                    "norm_gt": norm_gt,
+                    "gt_attribute": [ann['attribute']],
+                    'pred': pred_text,
+                    "norm_pred": norm_pred,
+                    'img_id': img_name
+                })
+
+        print(f'Cannot find pred for {count} samples.')
+        return preds,samples
+
+    def score(self)->dict:
+        metrics=self.process_generated_metric_results()
+        return metrics
+
+    def process_generated_metric_results(self,save_name:str='OmniDocBench_table'):
+        from .metrics import show_result, get_full_labels_results, get_page_split, METRIC_REGISTRY
+
+        p_scores={}
+        page_info={}
+        no_page_flag=False
+        samples=self.table_samples
+        pages=self.gt_samples
+
+        for page in pages:
+            if 'page_info' not in page:
+                no_page_flag=True
+                break
+            img_path=os.path.basename(page['page_info']['image_path'])
+            page_info[img_path]=page['page_info']['page_attribute']
+
+        for metric in self.metircs_list:
+            metric_val=METRIC_REGISTRY.get(metric)
+            samples, result = metric_val(samples).evaluate({}, save_name)
+            if result:
+                p_scores.update(result)
+        show_result(p_scores)
+        group_result=get_full_labels_results(samples)
+        if no_page_flag:
+            page_result={}
+        else:
+            page_result=get_page_split(samples,page_info)
+
+        result_all={
+            'all':p_scores,
+            'group':group_result,
+            'page':page_result
+        }
+
+        metric_result_file = get_intermediate_file_path(self.eval_file, f'_{save_name}_metric_result', 'json')
+        dump(result_all, metric_result_file)
+
+        dict_list=[]
+        dict_list.append(result_all["group"]["TEDS"])
+
+        df4 = pd.DataFrame(dict_list, index=['OmniDocBench_table'])
+        df4 = df4 * 100
+        df4 = df4.round(1)
+        selected_columns = df4[["language: table_en", "language: table_simplified_chinese", "language: table_en_ch_mixed", "line: full_line", "line: less_line", "line: fewer_line", "line: wireless_line",
+                        "with_span: True", "with_span: False", "include_equation: True", "include_equation: False", "include_background: True", "include_background: False", "table_layout: vertical", "table_layout: horizontal"]]
+
+        table_attr_file = get_intermediate_file_path(self.eval_file, '_table_attribute')
+        dump(selected_columns, table_attr_file)
+        print(f'The save path of table_attribute is :{table_attr_file}')
+        return selected_columns

VLMEvalKit-sudoku/vlmeval/dataset/mmmath.py

@@ -0,0 +1,459 @@
+import re
+import json
+
+import numpy as np
+import sys
+import math
+import os
+import argparse
+import timeout_decorator
+import logging
+
+from .image_base import ImageBaseDataset
+from ..utils import track_progress_rich
+from ..smp import load, dump, get_intermediate_file_path
+
+try:
+    import sympy as sp
+    from sympy import simplify, Eq, sympify, Pow, pi
+    from sympy.parsing.latex import parse_latex
+except ImportError:
+    logging.warning('sympy is not installed, please install it for MM-Math evaluation.')
+
+
+class AutoScoringJudge:
+    def __init__(self):
+        # Map of special symbols to their replacements
+        self.special_signal_map = {
+            "\\left": "",
+            "\\right": "",
+            "厘米":"",
+            # "∶": ":",
+            "，": ",",
+            "$": "",
+            "（":"(",
+            "）":")",
+            "\\infty":"oo",
+            "\\colon ":":",
+            # "\\approx": "=",
+            # "\\simeq": "=",
+            # "\\sim": "=",
+            # "^\\prime": "'",
+            # "^{\\prime}": "'",
+            "＋":"+",
+            "\\, ": "",
+            "\\,":"",
+            "^\\circ": "",
+            "^{\\circ}": "",
+            # "%": "",
+        }
+        self.pi = parse_latex("\\pi")
+        # MM-Math default precision
+        self.precision = 1e-2
+
+    def trans_greater_sign_to_interval(self, expr:str):
+        expr_tmp = expr.split("<")
+        return "(" + expr_tmp[0] + ", " + expr_tmp[-1] + ")"
+
+    def split_by_comma(self, expr: str):
+        # Splits expressions by commas outside of brackets
+        in_bracket_num = 0
+        splitted_expr = []
+        start_idx = 0
+        for i, char in enumerate(expr):
+            if char in ["(", "["]:
+                in_bracket_num += 1
+            elif char in [")", "]"]:
+                in_bracket_num -= 1
+            elif char == "," and in_bracket_num == 0:
+                splitted_expr.append(expr[start_idx:i].strip())
+                start_idx = i + 1
+
+        if start_idx < len(expr):
+            splitted_expr.append(expr[start_idx:].strip())
+
+        return splitted_expr
+
+    def trans_plus_minus_sign(self, expr_list: list):
+        # Translates plus-minus signs into separate expressions
+        new_expr_list = []
+        for expr in expr_list:
+            if "\\pm" in expr:
+                new_expr_list.append(expr.replace("\\pm", "+"))
+                new_expr_list.append(expr.replace("\\pm", "-"))
+            else:
+                new_expr_list.append(expr)
+
+        return new_expr_list
+
+    def judge(self, expression1, expression2, precision=1e-2):
+        # Judge if two expressions are equal (expression1 is considered as the Ground Truth)
+        # Default precision is a list for supporting multiple expressions
+        precision = precision if isinstance(precision, list) else [precision]
+
+        try:
+            expression1, expression2 = self.preprocess(expression1, expression2)
+        except:
+            return False
+        if expression1 == expression2:
+            # print("Exactly equal")
+            return True
+
+        # Remove Chinese characters from the string, as answers like "yes" or "no" in Chinese have been considered
+        expression1 = expression1 if re.fullmatch(r"[\u4e00-\u9fff]+", expression1) else re.sub(r'[\u4e00-\u9fff]+', '', expression1)  # noqa: E501
+        expression2 = expression2 if re.fullmatch(r'[\u4e00-\u9fff]+', expression2) else re.sub(r'[\u4e00-\u9fff]+', '', expression2)  # noqa: E501
+        # Check if two < or > in expression
+        if self.is_two_greater_sign(expression1):
+            expression1 = self.trans_greater_sign_to_interval(expression1)
+
+        if self.is_two_greater_sign(expression2):
+            expression2 = self.trans_greater_sign_to_interval(expression2)
+
+        expression1 = self.split_by_comma(expression1)
+        expression2 = self.split_by_comma(expression2)
+
+        temp_list1 = self.trans_plus_minus_sign(expression1)
+        temp_list2 = self.trans_plus_minus_sign(expression2)
+
+        # Set up a list for allowed errors
+        if len(precision) <= 1:
+            precision = precision * len(temp_list1)
+
+        if len(temp_list1) != len(temp_list2):
+            return False
+
+        # Check if elements in both lists can be paired and are equal
+        idx = -1
+        while len(temp_list1) != 0:
+            idx = (idx + 1) % len(temp_list1)
+
+            item1 = temp_list1[idx]
+            self.precision = precision[idx]
+
+            for item2 in temp_list2:
+                try:
+                    if self.is_equal(item1, item2):
+                        temp_list1.remove(item1)
+                        temp_list2.remove(item2)
+                        precision.remove(self.precision)
+                        break
+                except Exception as err:
+                    logging.warning(f'{type(err)}: {err}')
+                    continue
+            else:
+                # If no match was found, return False
+                return False
+
+        # If all elements are matched, return True
+        return True
+
+    def is_interval(self, expr):
+        # Checks if an expression is an interval
+        return expr.startswith(("(", "[")) and expr.endswith((")", "]"))
+
+    def is_two_greater_sign(self, expr):
+        match = re.findall(r'<', expr)
+        return len(match) == 2
+
+    def sympy_sub_pi(self, expression_sympy):
+        # Replaces the symbol for pi in sympy expressions with its numerical value
+        return expression_sympy.subs(self.pi, math.pi)
+
+    # Set timeout to 30 seconds for is_equal
+    @timeout_decorator.timeout(30)
+    def is_equal(self, expression1, expression2):
+        # Default first expression is ground truth. Check if expressions are equal in different aspects
+        if expression1 == expression2 and expression1 != "" and expression2 != "":
+            # print("Equivalent natively")
+            return True
+
+        # First check if both are intervals
+        if self.is_interval(expression1) and self.is_interval(expression2):
+            try:
+                if self.interval_equal(expression1, expression2):
+                    # print("Interval equivalent")
+                    return True
+            except:
+                return False
+
+        # Then check for numerical equality
+        try:
+            if self.numerical_equal(expression1, expression2):
+                # print("Numerically equivalent")
+                return True
+        except:
+            pass
+        # Then check if expressions are mathematically equal
+        try:
+            if self.expression_equal(expression1, expression2) and not ("=" in expression1 and "=" in expression2):
+                # print("Expression equivalent")
+                return True
+        except:
+            pass
+
+        # Lastly, check for equation equality
+        try:
+            if self.equation_equal(expression1, expression2):
+                # print("Equation equivalent")
+                return True
+        except:
+            pass
+
+        return False
+
+    def numerical_equal(self, expression1: str, expression2: str, include_percentage: bool = True):
+        # Check if two numerical values are equal within an allowed error range
+        # Includes possible percentage cases
+        reference = float(expression1)
+        prediction = float(expression2)
+
+        if include_percentage:
+            gt_result = [reference / 100, reference, reference * 100]
+        else:
+            gt_result = [reference]
+
+        for item in gt_result:
+            if abs(item - prediction) <= self.precision * 1.01:
+                return True
+        return False
+
+    def expression_equal(self, exp1, exp2):
+        # Check if two expressions are mathematically equivalent
+        # Extract expression and use sympy for equivalence checking
+        def extract_expression(expression):
+            if "=" in expression:
+                expression = expression.split("=")[1]
+            return expression.strip()
+
+        exp1 = extract_expression(exp1)
+        exp2 = extract_expression(exp2)
+
+        exp_too_long = len(exp1) > 300 or len(exp2) > 300
+
+        expr1_sym = sympify(parse_latex(exp1))
+        expr2_sym = sympify(parse_latex(exp2))
+        if expr1_sym == expr2_sym:
+            return True
+        else:
+            expr1_sym = self.sympy_sub_pi(expr1_sym)
+            expr2_sym = self.sympy_sub_pi(expr2_sym)
+
+            if (expr1_sym.has(sp.Symbol) and not expr2_sym.has(sp.Symbol)) or \
+                    (not expr1_sym.has(sp.Symbol) and expr2_sym.has(sp.Symbol)):
+                return False
+            elif not expr1_sym.has(sp.Symbol) and not expr2_sym.has(sp.Symbol):
+                try:
+                    if not (self.can_compute_power(expr1_sym) and self.can_compute_power(expr2_sym)):
+                        print("These two numbers cannot be calculated by the current computer for: "
+                              f"\"{str(expr1_sym)}\" and \"{str(expr2_sym)}\"")
+                        return False
+                    if exp_too_long:
+                        print(f'Expression {exp1} or {exp2} is too long to compute. ')
+                        return False
+                    if abs(expr1_sym.evalf() - expr2_sym.evalf()) <= self.precision * 1.01:
+                        return True
+                    else:
+                        return False
+                except:
+                    return False
+            elif exp_too_long:
+                print(f'Expression {exp1} or {exp2} is too long to compute. ')
+                return False
+            else:
+                try:
+                    simplified_expr = simplify(expr1_sym - expr2_sym)
+                    num_value = simplified_expr.evalf()
+                    return abs(num_value) < 1e-3
+                except:
+                    return False
+
+    def equation_equal(self, expression1, expression2):
+        # Check if two equations are mathematically equivalent
+        # Simplify equations and use sympy for equivalence checking
+        def simplify_equation(latex_eq):
+            lhs, rhs = latex_eq.split('=')
+
+            lhs_expr = parse_latex(lhs)
+            rhs_expr = parse_latex(rhs)
+
+            equation = Eq(lhs_expr, rhs_expr)
+
+            simplified_eq = simplify(equation.lhs - equation.rhs)
+
+            return simplified_eq
+
+        expr1_sym = simplify_equation(expression1)
+        expr2_sym = simplify_equation(expression2)
+
+        division_result_1 = simplify(expr1_sym / expr2_sym)
+        division_result_2 = simplify(expr2_sym / expr1_sym)
+
+        if ((division_result_1.is_Integer and division_result_1 != 0) or  # noqa: W504
+                (division_result_2.is_Integer and division_result_2 != 0)):
+            return True
+        else:
+            return False
+
+    def interval_equal(self, expression1, expression2):
+        # Check if two intervals are mathematically equivalent
+        def compare_two_interval(inter1, inter2):
+            if inter1[0] != inter2[0] or inter1[-1] != inter2[-1]:
+                return False
+
+            inter1 = inter1.strip('[]()')
+            inter2 = inter2.strip('[]()')
+
+            items_1 = inter1.split(',')
+            items_2 = inter2.split(',')
+
+            for item_1, item_2 in zip(items_1, items_2):
+                if not self.expression_equal(item_1, item_2):
+                    return False
+            return True
+
+        interval1 = expression1
+        interval2 = expression2
+
+        if interval1 == interval2:
+            return True
+        else:
+            inter_list1 = interval1.split("\\cup")
+            inter_list2 = interval2.split("\\cup")
+
+            if len(inter_list1) != len(inter_list2):
+                return False
+            else:
+                for inter1, inter2 in zip(inter_list1, inter_list2):
+                    if not compare_two_interval(inter1, inter2):
+                        return False
+                return True
+
+    def preprocess(self, expression1, expression2):
+        # Preprocess expressions to extract and replace special symbols
+        def extract_boxed_content(latex_str):
+            boxed_matches = re.finditer(r'\\boxed{', latex_str)
+            results = ""
+
+            for match in boxed_matches:
+                start_index = match.end()
+                end_index = start_index
+                stack = 1
+
+                while stack > 0 and end_index < len(latex_str):
+                    if latex_str[end_index] == '{':
+                        stack += 1
+                    elif latex_str[end_index] == '}':
+                        stack -= 1
+                    end_index += 1
+
+                if stack == 0:
+                    content = latex_str[start_index:end_index - 1]
+                    results += content + ","
+                else:
+                    raise ValueError("Mismatched braces in LaTeX string.")
+
+            if results == "":
+                last_line_ans = latex_str.strip().split("\n")[-1]
+                dollar_pattern = r"\$(.*?)\$"
+                answers = re.findall(dollar_pattern, last_line_ans)
+
+                if answers:
+                    for ans in answers:
+                        results += ans + ","
+                else:
+                    results = latex_str
+
+            return results
+
+        def sepcial_symbol_replace(expression):
+
+            expression = expression.replace("\\text{cm}^2", '').replace("\\text{cm}", "").replace("\\,cm", '').replace("\\text{ cm}", '').replace("cm", '').replace("\\text{分米}^2", '').replace("cm^{2}", '').replace("60 \\text{ cm}^2",'').replace("\\ \\text{m}", "").replace("\\text{米}","").strip()  # noqa: E501
+
+            expression = re.sub(r"(.+)m$", r"\1", expression)
+
+            if "\\in " in expression:
+                expression = expression.split("\\in ")[1]
+
+            for signal in self.special_signal_map:
+                expression = expression.replace(signal, self.special_signal_map[signal])
+
+            expression = re.sub(r'(\\sin|\\cos|\\tan)(\d+)', r'\1((\2/180)\\pi)', expression)
+
+            expression = expression.strip("\n,.:;^_=+`!@#%^&*~，。")
+
+            pattern = r'\\(?:mathrm|mathbf)\{~?([^}]*)\}'
+            expression = re.sub(pattern, r'\1', expression)
+
+            return expression
+
+        exp1, exp2 = extract_boxed_content(expression1), extract_boxed_content(expression2)
+
+        exp1, exp2 = sepcial_symbol_replace(exp1), sepcial_symbol_replace(exp2)
+
+        return exp1, exp2
+
+    def can_compute_power(self, expr):
+        # Checks if a power expression can be computed
+        if isinstance(expr, Pow):
+            base, exp = expr.as_base_exp()
+            if base.is_number and exp.is_number:
+                MAX_EXP = 1000  # Adjust based on computing environment
+                if abs(exp.evalf()) > MAX_EXP:
+                    return False
+                else:
+                    return True
+            else:
+                return False
+        else:
+            return True  # Not a power expression, can compute
+
+
+class MMMath(ImageBaseDataset):
+
+    TYPE = 'VQA'
+
+    DATASET_URL = {
+        'MM-Math': 'https://opencompass.openxlab.space/utils/VLMEval/MM-Math.tsv',
+    }
+    DATASET_MD5 = {
+        'MM-Math': '1f064ed7c4e0e8926a3fa65849419ca5',
+    }
+
+    @classmethod
+    def evaluate(self, eval_file, **kwargs):
+
+        data = load(eval_file)
+        judger = AutoScoringJudge()
+        func = judger.judge
+
+        tups = [dict(expression1=x, expression2=y) for x, y in zip(data['answer'], data['prediction'])]
+
+        res = track_progress_rich(func, tups, nproc=16)
+        data['hit'] = res
+        dump(data, eval_file)
+
+        score_file = get_intermediate_file_path(eval_file, '_score', 'json')
+        score = {}
+        score['overall'] = np.mean(data['hit'])
+        # Results by Difficulty
+        difficulties = set(data['difficulty'])
+        for d in difficulties:
+            score[f'Difficulty-{d}'] = np.mean(data[data['difficulty'] == d]['hit'])
+
+        # Results by Year
+        years = set(data['year'])
+        for y in years:
+            score[f'Year-{y}'] = np.mean(data[data['year'] == y]['hit'])
+
+        # Results by Knowledge-L1
+        points = set(data['knowledge_l1'])
+        for p in points:
+            score[f'Knowledge-L1-{p}'] = np.mean(data[data['knowledge_l1'] == p]['hit'])
+
+        # Results by Knowledge-L2
+        points = set(data['knowledge_l2'])
+        for p in points:
+            score[f'Knowledge-L2-{p}'] = np.mean(data[data['knowledge_l2'] == p]['hit'])
+
+        dump(score, score_file)
+        return score

VLMEvalKit-sudoku/vlmeval/dataset/utils/bmmr_grade.py

@@ -0,0 +1,470 @@
+# flake8: noqa
+# Copyright (c) 2024, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Copyright (c) Microsoft Corporation.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE
+
+# Copyright (c) 2023 OpenAI
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# Copyright (c) 2021 Dan Hendrycks
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+"""
+This logic is largely copied from the Hendrycks' MATH release (math_equivalence), and borrowed from:
+- https://github.com/microsoft/ToRA/blob/main/src/eval/grader.py
+- https://github.com/microsoft/ProphetNet/tree/master/CRITIC
+- https://github.com/openai/prm800k
+"""
+
+
+import contextlib
+import re
+import signal
+import math
+from math import isclose
+from typing import Union
+
+import sympy
+from sympy import N, simplify
+from sympy.parsing.latex import parse_latex
+from sympy.parsing.sympy_parser import parse_expr
+
+
+def is_digit(s):
+    try:
+        if "{,}" in str(s):
+            num = float(str(s).replace("{,}", ""))
+            return True, num
+
+        num = float(str(s).replace(",", ""))
+        return True, num
+    except ValueError:
+        return False, None
+
+
+def normalize(answer, pi) -> str:
+    # checking if answer is $<number> and removing $ in that case to compare
+    if isinstance(answer, str) and bool(re.match(r'\$\d+(\.\d+)?', answer)):
+        return answer[1:]
+
+    # checking if answer is <number>% or <number>\\% and removing %
+    if isinstance(answer, str) and (
+        bool(re.match(r'^\d+(\.\d+)?%$', answer)) or bool(re.match(r'^\d+(\.\d+)?\\%$', answer))
+    ):
+        return answer.replace("\\%", "").replace("%", "")
+
+    # handle base
+    answer = handle_base(answer)
+
+    # handle pi
+    answer = handle_pi(answer, pi)
+
+    return answer
+
+
+def handle_base(x) -> str:
+    if isinstance(x, str) and "_" in x:
+        try:
+            # Due to base
+            x = x.split("_")[0]
+            x = float(x)
+            return int(x)
+        except:
+            pass
+    return x
+
+
+def handle_pi(string, pi):
+
+    if isinstance(string, str) and "\pi" in string:
+        # Find the first occurrence of "\pi"
+        idx = string.find("\pi")
+
+        # Iterate over the string and find all occurrences of "\pi" with a valid previous character
+        while idx != -1:
+
+            if idx > 0 and string[idx - 1].isdigit():
+                # Replace "\pi" with "*math.pi" if the previous character is a digit
+                string = string[:idx] + f"*{pi}" + string[idx + 3:]
+            else:
+                # Replace "\pi" with "1*math.pi" if the previous character is not a digit
+                string = string[:idx] + f"1*{pi}" + string[idx + 3:]
+
+            # Find the next occurrence of "\pi"
+            idx = string.find("\pi", idx + 1)
+
+        # Evaluate the expression using eval() function
+        try:
+            string = eval(string)
+        except:
+            pass
+
+    return string
+
+
+def math_equal(
+    prediction: Union[bool, float, str],
+    reference: Union[float, str],
+    include_percentage: bool = True,
+    tolerance: float = 1e-4,
+    timeout: float = 10.0,
+    pi: float = math.pi
+) -> bool:
+    """
+    Exact match of math if and only if:
+    1. numerical equal: both can convert to float and are equal
+    2. symbolic equal: both can convert to sympy expression and are equal
+    """
+
+    prediction = normalize(prediction, pi)
+    reference = normalize(reference, pi)
+
+    if isinstance(prediction, str) and len(prediction) > 1000:  # handling weird corner-cases
+        prediction = prediction[:1000]
+
+    # 0. string comparison
+    if isinstance(prediction, str) and isinstance(reference, str):
+        if prediction.strip().lower() == reference.strip().lower():
+            return True
+        if prediction.replace(" ", "") == reference.replace(" ", ""):
+            return True
+
+    try:  # 1. numerical equal
+        if is_digit(prediction)[0] and is_digit(reference)[0]:
+            prediction = is_digit(prediction)[1]
+            reference = is_digit(reference)[1]
+            # number questions
+            if include_percentage:
+                gt_result = [reference / 100, reference, reference * 100]
+            else:
+                gt_result = [reference]
+            for item in gt_result:
+                try:
+                    if isclose(item, prediction, rel_tol=tolerance):
+                        return True
+                except Exception:
+                    continue
+            return False
+    except Exception:
+        pass
+
+    if not prediction and prediction not in [0, False]:
+        return False
+
+    # 2. symbolic equal
+    reference = str(reference).strip()
+    prediction = str(prediction).strip()
+
+    # deal with [], (), {}
+    prediction = format_intervals(prediction)
+
+    pred_str, ref_str = prediction, reference
+    if (prediction.startswith("[") and prediction.endswith("]") and not reference.startswith("(")) or (
+        prediction.startswith("(") and prediction.endswith(")") and not reference.startswith("[")
+    ):
+        pred_str = pred_str.strip("[]()")
+        ref_str = ref_str.strip("[]()")
+    for s in ["{", "}", "(", ")"]:
+        ref_str = ref_str.replace(s, "")
+        pred_str = pred_str.replace(s, "")
+    if pred_str == ref_str:
+        return True
+
+    # [a, b] vs. [c, d], return a==c and b==d
+    if (
+        prediction
+        and reference
+        and prediction[0] in "(["
+        and prediction[-1] in ")]"
+        and prediction[0] == reference[0]
+        and prediction[-1] == reference[-1]
+    ):
+        pred_parts = prediction[1:-1].split(",")
+        ref_parts = reference[1:-1].split(",")
+        if len(pred_parts) == len(ref_parts):
+            if all(
+                [
+                    math_equal(pred_pt, ref_pt, include_percentage, tolerance)
+                    for pred_pt, ref_pt in zip(pred_parts, ref_parts)
+                ]
+            ):
+                return True
+
+    if "," in prediction and "," in reference:
+        pred_parts = [item.strip() for item in prediction.split(",")]
+        ref_parts = [item.strip() for item in reference.split(",")]
+
+        if len(pred_parts) == len(ref_parts):
+            if all(
+                [
+                    math_equal(pred_parts[i], ref_parts[i], include_percentage, tolerance)
+                    for i in range(len(pred_parts))
+                ]
+            ):
+                return True
+            else:
+                return False
+
+    # if we have point == tuple of values
+    if len(reference) == 0:
+        return False
+    if prediction.startswith("Point") and reference[0] == "(" and reference[-1] == ")":
+        pred_parts = prediction[prediction.find("(") + 1: -1].split(",")
+        ref_parts = reference[1:-1].split(",")
+        if len(pred_parts) == len(ref_parts):
+            if all(
+                [
+                    math_equal(pred_pt, ref_pt, include_percentage, tolerance)
+                    for pred_pt, ref_pt in zip(pred_parts, ref_parts)
+                ]
+            ):
+                return True
+
+    # if reference is a matrix
+    if "\begin{pmatrix}" in reference and prediction.startswith("Matrix"):
+        try:
+            pred_matrix = parse_expr(prediction)
+            ref_matrix_items = reference.split()[1:-1:2]
+            if len(pred_matrix) == len(ref_matrix_items):
+                if all(
+                    [
+                        math_equal(pred, ref, include_percentage, tolerance)
+                        for ref, pred in zip(ref_matrix_items, pred_matrix)
+                    ]
+                ):
+                    return True
+        except Exception:
+            pass
+    elif "\begin{pmatrix}" in reference and prediction.startswith("[") and prediction.endswith("]"):
+        if isinstance(eval(prediction), list):
+            try:
+                pred_matrix = eval(prediction)
+                # ref_matrix_items = reference.split()[1:-1:2]
+                ref_matrix_items = reference.lstrip("\\begin{pmatrix}").lstrip("\begin{pmatrix}").rstrip("\\end{pmatrix}").rstrip("\end{pmatrix}")
+                ref_matrix_items = ref_matrix_items.split("\\")
+                ref_matrix_items = [row.split("&") if "&" in row else row for row in ref_matrix_items]
+                if len(pred_matrix) == len(ref_matrix_items):
+                    if all(
+                        [
+                            math_equal(pred, ref, include_percentage, tolerance)
+                            for ref, pred in zip(ref_matrix_items, pred_matrix)
+                        ]
+                    ):
+                        return True
+            except Exception:
+                pass
+
+    return symbolic_equal(prediction, reference, tolerance, timeout)
+
+
+def symbolic_equal(a, b, tolerance, timeout=10.0):
+    def _parse(s):
+        for f in [parse_expr, parse_latex]:
+            try:
+                with time_limit(timeout):
+                    return f(s)
+            except Exception:
+                pass
+        return s
+
+    a = _parse(a)
+    b = _parse(b)
+
+    try:
+        with time_limit(timeout):
+            if simplify(a - b) == 0:
+                return True
+    except Exception:
+        pass
+
+    try:
+        with time_limit(timeout):
+            if isclose(N(a), N(b), rel_tol=tolerance):
+                return True
+    except Exception:
+        pass
+    return False
+
+
+def extract_answer(string):
+    """Extract Answer String from \\boxed expression."""
+    idx = string.rfind("\\boxed")
+    if idx < 0:
+        idx = string.rfind("\\fbox")
+        if idx < 0:
+            return None
+
+    i = idx
+    right_brace_idx = None
+    num_left_braces_open = 0
+    while i < len(string):
+        if string[i] == "{":
+            num_left_braces_open += 1
+        if string[i] == "}":
+            num_left_braces_open -= 1
+            if num_left_braces_open == 0:
+                right_brace_idx = i
+                break
+        i += 1
+
+    if right_brace_idx is None:
+        retval = None
+    else:
+        retval = string[idx : right_brace_idx + 1]
+
+    if retval:
+        left = "\\boxed{"
+        try:
+            assert retval[: len(left)] == left
+            assert retval[-1] == "}"
+            return retval[len(left) : -1]
+        except AssertionError:
+            return None
+
+    return None
+
+
+class TimeoutException(Exception):
+    pass
+
+
+@contextlib.contextmanager
+def time_limit(seconds: float):
+    def signal_handler(signum, frame):
+        raise TimeoutException("Timed out!")
+
+    signal.setitimer(signal.ITIMER_REAL, seconds)
+    signal.signal(signal.SIGALRM, signal_handler)
+    try:
+        yield
+    finally:
+        signal.setitimer(signal.ITIMER_REAL, 0)
+
+
+def format_intervals(prediction):
+    patterns = {
+        "Interval(": r"^Interval\((.*)\)$",
+        "Interval.Ropen(": r"^Interval\.Ropen\((.*)\)$",
+        "Interval.Lopen(": r"^Interval\.Lopen\((.*)\)$",
+        "Interval.open(": r"^Interval\.open\((.*)\)$",
+    }
+
+    for key, pattern in patterns.items():
+        match = re.match(pattern, prediction)
+        if match:
+            inner_content = match.group(1)
+
+            if key == "Interval(":  # Intarval(a, b) == [a, b]
+                return f"[{inner_content}]"
+            elif key == "Interval.Ropen(":  # Intarval.Ropen(a, b) == [a, b)
+                return f"[{inner_content})"
+            elif key == "Interval.Lopen(":  # Intarval.Lopen(a, b) == (a, b]
+                return f"({inner_content}]"
+            elif key == "Interval.open(":  # Intarval.open(a, b) == (a, b)
+                return f"({inner_content})"
+
+    return prediction
+
+
+# def _test_math_equal():
+#     ref = "6,-2"
+#     pred = "6"
+#     print(math_equal(ref, pred))
+
+def _test_math_equal():
+    pi = math.pi
+    ref = "900\pi"
+    pred = 812.0
+    print(math_equal(pred, ref, pi=pi))
+
+    ref = "25\pi"
+    pred = 78.5
+    print(math_equal(pred, ref, pi=pi))
+
+    ref = "90\pi"
+    pred = 282.6
+    print(math_equal(pred, ref, pi=pi))
+
+    ref = "24+4\pi"
+    pred = 36.57142857142857
+    print(math_equal(pred, ref, pi=pi))
+
+    ref = "9\pi"
+    pred = 28.274309999999993
+    print(math_equal(pred, ref, pi=pi))
+
+
+# def _test_math_equal():
+#     ref = "\\begin{pmatrix}0&1\\1&0\\end{pmatrix}"
+#     # ref=ref.split()[1:-1:2]
+#     pred = [[0,1], [1,0]]
+#     print(math_equal(pred, ref))
+
+
+if __name__ == "__main__":
+    _test_math_equal()

VLMEvalKit-sudoku/vlmeval/dataset/utils/megabench/scoring/xml_nbbox_iou.py

@@ -0,0 +1,33 @@
+import logging
+from .common.metrics import calculate_iou
+from .common.conversions import parse_bboxes_from_xml
+from numbers import Number
+
+
+class XmlNbboxIouSingle:
+    """Calculates the IoU of bounding box.
+
+    Assumes that co-ordinates are normalized between 0 and 1 and that the bounding boxes
+    are of the form <box>top_left_x, top_left_y, bottom_right_x, bottom_right_y</box>
+    """
+
+    @classmethod
+    def match(cls, responses, targets) -> float:
+
+        logging.debug(f"{responses=}, {targets=}")
+        if not isinstance(responses, (tuple | list)):
+            responses = parse_bboxes_from_xml(responses)
+        if not isinstance(targets, (tuple | list)):
+            targets = parse_bboxes_from_xml(targets)
+
+        if len(responses) == 0:
+            return 0
+        elif isinstance(responses[0], Number) and len(responses) == 4:
+            responses = [responses]
+
+        iou_scores = calculate_iou(responses, targets)
+        if not iou_scores:
+            return 0
+
+        # Take the mean IoU score for now.
+        return sum(iou_scores) / len(iou_scores)

VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/hawk/__init__.py

@@ -0,0 +1 @@
+from .model import HawkQwenForCausalLM

VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/hawk/model/__init__.py

@@ -0,0 +1 @@
+from .language_model.hawk_qwen import HawkQwenConfig, HawkQwenForCausalLM

VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/hawk/model/vision_encoder/__init__.py

@@ -0,0 +1,5 @@
+from .qwen_vit import QwenVisionModel
+
+VISION_TRANSFORMER_CLASSES = {
+    'qwen_vit': QwenVisionModel
+}

VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/hawk/model/vision_encoder/qwen_vit/__init__.py

@@ -0,0 +1,2 @@
+from .modeling_qwen_vit import QwenVisionModel
+from .configuration_qwen_vit import QwenVisionConfig

VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/hawk/model/vision_encoder/qwen_vit/configuration_qwen_vit.py

@@ -0,0 +1,56 @@
+# --------------------------------------------------------
+# pandayin: Copied and modified from transformers/models/qwen2_vl/configuration_qwen2_vl.py
+# --------------------------------------------------------
+
+import os
+from typing import Union
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+
+class QwenVisionConfig(PretrainedConfig):
+    model_type = "qwen_vit"
+    # base_config_key = "vision_config"
+
+    def __init__(
+        self,
+        depth=32,
+        embed_dim=1280,
+        hidden_act="quick_gelu",
+        mlp_ratio=4,
+        num_heads=16,
+        in_channels=3,
+        patch_size=14,
+        spatial_merge_size=2,
+        temporal_patch_size=2,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.depth = depth
+        self.embed_dim = embed_dim
+        self.hidden_act = hidden_act
+        self.mlp_ratio = mlp_ratio
+        self.num_heads = num_heads
+        self.in_channels = in_channels
+        self.patch_size = patch_size
+        self.spatial_merge_size = spatial_merge_size
+        self.temporal_patch_size = temporal_patch_size
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> 'PretrainedConfig':
+        config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
+
+        if 'vision_config' in config_dict:
+            config_dict = config_dict['vision_config']
+
+        if 'model_type' in config_dict and hasattr(cls, 'model_type') and config_dict['model_type'] != cls.model_type:
+            logger.warning(
+                f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
+                f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'
+            )
+
+        return cls.from_dict(config_dict, **kwargs)

VLMEvalKit-sudoku/vlmeval/vlm/hawk_vl/hawk/utils.py

@@ -0,0 +1,16 @@
+import torch.distributed as dist
+
+
+def rank0_print(*args):
+    if dist.is_initialized():
+        if dist.get_rank() == 0:
+            print(f"Rank {dist.get_rank()}: ", *args)
+    else:
+        print(*args)
+
+
+def rank_print(*args):
+    if dist.is_initialized():
+        print(f"Rank {dist.get_rank()}: ", *args)
+    else:
+        print(*args)

VLMEvalKit-sudoku/vlmeval/vlm/internvl/__init__.py

@@ -0,0 +1,3 @@
+from .internvl_chat import InternVLChat
+
+__all__ = ['InternVLChat']

VLMEvalKit-sudoku/vlmeval/vlm/internvl/utils.py

@@ -0,0 +1,312 @@
+import math
+import pandas as pd
+import random
+import re
+import string
+import torch
+import torch.distributed as dist
+import torchvision.transforms as T
+import transformers
+import warnings
+from PIL import Image
+from torchvision.transforms.functional import InterpolationMode
+from transformers import AutoTokenizer, AutoConfig, AutoModel, CLIPImageProcessor
+
+from ..base import BaseModel
+from ...dataset import DATASET_TYPE, DATASET_MODALITY
+from ...smp import *
+
+IMAGENET_MEAN = (0.485, 0.456, 0.406)
+IMAGENET_STD = (0.229, 0.224, 0.225)
+
+
+def build_transform(input_size):
+    MEAN, STD = IMAGENET_MEAN, IMAGENET_STD
+    transform = T.Compose([
+        T.Lambda(lambda img: img.convert('RGB') if img.mode != 'RGB' else img),
+        T.Resize((input_size, input_size), interpolation=InterpolationMode.BICUBIC),
+        T.ToTensor(),
+        T.Normalize(mean=MEAN, std=STD)
+    ])
+    return transform
+
+
+def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
+    best_ratio_diff = float('inf')
+    best_ratio = (1, 1)
+    area = width * height
+    for ratio in target_ratios:
+        target_aspect_ratio = ratio[0] / ratio[1]
+        ratio_diff = abs(aspect_ratio - target_aspect_ratio)
+        if ratio_diff < best_ratio_diff:
+            best_ratio_diff = ratio_diff
+            best_ratio = ratio
+        elif ratio_diff == best_ratio_diff:
+            if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
+                best_ratio = ratio
+    return best_ratio
+
+
+def dynamic_preprocess(image, min_num=1, max_num=6, image_size=448, use_thumbnail=False):
+    orig_width, orig_height = image.size
+    aspect_ratio = orig_width / orig_height
+
+    # calculate the existing image aspect ratio
+    target_ratios = set(
+        (i, j) for n in range(min_num, max_num + 1) for i in range(1, n + 1) for j in range(1, n + 1) if
+        i * j <= max_num and i * j >= min_num)
+    target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+
+    # find the closest aspect ratio to the target
+    target_aspect_ratio = find_closest_aspect_ratio(
+        aspect_ratio, target_ratios, orig_width, orig_height, image_size)
+
+    # calculate the target width and height
+    target_width = image_size * target_aspect_ratio[0]
+    target_height = image_size * target_aspect_ratio[1]
+    blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
+
+    # resize the image
+    resized_img = image.resize((target_width, target_height))
+    processed_images = []
+    for i in range(blocks):
+        box = (
+            (i % (target_width // image_size)) * image_size,
+            (i // (target_width // image_size)) * image_size,
+            ((i % (target_width // image_size)) + 1) * image_size,
+            ((i // (target_width // image_size)) + 1) * image_size
+        )
+        # split the image
+        split_img = resized_img.crop(box)
+        processed_images.append(split_img)
+    assert len(processed_images) == blocks
+    if use_thumbnail and len(processed_images) != 1:
+        thumbnail_img = image.resize((image_size, image_size))
+        processed_images.append(thumbnail_img)
+    return processed_images
+
+
+def load_image(image_file, input_size=448, max_num=6, upscale=False):
+    image = Image.open(image_file).convert('RGB')
+    if upscale:
+        image = image.resize((image.width * 2, image.height * 2), Image.BILINEAR)
+    transform = build_transform(input_size=input_size)
+    images = dynamic_preprocess(image, image_size=input_size, use_thumbnail=True, max_num=max_num)
+    pixel_values = [transform(image) for image in images]
+    pixel_values = torch.stack(pixel_values)
+    return pixel_values
+
+
+def get_local_rank_and_local_world_size():
+    if not dist.is_available():
+        return 0, 1
+    if not dist.is_initialized():
+        return 0, 1
+
+    if 'SLURM_LOCALID' in os.environ:
+        local_rank = int(os.environ['SLURM_LOCALID'])
+        local_world_size = int(os.environ['SLURM_NTASKS_PER_NODE'])
+        return local_rank, local_world_size
+
+    if 'LOCAL_RANK' in os.environ and 'LOCAL_WORLD_SIZE' in os.environ:
+        return int(os.environ['LOCAL_RANK']), int(os.environ['LOCAL_WORLD_SIZE'])
+
+    raise NotImplementedError(
+        "Fail to get local_rank and local_world_size! "
+        "Please ensure that you set the environment variable "
+        "`LOCAL_RANK` and `LOCAL_WORLD_SIZE`"
+    )
+
+
+def build_mcq_cot_prompt(line, prompt, cot_prompt=None):
+    if cot_prompt is None:
+        cot_prompt = (
+            "Answer the preceding multiple choice question. The last line of your response should follow "
+            "this format: 'Answer: \\boxed{$LETTER}' (without quotes), where LETTER is one of the options. "
+            "If you are uncertain or the problem is too complex, make a reasoned guess based on the "
+            "information provided. Avoid repeating steps indefinitely—provide your best guess even if "
+            "unsure. Think step by step logically, considering all relevant information before answering."
+        )
+    prompt = prompt.replace("Answer with the option's letter from the given choices directly.", '').strip()
+    prompt = prompt + '\n' + cot_prompt
+
+    return prompt
+
+
+def build_qa_cot_prompt(line, prompt, cot_prompt=None):
+    if cot_prompt is None:
+        cot_prompt = (
+            "Answer the preceding question. The last line of your response should follow this format: "
+            "'Answer: \\boxed{$FINAL_ANSWER}' (without quotes), where 'FINAL_ANSWER' is your conclusion "
+            "based on the reasoning provided. If you are uncertain or the problem is too complex, make "
+            "a reasoned guess based on the information provided. Avoid repeating steps indefinitely—"
+            "provide your best guess even if unsure. Think step by step logically, considering all "
+            "relevant information before answering."
+        )
+    prompt = prompt + '\n' + cot_prompt
+
+    return prompt
+
+
+def build_multi_choice_prompt(line, dataset=None):
+    question = line['question']
+    hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+    if hint is not None:
+        question = hint + '\n' + question
+
+    options = {
+        cand: line[cand]
+        for cand in string.ascii_uppercase
+        if cand in line and not pd.isna(line[cand])
+    }
+    for key, item in options.items():
+        question += f'\n{key}. {item}'
+    prompt = question
+
+    if len(options):
+        prompt += '\n请直接回答选项字母。' if cn_string(
+            prompt) else "\nAnswer with the option's letter from the given choices directly."
+    else:
+        prompt += '\n请直接回答问题。' if cn_string(prompt) else '\nAnswer the question directly.'
+
+    return prompt
+
+
+def build_video_prompt(prompt, dataset=None, max_frames=64):
+    for start in range(0, max_frames, 8):
+        images_to_remove = ''.join([f'<Image-{i}>' for i in range(start + 1, start + 9)])
+        prompt = prompt.replace(images_to_remove, '')
+    for i in range(max_frames):
+        prompt = prompt.replace(f'Image-{i + 1}', f'Frame-{i + 1}')
+    if listinstr(['MMBench-Video'], dataset):
+        prompt = prompt.replace('\nAnswer:', '')
+    elif listinstr(['Video-MME', 'WorldSense'], dataset):
+        prompt = prompt.replace('\nAnswer:', '')
+        prompt += "\nAnswer with the option's letter from the given choices directly."
+    elif listinstr(['MVBench'], dataset):
+        prompt = prompt.replace('Best option:(', '')
+
+    return prompt
+
+
+def reorganize_prompt(message, image_num, dataset=None):
+    if dataset is not None and listinstr(['MUIRBench'], dataset):
+        prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+        images_to_remove = ' '.join(['<image>'] * image_num)
+        prompt = prompt.replace(images_to_remove, '')
+        for i in range(image_num):
+            prompt = prompt.replace('<image>', f'<Image-{i + 1}>', 1)
+        prompt = ''.join([f'Image-{i + 1}: <image>\n' for i in range(image_num)]) + prompt
+    elif dataset is not None and listinstr(["bmmr"], dataset.lower()):
+        if image_num == 1:
+            prompt = "\n".join([x["value"] for x in message if x["type"] == "text"])
+        else:
+            prompt, image_idx = "", 1
+            for x in message:
+                if x["type"] == "text":
+                    prompt += x["value"]
+                elif x["type"] == "image":
+                    image_idx += 1
+    elif image_num == 1:
+        prompt = '<image>\n' + '\n'.join([x['value'] for x in message if x['type'] == 'text'])
+    else:
+        prompt, image_idx = '', 1
+        for x in message:
+            if x['type'] == 'text':
+                prompt += x['value']
+            elif x['type'] == 'image':
+                prompt += f'<Image-{image_idx}>'
+                image_idx += 1
+        prompt = ''.join([f'Image-{i + 1}: <image>\n' for i in range(image_num)]) + prompt
+        images_to_remove = ''.join([f'<Image-{i + 1}>' for i in range(image_num)])
+        prompt = prompt.replace(images_to_remove, '')
+    return prompt
+
+
+mpo_prompt_with_final_answer = (
+    "Your task is to answer the question below. "
+    "Give step by step reasoning before you answer, and when you're ready to answer, "
+    "please use the format \"Final answer: ..\""
+    "\n\n"
+    "Question:"
+    "\n\n"
+    "{question}"
+)
+
+mpo_prompt_without_final_answer = (
+    "Your task is to answer the question below. "
+    "Give step by step reasoning. "
+    "\n\n"
+    "Question:"
+    "\n\n"
+    "{question}"
+)
+
+
+def mpo_post_processing(response, dataset):
+
+    def extract_answer(text):
+        match = re.search(r'(Final answer:|Answer:)\s*(.*)', text, re.IGNORECASE)
+        if match:
+            return match.group(2).strip()
+        return text
+
+    if dataset is not None and (DATASET_TYPE(dataset) in ['Y/N', 'MCQ'] or listinstr(['CRPE'], dataset)):
+        response = extract_answer(response).strip()
+    return response
+
+
+def parse_bbox_internvl(response):
+    # 使���正则表达式匹配bounding box
+    # pattern = r"<box>\[\[(\d+), (\d+), (\d+), (\d+)\]\]</box>"
+    pattern = r"\[\[(\d+), (\d+), (\d+), (\d+)\]\]"
+    match = re.search(pattern, response)
+    if match:
+        # 提取匹配到的坐标值并转换为整数
+        x1, y1, x2, y2 = map(int, match.groups())
+        return [(x1 + x2) / 2, (y1 + y2) / 2]
+    else:
+        return response
+
+
+def build_mpo_prompt(message, line, dataset):
+    if listinstr(['LLaVABench', 'MMVet'], dataset):
+        return message
+
+    question_orig = line['question']
+    if listinstr(['MathVerse', 'MathVision'], dataset):
+        question_orig = question_orig.split('Question:', 1)[-1].strip()
+        question_orig = question_orig.replace('Choices:\n', '').strip()
+    if listinstr(['WeMath'], dataset):
+        question_orig = question_orig.replace('Regarding the format, please answer following the template below, and be sure to include two <> symbols:\n<Thought process>: <<your thought process>> <Answer>: <<your option>>', '').strip()  # noqa: E501
+    options = {
+        cand: line[cand]
+        for cand in string.ascii_uppercase
+        if cand in line and not pd.isna(line[cand])
+    }
+    options_prompt = ''
+    for key, item in options.items():
+        options_prompt += f'{key}. {item}\n'
+
+    if options_prompt.strip():
+        question_orig = f'{question_orig}\n{options_prompt}'
+
+    cot_prompt = mpo_prompt_with_final_answer
+    prompt = cot_prompt.format(question=question_orig).strip()
+    message[0]['value'] = prompt
+    return message
+
+
+def format_nav_prompt(template, placeholders, **kwargs):
+    prompt = template
+    for placeholder in placeholders:
+        value = kwargs.get(placeholder, '')
+        prompt = prompt.replace(f"{{{placeholder}}}", str(value))
+    return prompt
+
+
+def pile_action_history(history, max_num=4):
+    if len(history) > 0:
+        return '\n'.join(history[-max_num:])
+    else:
+        return 'None'

VLMEvalKit-sudoku/vlmeval/vlm/minicpm_v.py

@@ -0,0 +1,1271 @@
+import math
+import torch
+import random
+import numpy as np
+from PIL import Image
+from transformers import AutoModel, AutoTokenizer
+
+from .base import BaseModel
+from ..smp import *
+from ..dataset import DATASET_TYPE, DATASET_MODALITY
+
+import re
+
+
+class MiniCPM_V(BaseModel):
+
+    INSTALL_REQ = False
+    INTERLEAVE = False
+
+    def __init__(self, model_path='openbmb/MiniCPM-V', **kwargs):
+        assert model_path is not None
+        self.model_path = model_path
+        print(f'load from {self.model_path}')
+        self.model = AutoModel.from_pretrained(self.model_path, trust_remote_code=True)
+        self.model = self.model.to(dtype=torch.bfloat16)
+        self.model.eval().cuda()
+        self.kwargs = kwargs
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+        torch.cuda.empty_cache()
+        self.num_beams = 3
+
+    def use_custom_prompt(self, dataset):
+        assert dataset is not None
+        if listinstr(['MMDU', 'MME-RealWorld', 'MME-RealWorld-CN', 'MMAlignBench'], dataset):
+            # For Multi-Turn we don't have custom prompt
+            return False
+        return False
+
+    def build_prompt(self, line, dataset=None):
+        assert dataset is None or isinstance(dataset, str)
+        assert self.use_custom_prompt(dataset)
+        tgt_path = self.dump_image(line, dataset)
+
+        question = line['question']
+        options = {
+            cand: line[cand]
+            for cand in string.ascii_uppercase
+            if cand in line and not pd.isna(line[cand])
+        }
+        options_prompt = 'Options:\n'
+        for key, item in options.items():
+            options_prompt += f'{key}. {item}\n'
+        hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+        prompt = ''
+        if hint is not None:
+            prompt += f'Hint: {hint}\n'
+        prompt += f'{question}\n'
+        if len(options):
+            prompt += options_prompt
+            prompt = 'Study the image carefully and pick the option associated with the correct answer. \
+                Focus solely on selecting the option and avoid including any other content.\n' + prompt
+        message = [dict(type='text', value=prompt)]
+        message.extend([dict(type='image', value=p) for p in tgt_path])
+
+        return message
+
+    def generate_inner(self, message, dataset=None):
+        prompt, image_path = self.message_to_promptimg(message, dataset=dataset)
+        image = Image.open(image_path).convert('RGB')
+        msgs = [{'role': 'user', 'content': prompt}]
+        if DATASET_TYPE(dataset) == 'MCQ':
+            max_new_tokens = 20
+        elif DATASET_TYPE(dataset) == 'Y/N':
+            max_new_tokens = 100
+        else:
+            max_new_tokens = 1024
+
+        default_kwargs = dict(
+            max_new_tokens=max_new_tokens,
+            sampling=False,
+            num_beams=self.num_beams
+        )
+        default_kwargs.update(self.kwargs)
+        res, _, _ = self.model.chat(
+            image=image,
+            msgs=msgs,
+            context=None,
+            tokenizer=self.tokenizer,
+            **default_kwargs
+        )
+        return res
+
+
+class MiniCPM_Llama3_V(BaseModel):
+
+    INSTALL_REQ = False
+    INTERLEAVE = True
+
+    def __init__(self, model_path='openbmb/MiniCPM-Llama3-V-2_5', **kwargs):
+        assert model_path is not None
+        self.model_path = model_path
+        print(f'load from {self.model_path}')
+        self.model = AutoModel.from_pretrained(self.model_path, trust_remote_code=True)
+        self.model = self.model.to(dtype=torch.float16)
+        self.model.eval().cuda()
+        self.kwargs = kwargs
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+        torch.cuda.empty_cache()
+        self.num_beams = 3
+        self.options_system_prompt = ('Carefully read the following question and select the letter corresponding '
+                                      'to the correct answer. Highlight the applicable choices without giving '
+                                      'explanations.')
+        self.wo_options_system_prompt = 'Carefully read the following question Answer the question directly.'
+        self.detail_system_prompt = 'Answer this question in detail.'
+        self.vqa_prompt = 'Answer the question using a single word or phrase.'
+
+    def use_custom_prompt(self, dataset):
+        if listinstr(['MCQ', 'VQA'], DATASET_TYPE(dataset)):
+            return True
+        elif dataset is not None and listinstr(['HallusionBench'], dataset):
+            return True
+        return False
+
+    def build_prompt(self, line, dataset=None):
+        if isinstance(line, int):
+            line = self.data.iloc[line]
+
+        tgt_path = self.dump_image(line, dataset)
+        system_prompt = ''
+
+        question = line['question']
+        if DATASET_TYPE(dataset) == 'MCQ':
+            options = {
+                cand: line[cand]
+                for cand in string.ascii_uppercase
+                if cand in line and not pd.isna(line[cand])
+            }
+            options_prompt = 'Options:\n'
+            for key, item in options.items():
+                options_prompt += f'{key}. {item}\n'
+            hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+            prompt = ''
+            if hint is not None:
+                prompt += f'Hint: {hint}\n'
+            prompt += f'Question: {question}\n'
+            if len(options):
+                prompt += options_prompt
+                system_prompt = self.options_system_prompt + '\nPlease just indicate your choice.'
+            else:
+                system_prompt = self.wo_options_system_prompt
+            if 'MMMU' in dataset:  # Corner Case
+                prompt = system_prompt + '\n' + prompt
+                system_prompt = ''
+        elif dataset is not None and listinstr(['HallusionBench'], dataset):
+            question = line['question'] + ' Yes or No?'
+            prompt = question
+        elif dataset is not None and listinstr(['MME'], dataset):
+            question = line['question'] + ' Yes or No?'
+            prompt = question
+        elif dataset is not None and listinstr(['OCRBench'], dataset):
+            system_prompt = self.vqa_prompt
+            question = line['question']
+            prompt = question
+        elif DATASET_TYPE(dataset) == 'VQA':
+            if listinstr(['LLaVABench', 'MMLongBench_DOC'], dataset):
+                system_prompt = ''
+                prompt = question
+            elif listinstr(['MMVet'], dataset):
+                system_prompt = self.detail_system_prompt
+                prompt = question
+            else:
+                system_prompt = self.vqa_prompt
+                prompt = question
+
+        msgs = []
+        if system_prompt:
+            msgs.append(dict(type='text', value=system_prompt))
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=prompt))
+        return msgs
+
+    def generate_inner(self, message, dataset=None):
+        if DATASET_TYPE(dataset) == 'MCQ':
+            max_new_tokens = 200
+        elif DATASET_TYPE(dataset) == 'Y/N':
+            max_new_tokens = 3
+        else:
+            max_new_tokens = 1024
+
+        default_kwargs = dict(
+            max_new_tokens=max_new_tokens,
+            sampling=False,
+            num_beams=self.num_beams,
+        )
+        default_kwargs.update(self.kwargs)
+
+        content = []
+        for x in message:
+            if x['type'] == 'text':
+                content.append(x['value'])
+            elif x['type'] == 'image':
+                image = Image.open(x['value']).convert('RGB')
+                content.append(image)
+        msgs = [{'role': 'user', 'content': content}]
+
+        res = self.model.chat(
+            msgs=msgs,
+            context=None,
+            image=None,
+            tokenizer=self.tokenizer,
+            **default_kwargs
+        )
+
+        if isinstance(res, tuple) and len(res) > 0:
+            res = res[0]
+        return res
+
+    def chat_inner(self, message, dataset=None):
+        max_new_tokens = 1024
+
+        default_kwargs = dict(
+            max_new_tokens=max_new_tokens,
+            sampling=False,
+            num_beams=self.num_beams,
+        )
+        default_kwargs.update(self.kwargs)
+
+        msgs = []
+        for msg in message:
+            content = []
+            if len(msg['content']) == 1 and msg['content'][0]['type'] == 'text':
+                msg_new = {'role': msg['role'], 'content': msg['content'][0]['value']}
+                msgs.append(msg_new)
+                continue
+
+            for x in msg['content']:
+                if x['type'] == 'text':
+                    content.append(x['value'])
+                elif x['type'] == 'image':
+                    image = Image.open(x['value']).convert('RGB')
+                    content.append(image)
+            msg_new = {'role': msg['role'], 'content': content}
+            msgs.append(msg_new)
+
+        res = self.model.chat(
+            msgs=msgs,
+            context=None,
+            image=None,
+            tokenizer=self.tokenizer,
+            **default_kwargs)
+
+        if isinstance(res, tuple) and len(res) > 0:
+            res = res[0]
+        return res
+
+
+class MiniCPM_V_2_6(BaseModel):
+    INSTALL_REQ = False
+    INTERLEAVE = True
+
+    def __init__(self, model_path='openbmb/MiniCPM-V-2_6', **kwargs):
+        random.seed(0)
+        np.random.seed(0)
+        torch.manual_seed(0)
+        torch.cuda.manual_seed_all(0)
+        self.use_lmdeploy = kwargs.get('use_lmdeploy', False)
+        assert model_path is not None
+        self.model_path = model_path
+        print(f'load from path {self.model_path}')
+        if self.use_lmdeploy:
+            logging.warning(
+                'Currently LMDeploy does not support interleaved text-image prompt. '
+                'All images will be placed at the beginning of the prompt, '
+                'which may lead to performance degradation.'
+            )
+            from lmdeploy import TurbomindEngineConfig, pipeline, ChatTemplateConfig
+            num_gpus = torch.cuda.device_count()
+            self.model = pipeline(
+                model_path,
+                backend_config=TurbomindEngineConfig(session_len=32768, cache_max_entry_count=0.1, tp=num_gpus)
+            )
+            torch.cuda.set_device(0)
+            self.device = 'cuda'
+        else:
+            self.model = AutoModel.from_pretrained(self.model_path, trust_remote_code=True)
+            self.model = self.model.to(dtype=torch.bfloat16)
+            self.model.eval().cuda()
+
+            self.kwargs = kwargs
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+            torch.cuda.empty_cache()
+
+        self.num_beams = 3
+
+        self.options_suffix_prompt = '''\nAnswer with the option's letter from the given choices directly.'''
+        self.wo_options_system_prompt = 'Carefully read the following question Answer the question directly.'
+        self.detail_system_prompt = 'Answer this question in detail.'
+        self.vqa_prompt = 'Answer the question using a single word or phrase.'
+
+        self.multi_choice_cot_prompt = ('''Carefully read the following multichoice question, solve it step '''
+                                        '''by step and finally pick the option associated with the correct '''
+                                        '''answer in the format of "Answer: selected option\n\n''')
+        self.short_ans_cot_prompt = ('''Read the following question carefully, solve it step by step, and '''
+                                     '''then output the final answer in the format of "Answer: single number '''
+                                     '''or single word or phrase".\n\n''')
+
+    def use_custom_prompt(self, dataset=None):
+        if dataset is None:
+            return False
+        if DATASET_TYPE(dataset) in ['MCQ', 'VQA', 'Y/N']:
+            return True
+        return False
+
+    def use_cot(self, dataset=None):
+        if dataset is None:
+            return False
+        if listinstr(['MMMU', 'HallusionBench', 'OCRBench', 'ChartQA'], dataset):
+            return True
+        elif listinstr(['MathVista', 'MMVet', 'MMBench', 'MMStar', 'AI2D', 'RealWorldQA',
+                        'POPE', 'ScienceQA', 'TextVQA', 'DocVQA'], dataset):
+            return False
+        else:
+            return False
+
+    def use_upsize(self, dataset=None):
+        if dataset is None:
+            return False
+        if listinstr(['MMVet', 'MMBench', 'MMStar', 'AI2D', 'OCRBench'], dataset):
+            return True
+        else:
+            return False
+
+    def build_prompt(self, line, dataset=None):
+        if isinstance(line, int):
+            line = self.data.iloc[line]
+
+        tgt_path = self.dump_image(line, dataset)
+        system_prompt, prompt = '', ''
+
+        question = line['question']
+
+        if not self.use_cot(dataset):
+            if DATASET_TYPE(dataset) == 'MCQ':
+                options = {
+                    cand: line[cand]
+                    for cand in string.ascii_uppercase
+                    if cand in line and not pd.isna(line[cand])
+                }
+                options_prompt = 'Options:\n'
+                for key, item in options.items():
+                    options_prompt += f'{key}. {item}\n'
+                hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+                if hint is not None:
+                    prompt += f'Hint: {hint}\n'
+                prompt += f'Question: {question}\n'
+                if len(options):
+                    prompt += options_prompt
+                    prompt += self.options_suffix_prompt
+                else:
+                    system_prompt = self.wo_options_system_prompt
+
+                if 'MMMU' in dataset:
+                    if len(system_prompt) > 0:
+                        prompt = system_prompt + '\n' + prompt
+                        system_prompt = ''
+            elif dataset is not None and listinstr(['HallusionBench'], dataset):
+                question += ' Yes or No?'
+                prompt = question
+            elif dataset is not None and listinstr(['OCRBench'], dataset):
+                system_prompt = self.vqa_prompt
+                prompt = question
+            elif DATASET_TYPE(dataset) == 'VQA':
+                if listinstr(['LLaVABench'], dataset):
+                    system_prompt = ''
+                elif listinstr(['MMVet'], dataset):
+                    system_prompt = self.detail_system_prompt
+                else:
+                    system_prompt = self.vqa_prompt
+                prompt = question
+            else:
+                prompt = question
+        else:
+            has_options = True
+            if DATASET_TYPE(dataset) == 'MCQ':
+                options = {
+                    cand: line[cand]
+                    for cand in string.ascii_uppercase
+                    if cand in line and not pd.isna(line[cand])
+                }
+                options_prompt = ''
+                for key, item in options.items():
+                    options_prompt += f'{key}. {item}\n'
+                hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+                if hint is not None:
+                    prompt += f'Hint: {hint}\n'
+                prompt += f'{question}\n'
+
+                if len(options):
+                    prompt += options_prompt
+                else:
+                    has_options = False
+
+                if 'MMMU' in dataset:
+                    if len(system_prompt) > 0:
+                        prompt = system_prompt + '\n' + prompt
+                        system_prompt = ''
+            else:
+                prompt = question
+
+            if DATASET_TYPE(dataset) in ['MCQ', 'Y/N', 'VQA']:
+                if DATASET_TYPE(dataset) == 'MCQ':
+                    if has_options:
+                        prompt = self.multi_choice_cot_prompt + prompt
+                    else:
+                        prompt = self.short_ans_cot_prompt + prompt
+                elif DATASET_TYPE(dataset) == 'Y/N':
+                    prompt = self.short_ans_cot_prompt + prompt
+                else:
+                    prompt = self.short_ans_cot_prompt + prompt
+
+        msgs = []
+        if system_prompt:
+            msgs.append(dict(type='text', value=system_prompt))
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=prompt))
+
+        return msgs
+
+    def message_to_lmdeploy(self, messages, system_prompt=None):
+        """
+        TODO:
+        Support interleaved text-image prompt
+        after LMDeploy supports it.
+        """
+        from PIL import Image
+        prompt, image_path = '', []
+        for msg in messages:
+            if msg['type'] == 'text':
+                prompt += msg['value']
+            elif msg['type'] == 'image':
+                image_path.append(msg['value'])
+        content = [{'type': 'text', 'text': prompt}]
+        for image in image_path:
+            img = Image.open(image).convert('RGB')
+            b64 = encode_image_to_base64(img)
+            img_struct = dict(url=f'data:image/jpeg;base64,{b64}')
+            content.append(dict(type='image_url', image_url=img_struct))
+        ret = []
+        if system_prompt is not None:
+            ret.append(dict(role='system', content=system_prompt))
+        ret.append(dict(role='user', content=content))
+        return [ret]
+
+    def generate_inner_transformers(self, message, dataset=None):
+        if dataset is not None and DATASET_MODALITY(dataset) == 'VIDEO':
+            max_slice_nums = 1
+            use_image_id = False
+            max_inp_length = 2048 * 10
+        else:
+            max_slice_nums = None
+            use_image_id = True
+            max_inp_length = 8192
+
+        max_new_tokens = 2048
+        default_kwargs = dict(
+            max_new_tokens=max_new_tokens,
+            sampling=False,
+            num_beams=self.num_beams,
+        )
+        default_kwargs.update(self.kwargs)
+
+        content = []
+
+        for x in message:
+            if x['type'] == 'text':
+                content.append(x['value'])
+            elif x['type'] == 'image':
+                image = Image.open(x['value']).convert('RGB')
+                if not self.use_upsize(dataset):
+                    content.append(image)
+                else:
+                    img_width, img_height = image.width, image.height
+                    if (img_width * img_height) >= (1344 * 1344):
+                        content.append(image)
+                    else:
+                        ratio = math.sqrt((1344 * 1344) / (img_width * img_height))
+                        max_img_width = int(img_width * ratio)
+                        new_img_width = random.randint(img_width, max_img_width)
+                        new_img_height = int(new_img_width / img_width * img_height)
+                        resized_image = image.resize((new_img_width, new_img_height))
+                        content.append(resized_image)
+        msgs = [{'role': 'user', 'content': content}]
+
+        res = self.model.chat(
+            image=None,
+            msgs=msgs,
+            context=None,
+            tokenizer=self.tokenizer,
+            max_inp_length=max_inp_length,
+            use_image_id=use_image_id,
+            max_slice_nums=max_slice_nums,
+            **default_kwargs
+        )
+
+        if isinstance(res, tuple) and len(res) > 0:
+            res = res[0]
+
+        return res
+
+    def generate_inner_lmdeploy(self, message, dataset=None):
+        from lmdeploy import GenerationConfig
+        gen_config = GenerationConfig(
+            max_new_tokens=2048,
+            top_p=0.001,
+            top_k=1,
+            temperature=0.01,
+            repetition_penalty=1.0,
+        )
+        gen_config.random_seed = None
+        messages_list = self.message_to_lmdeploy(message, system_prompt=None)
+        assert len(messages_list) == 1
+        response = self.model(messages_list, gen_config=gen_config)[0]
+        response = response.text
+        return response
+
+    def generate_inner(self, message, dataset=None):
+        if self.use_lmdeploy:
+            return self.generate_inner_lmdeploy(message, dataset)
+        else:
+            return self.generate_inner_transformers(message, dataset)
+
+
+class MiniCPM_o_2_6(BaseModel):
+    INSTALL_REQ = False
+    INTERLEAVE = True
+
+    def __init__(self, model_path='openbmb/MiniCPM-o-2_6', **kwargs):
+        random.seed(0)
+        np.random.seed(0)
+        torch.manual_seed(0)
+        torch.cuda.manual_seed_all(0)
+
+        assert model_path is not None
+        self.model_path = model_path
+        print(f'load from path {self.model_path}')
+        self.model = AutoModel.from_pretrained(
+            self.model_path,
+            trust_remote_code=True,
+            attn_implementation='sdpa',
+            torch_dtype=torch.bfloat16,
+            init_vision=True,
+            init_audio=False,
+            init_tts=False
+        )
+
+        self.model.eval().cuda()
+
+        self.kwargs = kwargs
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+        torch.cuda.empty_cache()
+
+        self.num_beams = int(os.getenv("NUM_BEAMS", "3"))
+
+        repetition_penalty = float(os.getenv("PENALTY", "1.2"))
+        self.repetition_penalty = repetition_penalty
+
+        self.options_suffix_prompt = '''\nAnswer with the option's letter from the given choices directly.'''
+        self.wo_options_system_prompt = 'Carefully read the following question Answer the question directly.'
+        self.detail_system_prompt = 'Answer this question in detail.'
+        self.vqa_prompt = 'Answer the question using a single word or phrase.'
+
+        self.multi_choice_cot_prompt = ('''Carefully read the following multichoice question, solve it step '''
+                                        '''by step and finally pick the option associated with the correct '''
+                                        '''answer in the format of "Answer: selected option\n\n''')
+        self.short_ans_cot_prompt = ('''Read the following question carefully, solve it step by step, and '''
+                                     '''then output the final answer in the format of "Answer: single number '''
+                                     '''or single word or phrase".\n\n''')
+
+    def use_custom_prompt(self, dataset=None):
+        if dataset is None:
+            return False
+        if listinstr(['MCQ', 'VQA', 'Y/N'], DATASET_TYPE(dataset)) and not listinstr(['Video'], DATASET_TYPE(dataset)):
+            return True
+        return False
+
+    def use_cot(self, dataset=None):
+        if dataset is None:
+            return False
+        if listinstr(['MMMU', 'MathVista', 'OCRBench', 'ChartQA', 'MathVision', 'MathVerse_MINI_Vision_Only'], dataset):
+            return True
+        elif listinstr(['MMVet', 'MMBench', 'MMStar', 'HallusionBench', 'AI2D', 'RealWorldQA',
+                        'POPE', 'ScienceQA', 'TextVQA', 'DocVQA'], dataset):
+            return False
+        else:
+            return False
+
+    def use_upsize(self, dataset=None):
+        if dataset is None:
+            return False
+        if listinstr(['MathVista', 'MMBench_TEST_CN', 'MMStar', 'AI2D', 'OCRBench', 'DynaMath'], dataset):
+            return True
+        else:
+            return False
+
+    def build_prompt(self, line, dataset=None):
+        if isinstance(line, int):
+            line = self.data.iloc[line]
+
+        tgt_path = self.dump_image(line, dataset)
+        system_prompt, prompt = '', ''
+
+        question = line['question']
+
+        if not self.use_cot(dataset):
+            if DATASET_TYPE(dataset) == 'MCQ':
+                options = {
+                    cand: line[cand]
+                    for cand in string.ascii_uppercase
+                    if cand in line and not pd.isna(line[cand])
+                }
+                options_prompt = 'Options:\n'
+                for key, item in options.items():
+                    options_prompt += f'{key}. {item}\n'
+                hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+                if hint is not None:
+                    prompt += f'Hint: {hint}\n'
+                prompt += f'Question: {question}\n'
+                if len(options):
+                    prompt += options_prompt
+                    prompt += self.options_suffix_prompt
+                else:
+                    system_prompt = self.wo_options_system_prompt
+
+                if 'MMMU' in dataset:
+                    if len(system_prompt) > 0:
+                        prompt = system_prompt + '\n' + prompt
+                        system_prompt = ''
+            elif dataset is not None and listinstr(['HallusionBench'], dataset):
+                question += ' Yes or No?'
+                prompt = question
+            elif dataset is not None and listinstr(['OCRBench'], dataset):
+                system_prompt = self.vqa_prompt
+                prompt = question
+            elif DATASET_TYPE(dataset) == 'VQA':
+                if listinstr(['LLaVABench'], dataset):
+                    system_prompt = ''
+                elif listinstr(['MMVet'], dataset):
+                    system_prompt = self.detail_system_prompt
+                else:
+                    system_prompt = self.vqa_prompt
+                prompt = question
+            else:
+                prompt = question
+        else:
+            has_options = True
+            if DATASET_TYPE(dataset) == 'MCQ':
+                options = {
+                    cand: line[cand]
+                    for cand in string.ascii_uppercase
+                    if cand in line and not pd.isna(line[cand])
+                }
+                options_prompt = ''
+                for key, item in options.items():
+                    options_prompt += f'{key}. {item}\n'
+                hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+                if hint is not None:
+                    prompt += f'Hint: {hint}\n'
+                prompt += f'{question}\n'
+
+                if len(options):
+                    prompt += options_prompt
+                else:
+                    has_options = False
+
+                if 'MMMU' in dataset:
+                    if len(system_prompt) > 0:
+                        prompt = system_prompt + '\n' + prompt
+                        system_prompt = ''
+            else:
+                prompt = question
+
+            if DATASET_TYPE(dataset) in ['MCQ', 'Y/N', 'VQA']:
+                if DATASET_TYPE(dataset) == 'MCQ':
+                    if has_options:
+                        prompt = self.multi_choice_cot_prompt + prompt
+                    else:
+                        prompt = self.short_ans_cot_prompt + prompt
+                elif DATASET_TYPE(dataset) == 'Y/N':
+                    prompt = self.short_ans_cot_prompt + prompt
+                else:
+                    prompt = self.short_ans_cot_prompt + prompt
+
+        msgs = []
+        if system_prompt:
+            msgs.append(dict(type='text', value=system_prompt))
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=prompt))
+
+        return msgs
+
+    def extract_answer(self, res, dataset=None):
+        if dataset is None:
+            return res
+        if self.use_cot(dataset):
+            if DATASET_TYPE(dataset) == 'MCQ':
+                pattern = r'Answer:\s*([A-Ia-i])(?![A-Za-z])'
+                matches = re.findall(pattern, res, re.DOTALL)
+                if matches:
+                    extracted_res = matches[-1].strip()
+                else:
+                    extracted_res = res
+                return extracted_res
+            elif DATASET_TYPE(dataset) == 'VQA' and not listinstr(['OCRBench'], dataset):
+                pattern = r'Answer:\s*(.*)\s*$'
+                match = re.search(pattern, res, re.DOTALL)
+                if match:
+                    extracted_res = match.group(1)
+                else:
+                    extracted_res = res
+                return extracted_res
+        return res
+
+    def generate_inner(self, message, dataset=None):
+        if dataset is not None and DATASET_MODALITY(dataset) == 'VIDEO':
+            max_slice_nums = 1
+            use_image_id = False
+            max_inp_length = 2048 * 10
+        else:
+            max_slice_nums = None
+            use_image_id = True
+            max_inp_length = 8192
+
+        max_new_tokens = 2048
+        default_kwargs = dict(
+            max_new_tokens=max_new_tokens,
+            sampling=False,
+            repetition_penalty=self.repetition_penalty,
+            num_beams=self.num_beams,
+        )
+        default_kwargs.update(self.kwargs)
+
+        content = []
+
+        if dataset is not None and DATASET_TYPE(dataset) == 'Video-MCQ':
+            message.append(dict(type='text', value=self.options_suffix_prompt))
+
+        for x in message:
+            if x['type'] == 'text':
+                content.append(x['value'])
+            elif x['type'] == 'image':
+                image = Image.open(x['value']).convert('RGB')
+                if not self.use_upsize(dataset):
+                    content.append(image)
+                else:
+                    img_width, img_height = image.width, image.height
+                    if (img_width * img_height) >= (1344 * 1344):
+                        content.append(image)
+                    else:
+                        ratio = math.sqrt((1344 * 1344) / (img_width * img_height))
+                        max_img_width = int(img_width * ratio)
+                        new_img_width = random.randint(img_width, max_img_width)
+                        new_img_height = int(new_img_width / img_width * img_height)
+                        resized_image = image.resize((new_img_width, new_img_height))
+                        content.append(resized_image)
+        msgs = [{'role': 'user', 'content': content}]
+
+        res = self.model.chat(
+            image=None,
+            msgs=msgs,
+            context=None,
+            tokenizer=self.tokenizer,
+            max_inp_length=max_inp_length,
+            use_image_id=use_image_id,
+            max_slice_nums=max_slice_nums,
+            **default_kwargs
+        )
+
+        if isinstance(res, tuple) and len(res) > 0:
+            res = res[0]
+
+        res = self.extract_answer(res, dataset)
+
+        return res
+
+
+class MiniCPM_V_4(BaseModel):
+    INSTALL_REQ = False
+    INTERLEAVE = True
+
+    def __init__(self, model_path='openbmb/MiniCPM-V-4', **kwargs):
+        random.seed(0)
+        np.random.seed(0)
+        torch.manual_seed(0)
+        torch.cuda.manual_seed_all(0)
+        assert model_path is not None
+        self.model_path = model_path
+        print(f'load from path {self.model_path}')
+        self.model = AutoModel.from_pretrained(self.model_path, trust_remote_code=True)
+        self.model = self.model.to(dtype=torch.bfloat16)
+        self.model.eval().cuda()
+        self.kwargs = kwargs
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True)
+        torch.cuda.empty_cache()
+
+        self.num_beams = 3
+        self.max_new_tokens = 2048
+        self.options_suffix_prompt = '''\nAnswer with the option's letter from the given choices directly.'''
+        self.wo_options_system_prompt = 'Carefully read the following question. Answer the question directly.'
+        self.detail_system_prompt = 'Answer this question in detail.'
+        self.vqa_prompt = 'Answer the question using a single word or phrase.'
+        self.multi_choice_cot_prompt = ('''Carefully read the following multichoice question, solve it step '''
+                                        '''by step and finally pick the option associated with the correct '''
+                                        '''answer in the format of "Answer: selected option\n\n''')
+        self.short_ans_cot_prompt = ('''Read the following question carefully, solve it step by step, and '''
+                                     '''then output the final answer in the format of "Answer: single number '''
+                                     '''or single word or phrase".\n\n''')
+        self.ocrbench_cot_prompt = 'Carefully observe the image and answer the OCR-related questions below. \n\n'
+
+    def use_custom_prompt(self, dataset=None):
+        if dataset is None:
+            return False
+        if listinstr(['MCQ', 'VQA', 'Y/N'], DATASET_TYPE(dataset)):
+            return True
+        return False
+
+    def use_cot(self, dataset=None):
+        if dataset is None:
+            return False
+        if listinstr([
+                'MMMU', 'MathVista', 'MMStar', 'HallusionBench', 'OCRBench',
+                'ChartQA', 'MathVision', 'MathVerse_MINI_Vision_Only'
+        ], dataset):
+            return True
+        elif listinstr([
+                'MMVet', 'MMBench', 'AI2D', 'RealWorldQA', 'POPE', 'ScienceQA',
+                'TextVQA', 'DocVQA'
+        ], dataset):
+            return False
+        else:
+            return False
+
+    def use_upsize(self, dataset=None):
+        if dataset is None:
+            return False
+        if listinstr([
+                'MathVista', 'MMVet', 'MMStar', 'AI2D', 'OCRBench', 'ChartQA',
+                'TextVQA'
+        ], dataset):
+            return True
+        else:
+            return False
+
+    def build_prompt(self, line, dataset=None):
+        if isinstance(line, int):
+            line = self.data.iloc[line]
+
+        tgt_path = self.dump_image(line, dataset)
+        system_prompt, prompt = '', ''
+
+        question = line['question']
+
+        if not self.use_cot(dataset):
+            if DATASET_TYPE(dataset) == 'MCQ':
+                options = {
+                    cand: line[cand]
+                    for cand in string.ascii_uppercase
+                    if cand in line and not pd.isna(line[cand])
+                }
+                options_prompt = 'Options:\n'
+                for key, item in options.items():
+                    options_prompt += f'{key}. {item}\n'
+                hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+                if hint is not None:
+                    prompt += f'Hint: {hint}\n'
+                prompt += f'Question: {question}\n'
+                if len(options):
+                    prompt += options_prompt
+                    prompt += self.options_suffix_prompt
+                else:
+                    system_prompt = self.wo_options_system_prompt
+
+                if 'MMMU' in dataset:
+                    if len(system_prompt) > 0:
+                        prompt = system_prompt + '\n' + prompt
+                        system_prompt = ''
+            elif dataset is not None and listinstr(['HallusionBench'], dataset):
+                question += ' Yes or No?'
+                prompt = question
+            elif dataset is not None and listinstr(['OCRBench'], dataset):
+                system_prompt = self.vqa_prompt
+                prompt = question
+            elif DATASET_TYPE(dataset) == 'VQA':
+                if listinstr(['LLaVABench'], dataset):
+                    system_prompt = ''
+                elif listinstr(['MMVet'], dataset):
+                    system_prompt = self.detail_system_prompt
+                else:
+                    system_prompt = self.vqa_prompt
+                prompt = question
+            else:
+                prompt = question
+        else:
+            has_options = True
+            if DATASET_TYPE(dataset) == 'MCQ':
+                options = {
+                    cand: line[cand]
+                    for cand in string.ascii_uppercase
+                    if cand in line and not pd.isna(line[cand])
+                }
+                options_prompt = ''
+                for key, item in options.items():
+                    options_prompt += f'{key}. {item}\n'
+                hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+                if hint is not None:
+                    prompt += f'Hint: {hint}\n'
+                prompt += f'{question}\n'
+
+                if len(options):
+                    prompt += options_prompt
+                else:
+                    has_options = False
+
+                if 'MMMU' in dataset:
+                    if len(system_prompt) > 0:
+                        prompt = system_prompt + '\n' + prompt
+                        system_prompt = ''
+            else:
+                prompt = question
+
+            if DATASET_TYPE(dataset) in ['MCQ', 'Y/N', 'VQA']:
+                if DATASET_TYPE(dataset) == 'MCQ':
+                    if has_options:
+                        prompt = self.multi_choice_cot_prompt + prompt
+                    else:
+                        prompt = self.short_ans_cot_prompt + prompt
+                elif DATASET_TYPE(dataset) == 'Y/N':
+                    prompt = self.short_ans_cot_prompt + prompt
+                elif listinstr(['OCRBench'], dataset):
+                    prompt = self.ocrbench_cot_prompt + prompt
+                else:
+                    prompt = self.short_ans_cot_prompt + prompt
+
+        msgs = []
+        if system_prompt:
+            msgs.append(dict(type='text', value=system_prompt))
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=prompt))
+
+        if dataset.startswith('MMMU_'):
+            from .. import MMMUDataset
+            msgs = MMMUDataset.split_MMMU(msgs)
+
+        return msgs
+
+    def extract_answer(self, res, dataset=None):
+        if dataset is None:
+            return res
+        if self.use_cot(dataset):
+            if DATASET_TYPE(dataset) == 'MCQ':
+                pattern = r'Answer:\s*([A-Ia-i])(?![A-Za-z])'
+                matches = re.findall(pattern, res, re.DOTALL)
+                if matches:
+                    extracted_res = matches[-1].strip()
+                else:
+                    extracted_res = res
+                return extracted_res
+            elif DATASET_TYPE(dataset) == 'VQA' and not listinstr(['OCRBench', 'MMVet'], dataset):
+                pattern = r'Answer:\s*(.*)\s*$'
+                match = re.search(pattern, res, re.DOTALL)
+                if match:
+                    extracted_res = match.group(1)
+                else:
+                    extracted_res = res
+                return extracted_res
+            elif DATASET_TYPE(dataset) == 'Y/N':
+                pattern = r'Answer:\s*(.*)\s*$'
+                match = re.search(pattern, res, re.DOTALL)
+                if match:
+                    extracted_res = match.group(1)
+                else:
+                    extracted_res = res
+                return extracted_res
+        return res
+
+    def generate_inner(self, message, dataset=None):
+        if self.use_cot(dataset):
+            max_new_tokens = self.max_new_tokens
+        else:
+            max_new_tokens = 1024
+        default_kwargs = dict(
+            max_new_tokens=max_new_tokens,
+            sampling=False,
+            num_beams=self.num_beams,
+        )
+        default_kwargs.update(self.kwargs)
+
+        content = []
+
+        for x in message:
+            if x['type'] == 'text':
+                content.append(x['value'])
+            elif x['type'] == 'image':
+                image = Image.open(x['value']).convert('RGB')
+                if not self.use_upsize(dataset):
+                    content.append(image)
+                else:
+                    img_width, img_height = image.width, image.height
+                    if (img_width * img_height) >= (1344 * 1344):
+                        content.append(image)
+                    else:
+                        ratio = math.sqrt((1344 * 1344) / (img_width * img_height))
+                        max_img_width = int(img_width * ratio)
+                        new_img_width = random.randint(img_width, max_img_width)
+                        new_img_height = int(new_img_width / img_width * img_height)
+                        resized_image = image.resize((new_img_width, new_img_height))
+                        content.append(resized_image)
+        msgs = [{'role': 'user', 'content': content}]
+
+        res = self.model.chat(
+            image=None,
+            msgs=msgs,
+            context=None,
+            tokenizer=self.tokenizer,
+            max_inp_length=8192,
+            **default_kwargs
+        )
+
+        if isinstance(res, tuple) and len(res) > 0:
+            res = res[0]
+        res = self.extract_answer(res, dataset)
+
+        return res
+
+
+class MiniCPM_V_4_5(MiniCPM_V_4):
+    INSTALL_REQ = False
+    INTERLEAVE = True
+
+    def __init__(self, model_path='openbmb/MiniCPM-V-4_5', **kwargs):
+        super().__init__(model_path, **kwargs)
+        from transformers import AutoProcessor
+        self.processor = AutoProcessor.from_pretrained(self.model_path, trust_remote_code=True)
+        self._original_chat_template = self.tokenizer.chat_template
+        self._long_cot_chat_template = self._original_chat_template.replace(
+            "{{- '<think>\\n' }}", "{{- '<think>\\nI' }}")
+
+    def use_long_cot(self, dataset=None):
+        if dataset is None:
+            return False
+        if listinstr([
+                'MMMU', 'MathVista', 'MMVet', 'MMBench', 'HallusionBench',
+                'MMStar', 'MathVision', 'MathVerse_MINI',
+                'MathVerse_MINI_Vision_Only', 'DynaMath', 'LogicVista'
+        ], dataset):
+            return True
+        else:
+            return False
+
+    def use_cot(self, dataset=None):
+        if dataset is None:
+            return False
+        if listinstr([
+                'MMMU', 'MathVista', 'MMBench', 'HallusionBench', 'MMStar',
+                'OCRBench', 'ChartQA', 'MathVision', 'MathVerse_MINI',
+                'MathVerse_MINI_Vision_Only', 'DynaMath', 'LogicVista'
+        ], dataset):
+            return True
+        else:
+            return False
+
+    def use_upsize(self, dataset=None):
+        if dataset is None:
+            return False
+        if self.use_long_cot(dataset):
+            return True
+        if listinstr(['AI2D', 'OCRBench', 'ChartQA', 'TextVQA'], dataset):
+            return True
+        else:
+            return False
+
+    def build_prompt(self, line, dataset=None):
+        if self.use_long_cot(dataset):
+            self.tokenizer.chat_template = self._long_cot_chat_template
+        else:
+            self.tokenizer.chat_template = self._original_chat_template
+
+        if isinstance(line, int):
+            line = self.data.iloc[line]
+
+        tgt_path = self.dump_image(line, dataset)
+        system_prompt, prompt = '', ''
+        question = line['question']
+
+        if not self.use_cot(dataset):
+            if DATASET_TYPE(dataset) == 'MCQ':
+                options = {
+                    cand: line[cand]
+                    for cand in string.ascii_uppercase
+                    if cand in line and not pd.isna(line[cand])
+                }
+                options_prompt = 'Options:\n'
+                for key, item in options.items():
+                    options_prompt += f'{key}. {item}\n'
+                hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+                if hint is not None:
+                    prompt += f'Hint: {hint}\n'
+                prompt += f'Question: {question}\n'
+                if len(options):
+                    prompt += options_prompt
+                    prompt += self.options_suffix_prompt
+                else:
+                    system_prompt = self.wo_options_system_prompt
+
+                if 'MMMU' in dataset:
+                    if len(system_prompt) > 0:
+                        prompt = system_prompt + '\n' + prompt
+                        system_prompt = ''
+            elif dataset is not None and listinstr(['HallusionBench'], dataset):
+                question += ' Yes or No?'
+                prompt = question
+            elif dataset is not None and listinstr(['OCRBench'], dataset):
+                system_prompt = self.vqa_prompt
+                prompt = question
+            elif DATASET_TYPE(dataset) == 'VQA':
+                if listinstr(['LLaVABench'], dataset):
+                    system_prompt = ''
+                elif listinstr(['MMVet'], dataset):
+                    system_prompt = self.detail_system_prompt
+                else:
+                    system_prompt = self.vqa_prompt
+                prompt = question
+            else:
+                prompt = question
+        else:
+            has_options = True
+            if DATASET_TYPE(dataset) == 'MCQ':
+                options = {
+                    cand: line[cand]
+                    for cand in string.ascii_uppercase
+                    if cand in line and not pd.isna(line[cand])
+                }
+                options_prompt = ''
+                for key, item in options.items():
+                    options_prompt += f'{key}. {item}\n'
+                hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None
+                if hint is not None:
+                    prompt += f'Hint: {hint}\n'
+                prompt += f'{question}\n'
+
+                if len(options):
+                    prompt += options_prompt
+                else:
+                    has_options = False
+
+                if 'MMMU' in dataset:
+                    if len(system_prompt) > 0:
+                        prompt = system_prompt + '\n' + prompt
+                        system_prompt = ''
+            else:
+                prompt = question
+
+            if DATASET_TYPE(dataset) in ['MCQ', 'Y/N', 'VQA']:
+                if DATASET_TYPE(dataset) == 'MCQ':
+                    if has_options:
+                        prompt = self.multi_choice_cot_prompt + prompt
+                    else:
+                        prompt = self.short_ans_cot_prompt + prompt
+                elif DATASET_TYPE(dataset) == 'Y/N':
+                    prompt = self.short_ans_cot_prompt + prompt
+                elif listinstr(['OCRBench'], dataset):
+                    prompt = self.ocrbench_cot_prompt + prompt
+                else:
+                    prompt = self.short_ans_cot_prompt + prompt
+
+        msgs = []
+        if system_prompt:
+            msgs.append(dict(type='text', value=system_prompt))
+        if isinstance(tgt_path, list):
+            msgs.extend([dict(type='image', value=p) for p in tgt_path])
+        else:
+            msgs = [dict(type='image', value=tgt_path)]
+        msgs.append(dict(type='text', value=prompt))
+
+        if dataset.startswith('MMMU_'):
+            from .. import MMMUDataset
+            msgs = MMMUDataset.split_MMMU(msgs)
+
+        return msgs
+
+    def generate_inner(self, message, dataset=None):
+        if self.use_long_cot(dataset):
+            default_kwargs = dict(
+                enable_thinking=True,
+                max_new_tokens=8192,
+                sampling=True,
+                temperature=0.7,
+                num_beams=1,
+                top_p=1.0,
+                top_k=0,
+                repetition_penalty=1.0,
+                no_repeat_ngram_size=0
+            )
+        elif self.use_cot(dataset):
+            default_kwargs = dict(
+                max_new_tokens=2048,
+                sampling=False,
+                num_beams=self.num_beams,
+                repetition_penalty=1.2
+            )
+        else:
+            default_kwargs = dict(
+                max_new_tokens=1024,
+                sampling=False,
+                num_beams=self.num_beams,
+                repetition_penalty=1.2
+            )
+
+        default_kwargs.update(self.kwargs)
+
+        content = []
+        for x in message:
+            if x['type'] == 'text':
+                content.append(x['value'])
+            elif x['type'] == 'image':
+                image = Image.open(x['value']).convert('RGB')
+                if not self.use_upsize(dataset):
+                    content.append(image)
+                else:
+                    img_width, img_height = image.width, image.height
+                    if (img_width * img_height) >= (1344 * 1344):
+                        content.append(image)
+                    else:
+                        ratio = math.sqrt((1344 * 1344) / (img_width * img_height))
+                        max_img_width = int(img_width * ratio)
+                        new_img_width = random.randint(img_width, max_img_width)
+                        new_img_height = int(new_img_width / img_width * img_height)
+                        resized_image = image.resize((new_img_width, new_img_height))
+                        content.append(resized_image)
+        msgs = [{'role': 'user', 'content': content}]
+
+        self.processor.tokenizer = self.tokenizer
+
+        res = self.model.chat(
+            image=None,
+            msgs=msgs,
+            context=None,
+            tokenizer=self.tokenizer,
+            processor=self.processor,
+            max_inp_length=8192,
+            **default_kwargs
+        )
+
+        if isinstance(res, tuple) and len(res) > 0:
+            res = res[0]
+
+        res = res.replace('<think>\n', '<think>\nI ')
+        res = self.extract_answer(res, dataset)
+
+        return res

VLMEvalKit-sudoku/vlmeval/vlm/misc/minigpt4_7b_eval.yaml

@@ -0,0 +1,38 @@
+model:
+  arch: minigpt4
+  model_type: pretrain_vicuna_7b
+  max_txt_len: 160
+  end_sym: "###"
+  low_resource: True
+  prompt_template: '###Human: {} ###Assistant: '
+  ckpt: "please set this value to the path of pretrained checkpoint"
+
+  # vit encoder
+  image_size: 224
+  drop_path_rate: 0
+  use_grad_checkpoint: False
+  vit_precision: "fp16"
+  freeze_vit: True
+  freeze_qformer: True
+
+  # Q-Former
+  num_query_token: 32
+
+  # generation configs
+  prompt: ""
+
+  llama_model: "please set this value to the path of vicuna-7b-v0"
+
+
+datasets:
+  cc_sbu_align:
+    vis_processor:
+      train:
+        name: "blip2_image_eval"
+        image_size: 224
+    text_processor:
+      train:
+        name: "blip_caption"
+
+run:
+  task: image_text_pretrain