From 8ec8203c44b420d299e01a5f74410455da34a52d Mon Sep 17 00:00:00 2001 From: KainingYing Date: Fri, 26 Apr 2024 12:28:23 +0800 Subject: [PATCH] release evaluation code and val split --- .github/workflows/lint.yml | 23 + .gitignore | 166 +++++++ .vscode/launch.json | 28 ++ Quickstart.md | 118 +++++ README.md | 41 +- assets/LOGO.svg | 24 + assets/apple.jpg | Bin 0 -> 4576 bytes requirements.txt | 31 ++ run.py | 147 ++++++ setup.py | 122 +++++ vlmeval/__init__.py | 13 + vlmeval/api/__init__.py | 14 + vlmeval/api/base.py | 176 +++++++ vlmeval/api/claude.py | 99 ++++ vlmeval/api/gemini.py | 65 +++ vlmeval/api/gpt.py | 175 +++++++ vlmeval/api/gpt_int.py | 94 ++++ vlmeval/api/hf_chat_model.py | 245 ++++++++++ vlmeval/api/qwen_api.py | 75 +++ vlmeval/api/qwen_vl_api.py | 79 +++ vlmeval/api/stepai.py | 85 ++++ vlmeval/config.py | 137 ++++++ vlmeval/evaluate/OCRBench.py | 65 +++ vlmeval/evaluate/__init__.py | 9 + vlmeval/evaluate/coco_eval.py | 74 +++ vlmeval/evaluate/llavabench.py | 113 +++++ vlmeval/evaluate/mathvista_eval.py | 234 +++++++++ vlmeval/evaluate/misc.py | 29 ++ vlmeval/evaluate/mmvet_eval.py | 185 ++++++++ vlmeval/evaluate/multiple_choice.py | 448 ++++++++++++++++++ vlmeval/evaluate/vqa_eval.py | 340 +++++++++++++ vlmeval/evaluate/yes_or_no.py | 247 ++++++++++ vlmeval/inference.py | 183 +++++++ vlmeval/smp/__init__.py | 4 + vlmeval/smp/file.py | 214 +++++++++ vlmeval/smp/log.py | 44 ++ vlmeval/smp/misc.py | 191 ++++++++ vlmeval/smp/vlm.py | 133 ++++++ vlmeval/utils/__init__.py | 12 + vlmeval/utils/custom_prompt.py | 33 ++ vlmeval/utils/dataset.py | 179 +++++++ vlmeval/utils/dataset_config.py | 137 ++++++ vlmeval/utils/matching_util.py | 69 +++ vlmeval/utils/mp_util.py | 191 ++++++++ vlmeval/vlm/__init__.py | 25 + vlmeval/vlm/base.py | 153 ++++++ vlmeval/vlm/cogvlm.py | 84 ++++ vlmeval/vlm/deepseek_vl.py | 69 +++ vlmeval/vlm/emu.py | 89 ++++ vlmeval/vlm/idefics.py | 80 ++++ vlmeval/vlm/instructblip.py | 57 +++ vlmeval/vlm/internvl_chat.py | 213 +++++++++ vlmeval/vlm/llava/__init__.py | 4 + vlmeval/vlm/llava/llava.py | 260 ++++++++++ vlmeval/vlm/llava/llava_xtuner.py | 226 +++++++++ vlmeval/vlm/minicpm_v.py | 85 ++++ vlmeval/vlm/minigpt4.py | 85 ++++ vlmeval/vlm/misc/000000028137.jpg | Bin 0 -> 184441 bytes vlmeval/vlm/misc/000000039769.jpg | Bin 0 -> 173131 bytes vlmeval/vlm/misc/Idefics.jpg | Bin 0 -> 16414 bytes .../vlm/misc/blip2_instruct_vicuna13b.yaml | 43 ++ vlmeval/vlm/misc/blip2_instruct_vicuna7b.yaml | 43 ++ vlmeval/vlm/misc/minigpt4_13b_eval.yaml | 37 ++ vlmeval/vlm/misc/minigpt4_7b_eval.yaml | 38 ++ vlmeval/vlm/misc/minigptv2_eval.yaml | 36 ++ vlmeval/vlm/mmalaya.py | 64 +++ vlmeval/vlm/monkey.py | 165 +++++++ vlmeval/vlm/mplug_owl2.py | 126 +++++ vlmeval/vlm/omnilmm.py | 152 ++++++ vlmeval/vlm/open_flamingo.py | 99 ++++ vlmeval/vlm/pandagpt.py | 61 +++ vlmeval/vlm/qwen_vl.py | 94 ++++ vlmeval/vlm/transcore_m.py | 162 +++++++ vlmeval/vlm/visualglm.py | 36 ++ vlmeval/vlm/xcomposer/__init__.py | 6 + vlmeval/vlm/xcomposer/sharecaptioner.py | 92 ++++ vlmeval/vlm/xcomposer/xcomposer.py | 150 ++++++ vlmeval/vlm/xcomposer/xcomposer2.py | 213 +++++++++ vlmeval/vlm/xcomposer/xcomposer2_4KHD.py | 235 +++++++++ vlmeval/vlm/yi_vl.py | 156 ++++++ 80 files changed, 8524 insertions(+), 5 deletions(-) create mode 100644 .github/workflows/lint.yml create mode 100644 .gitignore create mode 100644 .vscode/launch.json create mode 100644 Quickstart.md create mode 100644 assets/LOGO.svg create mode 100644 assets/apple.jpg create mode 100644 requirements.txt create mode 100644 run.py create mode 100644 setup.py create mode 100644 vlmeval/__init__.py create mode 100644 vlmeval/api/__init__.py create mode 100644 vlmeval/api/base.py create mode 100644 vlmeval/api/claude.py create mode 100644 vlmeval/api/gemini.py create mode 100644 vlmeval/api/gpt.py create mode 100644 vlmeval/api/gpt_int.py create mode 100644 vlmeval/api/hf_chat_model.py create mode 100644 vlmeval/api/qwen_api.py create mode 100644 vlmeval/api/qwen_vl_api.py create mode 100644 vlmeval/api/stepai.py create mode 100644 vlmeval/config.py create mode 100644 vlmeval/evaluate/OCRBench.py create mode 100644 vlmeval/evaluate/__init__.py create mode 100644 vlmeval/evaluate/coco_eval.py create mode 100644 vlmeval/evaluate/llavabench.py create mode 100644 vlmeval/evaluate/mathvista_eval.py create mode 100644 vlmeval/evaluate/misc.py create mode 100644 vlmeval/evaluate/mmvet_eval.py create mode 100644 vlmeval/evaluate/multiple_choice.py create mode 100644 vlmeval/evaluate/vqa_eval.py create mode 100644 vlmeval/evaluate/yes_or_no.py create mode 100644 vlmeval/inference.py create mode 100644 vlmeval/smp/__init__.py create mode 100644 vlmeval/smp/file.py create mode 100644 vlmeval/smp/log.py create mode 100644 vlmeval/smp/misc.py create mode 100644 vlmeval/smp/vlm.py create mode 100644 vlmeval/utils/__init__.py create mode 100644 vlmeval/utils/custom_prompt.py create mode 100644 vlmeval/utils/dataset.py create mode 100644 vlmeval/utils/dataset_config.py create mode 100644 vlmeval/utils/matching_util.py create mode 100644 vlmeval/utils/mp_util.py create mode 100644 vlmeval/vlm/__init__.py create mode 100644 vlmeval/vlm/base.py create mode 100644 vlmeval/vlm/cogvlm.py create mode 100644 vlmeval/vlm/deepseek_vl.py create mode 100644 vlmeval/vlm/emu.py create mode 100644 vlmeval/vlm/idefics.py create mode 100644 vlmeval/vlm/instructblip.py create mode 100644 vlmeval/vlm/internvl_chat.py create mode 100644 vlmeval/vlm/llava/__init__.py create mode 100644 vlmeval/vlm/llava/llava.py create mode 100644 vlmeval/vlm/llava/llava_xtuner.py create mode 100644 vlmeval/vlm/minicpm_v.py create mode 100644 vlmeval/vlm/minigpt4.py create mode 100644 vlmeval/vlm/misc/000000028137.jpg create mode 100644 vlmeval/vlm/misc/000000039769.jpg create mode 100644 vlmeval/vlm/misc/Idefics.jpg create mode 100644 vlmeval/vlm/misc/blip2_instruct_vicuna13b.yaml create mode 100644 vlmeval/vlm/misc/blip2_instruct_vicuna7b.yaml create mode 100644 vlmeval/vlm/misc/minigpt4_13b_eval.yaml create mode 100644 vlmeval/vlm/misc/minigpt4_7b_eval.yaml create mode 100644 vlmeval/vlm/misc/minigptv2_eval.yaml create mode 100644 vlmeval/vlm/mmalaya.py create mode 100644 vlmeval/vlm/monkey.py create mode 100644 vlmeval/vlm/mplug_owl2.py create mode 100644 vlmeval/vlm/omnilmm.py create mode 100644 vlmeval/vlm/open_flamingo.py create mode 100644 vlmeval/vlm/pandagpt.py create mode 100644 vlmeval/vlm/qwen_vl.py create mode 100644 vlmeval/vlm/transcore_m.py create mode 100644 vlmeval/vlm/visualglm.py create mode 100644 vlmeval/vlm/xcomposer/__init__.py create mode 100644 vlmeval/vlm/xcomposer/sharecaptioner.py create mode 100644 vlmeval/vlm/xcomposer/xcomposer.py create mode 100644 vlmeval/vlm/xcomposer/xcomposer2.py create mode 100644 vlmeval/vlm/xcomposer/xcomposer2_4KHD.py create mode 100644 vlmeval/vlm/yi_vl.py diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..336bd9c --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,23 @@ +name: lint + +on: [push, pull_request] + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.7 + uses: actions/setup-python@v2 + with: + python-version: 3.7 + - name: Install pre-commit hook + run: | + pip install pre-commit + pre-commit install + - name: Linting + run: pre-commit run --all-files diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a20eec9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,166 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# Images +images/ + +scripts/*ttf + +lvlm_zoo/ +LMUData/ +work_dirs + +batchscript-* +phoenix-slurm-* +LMUData diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..42b6815 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,28 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": "Python Debugger: Current File", + "type": "debugpy", + "request": "launch", + "program": "${file}", + "console": "integratedTerminal" + }, + { + "name": "main", + "type": "python", + "request": "launch", + "program": "run.py", + "console": "integratedTerminal", + "justMyCode": true, + "args": [ + "--data", "MMT-Bench_ALL", + "--model", "llava_v1.5_7b", + "--work-dir", "work_dirs/mmtbench" + ] + }, + ] +} \ No newline at end of file diff --git a/Quickstart.md b/Quickstart.md new file mode 100644 index 0000000..aa58acd --- /dev/null +++ b/Quickstart.md @@ -0,0 +1,118 @@ +# Quickstart + +## Prepare the Dataset + +You can download the MMT-Bench dataset in the following links: [HuggingFace](https://huggingface.co/datasets/Kaining/MMT-Bench/blob/main/MMT-Bench_VAL.tsv). **Note**: We only provide `VAL` split now. And we will support `TEST` split in the furture. + +Put the data under the `LMUData/` + +## Step 0. Installation & Setup essential keys + +**Installation.** + +```bash +pip install -e . +``` + +**Setup Keys.** + +To infer with API models (GPT-4v, Gemini-Pro-V, etc.) or use LLM APIs as the **judge or choice extractor**, you need to first setup API keys. VLMEvalKit will use an judge **LLM** to extract answer from the output if you set the key, otherwise it uses the **exact matching** mode (find "Yes", "No", "A", "B", "C"... in the output strings). **The exact matching can only be applied to the Yes-or-No tasks and the Multi-choice tasks.** +- You can place the required keys in `$VLMEvalKit/.env` or directly set them as the environment variable. If you choose to create a `.env` file, its content will look like: + + ```bash + # The .env file, place it under $VLMEvalKit + # Alles-apin-token, for intra-org use only + ALLES= + # API Keys of Proprietary VLMs + DASHSCOPE_API_KEY= + GOOGLE_API_KEY= + OPENAI_API_KEY= + OPENAI_API_BASE= + STEPAI_API_KEY= + ``` + +- Fill the blanks with your API keys (if necessary). Those API keys will be automatically loaded when doing the inference and evaluation. +## Step 1. Configuration + +**VLM Configuration**: All VLMs are configured in `vlmeval/config.py`, for some VLMs, you need to configure the code root (MiniGPT-4, PandaGPT, etc.) or the model_weight root (LLaVA-v1-7B, etc.) before conducting the evaluation. During evaluation, you should use the model name specified in `supported_VLM` in `vlmeval/config.py` to select the VLM. For MiniGPT-4 and InstructBLIP, you also need to modify the config files in `vlmeval/vlm/misc` to configure LLM path and ckpt path. + +Following VLMs require the configuration step: + +**Code Preparation & Installation**: InstructBLIP ([LAVIS](https://github.com/salesforce/LAVIS)), LLaVA ([LLaVA](https://github.com/haotian-liu/LLaVA)), MiniGPT-4 ([MiniGPT-4](https://github.com/Vision-CAIR/MiniGPT-4)), mPLUG-Owl2 ([mPLUG-Owl2](https://github.com/X-PLUG/mPLUG-Owl/tree/main/mPLUG-Owl2)), OpenFlamingo-v2 ([OpenFlamingo](https://github.com/mlfoundations/open_flamingo)), PandaGPT-13B ([PandaGPT](https://github.com/yxuansu/PandaGPT)), TransCore-M ([TransCore-M](https://github.com/PCIResearch/TransCore-M)). + +**Manual Weight Preparation & Configuration**: InstructBLIP, LLaVA-v1-7B, MiniGPT-4, PandaGPT-13B + +## Step 2. Evaluation + +We use `run.py` for evaluation. To use the script, you can use `$VLMEvalKit/run.py` or create a soft-link of the script (to use the script anywhere): + +**Arguments** + +- `--data (list[str])`: Set the dataset names that are supported in VLMEvalKit (defined in `vlmeval/utils/dataset_config.py`). +- `--model (list[str])`: Set the VLM names that are supported in VLMEvalKit (defined in `supported_VLM` in `vlmeval/config.py`). +- `--mode (str, default to 'all', choices are ['all', 'infer'])`: When `mode` set to "all", will perform both inference and evaluation; when set to "infer", will only perform the inference. +- `--nproc (int, default to 4)`: The number of threads for OpenAI API calling. + +**Command** + +You can run the script with `python` or `torchrun`: + +```bash +# When running with `python`, only one VLM instance is instantiated, and it might use multiple GPUs (depending on its default behavior). +# That is recommended for evaluating very large VLMs (like IDEFICS-80B-Instruct). + +# IDEFICS-80B-Instruct on MMT-Bench, Inference and Evalution +python run.py --data MMT-Bench_VAL --model idefics_80b_instruct --verbose +# IDEFICS-80B-Instruct on MMT-Bench, Inference only +python run.py --data MMT-Bench_VAL --model idefics_80b_instruct --verbose --mode infer + + +# IDEFICS-9B-Instruct, Qwen-VL-Chat, mPLUG-Owl2 on MMT-Bench. On a node with 8 GPU. Inference and Evaluation. +torchrun --nproc-per-node=8 run.py --data MMT-Bench_VAL --model idefics_80b_instruct qwen_chat mPLUG-Owl2 --verbose +# Qwen-VL-Chat on MMT-Bench. On a node with 2 GPU. Inference and Evaluation. +torchrun --nproc-per-node=2 run.py --data MMT-Bench_VAL --model qwen_chat --verbose +``` + +The evaluation results will be printed as logs, besides. **Result Files** will also be generated in the directory `$YOUR_WORKING_DIRECTORY/{model_name}`. Files ending with `.csv` contain the evaluated metrics. + +## Deploy a local language model as the judge / choice extractor +The default setting mentioned above uses OpenAI's GPT as the judge LLM. However, you can also deploy a local judge LLM with [LMDeploy](https://github.com/InternLM/lmdeploy). + +First install: +``` +pip install lmdeploy openai +``` + +And then deploy a local judge LLM with the single line of code. LMDeploy will automatically download the model from Huggingface. Assuming we use internlm2-chat-1_8b as the judge, port 23333, and the key sk-123456 (the key must start with "sk-" and follow with any number you like): +``` +lmdeploy serve api_server internlm/internlm2-chat-1_8b --server-port 23333 +``` + +You need to get the model name registered by LMDeploy with the following python code: +``` +from openai import OpenAI +client = OpenAI( + api_key='sk-123456', + base_url="http://0.0.0.0:23333/v1" +) +model_name = client.models.list().data[0].id +``` + +Now set some environment variables to tell VLMEvalKit how to use the local judge LLM. As mentioned above, you can also set them in `$VLMEvalKit/.env` file: +``` +OPENAI_API_KEY=sk-123456 +OPENAI_API_BASE=http://0.0.0.0:23333/v1/chat/completions +LOCAL_LLM= +``` + +Finally, you can run the commands in step 2 to evaluate your VLM with the local judge LLM. + +Note that + +- If you hope to deploy the judge LLM in a single GPU and evaluate your VLM on other GPUs because of limited GPU memory, try `CUDA_VISIBLE_DEVICES=x` like +``` +CUDA_VISIBLE_DEVICES=0 lmdeploy serve api_server internlm/internlm2-chat-1_8b --server-port 23333 +CUDA_VISIBLE_DEVICES=1,2,3 torchrun --nproc-per-node=3 run.py --data HallusionBench --model qwen_chat --verbose +``` +- If the local judge LLM is not good enough in following the instructions, the evaluation may fail. Please report such failures (e.g., by issues). +- It's possible to deploy the judge LLM in different ways, e.g., use a private LLM (not from HuggingFace) or use a quantized LLM. Please refer to the [LMDeploy doc](https://lmdeploy.readthedocs.io/en/latest/serving/api_server.html). You can use any other deployment framework if they support OpenAI API. diff --git a/README.md b/README.md index 706a1a9..3286462 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,28 @@ # MMT-Bench -This repository is the official implementation of [MMT-Bench](xxx). +

+ Quick Start | + HomePage | + arXiv | + Dataset | + Citation
-> [MMT-Bench: A Multimodal MultiTask Benchmark for Comprehensive Evaluation of Large Vision-Language Models](xxx) +

+ + +This repository is the official implementation of [MMT-Bench](https://arxiv.org/abs/2404.16006). + +> [MMT-Bench: A Multimodal MultiTask Benchmark for Comprehensive Evaluation of Large Vision-Language Models](https://arxiv.org/abs/2404.16006) > Kaining Ying\*, Fanqing Meng\*, Jin Wang\*, Zhiqian Li, Han Lin, Yue Yang, Hao Zhang, Wenbo Zhang, Yuqi Lin, Shuo Liu, jiayi lei, Quanfeng Lu, Peng Gao, Runjian Chen, Peng Xu, Renrui Zhang, Haozhe Zhang, Yali Wang, Yu Qiao, Ping Luo, Kaipeng Zhang\#, Wenqi Shao\# -> \* KY, FM and JW contribute equally. \# KZ (zhangkaipeng@pjlab.org.cn) and WS (shaowenqi@pjlab.org.cn) are correponding authors. +> \* KY, FM and JW contribute equally. +> \# WS (shaowenqi@pjlab.org.cn) and KZ (zhangkaipeng@pjlab.org.cn) are correponding authors. ![overview](assets/overview.jpg) ## 🏆 Leaderboard +### Full Set + | Rank | Model | Overall | |------|-----------------------|---------| | 1 | InternVL-Chat-v1.2 | 63.4 | @@ -45,10 +58,21 @@ This repository is the official implementation of [MMT-Bench](xxx). | 31 | Frequency Guess | 31.7 | | 32 | Random Guess | 28.5 | +### VAL Split + +Coming soon. + +### TEST Split + +Coming soon. + ## 💡 News +- `2024/04/24`: The technical report of [MMT-Bench](https://arxiv.org/abs/2404.16006) is released! And check our [project page](https://mmt-bench.github.io/)! +- `2024/04/26`: We release the evaluation code and the `VAL` split. + ## 🚀 Quick Start @@ -59,11 +83,18 @@ Please refer to [this](Quickstart.md) to quick start. ## 💐 Acknowledgement We expressed sincerely gratitude for the projects listed following: -- [VLMEvalKit](https://github.com/open-compass/VLMEvalKit) provides useful out-of-box tools and implements many adavanced LVLMs. +- [VLMEvalKit](https://github.com/open-compass/VLMEvalKit) provides useful out-of-box tools and implements many adavanced LVLMs. Thanks for their selfless dedication. ## 🖊️ Citation If you feel MMT-Bench useful in your project or research, please kindly use the following BibTeX entry to cite our paper. Thanks! ``` -xxx +@misc{mmtbench, + title={MMT-Bench: A Comprehensive Multimodal Benchmark for Evaluating Large Vision-Language Models Towards Multitask AGI}, + author={Kaining Ying and Fanqing Meng and Jin Wang and Zhiqian Li and Han Lin and Yue Yang and Hao Zhang and Wenbo Zhang and Yuqi Lin and Shuo Liu and Jiayi Lei and Quanfeng Lu and Runjian Chen and Peng Xu and Renrui Zhang and Haozhe Zhang and Peng Gao and Yali Wang and Yu Qiao and Ping Luo and Kaipeng Zhang and Wenqi Shao}, + year={2024}, + eprint={2404.16006}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} ``` \ No newline at end of file diff --git a/assets/LOGO.svg b/assets/LOGO.svg new file mode 100644 index 0000000..39b6226 --- /dev/null +++ b/assets/LOGO.svg @@ -0,0 +1,24 @@ + + + +Created with Fabric.js 5.3.0 + + + + + + + + + + + + + VLMEvalKit + \ No newline at end of file diff --git a/assets/apple.jpg b/assets/apple.jpg new file mode 100644 index 0000000000000000000000000000000000000000..34e1859aa4b053958abbfd254e8f53dc40a6cd2d GIT binary patch literal 4576 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 literal 0 HcmV?d00001 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..63e3886 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,31 @@ +einops +gradio==4.15.0 +huggingface_hub +matplotlib +numpy>=1.23.4 +omegaconf +openai==1.3.5 +opencv-python>=4.4.0.46 +openpyxl +pandas>=1.5.3 +pillow +portalocker +protobuf +pycocoevalcap +python-dotenv +requests +rich +seaborn +sentencepiece +sty +tabulate +tiktoken +timeout-decorator +torch>=2.0.1 +tqdm +transformers +typing_extensions==4.7.1 +validators +visual_genome +xlsxwriter +xtuner diff --git a/run.py b/run.py new file mode 100644 index 0000000..6385f7d --- /dev/null +++ b/run.py @@ -0,0 +1,147 @@ +import os +os.environ['LMUData'] = "LMUData/" + +import torch +import torch.distributed as dist +from vlmeval.smp import * +from vlmeval.evaluate import * +from vlmeval.inference import infer_data_job +from vlmeval.config import supported_VLM +from vlmeval.utils import dataset_URLs, DATASET_TYPE, abbr2full, MMMU_result_transfer + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument('--data', type=str, nargs='+', required=True) + parser.add_argument('--model', type=str, nargs='+', required=True) + parser.add_argument('--work-dir', type=str, default='.', help='select the output directory') + parser.add_argument('--mode', type=str, default='all', choices=['all', 'infer']) + parser.add_argument('--nproc', type=int, default=4, help='Parallel API calling') + parser.add_argument('--retry', type=int, default=None, help='retry numbers for API VLMs') + parser.add_argument('--judge', type=str, default=None) + parser.add_argument('--ignore', action='store_true', help='Ignore failed indices. ') + parser.add_argument('--verbose', action='store_true') + args = parser.parse_args() + return args + + +def main(): + logger = get_logger('RUN') + + args = parse_args() + assert len(args.data), '--data should be a list of data files' + + if args.retry is not None: + for k, v in supported_VLM.items(): + if hasattr(v, 'keywords') and 'retry' in v.keywords: + v.keywords['retry'] = args.retry + supported_VLM[k] = v + if hasattr(v, 'keywords') and 'verbose' in v.keywords: + v.keywords['verbose'] = args.verbose + supported_VLM[k] = v + + rank, world_size = get_rank_and_world_size() + if world_size > 1: + local_rank = os.environ.get('LOCAL_RANK', 0) + torch.cuda.set_device(local_rank) + dist.init_process_group(backend='nccl', timeout=datetime.timedelta(seconds=10800)) + + for _, model_name in enumerate(args.model): + model = None + + pred_root = osp.join(args.work_dir, model_name) + os.makedirs(pred_root, exist_ok=True) + + for _, dataset_name in enumerate(args.data): + custom_flag = False + + if dataset_name not in dataset_URLs: + dataset_name = abbr2full(dataset_name) + + if dataset_name not in dataset_URLs: + logger.warning(f'Dataset {dataset_name} is not officially supported. ') + file_path = osp.join(LMUDataRoot(), f'{dataset_name}.tsv') + if not osp.exists(file_path): + logger.error(f'Cannot find the local dataset {dataset_name}. ') + continue + else: + custom_flag = True + + result_file = f'{pred_root}/{model_name}_{dataset_name}.xlsx' + + if model is None: + model = model_name # which is only a name + + model = infer_data_job( + model, + work_dir=pred_root, + model_name=model_name, + dataset_name=dataset_name, + verbose=args.verbose, + api_nproc=args.nproc, + ignore_failed=args.ignore) + + if rank == 0: + if dataset_name in ['MMMU_TEST']: + result_json = MMMU_result_transfer(result_file) + logger.info(f'Transfer MMMU_TEST result to json for official evaluation, json file saved in {result_json}') # noqa: E501 + + if dataset_name in ['MMBench_TEST_CN', 'MMBench_TEST_EN', 'MMMU_TEST']: + if not MMBenchOfficialServer(): + logger.error( + f'Can not evaluate {dataset_name} on non-official servers, ' + 'will skip the evaluation. ' + ) + continue + + judge_kwargs = { + 'nproc': args.nproc, + 'verbose': args.verbose, + } + if args.retry is not None: + judge_kwargs['retry'] = args.retry + if args.judge is not None: + judge_kwargs['model'] = args.judge + else: + if DATASET_TYPE(dataset_name) in ['multi-choice', 'Y/N']: + judge_kwargs['model'] = 'chatgpt-0613' + elif listinstr(['MMVet', 'MathVista', 'LLaVABench'], dataset_name): + judge_kwargs['model'] = 'gpt-4-turbo' + if 'OPENAI_API_KEY_JUDGE' in os.environ and len(os.environ['OPENAI_API_KEY_JUDGE']): + judge_kwargs['key'] = os.environ['OPENAI_API_KEY_JUDGE'] + if 'OPENAI_API_BASE_JUDGE' in os.environ and len(os.environ['OPENAI_API_BASE_JUDGE']): + judge_kwargs['api_base'] = os.environ['OPENAI_API_BASE_JUDGE'] + + if rank == 0 and args.mode == 'all': + if DATASET_TYPE(dataset_name) == 'multi-choice': + dataset_name = 'default' if custom_flag else dataset_name + multiple_choice_eval( + result_file, + dataset=dataset_name, + **judge_kwargs) + + elif DATASET_TYPE(dataset_name) == 'Y/N': + YOrN_eval( + result_file, + dataset=dataset_name, + **judge_kwargs) + + elif DATASET_TYPE(dataset_name) == 'Caption': + COCO_eval(result_file) + elif dataset_name == 'MMVet': + MMVet_eval(result_file, **judge_kwargs) + elif dataset_name == 'OCRBench': + OCRBench_eval(result_file) + elif listinstr(['OCRVQA', 'TextVQA', 'ChartQA', 'DocVQA', 'InfoVQA'], dataset_name): + VQAEval(result_file, dataset_name) + elif listinstr(['MathVista'], dataset_name): + MathVista_eval(result_file, **judge_kwargs) + elif listinstr(['LLaVABench'], dataset_name): + LLaVABench_eval(result_file, **judge_kwargs) + else: + logger.error(f'Dataset {dataset_name} is not handled by evaluator, will be skipped. ') + + +if __name__ == '__main__': + load_env() + main() diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..72b742e --- /dev/null +++ b/setup.py @@ -0,0 +1,122 @@ +import re +import sys +from os.path import exists +from setuptools import find_packages, setup + + +def parse_requirements(fname='requirements.txt', with_version=True): + """Parse the package dependencies listed in a requirements file but strips + specific versioning information. + + Args: + fname (str): path to requirements file + with_version (bool, default=False): if True include version specs + + Returns: + List[str]: list of requirements items + + CommandLine: + python -c "import setup; print(setup.parse_requirements())" + """ + + require_fpath = fname + + def parse_line(line): + """Parse information from a line in a requirements text file.""" + if line.startswith('-r '): + # Allow specifying requirements in other files + target = line.split(' ')[1] + for info in parse_require_file(target): + yield info + else: + info = {'line': line} + if line.startswith('-e '): + info['package'] = line.split('#egg=')[1] + elif '@git+' in line: + info['package'] = line + else: + # Remove versioning from the package + pat = '(' + '|'.join(['>=', '==', '>']) + ')' + parts = re.split(pat, line, maxsplit=1) + parts = [p.strip() for p in parts] + + info['package'] = parts[0] + if len(parts) > 1: + op, rest = parts[1:] + if ';' in rest: + # Handle platform specific dependencies + # http://setuptools.readthedocs.io/en/latest/setuptools.html#declaring-platform-specific-dependencies + version, platform_deps = map(str.strip, + rest.split(';')) + info['platform_deps'] = platform_deps + else: + version = rest # NOQA + info['version'] = (op, version) + yield info + + def parse_require_file(fpath): + with open(fpath, 'r') as f: + for line in f.readlines(): + line = line.strip() + if line and not line.startswith('#'): + for info in parse_line(line): + yield info + + def gen_packages_items(): + if exists(require_fpath): + for info in parse_require_file(require_fpath): + parts = [info['package']] + if with_version and 'version' in info: + parts.extend(info['version']) + if not sys.version.startswith('3.4'): + # apparently package_deps are broken in 3.4 + platform_deps = info.get('platform_deps') + if platform_deps is not None: + parts.append(';' + platform_deps) + item = ''.join(parts) + yield item + + packages = list(gen_packages_items()) + return packages + + +with open('README.md') as f: + readme = f.read() + + +def do_setup(): + setup( + name='vlmeval', + version='0.1.0', + description='OpenCompass VLM Evaluation Kit', + author='Haodong Duan', + author_email='dhd.efz@gmail.com', + maintainer='Haodong Duan', + maintainer_email='dhd.efz@gmail.com', + long_description=readme, + long_description_content_type='text/markdown', + cmdclass={}, + install_requires=parse_requirements('requirements.txt'), + setup_requires=[], + python_requires='>=3.7.0', + packages=find_packages(exclude=[ + 'test*', + 'paper_test*', + ]), + keywords=['AI', 'NLP', 'in-context learning'], + entry_points={ + 'console_scripts': [] + }, + classifiers=[ + 'Programming Language :: Python :: 3.7', + 'Programming Language :: Python :: 3.8', + 'Programming Language :: Python :: 3.9', + 'Programming Language :: Python :: 3.10', + 'Intended Audience :: Developers', + 'Intended Audience :: Education', + 'Intended Audience :: Science/Research', + ]) + + +if __name__ == '__main__': + do_setup() diff --git a/vlmeval/__init__.py b/vlmeval/__init__.py new file mode 100644 index 0000000..336a61a --- /dev/null +++ b/vlmeval/__init__.py @@ -0,0 +1,13 @@ +try: + import torch +except ImportError: + pass + +from .smp import * +from .api import * +from .evaluate import * +from .utils import * +from .vlm import * +from .config import * + +load_env() diff --git a/vlmeval/api/__init__.py b/vlmeval/api/__init__.py new file mode 100644 index 0000000..63a2e31 --- /dev/null +++ b/vlmeval/api/__init__.py @@ -0,0 +1,14 @@ +from .gpt import OpenAIWrapper, GPT4V +from .gpt_int import OpenAIWrapperInternal, GPT4V_Internal +from .hf_chat_model import HFChatModel +from .gemini import GeminiWrapper, GeminiProVision +from .qwen_vl_api import QwenVLWrapper, QwenVLAPI +from .qwen_api import QwenAPI +from .stepai import Step1V +from .claude import Claude_Wrapper, Claude3V + +__all__ = [ + 'OpenAIWrapper', 'HFChatModel', 'OpenAIWrapperInternal', 'GeminiWrapper', + 'GPT4V', 'GPT4V_Internal', 'GeminiProVision', 'QwenVLWrapper', 'QwenVLAPI', + 'QwenAPI', 'Step1V', 'Claude3V', 'Claude_Wrapper' +] diff --git a/vlmeval/api/base.py b/vlmeval/api/base.py new file mode 100644 index 0000000..b7933bf --- /dev/null +++ b/vlmeval/api/base.py @@ -0,0 +1,176 @@ +import time +import random as rd +from abc import abstractmethod +import os.path as osp +import copy as cp +from ..smp import get_logger, parse_file + + +class BaseAPI: + + allowed_types = ['text', 'image'] + INTERLEAVE = True + INSTALL_REQ = False + + def __init__(self, + retry=10, + wait=3, + system_prompt=None, + verbose=True, + fail_msg='Failed to obtain answer via API.', + **kwargs): + """Base Class for all APIs. + + Args: + retry (int, optional): The retry times for `generate_inner`. Defaults to 10. + wait (int, optional): The wait time after each failed retry of `generate_inner`. Defaults to 3. + system_prompt (str, optional): Defaults to None. + verbose (bool, optional): Defaults to True. + fail_msg (str, optional): The message to return when failed to obtain answer. + Defaults to 'Failed to obtain answer via API.'. + **kwargs: Other kwargs for `generate_inner`. + """ + + self.wait = wait + self.retry = retry + self.system_prompt = system_prompt + self.verbose = verbose + self.fail_msg = fail_msg + self.logger = get_logger('ChatAPI') + + if len(kwargs): + self.logger.info(f'BaseAPI received the following kwargs: {kwargs}') + self.logger.info('Will try to use them as kwargs for `generate`. ') + self.default_kwargs = kwargs + + @abstractmethod + def generate_inner(self, inputs, **kwargs): + """The inner function to generate the answer. + + Returns: + tuple(int, str, str): ret_code, response, log + """ + self.logger.warning('For APIBase, generate_inner is an abstract method. ') + assert 0, 'generate_inner not defined' + ret_code, answer, log = None, None, None + # if ret_code is 0, means succeed + return ret_code, answer, log + + def working(self): + """If the API model is working, return True, else return False. + + Returns: + bool: If the API model is working, return True, else return False. + """ + retry = 3 + while retry > 0: + ret = self.generate('hello') + if ret is not None and ret != '' and self.fail_msg not in ret: + return True + retry -= 1 + return False + + def check_content(self, msgs): + """Check the content type of the input. Four types are allowed: str, dict, liststr, listdict. + + Args: + msgs: Raw input messages. + + Returns: + str: The message type. + """ + if isinstance(msgs, str): + return 'str' + if isinstance(msgs, dict): + return 'dict' + if isinstance(msgs, list): + types = [self.check_content(m) for m in msgs] + if all(t == 'str' for t in types): + return 'liststr' + if all(t == 'dict' for t in types): + return 'listdict' + return 'unknown' + + def preproc_content(self, inputs): + """Convert the raw input messages to a list of dicts. + + Args: + inputs: raw input messages. + + Returns: + list(dict): The preprocessed input messages. Will return None if failed to preprocess the input. + """ + if self.check_content(inputs) == 'str': + return [dict(type='text', value=inputs)] + elif self.check_content(inputs) == 'dict': + assert 'type' in inputs and 'value' in inputs + return [inputs] + elif self.check_content(inputs) == 'liststr': + res = [] + for s in inputs: + mime, pth = parse_file(s) + if mime is None or mime == 'unknown': + res.append(dict(type='text', value=s)) + else: + res.append(dict(type=mime.split('/')[0], value=pth)) + return res + elif self.check_content(inputs) == 'listdict': + for item in inputs: + assert 'type' in item and 'value' in item + mime, s = parse_file(item['value']) + if mime is None: + assert item['type'] == 'text', item['value'] + else: + assert mime.split('/')[0] == item['type'] + item['value'] = s + return inputs + else: + return None + + def generate(self, message, **kwargs1): + """The main function to generate the answer. Will call `generate_inner` with the preprocessed input messages. + + Args: + message: raw input messages. + + Returns: + str: The generated answer of the Failed Message if failed to obtain answer. + """ + assert self.check_content(message) in ['str', 'dict', 'liststr', 'listdict'], f'Invalid input type: {message}' + message = self.preproc_content(message) + assert message is not None and self.check_content(message) == 'listdict' + for item in message: + assert item['type'] in self.allowed_types, f'Invalid input type: {item["type"]}' + + # merge kwargs + kwargs = cp.deepcopy(self.default_kwargs) + kwargs.update(kwargs1) + + answer = None + # a very small random delay [0s - 0.5s] + T = rd.random() * 0.5 + time.sleep(T) + + for i in range(self.retry): + try: + ret_code, answer, log = self.generate_inner(message, **kwargs) + if ret_code == 0 and self.fail_msg not in answer and answer != '': + if self.verbose: + print(answer) + return answer + elif self.verbose: + if not isinstance(log, str): + try: + log = log.text + except: + self.logger.warning(f'Failed to parse {log} as an http response. ') + self.logger.info(f'RetCode: {ret_code}\nAnswer: {answer}\nLog: {log}') + except Exception as err: + if self.verbose: + self.logger.error(f'An error occured during try {i}:') + self.logger.error(err) + # delay before each retry + T = rd.random() * self.wait * 2 + time.sleep(T) + + return self.fail_msg if answer in ['', None] else answer diff --git a/vlmeval/api/claude.py b/vlmeval/api/claude.py new file mode 100644 index 0000000..f1e5892 --- /dev/null +++ b/vlmeval/api/claude.py @@ -0,0 +1,99 @@ +from vlmeval.smp import * +from vlmeval.api.base import BaseAPI +from time import sleep +import base64 +import mimetypes + +url = 'https://openxlab.org.cn/gw/alles-apin-hub/v1/claude/v1/text/chat' +headers = { + 'alles-apin-token': '', + 'Content-Type': 'application/json' +} + + +class Claude_Wrapper(BaseAPI): + + is_api: bool = True + + def __init__(self, + model: str = 'claude-3-opus-20240229', + key: str = None, + retry: int = 10, + wait: int = 3, + system_prompt: str = None, + verbose: bool = True, + temperature: float = 0, + max_tokens: int = 1024, + **kwargs): + + self.model = model + self.headers = headers + self.temperature = temperature + self.max_tokens = max_tokens + if key is not None: + self.key = key + else: + self.key = os.environ.get('ALLES', '') + self.headers['alles-apin-token'] = self.key + + super().__init__(retry=retry, wait=wait, verbose=verbose, system_prompt=system_prompt, **kwargs) + + def build_msgs(self, msgs_raw): + + messages = [] + message = {'role': 'user', 'content': []} + for msg in msgs_raw: + if msg['type'] == 'image': + pth = msg['value'] + suffix = osp.splitext(pth)[-1].lower() + media_type = mimetypes.types_map.get(suffix, None) + assert media_type is not None + + item = { + 'type': 'image', + 'source': {'type': 'base64', 'media_type': media_type, 'data': encode_image_file_to_base64(pth)} + } + + elif msg['type'] == 'text': + item = {'type': 'text', 'text': msg['value']} + else: + raise NotImplementedError(f'Unsupported message type: {msg["type"]}') + + message['content'].append(item) + messages.append(message) + return messages + + def generate_inner(self, inputs, **kwargs) -> str: + + payload = json.dumps({ + 'model': self.model, + 'max_tokens': self.max_tokens, + 'messages': self.build_msgs(msgs_raw=inputs), + **kwargs + }) + response = requests.request('POST', url, headers=headers, data=payload) + + ret_code = response.status_code + retry = self.retry + while ret_code == 429 and retry > 0: + sleep(15) + response = requests.request('POST', url, headers=headers, data=payload) + ret_code = response.status_code + retry -= 1 + + ret_code = 0 if (200 <= int(ret_code) < 300) else ret_code + answer = self.fail_msg + + try: + resp_struct = json.loads(response.text) + answer = resp_struct['data']['content'][0]['text'].strip() + except: + pass + + return ret_code, answer, response + + +class Claude3V(Claude_Wrapper): + + def generate(self, message, dataset=None): + return super(Claude_Wrapper, self).generate(message) diff --git a/vlmeval/api/gemini.py b/vlmeval/api/gemini.py new file mode 100644 index 0000000..04aa9db --- /dev/null +++ b/vlmeval/api/gemini.py @@ -0,0 +1,65 @@ +from vlmeval.smp import * +from vlmeval.api.base import BaseAPI + +headers = 'Content-Type: application/json' + + +class GeminiWrapper(BaseAPI): + + is_api: bool = True + + def __init__(self, + retry: int = 5, + wait: int = 5, + key: str = None, + verbose: bool = True, + temperature: float = 0.0, + system_prompt: str = None, + max_tokens: int = 1024, + proxy: str = None, + **kwargs): + + self.fail_msg = 'Failed to obtain answer via API. ' + self.max_tokens = max_tokens + self.temperature = temperature + if key is None: + key = os.environ.get('GOOGLE_API_KEY', None) + assert key is not None + self.api_key = key + if proxy is not None: + proxy_set(proxy) + super().__init__(wait=wait, retry=retry, system_prompt=system_prompt, verbose=verbose, **kwargs) + + def build_msgs(self, inputs): + messages = [] if self.system_prompt is None else [self.system_prompt] + for inp in inputs: + if inp['type'] == 'text': + messages.append(inp['value']) + elif inp['type'] == 'image': + messages.append(Image.open(inp['value'])) + return messages + + def generate_inner(self, inputs, **kwargs) -> str: + import google.generativeai as genai + assert isinstance(inputs, list) + pure_text = np.all([x['type'] == 'text' for x in inputs]) + genai.configure(api_key=self.api_key) + model = genai.GenerativeModel('gemini-pro') if pure_text else genai.GenerativeModel('gemini-pro-vision') + messages = self.build_msgs(inputs) + gen_config = dict(max_output_tokens=self.max_tokens, temperature=self.temperature) + gen_config.update(kwargs) + try: + answer = model.generate_content(messages, generation_config=genai.types.GenerationConfig(**gen_config)).text + return 0, answer, 'Succeeded! ' + except Exception as err: + if self.verbose: + self.logger.error(err) + self.logger.error(f'The input messages are {inputs}.') + + return -1, '', '' + + +class GeminiProVision(GeminiWrapper): + + def generate(self, message, dataset=None): + return super(GeminiProVision, self).generate(message) diff --git a/vlmeval/api/gpt.py b/vlmeval/api/gpt.py new file mode 100644 index 0000000..eefeba1 --- /dev/null +++ b/vlmeval/api/gpt.py @@ -0,0 +1,175 @@ +from ..smp import * +import os +import sys +from .base import BaseAPI + +APIBASES = { + 'OFFICIAL': 'https://api.openai.com/v1/chat/completions', +} + + +def GPT_context_window(model): + length_map = { + 'gpt-4-1106-preview': 128000, + 'gpt-4-vision-preview': 128000, + 'gpt-4': 8192, + 'gpt-4-32k': 32768, + 'gpt-4-0613': 8192, + 'gpt-4-32k-0613': 32768, + 'gpt-3.5-turbo-1106': 16385, + 'gpt-3.5-turbo': 4096, + 'gpt-3.5-turbo-16k': 16385, + 'gpt-3.5-turbo-instruct': 4096, + 'gpt-3.5-turbo-0613': 4096, + 'gpt-3.5-turbo-16k-0613': 16385, + } + if model in length_map: + return length_map[model] + else: + return 128000 + + +class OpenAIWrapper(BaseAPI): + + is_api: bool = True + + def __init__(self, + model: str = 'gpt-3.5-turbo-0613', + retry: int = 5, + wait: int = 5, + key: str = None, + verbose: bool = True, + system_prompt: str = None, + temperature: float = 0, + timeout: int = 60, + api_base: str = None, + max_tokens: int = 1024, + img_size: int = 512, + img_detail: str = 'low', + **kwargs): + + self.model = model + self.cur_idx = 0 + self.fail_msg = 'Failed to obtain answer via API. ' + self.max_tokens = max_tokens + self.temperature = temperature + + env_key = os.environ.get('OPENAI_API_KEY', '') + openai_key = env_key if key is None else key + self.openai_key = openai_key + assert img_size > 0 or img_size == -1 + self.img_size = img_size + assert img_detail in ['high', 'low'] + self.img_detail = img_detail + + self.vision = False + if model == 'gpt-4-vision-preview': + self.vision = True + self.timeout = timeout + + assert isinstance(openai_key, str) and (openai_key.startswith('sk-') or openai_key.startswith('sb-')), ( + f'Illegal openai_key {openai_key}. ' + 'Please set the environment variable OPENAI_API_KEY to your openai key. ' + ) + super().__init__(wait=wait, retry=retry, system_prompt=system_prompt, verbose=verbose, **kwargs) + + if api_base is None: + if 'OPENAI_API_BASE' in os.environ and os.environ['OPENAI_API_BASE'] != '': + self.logger.error('Environment variable OPENAI_API_BASE is set. Will use it as api_base. ') + api_base = os.environ['OPENAI_API_BASE'] + else: + api_base = 'OFFICIAL' + + assert api_base is not None + + if api_base in APIBASES: + self.api_base = APIBASES[api_base] + elif api_base.startswith('http'): + self.api_base = api_base + else: + self.logger.error('Unknown API Base. ') + sys.exit(-1) + + # inputs can be a lvl-2 nested list: [content1, content2, content3, ...] + # content can be a string or a list of image & text + def prepare_inputs(self, inputs): + input_msgs = [] + if self.system_prompt is not None: + input_msgs.append(dict(role='system', content=self.system_prompt)) + has_images = np.sum([x['type'] == 'image' for x in inputs]) + if has_images: + content_list = [] + for msg in inputs: + if msg['type'] == 'text': + content_list.append(dict(type='text', text=msg['value'])) + elif msg['type'] == 'image': + from PIL import Image + img = Image.open(msg['value']) + b64 = encode_image_to_base64(img, target_size=self.img_size) + img_struct = dict(url=f'data:image/jpeg;base64,{b64}', detail=self.img_detail) + content_list.append(dict(type='image_url', image_url=img_struct)) + input_msgs.append(dict(role='user', content=content_list)) + else: + assert all([x['type'] == 'text' for x in inputs]) + text = '\n'.join([x['value'] for x in inputs]) + input_msgs.append(dict(role='user', content=text)) + return input_msgs + + def generate_inner(self, inputs, **kwargs) -> str: + input_msgs = self.prepare_inputs(inputs) + temperature = kwargs.pop('temperature', self.temperature) + max_tokens = kwargs.pop('max_tokens', self.max_tokens) + + context_window = GPT_context_window(self.model) + max_tokens = min(max_tokens, context_window - self.get_token_len(inputs)) + if 0 < max_tokens <= 100: + self.logger.warning( + 'Less than 100 tokens left, ' + 'may exceed the context window with some additional meta symbols. ' + ) + if max_tokens <= 0: + return 0, self.fail_msg + 'Input string longer than context window. ', 'Length Exceeded. ' + + headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {self.openai_key}'} + payload = dict( + model=self.model, + messages=input_msgs, + max_tokens=max_tokens, + n=1, + temperature=temperature, + **kwargs) + response = requests.post(self.api_base, headers=headers, data=json.dumps(payload), timeout=self.timeout * 1.1) + ret_code = response.status_code + ret_code = 0 if (200 <= int(ret_code) < 300) else ret_code + answer = self.fail_msg + try: + resp_struct = json.loads(response.text) + answer = resp_struct['choices'][0]['message']['content'].strip() + except: + pass + return ret_code, answer, response + + def get_token_len(self, inputs) -> int: + import tiktoken + try: + enc = tiktoken.encoding_for_model(self.model) + except: + enc = tiktoken.encoding_for_model('gpt-4') + assert isinstance(inputs, list) + tot = 0 + for item in inputs: + if item['type'] == 'text': + tot += len(enc.encode(item['value'])) + elif item['type'] == 'image': + tot += 85 + if self.img_detail == 'high': + img = Image.open(item['value']) + npatch = np.ceil(img.size[0] / 512) * np.ceil(img.size[1] / 512) + tot += npatch * 170 + return tot + + +class GPT4V(OpenAIWrapper): + + def generate(self, message, dataset=None): + return super(GPT4V, self).generate(message) diff --git a/vlmeval/api/gpt_int.py b/vlmeval/api/gpt_int.py new file mode 100644 index 0000000..f520747 --- /dev/null +++ b/vlmeval/api/gpt_int.py @@ -0,0 +1,94 @@ +import json +import warnings +import requests +from ..smp import * +from .gpt import GPT_context_window, OpenAIWrapper + +url = 'http://ecs.sv.us.alles-apin.openxlab.org.cn/v1/openai/v2/text/chat' +headers = { + 'Content-Type': 'application/json' +} + + +class OpenAIWrapperInternal(OpenAIWrapper): + + is_api: bool = True + + def __init__(self, + model: str = 'gpt-3.5-turbo-0613', + retry: int = 5, + wait: int = 3, + verbose: bool = True, + system_prompt: str = None, + temperature: float = 0, + timeout: int = 60, + max_tokens: int = 1024, + img_size: int = 512, + img_detail: str = 'low', + **kwargs): + + self.model = model + if 'KEYS' in os.environ and osp.exists(os.environ['KEYS']): + keys = load(os.environ['KEYS']) + headers['alles-apin-token'] = keys.get('alles-apin-token', '') + elif 'ALLES' in os.environ: + headers['alles-apin-token'] = os.environ['ALLES'] + self.headers = headers + self.temperature = temperature + self.timeout = timeout + self.max_tokens = max_tokens + + assert img_size > 0 or img_size == -1 + self.img_size = img_size + assert img_detail in ['high', 'low'] + self.img_detail = img_detail + + self.vision = False + if model == 'gpt-4-vision-preview': + self.vision = True + + super(OpenAIWrapper, self).__init__( + wait=wait, retry=retry, system_prompt=system_prompt, verbose=verbose, **kwargs) + + def generate_inner(self, inputs, **kwargs) -> str: + input_msgs = self.prepare_inputs(inputs) + + temperature = kwargs.pop('temperature', self.temperature) + max_tokens = kwargs.pop('max_tokens', self.max_tokens) + + # Held out 100 tokens as buffer + context_window = GPT_context_window(self.model) + max_tokens = min(max_tokens, context_window - self.get_token_len(inputs)) + if 0 < max_tokens <= 100: + print('Less than 100 tokens left, may exceed the context window with some additional meta symbols. ') + if max_tokens <= 0: + return 0, self.fail_msg + 'Input string longer than context window. ', 'Length Exceeded. ' + + payload = dict( + model=self.model, + messages=input_msgs, + max_tokens=max_tokens, + n=1, + stop=None, + timeout=self.timeout, + temperature=temperature, + **kwargs) + + response = requests.post(url, headers=headers, data=json.dumps(payload), timeout=self.timeout * 1.1) + ret_code = response.status_code + ret_code = 0 if (200 <= int(ret_code) < 300) else ret_code + + answer = self.fail_msg + try: + resp_struct = json.loads(response.text) + assert resp_struct['msg'] == 'ok' and resp_struct['msgCode'] == '10000', resp_struct + answer = resp_struct['data']['choices'][0]['message']['content'].strip() + except: + pass + return ret_code, answer, response + + +class GPT4V_Internal(OpenAIWrapperInternal): + + def generate(self, message, dataset=None): + return super(GPT4V_Internal, self).generate(message) diff --git a/vlmeval/api/hf_chat_model.py b/vlmeval/api/hf_chat_model.py new file mode 100644 index 0000000..9f2ae3c --- /dev/null +++ b/vlmeval/api/hf_chat_model.py @@ -0,0 +1,245 @@ +import os +import sys +import os.path as osp +import torch +from ..smp import * + + +def get_gpu_num(model_name): + model_name = model_name.lower() + kws = { + 8: ['65b', '70b'], + 4: ['30b', '33b', '35b', '40b'], + 2: ['13b', '14b', '20b'], + 1: ['6b', '7b', 'moss'], + } + for k in [8, 4, 2, 1]: + for keyword in kws[k]: + if keyword in model_name: + return k + return 8 + + +validated_llms = [ + 'internlm/internlm-chat-7b', 'internlm/internlm-chat-7b-8k', 'internlm/internlm-chat-20b', + 'Qwen/Qwen-7B-Chat', 'Qwen/Qwen-14B-Chat', + 'THUDM/chatglm2-6b', 'THUDM/chatglm2-6b-32k', 'THUDM/chatglm3-6b', 'THUDM/chatglm3-6b-32k', + 'baichuan-inc/Baichuan2-7B-Chat', 'baichuan-inc/Baichuan2-13B-Chat', + 'lmsys/vicuna-7b-v1.5', 'lmsys/vicuna-13b-v1.5', + 'meta-llama/Llama-2-7b-chat-hf' +] +Auto_model = ['chatglm'] + + +class HFChatModel: + + def _get_context_length(self, model, model_path): + # By default, we use model.config.seq_length + model_path = model_path.lower() + if 'baichuan' in model_path: + context_window = model.config.model_max_length + elif 'internlm' in model_path or 'llama' in model_path: + context_window = model.config.max_position_embeddings + elif 'vicuna' in model_path: + context_window = model.generation_config.max_length + else: + # chatglm & qwen + context_window = model.config.seq_length + return context_window + + def _get_context_length_robust(self, model, model_path): + try: + context_window = self._get_context_length(model, model_path) + return context_window + except: + self.logger.critical( + 'Failed to extract context_window information from config / generation_config. ' + 'Please read the above code and check if the logic works for you model path' + ) + raise NotImplementedError + + def __init__(self, + model_path, + system_prompt: str = None, + **kwargs): + + self.logger = get_logger('HFChatModel') + if 'vicuna' in model_path.lower(): + try: + from fastchat.model import get_conversation_template + except: + self.logger.critical('Please install fastchat first to use vicuna. ') + sys.exit(-1) + + self.explicit_device = kwargs.pop('device', None) + + if self.explicit_device is None: + # If CUDA_VISIBLE_DEVICES is not properly set + if 'CUDA_VISIBLE_DEVICES' not in os.environ or os.environ['CUDA_VISIBLE_DEVICES'] == '0,1,2,3,4,5,6,7': + num_gpu = get_gpu_num(model_path) + gpu_offset = kwargs.pop('gpu_offset', 0) + cuda_visible_devices = ','.join([str(i) for i in range(gpu_offset, gpu_offset + num_gpu)]) + os.environ['CUDA_VISIBLE_DEVICES'] = cuda_visible_devices + + from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModel + from transformers.generation import GenerationConfig + + if model_path not in validated_llms: + self.logger.warning(f'{model_path} not in validated LLMs, may have inference troubles. ') + + self.model_path = model_path + if listinstr(Auto_model, model_path): + LoadModel = AutoModel + else: + LoadModel = AutoModelForCausalLM + + assert osp.exists(model_path) or len(model_path.split('/')) == 2 + + device = self.explicit_device if self.explicit_device else 'auto' + + precision = {} + if 'internlm-chat-7b' in model_path: + precision = {'torch_dtype': torch.float16} + elif 'internlm-chat-20b' in model_path: + precision = {'torch_dtype': torch.bfloat16} + + self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) + model = LoadModel.from_pretrained(model_path, trust_remote_code=True, device_map='cpu', **precision) + model = model.eval() + + if device != 'cpu': + model = model.to(f'cuda:{device}' if isinstance(device, int) else 'cuda') + try: + model.generation_config = GenerationConfig.from_pretrained( + model_path, trust_remote_code=True, device_map=device) + except: + pass + + torch.cuda.empty_cache() + self.model = model + self.context_length = self._get_context_length_robust(model=model, model_path=model_path) + self.answer_buffer = 192 + self.system_prompt = system_prompt + for k, v in kwargs.items(): + self.logger.info(f'Following args will be used for generation (If not set specifically), {k}: {v}. ') + self.kwargs = kwargs + + def generate_str(self, input, **kwargs): + if 'baichuan' in self.model_path.lower(): + messages = [] + messages.append({'role': 'user', 'content': input}) + resp = self.model.chat(self.tokenizer, messages, **kwargs) + elif 'vicuna' in self.model_path.lower(): + from fastchat.model import get_conversation_template + conv = get_conversation_template('vicuna') + conv.append_message(conv.roles[0], input) + conv.append_message(conv.roles[1], None) + prompt = conv.get_prompt() + inputs = self.tokenizer([prompt], return_tensors='pt') + if torch.cuda.is_available(): + for k in inputs: + inputs[k] = inputs[k].cuda() + + params = dict(do_sample=True, temperature=0.7, repetition_penalty=1.0, max_new_tokens=512) + params.update(self.kwargs) + params.update(kwargs) + outputs = self.model.generate(**inputs, **params) + resp = self.tokenizer.decode( + outputs[0][len(inputs['input_ids'][0]):], + skip_special_tokens=True, + spaces_between_special_tokens=False) + + else: + params = self.kwargs + params.update(kwargs) + resp, _ = self.model.chat(self.tokenizer, input, history=[], **params) + + return resp + + def length_ok(self, inputs): + tot = len(self.tokenizer.encode(self.system_prompt)) if self.system_prompt is not None else 0 + for s in inputs: + tot += len(self.tokenizer.encode(s)) + return tot + self.answer_buffer < self.context_length + + def generate_list(self, full_inputs, offset=0, **kwargs): + assert isinstance(full_inputs, list) + + inputs = full_inputs[offset:] + if not self.length_ok(inputs): + return self.chat(full_inputs, offset + 1) + + model_path = self.model_path.lower() + + if sum([x in model_path for x in ['baichuan']]): + input_msgs = [] + if self.system_prompt is not None: + input_msgs.append(dict(role='user', content=self.system_prompt)) + if len(inputs): + assert isinstance(inputs, list) and isinstance(inputs[0], str) + roles = ['user', 'assistant'] if len(inputs) % 2 == 1 else ['assistant', 'user'] + roles = roles * len(inputs) + for role, msg in zip(roles, inputs): + input_msgs.append(dict(role=role, content=msg)) + response = self.model.chat(self.tokenizer, input_msgs) + elif sum([x in model_path for x in ['vicuna']]): + from fastchat.model import get_conversation_template + conv = get_conversation_template('vicuna') + assert isinstance(inputs, list) and isinstance(inputs[0], str) + if len(inputs) % 2 == 1: + if self.system_prompt is not None: + conv.append_message(conv.roles[0], self.system_prompt) + for i in range(len(inputs) // 2): + conv.append_message(conv.roles[0], inputs[2 * i]) + conv.append_message(conv.roles[1], inputs[2 * i + 1]) + else: + assert self.system_prompt is not None + conv.append_message(conv.roles[0], self.system_prompt) + conv.append_message(conv.roles[1], inputs[0]) + for i in range(len(inputs) // 2 - 1): + conv.append_message(conv.roles[0], inputs[2 * i + 1]) + conv.append_message(conv.roles[1], inputs[2 * i + 2]) + conv.append_message(conv.roles[0], inputs[-1]) + conv.append_message(conv.roles[1], None) + prompt = conv.get_prompt() + inputs = self.tokenizer([prompt], return_tensors='pt') + if torch.cuda.is_available(): + for k in inputs: + inputs[k] = inputs[k].cuda() + + params = dict(do_sample=True, temperature=0.7, repetition_penalty=1.0, max_new_tokens=512) + params.update(self.kwargs) + params.update(kwargs) + + outputs = self.model.generate(**inputs, **params) + response = self.tokenizer.decode( + outputs[0][len(inputs['input_ids'][0]):], + skip_special_tokens=True, + spaces_between_special_tokens=False) + response = response.lstrip('\n') + else: + # The default option, support internlm, chatglm, qwen + history, msg = [], None + if len(inputs) % 2 == 1: + if self.system_prompt is not None: + history = [(self.system_prompt, '')] + for i in range(len(inputs) // 2): + history.append((inputs[2 * i], inputs[2 * i + 1])) + else: + assert self.system_prompt is not None + history = [(self.system_prompt, inputs[0])] + for i in range(len(inputs) // 2 - 1): + history.append((inputs[2 * i + 1], inputs[2 * i + 2])) + msg = inputs[-1] + + params = self.kwargs + params.update(kwargs) + response, _ = self.model.chat(self.tokenizer, msg, history=history, **params) + + return response, offset + + def generate(self, inputs, **kwargs): + if isinstance(inputs, str): + return self.generate_str(inputs, **kwargs) + elif isinstance(inputs, list): + return self.generate_list(inputs, **kwargs) diff --git a/vlmeval/api/qwen_api.py b/vlmeval/api/qwen_api.py new file mode 100644 index 0000000..4e490d5 --- /dev/null +++ b/vlmeval/api/qwen_api.py @@ -0,0 +1,75 @@ +from http import HTTPStatus +import os +from vlmeval.api.base import BaseAPI +from vlmeval.smp import * + + +# Note: This is a pure language model API. +class QwenAPI(BaseAPI): + + is_api: bool = True + + def __init__(self, + model: str = 'qwen-max-1201', + retry: int = 5, + wait: int = 5, + verbose: bool = True, + seed: int = 2680, + temperature: float = 0.0, + system_prompt: str = None, + key: str = None, + max_tokens: int = 1024, + proxy: str = None, + **kwargs): + + assert model in ['qwen-turbo', 'qwen-plus', 'qwen-max', 'qwen-max-1201', 'qwen-max-longcontext'] + self.model = model + import dashscope + self.fail_msg = 'Failed to obtain answer via API. ' + self.max_tokens = max_tokens + self.temperature = temperature + self.seed = seed + if key is None: + key = os.environ.get('DASHSCOPE_API_KEY', None) + assert key is not None, ( + 'Please set the API Key (obtain it here: ' + 'https://help.aliyun.com/zh/dashscope/developer-reference/vl-plus-quick-start)' + ) + dashscope.api_key = key + if proxy is not None: + proxy_set(proxy) + super().__init__(wait=wait, retry=retry, system_prompt=system_prompt, verbose=verbose, **kwargs) + + @staticmethod + def build_msgs(msgs_raw, system_prompt=None): + msgs = cp.deepcopy(msgs_raw) + ret = [] + if system_prompt is not None: + ret.append(dict(role='system', content=system_prompt)) + for i, msg in enumerate(msgs): + role = 'user' if i % 2 == 0 else 'assistant' + ret.append(dict(role=role, content=msg)) + return ret + + def generate_inner(self, inputs, **kwargs) -> str: + from dashscope import MultiModalConversation + assert isinstance(inputs, str) or isinstance(inputs, list) + inputs = [inputs] if isinstance(inputs, str) else inputs + messages = self.build_msgs(msgs_raw=inputs, system_prompt=self.system_prompt) + + import dashscope + response = dashscope.Generation.call( + model=self.model, + messages=messages, + seed=self.seed, + temperature=self.temperature, + max_tokens=self.max_tokens, + result_format='message', # set the result to be "message" format. + ) + if response.status_code != HTTPStatus.OK: + return -1, 'Error: Bad Response Statuse Code. ', f'The response status code is {response.status_code}. ' + + try: + return 0, response['output']['choices'][0]['message']['content'].strip(), 'Succeeded! ' + except Exception as err: + return -1, f'Error: Failed to parse the response. {err}', response diff --git a/vlmeval/api/qwen_vl_api.py b/vlmeval/api/qwen_vl_api.py new file mode 100644 index 0000000..131c89a --- /dev/null +++ b/vlmeval/api/qwen_vl_api.py @@ -0,0 +1,79 @@ +from vlmeval.smp import * +from vlmeval.api.base import BaseAPI + + +class QwenVLWrapper(BaseAPI): + + is_api: bool = True + + def __init__(self, + model: str = 'qwen-vl-plus', + retry: int = 5, + wait: int = 5, + key: str = None, + verbose: bool = True, + temperature: float = 0.0, + system_prompt: str = None, + max_tokens: int = 1024, + proxy: str = None, + **kwargs): + + assert model in ['qwen-vl-plus', 'qwen-vl-max'] + self.model = model + import dashscope + self.fail_msg = 'Failed to obtain answer via API. ' + self.max_tokens = max_tokens + self.temperature = temperature + if key is None: + key = os.environ.get('DASHSCOPE_API_KEY', None) + assert key is not None, ( + 'Please set the API Key (obtain it here: ' + 'https://help.aliyun.com/zh/dashscope/developer-reference/vl-plus-quick-start)' + ) + dashscope.api_key = key + if proxy is not None: + proxy_set(proxy) + super().__init__(wait=wait, retry=retry, system_prompt=system_prompt, verbose=verbose, **kwargs) + + @staticmethod + def build_msgs(msgs_raw, system_prompt=None): + msgs = cp.deepcopy(msgs_raw) + ret = [] + if system_prompt is not None: + content = list(dict(text=system_prompt)) + ret.append(dict(role='system', content=content)) + content = [] + for msg in msgs: + if msg['type'] == 'text': + content.append(dict(text=msg['value'])) + elif msg['type'] == 'image': + content.append(dict(image='file://' + msg['value'])) + ret.append(dict(role='user', content=content)) + return ret + + def generate_inner(self, inputs, **kwargs) -> str: + from dashscope import MultiModalConversation + assert isinstance(inputs, str) or isinstance(inputs, list) + pure_text = np.all([x['type'] == 'text' for x in inputs]) + assert not pure_text + messages = self.build_msgs(msgs_raw=inputs, system_prompt=self.system_prompt) + gen_config = dict(max_output_tokens=self.max_tokens, temperature=self.temperature) + gen_config.update(kwargs) + try: + response = MultiModalConversation.call(model=self.model, messages=messages) + if self.verbose: + print(response) + answer = response.output.choices[0]['message']['content'][0]['text'] + return 0, answer, 'Succeeded! ' + except Exception as err: + if self.verbose: + self.logger.error(err) + self.logger.error(f'The input messages are {inputs}.') + + return -1, '', '' + + +class QwenVLAPI(QwenVLWrapper): + + def generate(self, message, dataset=None): + return super(QwenVLAPI, self).generate(message) diff --git a/vlmeval/api/stepai.py b/vlmeval/api/stepai.py new file mode 100644 index 0000000..f1c3dd1 --- /dev/null +++ b/vlmeval/api/stepai.py @@ -0,0 +1,85 @@ +from vlmeval.smp import * +from vlmeval.api.base import BaseAPI + +url = 'https://b-openapi.basemind.com/openapi/v1/chat/completions' +headers = { + 'X-Request-Orgcode': 'companyA', + 'Authorization': 'Bearer {}', + 'Content-Type': 'application/json' +} + + +class StepAPI(BaseAPI): + + is_api: bool = True + + def __init__(self, + model: str = 'stepapi-rankboard', + retry: int = 10, + wait: int = 3, + key: str = None, + temperature: float = 0, + max_tokens: int = 300, + verbose: bool = True, + system_prompt: str = None, + **kwargs): + self.model = model + self.fail_msg = 'Fail to obtain answer via API.' + self.headers = headers + self.temperature = temperature + self.max_tokens = max_tokens + self.system_prompt = system_prompt + if key is not None: + self.key = key + else: + self.key = os.environ.get('STEPAI_API_KEY', '') + headers['Authorization'] = headers['Authorization'].format(self.key) + + super().__init__(retry=retry, wait=wait, verbose=verbose, system_prompt=system_prompt, **kwargs) + + @staticmethod + def build_msgs(msgs_raw): + messages = [] + message = {'role': 'user', 'content': []} + + for msg in msgs_raw: + if msg['type'] == 'image': + image_b64 = encode_image_file_to_base64(msg['value']) + message['content'].append({ + 'image_b64': {'b64_json': image_b64}, + 'type': 'image_b64' + }) + elif msg['type'] == 'text': + message['content'].append({ + 'text': msg['value'], + 'type': 'text' + }) + + messages.append(message) + return messages + + def generate_inner(self, inputs, **kwargs) -> str: + print(inputs, '\n') + payload = dict( + model=self.model, + max_tokens=self.max_tokens, + temperature=self.temperature, + messages=self.build_msgs(msgs_raw=inputs), + **kwargs) + response = requests.post(url, headers=headers, data=json.dumps(payload)) + ret_code = response.status_code + ret_code = 0 if (200 <= int(ret_code) < 300) else ret_code + + answer = self.fail_msg + try: + resp_struct = json.loads(response.text) + answer = resp_struct['choices'][0]['message']['content'].strip() + except: + pass + return ret_code, answer, response + + +class Step1V(StepAPI): + + def generate(self, message, dataset=None): + return super(StepAPI, self).generate(message) diff --git a/vlmeval/config.py b/vlmeval/config.py new file mode 100644 index 0000000..9c0f129 --- /dev/null +++ b/vlmeval/config.py @@ -0,0 +1,137 @@ +from vlmeval.vlm import * +from vlmeval.api import * +from functools import partial + +PandaGPT_ROOT = None +MiniGPT4_ROOT = None +TransCore_ROOT = None +Yi_ROOT = None +OmniLMM_ROOT = None +LLAVA_V1_7B_MODEL_PTH = 'Please set your local path to LLaVA-7B-v1.1 here, the model weight is obtained by merging LLaVA delta weight based on vicuna-7b-v1.1 in https://github.com/haotian-liu/LLaVA/blob/main/docs/MODEL_ZOO.md with vicuna-7b-v1.1. ' + +ungrouped = { + 'TransCore_M': partial(TransCoreM, root=TransCore_ROOT), + 'PandaGPT_13B': partial(PandaGPT, name='PandaGPT_13B', root=PandaGPT_ROOT), + 'flamingov2': partial(OpenFlamingo, name='v2', mpt_pth='anas-awadalla/mpt-7b', ckpt_pth='openflamingo/OpenFlamingo-9B-vitl-mpt7b'), + 'VisualGLM_6b': partial(VisualGLM, model_path='THUDM/visualglm-6b'), + 'mPLUG-Owl2': partial(mPLUG_Owl2, model_path='MAGAer13/mplug-owl2-llama2-7b'), + 'cogvlm-grounding-generalist':partial(CogVlm, name='cogvlm-grounding-generalist',tokenizer_name ='lmsys/vicuna-7b-v1.5'), + 'cogvlm-chat':partial(CogVlm, name='cogvlm-chat',tokenizer_name ='lmsys/vicuna-7b-v1.5'), + 'emu2_chat':partial(Emu, model_path='BAAI/Emu2-Chat',), + 'MMAlaya':partial(MMAlaya, model_path='DataCanvas/MMAlaya'), + 'MiniCPM-V':partial(MiniCPM_V, model_path='openbmb/MiniCPM-V'), + 'MiniCPM-V-2':partial(MiniCPM_V, model_path='openbmb/MiniCPM-V-2'), + 'OmniLMM_12B':partial(OmniLMM12B, model_path='openbmb/OmniLMM-12B', root=OmniLMM_ROOT), +} + +api_models = { + 'GPT4V': partial(GPT4V, model='gpt-4-1106-vision-preview', temperature=0, img_size=512, img_detail='low', retry=10), + 'GPT4V_HIGH': partial(GPT4V, model='gpt-4-1106-vision-preview', temperature=0, img_size=-1, img_detail='high', retry=10), + 'GPT4V_20240409': partial(GPT4V, model='gpt-4-turbo-2024-04-09', temperature=0, img_size=512, img_detail='low', retry=10), + 'GPT4V_20240409_HIGH': partial(GPT4V, model='gpt-4-turbo-2024-04-09', temperature=0, img_size=-1, img_detail='high', retry=10), + 'GeminiProVision': partial(GeminiProVision, temperature=0, retry=10), + 'QwenVLPlus': partial(QwenVLAPI, model='qwen-vl-plus', temperature=0, retry=10), + 'QwenVLMax': partial(QwenVLAPI, model='qwen-vl-max', temperature=0, retry=10), + # Internal Only + 'GPT4V_INT': partial(GPT4V_Internal, model='gpt-4-vision-preview', temperature=0, img_size=512, img_detail='low', retry=10), + 'Step1V': partial(Step1V, temperature=0, retry=10), + 'Claude3V_Opus': partial(Claude3V, model='claude-3-opus-20240229', temperature=0, retry=10), + 'Claude3V_Sonnet': partial(Claude3V, model='claude-3-sonnet-20240229', temperature=0, retry=10), + 'Claude3V_Haiku': partial(Claude3V, model='claude-3-haiku-20240307', temperature=0, retry=10), +} + +xtuner_series = { + 'llava-internlm2-7b': partial(LLaVA_XTuner, llm_path='internlm/internlm2-chat-7b', llava_path='xtuner/llava-internlm2-7b', visual_select_layer=-2, prompt_template='internlm2_chat'), + 'llava-internlm2-20b': partial(LLaVA_XTuner, llm_path='internlm/internlm2-chat-20b', llava_path='xtuner/llava-internlm2-20b', visual_select_layer=-2, prompt_template='internlm2_chat'), + 'llava-internlm-7b': partial(LLaVA_XTuner, llm_path='internlm/internlm-chat-7b', llava_path='xtuner/llava-internlm-7b', visual_select_layer=-2, prompt_template='internlm_chat'), + 'llava-v1.5-7b-xtuner': partial(LLaVA_XTuner, llm_path='lmsys/vicuna-7b-v1.5', llava_path='xtuner/llava-v1.5-7b-xtuner', visual_select_layer=-2, prompt_template='vicuna'), + 'llava-v1.5-13b-xtuner': partial(LLaVA_XTuner, llm_path='lmsys/vicuna-13b-v1.5', llava_path='xtuner/llava-v1.5-13b-xtuner', visual_select_layer=-2, prompt_template='vicuna'), +} + +qwen_series = { + 'qwen_base': partial(QwenVL, model_path='Qwen/Qwen-VL'), + 'qwen_chat': partial(QwenVL, model_path='Qwen/Qwen-VL-Chat'), + 'monkey':partial(Monkey, model_path='echo840/Monkey'), + 'monkey-chat':partial(MonkeyChat, model_path='echo840/Monkey-Chat') +} + +llava_series = { + 'llava_v1.5_7b': partial(LLaVA, model_pth='liuhaotian/llava-v1.5-7b'), + 'llava_v1.5_13b': partial(LLaVA, model_pth='liuhaotian/llava-v1.5-13b'), + 'llava_v1_7b': partial(LLaVA, model_pth=LLAVA_V1_7B_MODEL_PTH), + 'sharegpt4v_7b': partial(LLaVA, model_pth='Lin-Chen/ShareGPT4V-7B'), + 'sharegpt4v_13b': partial(LLaVA, model_pth='Lin-Chen/ShareGPT4V-13B'), + 'llava_next_vicuna_7b': partial(LLaVA_Next, model_pth='llava-hf/llava-v1.6-vicuna-7b-hf'), + 'llava_next_vicuna_13b': partial(LLaVA_Next, model_pth='llava-hf/llava-v1.6-vicuna-13b-hf'), + 'llava_next_mistral_7b': partial(LLaVA_Next, model_pth='llava-hf/llava-v1.6-mistral-7b-hf'), + 'llava_next_yi_34b': partial(LLaVA_Next, model_pth='llava-hf/llava-v1.6-34b-hf'), +} + +internvl_series = { + 'InternVL-Chat-V1-1':partial(InternVLChat, model_path='OpenGVLab/InternVL-Chat-Chinese-V1-1'), + 'InternVL-Chat-V1-2': partial(InternVLChat, model_path='OpenGVLab/InternVL-Chat-Chinese-V1-2'), + 'InternVL-Chat-V1-2-Plus': partial(InternVLChat, model_path='OpenGVLab/InternVL-Chat-Chinese-V1-2-Plus'), + 'InternVL-Chat-V1-5': partial(InternVLChat, model_path='OpenGVLab/InternVL-Chat-V1-5-Preview'), +} + +yivl_series = { + 'Yi_VL_6B':partial(Yi_VL, model_path='01-ai/Yi-VL-6B', root=Yi_ROOT), + 'Yi_VL_34B':partial(Yi_VL, model_path='01-ai/Yi-VL-34B', root=Yi_ROOT), +} + +xcomposer_series = { + 'XComposer': partial(XComposer, model_path='internlm/internlm-xcomposer-vl-7b'), + 'sharecaptioner': partial(ShareCaptioner, model_path='Lin-Chen/ShareCaptioner'), + 'XComposer2': partial(XComposer2, model_path='internlm/internlm-xcomposer2-vl-7b'), + 'XComposer2_1.8b': partial(XComposer2, model_path='internlm/internlm-xcomposer2-vl-1_8b'), + 'XComposer2_4KHD': partial(XComposer2_4KHD, model_path='internlm/internlm-xcomposer2-4khd-7b'), +} + +minigpt4_series = { + 'MiniGPT-4-v2': partial(MiniGPT4, mode='v2', root=MiniGPT4_ROOT), + 'MiniGPT-4-v1-7B': partial(MiniGPT4, mode='v1_7b', root=MiniGPT4_ROOT), + 'MiniGPT-4-v1-13B': partial(MiniGPT4, mode='v1_13b', root=MiniGPT4_ROOT), +} + +idefics_series = { + 'idefics_9b_instruct': partial(IDEFICS, model_pth='HuggingFaceM4/idefics-9b-instruct'), + 'idefics_80b_instruct': partial(IDEFICS, model_pth='HuggingFaceM4/idefics-80b-instruct'), + 'idefics2_8b': partial(IDEFICS2, model_path='HuggingFaceM4/idefics2-8b'), +} + +instructblip_series = { + 'instructblip_7b': partial(InstructBLIP, name='instructblip_7b'), + 'instructblip_13b': partial(InstructBLIP, name='instructblip_13b'), +} + +deepseekvl_series = { + 'deepseek_vl_7b': partial(DeepSeekVL, model_path='deepseek-ai/deepseek-vl-7b-chat'), + 'deepseek_vl_1.3b': partial(DeepSeekVL, model_path='deepseek-ai/deepseek-vl-1.3b-chat'), +} + +supported_VLM = {} + +model_groups = [ + ungrouped, api_models, + xtuner_series, qwen_series, llava_series, internvl_series, yivl_series, + xcomposer_series, minigpt4_series, idefics_series, instructblip_series, + deepseekvl_series +] + +for grp in model_groups: + supported_VLM.update(grp) + +transformer_ver = {} +transformer_ver['4.33.0'] = list(qwen_series) + list(internvl_series) + list(xcomposer_series) + [ + 'mPLUG-Owl2', 'flamingov2', 'VisualGLM_6b', 'MMAlaya', 'PandaGPT_13B' +] + list(idefics_series) + list(minigpt4_series) + list(instructblip_series) +transformer_ver['4.37.0'] = [x for x in llava_series if 'next' not in x] + [ + 'TransCore_M', 'cogvlm-chat', 'cogvlm-grounding-generalist', 'emu2_chat', 'MiniCPM-V', 'MiniCPM-V-2', 'OmniLMM_12B' +] + list(xtuner_series) + list(yivl_series) + list(deepseekvl_series) +transformer_ver['4.39.0'] = [x for x in llava_series if 'next' in x] + +if __name__ == '__main__': + import sys + ver = sys.argv[1] + if ver in transformer_ver: + print(' '.join(transformer_ver[ver])) \ No newline at end of file diff --git a/vlmeval/evaluate/OCRBench.py b/vlmeval/evaluate/OCRBench.py new file mode 100644 index 0000000..c37ad08 --- /dev/null +++ b/vlmeval/evaluate/OCRBench.py @@ -0,0 +1,65 @@ +from vlmeval.smp import * + + +def OCRBench_eval(eval_file): + OCRBench_score = { + 'Regular Text Recognition': 0, + 'Irregular Text Recognition': 0, + 'Artistic Text Recognition': 0, + 'Handwriting Recognition': 0, + 'Digit String Recognition': 0, + 'Non-Semantic Text Recognition': 0, + 'Scene Text-centric VQA': 0, + 'Doc-oriented VQA': 0, + 'Key Information Extraction': 0, + 'Handwritten Mathematical Expression Recognition': 0 + } + + logger = get_logger('Evaluation') + + data = load(eval_file) + lt = len(data) + lines = [data.iloc[i] for i in range(lt)] + for i in tqdm(range(len(lines))): + line = lines[i] + predict = str(line['prediction']) + answers = eval(line['answer']) + category = line['category'] + if category == 'Handwritten Mathematical Expression Recognition': + for j in range(len(answers)): + answer = answers[j].strip().replace('\n', ' ').replace(' ', '') + predict = predict.strip().replace('\n', ' ').replace(' ', '') + if answer in predict: + OCRBench_score[category] += 1 + break + else: + for j in range(len(answers)): + answer = answers[j].lower().strip().replace('\n', ' ') + predict = predict.lower().strip().replace('\n', ' ') + if answer in predict: + OCRBench_score[category] += 1 + break + + final_score_dict = {} + final_score_dict['Text Recognition'] = ( + OCRBench_score['Regular Text Recognition'] + OCRBench_score['Irregular Text Recognition'] + + OCRBench_score['Artistic Text Recognition'] + OCRBench_score['Handwriting Recognition'] + + OCRBench_score['Digit String Recognition'] + OCRBench_score['Non-Semantic Text Recognition'] + ) + final_score_dict['Scene Text-centric VQA'] = OCRBench_score['Scene Text-centric VQA'] + final_score_dict['Doc-oriented VQA'] = OCRBench_score['Doc-oriented VQA'] + final_score_dict['Key Information Extraction'] = OCRBench_score['Key Information Extraction'] + final_score_dict['Handwritten Mathematical Expression Recognition'] = \ + OCRBench_score['Handwritten Mathematical Expression Recognition'] + final_score_dict['Final Score'] = ( + final_score_dict['Text Recognition'] + final_score_dict['Scene Text-centric VQA'] + + final_score_dict['Doc-oriented VQA'] + final_score_dict['Key Information Extraction'] + + final_score_dict['Handwritten Mathematical Expression Recognition'] + ) + final_score_dict['Final Score Norm'] = float(final_score_dict['Final Score']) / 10 + score_pth = eval_file.replace('.xlsx', '_score.json') + dump(final_score_dict, score_pth) + logger.info(f'OCRBench_eval successfully finished evaluating {eval_file}, results saved in {score_pth}') + logger.info('Score: ') + for key, value in final_score_dict.items(): + logger.info('{}:{}'.format(key, value)) diff --git a/vlmeval/evaluate/__init__.py b/vlmeval/evaluate/__init__.py new file mode 100644 index 0000000..10248c4 --- /dev/null +++ b/vlmeval/evaluate/__init__.py @@ -0,0 +1,9 @@ +from .yes_or_no import default_rating, MME_rating, YOrN_eval +from .mmvet_eval import MMVet_eval +from .multiple_choice import multiple_choice_eval +from .coco_eval import COCO_eval +from .vqa_eval import VQAEval +from .mathvista_eval import MathVista_eval +from .llavabench import LLaVABench_eval +from .misc import build_judge +from .OCRBench import OCRBench_eval diff --git a/vlmeval/evaluate/coco_eval.py b/vlmeval/evaluate/coco_eval.py new file mode 100644 index 0000000..9ae8f4f --- /dev/null +++ b/vlmeval/evaluate/coco_eval.py @@ -0,0 +1,74 @@ +from vlmeval.smp import * +from pycocoevalcap.bleu.bleu import Bleu +from pycocoevalcap.rouge.rouge import Rouge +from pycocoevalcap.cider.cider import Cider + + +class COCO_Caption_Scorer(): + def __init__(self, ref, gt): + self.ref = ref + self.gt = gt + print('setting up scorers...') + self.scorers = [ + (Bleu(4), ['Bleu_1', 'Bleu_2', 'Bleu_3', 'Bleu_4']), + # (Meteor(), "METEOR"), # need java version 11.0.16+ + (Rouge(), 'ROUGE_L'), + (Cider(), 'CIDEr'), + # (Spice(), "SPICE"), # need java version 11.0.16+ + ] + + def compute_scores(self): + total_scores = {} + for scorer, method in self.scorers: + print('computing %s score...' % (scorer.method())) + score, scores = scorer.compute_score(self.gt, self.ref) + if type(method) == list: + for sc, scs, m in zip(score, scores, method): + print('%s: %0.3f' % (m, sc * 100)) + total_scores['Bleu'] = [x * 100 for x in score] + else: + print('%s: %0.3f' % (method, score * 100)) + total_scores[method] = score * 100 + + print('*****DONE*****') + for key, value in total_scores.items(): + print('{}:{}'.format(key, value)) + return total_scores + + +def COCO_eval(eval_file, nproc=4, verbose=False): + logger = get_logger('Evaluation') + + data = load(eval_file) + + lt = len(data) + lines = [data.iloc[i] for i in range(lt)] + ref = {} + gt = {} + for i, line in enumerate(lines): + ref[str(i)] = [str(line['prediction'])] + gt[str(i)] = eval(line['answer']) + + scorer = COCO_Caption_Scorer(ref, gt) + coco_caption_score_dict = scorer.compute_scores() + + score_pth = eval_file.replace('.xlsx', '_score.json') + dump(coco_caption_score_dict, score_pth) + logger.info(f'COCO_eval successfully finished evaluating {eval_file}, results saved in {score_pth}') + logger.info('Score: ') + for key, value in coco_caption_score_dict.items(): + logger.info('{}:{}'.format(key, value)) + + +def parse_args(): + parser = argparse.ArgumentParser(description='Inference LLM Answers. ') + parser.add_argument('--data', type=str, help='The question set for inference, in excel / tsv / json format. ') + parser.add_argument('--nproc', type=int, default=4) + parser.add_argument('--verbose', action='store_true') + args = parser.parse_args() + return args + + +if __name__ == '__main__': + args = parse_args() + COCO_eval(eval_file=args.data, nproc=args.nproc, verbose=args.verbose) diff --git a/vlmeval/evaluate/llavabench.py b/vlmeval/evaluate/llavabench.py new file mode 100644 index 0000000..c44b203 --- /dev/null +++ b/vlmeval/evaluate/llavabench.py @@ -0,0 +1,113 @@ +import argparse +import numpy as np +import pandas as pd +import os.path as osp +from vlmeval.evaluate.misc import build_judge +from vlmeval.smp import get_logger, load, dump, defaultdict +from vlmeval.utils import track_progress_rich + +rule_dict = { + 'llava_bench_conv': {'role': 'Assistant', 'prompt': 'We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above. The user asks the question on observing an image. For your reference, the visual content in the image is represented with a few sentences describing the image. \nPlease rate the helpfulness, relevance, accuracy, level of details of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance.\nPlease first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space.\nIn the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment.'}, # noqa: E501 + 'llava_bench_detail': {'role': 'Assistant', 'prompt': 'We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above. The user asks the question on observing an image. For your reference, the visual content in the image is represented with a few sentences describing the image. \nPlease rate the helpfulness, relevance, accuracy, level of details of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance.\nPlease first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space.\nIn the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment.'}, # noqa: E501 + 'llava_bench_complex': {'role': 'Assistant', 'prompt': 'We would like to request your feedback on the performance of two AI assistants in response to the user question displayed above. The user asks the question on observing an image. For your reference, the visual content in the image is represented with a few sentences describing the image. \nPlease rate the helpfulness, relevance, accuracy, level of details of their responses. Each assistant receives an overall score on a scale of 1 to 10, where a higher score indicates better overall performance.\nPlease first output a single line containing only two values indicating the scores for Assistant 1 and 2, respectively. The two scores are separated by a space.\nIn the subsequent line, please provide a comprehensive explanation of your evaluation, avoiding any potential bias and ensuring that the order in which the responses were presented does not affect your judgment.'} # noqa: E501 +} + + +def get_eval(judge, content): + return judge.generate(content) + + +def parse_score(review): + logger = get_logger('Evaluation') + try: + score_pair = review.split('\n')[0] + score_pair = score_pair.replace(',', ' ') + sp = score_pair.split(' ') + if len(sp) == 2: + return [float(sp[0]), float(sp[1])] + else: + logger.error('error', review) + return [-1, -1] + except Exception as e: + logger.error(e, 'error', review) + return [-1, -1] + + +def build_prompt(line): + cap_str = line['caption'] + question = line['question'] + ans1 = line['gpt4_ans'] + ans2 = line['prediction'] + category = 'llava_bench_' + line['category'] + rule = rule_dict[category] + role, prompt = rule['role'], rule['prompt'] + + content = (f'[Context]\n{cap_str}\n\n' + f'[Question]\n{question}\n\n' + f'[{role} 1]\n{ans1}\n\n[End of {role} 1]\n\n' + f'[{role} 2]\n{ans2}\n\n[End of {role} 2]\n\n' + f'[System]\n{prompt}\n\n') + return content + + +def LLaVABench_atomeval(model, prompt): + review = get_eval(model, prompt) + scores = parse_score(review) + return scores + + +def LLaVABench_score(data): + cates = ['overall'] + list(set(data['category'])) + ret = defaultdict(list) + + for c in cates: + ret['split'].append(c) + sub = data[data['category'] == c] if c != 'overall' else data + ret['Relative Score (main)'].append(np.mean(sub['score']) / np.mean(sub['gpt4_score']) * 100) + ret['VLM Score'].append(np.mean(sub['score']) * 10) + ret['GPT4 Score'].append(np.mean(sub['gpt4_score']) * 10) + return pd.DataFrame(ret) + + +def LLaVABench_eval(eval_file, **judge_kwargs): + suffix = '.' + eval_file.split('.')[-1] + record_file = eval_file.replace(suffix, '_openai_result' + suffix) + score_file = eval_file.replace(suffix, '_score.csv') + nproc = judge_kwargs.pop('nproc', 4) + + if not osp.exists(record_file): + data = load(eval_file) + lines = [data.iloc[i] for i in range(len(data))] + model = build_judge( + temperature=0.2, + system_prompt='You are a helpful and precise assistant for checking the quality of the answer.', + **judge_kwargs) + prompts = [build_prompt(line) for line in lines] + tups = [(model, prompt) for prompt in prompts] + scores = track_progress_rich(LLaVABench_atomeval, tups, nproc=nproc, chunksize=nproc) + data['gpt4_score'] = [x[0] for x in scores] + data['score'] = [x[1] for x in scores] + dump(data, record_file) + + data = load(record_file) + ret = LLaVABench_score(data).round(1) + print(ret) + dump(ret, score_file) + return ret + + +def parse_args(): + parser = argparse.ArgumentParser(description='LLaVABench Evaluation. ') + parser.add_argument('data', type=str, help='The question set for inference, in excel / tsv / json format. ') + parser.add_argument( + '--model', type=str, help='The LLM (GPT) used for inference. ', default='gpt-4-turbo', + choices=['gpt-4-0613', 'gpt-4-turbo', 'chatgpt-1106', 'chatgpt-0613', 'gpt-4-0314']) + parser.add_argument('--nproc', type=int, default=4) + parser.add_argument('--verbose', action='store_true') + args = parser.parse_args() + return args + + +if __name__ == '__main__': + args = parse_args() + LLaVABench_eval(eval_file=args.data, model=args.model, nproc=args.nproc, verbose=args.verbose) diff --git a/vlmeval/evaluate/mathvista_eval.py b/vlmeval/evaluate/mathvista_eval.py new file mode 100644 index 0000000..b84e967 --- /dev/null +++ b/vlmeval/evaluate/mathvista_eval.py @@ -0,0 +1,234 @@ +from vlmeval.evaluate.misc import build_judge +from vlmeval.smp import * +from vlmeval.utils import track_progress_rich +from vlmeval.utils.matching_util import can_infer + + +def get_gpt4_ICE(): + example_1 = """ +Hint: Please answer the question requiring an integer answer and provide the final value, +e.g., 1, 2, 3, at the end.\n +Question: Which number is missing?\n +Model response: The number missing in the sequence is 14.\n +Extracted answer: 14 +""" + + example_2 = """ +Hint: Please answer the question requiring a floating-point number with one decimal place and provide the final value, +e.g., 1.2, 1.3, 1.4, at the end.\n +Question: What is the fraction of females facing the camera?\n +Model response: The fraction of females facing the camera is 0.6, +which means that six out of ten females in the group are facing the camera.\n +Extracted answer: 0.6 +""" + + example_3 = """ +Hint: Please answer the question requiring a floating-point number with two decimal places and provide the final value, +e.g., 1.23, 1.34, 1.45, at the end.\n +Question: How much money does Luca need to buy a sour apple candy and a butter-scotch candy? (Unit: $)\n +Model response: Luca needs $1.45 to buy a sour apple candy and a butterscotch candy.\n +Extracted answer: 1.45 +""" + + example_4 = """ +Hint: Please answer the question requiring a Python list as an answer and provide the final list, +e.g., [1, 2, 3], [1.2, 1.3, 1.4], at the end.\n +Question: Between which two years does the line graph saw its maximum peak?\n +Model response: The line graph saw its maximum peak between 2007 and 2008.\n +Extracted answer: [2007, 2008] +""" + + example_5 = """ +Hint: Please answer the question and provide the correct option letter, e.g., A, B, C, D, at the end.\n +Question: What fraction of the shape is blue?\n +Choices: (A) 3/11 (B) 8/11 (C) 6/11 (D) 3/5\n +Model response: The correct answer is (B) 8/11.\n +Extracted answer: B +""" + + return [example_1, example_2, example_3, example_4, example_5] + + +def build_mathvista_gpt4_prompt(line): + task_description = """ +Please read the following example. +Then extract the answer from the model response and type it at the end of the prompt.\n +""" + question = line['question'] + prediction = str(line['prediction']) + prompt = task_description + examples = get_gpt4_ICE() + for example in examples: + prompt += example + '\n' + prompt += question + '\n' + prompt += 'Model respone: ' + prediction + prompt += 'Extracted answer:' + return prompt + + +def list_to_dict(lst): + return {chr(65 + i): val for i, val in enumerate(lst)} + + +def post_check(line, prefetch=False): + res = None + ans = line['answer'] + response = line['prediction'] if prefetch else line['res'] + try: + if line['question_type'] == 'multi_choice': + ans = line['answer_option'] + choices = list_to_dict(eval(line['choices'])) + res = can_infer(response, choices) + if prefetch: + return res + else: + if line['answer_type'] == 'integer': + res = int(response) + ans = int(line['answer']) + elif line['answer_type'] == 'float': + res = float(response) + ans = float(line['answer']) + else: + res = str(res) + ans = str(ans) + except ValueError: + pass + + if res == ans: + return res if prefetch else True + else: + return False + + +def MathVista_auxeval(model, line): + prompt = build_mathvista_gpt4_prompt(line) + log = '' + retry = 5 + if post_check(line, prefetch=True): + res = post_check(line, prefetch=True) + return dict(log='Prefetch succeed', res=res) + for i in range(retry): + prediction = line['prediction'] + res = model.generate(prompt, temperature=i * 0.5) + if res is None: + log += f'Try {i}: output is {prediction}, failed to parse.\n' + else: + log += 'Succeed' + return dict(log=log, res=res) + log += 'All 5 retries failed.\n' + return dict(log=log, res='') + + +def MathVista_acc(result_file): + data = load(result_file) + tot = defaultdict(lambda: 0) + fetch = defaultdict(lambda: 0) + hit = defaultdict(lambda: 0) + lt = len(data) + skill_list = [] + for i in range(lt): + item = data.iloc[i] + cate = item['task'] + tot['Overall'] += 1 + try: + skills = eval(item['skills']) + except SyntaxError: + skills = [item['skills']] + for skill in skills: + if skill not in skill_list: + skill_list.append(skill) + tot[skill] += 1 + tot[cate] += 1 + if item['log'] == 'Prefetch succeed': + fetch['Overall'] += 1 + fetch[cate] += 1 + for skill in skills: + fetch[skill] += 1 + if post_check(item, prefetch=False): + hit['Overall'] += 1 + hit[cate] += 1 + for skill in skills: + hit[skill] += 1 + + res = defaultdict(list) + for k in tot.keys(): + res['Task&Skill'].append(k) + res['tot'].append(tot[k]) + res['prefetch'].append(fetch[k]) + res['hit'].append(hit[k]) + res['prefetch_rate'].append(fetch[k] / tot[k] * 100) + res['acc'].append(hit[k] / tot[k] * 100) + res = pd.DataFrame(res) + return res + + +def MathVista_eval(eval_file, **judge_kwargs): + logger = get_logger('Evaluation') + model = judge_kwargs['model'] + + suffix = eval_file.split('.')[-1] + storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx') + tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl') + nproc = judge_kwargs.pop('nproc', 4) + + if osp.exists(storage): + logger.warning(f'GPT scoring file {storage} already exists, will reuse it in MathVista_eval. ') + else: + data = load(eval_file) + model = build_judge(max_tokens=128, **judge_kwargs) + lt = len(data) + lines = [data.iloc[i] for i in range(lt)] + tups = [(model, line) for line in lines] + indices = [line['index'] for line in lines] + + ans = {} + if osp.exists(tmp_file): + ans = load(tmp_file) + tups = [x for x, i in zip(tups, indices) if i not in ans] + indices = [i for i in indices if i not in ans] + + if len(indices): + new_results = track_progress_rich( + MathVista_auxeval, tups, nproc=nproc, chunksize=nproc, + keys=indices, save=tmp_file) + ans = load(tmp_file) + for k, v in zip(indices, new_results): + assert k in ans + assert ans[k]['log'] == v['log'] and ans[k]['res'] == v['res'] + + log_map, res_map = {}, {} + all_inds = [line['index'] for line in lines] + for k in all_inds: + log_map[k] = ans[k]['log'] + res_map[k] = ans[k]['res'] + data['res'] = [res_map[idx] for idx in data['index']] + data['log'] = [log_map[idx] for idx in data['index']] + dump(data, storage) + + score = MathVista_acc(storage) + score_pth = storage.replace('.xlsx', '_score.csv') + + dump(score, score_pth) + logger.info(f'MathVista_eval successfully finished evaluating {eval_file}, results saved in {score_pth}') + logger.info('Score: ') + logger.info(score) + + +def parse_args(): + parser = argparse.ArgumentParser(description='Inference LLM Answers. ') + parser.add_argument('data', type=str, help='The question set for inference, in excel / tsv / json format. ') + parser.add_argument( + '--model', + type=str, + help='The LLM (GPT) used for inference. ', + default='gpt-4-turbo', + choices=['gpt-4-0613', 'gpt-4-turbo', 'chatgpt-1106', 'chatgpt-0613']) + parser.add_argument('--nproc', type=int, default=4) + parser.add_argument('--verbose', action='store_true') + args = parser.parse_args() + return args + + +if __name__ == '__main__': + args = parse_args() + MathVista_eval(eval_file=args.data, model=args.model, nproc=args.nproc, verbose=args.verbose) diff --git a/vlmeval/evaluate/misc.py b/vlmeval/evaluate/misc.py new file mode 100644 index 0000000..ddf0c9e --- /dev/null +++ b/vlmeval/evaluate/misc.py @@ -0,0 +1,29 @@ +import os +from vlmeval.api import OpenAIWrapper, OpenAIWrapperInternal +from vlmeval.smp import load_env + +INTERNAL = os.environ.get('INTERNAL', 0) + + +def build_judge(**kwargs): + model = kwargs.pop('model', None) + load_env() + LOCAL_LLM = os.environ.get('LOCAL_LLM', None) + if LOCAL_LLM is None: + model_map = { + 'gpt-4-turbo': 'gpt-4-1106-preview', + 'gpt-4-0613': 'gpt-4-0613', + 'gpt-4-0314': 'gpt-4-0314', + 'gpt-4-0125': 'gpt-4-0125-preview', + 'chatgpt-1106': 'gpt-3.5-turbo-1106', + 'chatgpt-0613': 'gpt-3.5-turbo-0613', + 'chatgpt-0125': 'gpt-3.5-turbo-0125' + } + model_version = model_map[model] + else: + model_version = LOCAL_LLM + if INTERNAL: + model = OpenAIWrapperInternal(model_version, **kwargs) + else: + model = OpenAIWrapper(model_version, **kwargs) + return model diff --git a/vlmeval/evaluate/mmvet_eval.py b/vlmeval/evaluate/mmvet_eval.py new file mode 100644 index 0000000..0c3868a --- /dev/null +++ b/vlmeval/evaluate/mmvet_eval.py @@ -0,0 +1,185 @@ +from vlmeval.evaluate.misc import build_judge +from vlmeval.smp import * +from vlmeval.utils import track_progress_rich + + +def build_mmvet_gpt4_prompt(line): + question = line['question'] + gt = str(line['answer']) + prediction = str(line['prediction']) + prompt = """ +Compare the ground truth and prediction from AI models, to give a correctness score for the prediction. + in the ground truth means it is totally right +only when all elements in the ground truth are present in the prediction, +and means it is totally right when any one element in the ground truth is present in the prediction. +The correctness score is 0.0 (totally wrong), 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, or 1.0 (totally right). +Just complete the last space of the correctness score. + +Question | Ground truth | Prediction | Correctness +--- | --- | --- | --- +What is x in the equation? | -1 -5 | x = 3 | 0.0 +What is x in the equation? | -1 -5 | x = -1 | 0.5 +What is x in the equation? | -1 -5 | x = -5 | 0.5 +What is x in the equation? | -1 -5 | x = -5 or 5 | 0.5 +What is x in the equation? | -1 -5 | x = -1 or x = -5 | 1.0 +Can you explain this meme? | This meme is poking fun at the fact that the names of the countries +Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, +while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues +because the names of these countries do not accurately represent their landscapes. | +The meme talks about Iceland and Greenland. It's pointing out that despite their names, +Iceland is not very icy and Greenland isn't very green. | 0.4 +Can you explain this meme? | This meme is poking fun at the fact that the names of the countries +Iceland and Greenland are misleading. Despite its name, Iceland is known for its beautiful green landscapes, +while Greenland is mostly covered in ice and snow. The meme is saying that the person has trust issues +because the names of these countries do not accurately represent their landscapes. | +The meme is using humor to point out the misleading nature of Iceland's and Greenland's names. +Iceland, despite its name, has lush green landscapes while Greenland is mostly covered in ice and snow. +The text 'This is why I have trust issues' is a playful way to suggest +that these contradictions can lead to distrust or confusion. +The humor in this meme is derived from the unexpected contrast between the names of the countries +and their actual physical characteristics. | 1.0 +""" + gpt4_prompt = prompt + '\n' + ' | '.join( + [question, gt.replace('', ' ').replace('', ' '), prediction, '']) + return gpt4_prompt + + +def MMVet_auxeval(model, line): + def float_cvt(s): + try: + return float(s) + except ValueError: + return None + + prompt = build_mmvet_gpt4_prompt(line) + log = '' + retry = 5 + for i in range(retry): + output = model.generate(prompt, temperature=i * 0.5) + score = float_cvt(output) + if score is None: + log += f'Try {i}: output is {output}, failed to parse.\n' + elif score < 0 or score > 1: + log += f'Try {i}: output is {output}, invalid score: {score}.\n' + else: + log += 'Succeed' + return dict(log=log, score=score) + log += 'All 5 retries failed.\n' + return dict(log=log, score=0.0) + + +def MMVet_acc(result_file): + data = load(result_file) + tot = defaultdict(lambda: 0) + score = defaultdict(lambda: 0) + lt = len(data) + cate2_list = [] + for i in range(lt): + item = data.iloc[i] + cate = item['category'] + cate2 = cate.replace(',', '_') + if cate2 not in cate2_list: + cate2_list.append(cate2) + grade = float(item['score']) + cate_list = ['rec', 'ocr', 'know', 'gen', 'spat', 'math'] + for capa in cate_list: + if capa in cate: + tot[capa] += 1 + score[capa] += grade + tot['Overall'] += 1 + tot[cate2] += 1 + score['Overall'] += grade + score[cate2] += grade + + res = defaultdict(list) + res2 = defaultdict(list) + cate_list.append('Overall') + cate2_list.append('Overall') + for k in cate_list: + res['Category'].append(k) + res['tot'].append(tot[k]) + res['acc'].append(score[k] / tot[k] * 100) + for v in cate2_list: + res2['Category'].append(v) + res2['tot'].append(tot[v]) + res2['acc'].append(score[v] / tot[v] * 100) + res = pd.DataFrame(res) + res2 = pd.DataFrame(res2) + return res, res2 + + +def MMVet_eval(eval_file, **judge_kwargs): + logger = get_logger('Evaluation') + + suffix = eval_file.split('.')[-1] + model = judge_kwargs['model'] + storage = eval_file.replace(f'.{suffix}', f'_{model}.xlsx') + tmp_file = eval_file.replace(f'.{suffix}', f'_{model}.pkl') + nproc = judge_kwargs.pop('nproc', 4) + if osp.exists(storage): + logger.warning(f'GPT scoring file {storage} already exists, will reuse it in MMVet_eval. ') + else: + data = load(eval_file) + model = build_judge(max_tokens=3, **judge_kwargs) + + lt = len(data) + lines = [data.iloc[i] for i in range(lt)] + tups = [(model, line) for line in lines] + indices = [line['index'] for line in lines] + + ans = {} + if osp.exists(tmp_file): + ans = load(tmp_file) + tups = [x for x, i in zip(tups, indices) if i not in ans] + indices = [i for i in indices if i not in ans] + + if len(indices): + new_results = track_progress_rich( + MMVet_auxeval, tups, nproc=nproc, chunksize=nproc, + keys=indices, save=tmp_file) + ans = load(tmp_file) + for k, v in zip(indices, new_results): + assert k in ans + assert ans[k]['log'] == v['log'] and ans[k]['score'] == v['score'] + + log_map, score_map = {}, {} + all_inds = [line['index'] for line in lines] + for k in all_inds: + log_map[k] = ans[k]['log'] + score_map[k] = ans[k]['score'] + data['score'] = [score_map[idx] for idx in data['index']] + data['log'] = [log_map[idx] for idx in data['index']] + dump(data, storage) + + score, score_fine = MMVet_acc(storage) + score_pth = storage.replace('.xlsx', '_score.csv') + score_fine_pth = storage.replace('.xlsx', '_score_fine.csv') + + dump(score, score_pth) + dump(score_fine, score_fine_pth) + logger.info( + f'MMVet_eval successfully finished evaluating {eval_file}, ' + f'results saved in {score_pth} and {score_fine_pth}' + ) + logger.info('Score: ') + logger.info(score) + + +def parse_args(): + parser = argparse.ArgumentParser(description='Inference LLM Answers. ') + parser.add_argument('data', type=str, help='The question set for inference, in excel / tsv / json format. ') + parser.add_argument( + '--model', + type=str, + help='The LLM (GPT) used for inference. ', + default='gpt-4-turbo', + choices=['gpt-4-0613', 'gpt-4-turbo', 'chatgpt-1106', 'chatgpt-0613']) + parser.add_argument('--nproc', type=int, default=4) + parser.add_argument('--verbose', action='store_true') + args = parser.parse_args() + return args + + +if __name__ == '__main__': + args = parse_args() + MMVet_eval(eval_file=args.data, model=args.model, nproc=args.nproc, verbose=args.verbose) diff --git a/vlmeval/evaluate/multiple_choice.py b/vlmeval/evaluate/multiple_choice.py new file mode 100644 index 0000000..b806a6f --- /dev/null +++ b/vlmeval/evaluate/multiple_choice.py @@ -0,0 +1,448 @@ +import os.path as osp +import pandas as pd +from tqdm import tqdm +from vlmeval.evaluate.misc import build_judge +from vlmeval.utils import can_infer, track_progress_rich, TSVDataset +from vlmeval.smp import * +import numpy as np + +INTERNAL = os.environ.get('INTERNAL', 0) + +# abbrs = { +# 'coarse_perception': 'CP', +# 'finegrained_perception (instance-level)': 'FP-S', +# 'finegrained_perception (cross-instance)': 'FP-C', +# 'logic_reasoning': 'LR', +# 'relation_reasoning': 'RR', +# 'attribute_reasoning': 'AR' +# } + +# MMT-Bench abbrs +abbrs = { + # 'coarse_perception': 'CP', + # 'finegrained_perception (instance-level)': 'FP-S', + # 'finegrained_perception (cross-instance)': 'FP-C', + # 'logic_reasoning': 'LR', + # 'relation_reasoning': 'RR', + # 'attribute_reasoning': 'AR', + "visual_recognition": "VR", + "localization": "Loc", + "ocr": "OCR", + "counting": "Count", + "hallucination": "HLN", + "image_retrieval": "IR", + "threed": "3D", + "visual_captioning": "VC", + "visual_grounding": "VG", + "doc_understanding": "DU", + "action_recognition": "AR", + "pixel_level_perception": "PLP", + "image-to-image_translation": "I2IT", + "relation_reasoning": "RR", + "intelligence_quotient_test": "IQT", + "emotion": "Emo", + "visual_illusion": "VI", + "meme_understanding": "MemU", + "visual_prompt_understanding": "VPU", + "anomaly_detection": "AND", + "keypoint_detection": "KD", + "visual_commonsense_reasoning": "VCR", + "image_evaluation_judgement": "IEJ", + "multiple_image_analysis": "MIA", + "cross_image_matching": "CIM", + "temporal_understanding": "TU", + "visual_code": "VP", + "medical_understanding": "MedU", + "autonomous_driving": "AUD", + "discipline_knowledge_reasoning": "DKR", + "embodied_ai": "EA", + "gui_navigation": "GN" +} + + +def MMMU_preproc(data): + logger = get_logger('Evaluation') + cnt = 0 + As, Bs, Ans = list(data['A']), list(data['B']), list(data['answer']) + lt = len(data) + for i in range(lt): + if pd.isna(As[i]): + As[i] = Ans[i] + Bs[i] = 'Other Answers' + cnt += 1 + logger.info(f'During MMMU_preproc in Evaluation, {cnt} open questions are re-formulated to multi-choice ones. ') + data['A'] = As + data['B'] = Bs + return data + + +def report_acc(df): + # assert group in [None, 'category', 'l2-category'] + res = defaultdict(list) + + if 'split' in df: + splits = list(set(df['split'])) + res['split'] = splits + + else: + df['split'] = ['none'] * len(df) + res['split'] = ['none'] + + for group in [None, 'l2-category', 'category']: + if group is None: + res['Overall'] = [np.mean(df[df['split'] == sp]['hit']) for sp in res['split']] + res['Overall'].extend([np.mean(df['hit'])]) + elif group not in df: + continue + elif group == "category": + abilities = list(set(df[group])) + abilities.sort() + for ab in abilities: + ab_name = ab + sub_df = df[df[group] == ab] + res[ab_name] = [np.mean(sub_df[sub_df['split'] == sp]['hit']) for sp in res['split']] + res[ab_name].extend([np.mean(sub_df['hit'])]) + else: + abilities = list(set(df[group])) + abilities.sort() + for ab in abilities: + ab_name = abbrs[ab] if ab in abbrs else ab + sub_df = df[df[group] == ab] + res[ab_name] = [np.mean(sub_df[sub_df['split'] == sp]['hit']) for sp in res['split']] + res[ab_name].extend([np.mean(sub_df['hit'])]) + res['split'].append('ALL') + # for key, value in res.items(): + # print(key, value, len(value)) + return pd.DataFrame(res) + + +def build_prompt(question, options, prediction): + tmpl = ( + 'You are an AI assistant who will help me to match ' + 'an answer with several options of a single-choice question. ' + 'You are provided with a question, several options, and an answer, ' + 'and you need to find which option is most similar to the answer. ' + 'If the meaning of all options are significantly different from the answer, output Z. ' + 'Your should output a single uppercase character in A, B, C, D (if they are valid options), and Z. \n' + 'Example 1: \n' + 'Question: What is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n' + 'Answer: a cute teddy bear\nYour output: A\n' + 'Example 2: \n' + 'Question: What is the main object in image?\nOptions: A. teddy bear B. rabbit C. cat D. dog\n' + 'Answer: Spider\nYour output: Z\n' + 'Example 3: \n' + 'Question: {}?\nOptions: {}\nAnswer: {}\nYour output: ' + ) + return tmpl.format(question, options, prediction) + + +def build_prompt_cn(question, options, prediction): + tmpl = ( + '你是一个帮助我匹配答案与单选题中多个选项的 AI 助手。' + '你会被提供：一个问题，多个选项，一个答案。你的任务是找到与答案意义最相近的选项。' + '如果所有选项的意义都与答案显著不同，则输出 Z。' + '你应该输出一个单个的大写字母，例如 A, B, C, D（如果它们是有效选项），或 Z。' + '例 1:' + '问题: 图中最主要的物体是什么?\n选项: A. 泰迪熊 B. 兔子 C. 猫 D. 狗\n答案: 一只可爱的泰迪熊\n输出: A\n' + '例 2: \n' + '问题: 图中最主要的物体是什么?\n选项: A. 泰迪熊 B. 兔子 C. 猫 D. 狗\n答案: 蜘蛛\n输出: Z\n' + '例 3: \n' + '问题: {}?\n选项: {}\n答案: {}\n输出: ' + ) + return tmpl.format(question, options, prediction) + + +def build_choices(item): + ret = {} + for ch in string.ascii_uppercase: + if ch in item and (not pd.isna(item[ch])): + ret[ch] = item[ch] + return ret + + +def prefetch_answer(item): + choices = build_choices(item) + return can_infer(item['prediction'], choices) + + +def extract_answer_from_item(model, item): + logger = get_logger('Evaluation') + # It will return: (pred, raw, llm_time) + choices = build_choices(item) + option_str = build_option_str(choices) + + if cn_string(item['question']): + prompt = build_prompt_cn(item['question'], option_str, item['prediction']) + else: + prompt = build_prompt(item['question'], option_str, item['prediction']) + retry = 3 + + ret = can_infer(item['prediction'], choices) + if ret: + return dict(opt=ret, log=item['prediction']) + + while retry: + ans = model.generate(prompt) + if 'Failed to obtain answer via API' in ans: + logger.warning('GPT API failed to answer. ') + else: + ret = can_infer(ans, choices) + if ret: + return dict(opt=ret, log=ans) + else: + logger.warning(f'Output includes 0 / > 1 letter among candidates {set(choices)} and Z: {ans}') + retry -= 1 + + if retry == 0: + options = list(choices) + ['Z'] if 'Z' not in choices else [] + return dict(opt=rd.choice(options), log='Failed to predict, thus randomly generate one. ') + + +def prefetch_sub_data(sub_data, answer_map, verbose=False): + lt = len(sub_data) + GT, PRED = [], [] + for i in range(lt): + item = sub_data.iloc[i] + idx = item['index'] + GT.append(answer_map[idx]) + PRED.append(prefetch_answer(item)) + if PRED[-1] and (GT[-1] != PRED[-1]): + log = ( + f'Failed in Prefetching Rolling {i}: Answer is {GT[-1]}, ' + f"Prediction is {item['prediction']}, Pre-fetched is {PRED[-1]}. " + ) + return dict(hit=0, log=log) + flag = True + for g, p in zip(GT, PRED): + if g != p: + flag = False + ret = (dict(hit=1, log='Succeed During Pre-fetching'), ) if flag else (None, ) + ret = ret + (GT, PRED) if verbose else ret + return ret if len(ret) > 1 else ret[0] + + +def eval_sub_data(model, sub_data, answer_map): + res, GT, PRED = prefetch_sub_data(sub_data, answer_map, verbose=True) + if res is not None: + return res + + lt = len(sub_data) + log = '' + for i in range(lt): + if PRED[i]: + log += f'Rolling {i} Matched.\n' + else: + res = extract_answer_from_item(model, sub_data.iloc[i]) + opt, match_log = res['opt'], res['log'] + PRED[i] = opt + if PRED[i] != GT[i]: + log += ( + f"Failed in Rolling {i}: Answer is {GT[i]}; Prediction is {sub_data.iloc[i]['prediction']}; " + f'Pre-fetched is {PRED[i]}; Match Log is {match_log}.\n' + ) + return dict(hit=0, log=log) + else: + log += ( + f"Rolling {i}: Answer is {GT[i]}, Prediction is {sub_data.iloc[i]['prediction']}, " + f'Pre-fetched is {PRED[i]}.\n' + ) + + return dict(hit=1, log=log) + + +def eval_data_groups(model, data_groups, answer_map, result, result_file, nproc=16): + prefetched = [prefetch_sub_data(g, answer_map, verbose=False) for g in data_groups] + remain = [] + for dg, pf in zip(data_groups, prefetched): + if pf: + result[dg.iloc[0]['index'] % 1e6] = pf + else: + remain.append(dg) + dump(result, result_file) + tups = [(model, x, answer_map) for x in remain] + keys = [x.iloc[0]['index'] % 1e6 for x in remain] + if len(tups) == 0: + return + + if model is None: + logger = get_logger('Evaluation') + logger.warning('Exact Matching mode, will not do GPT-based answer matching. ') + for k in keys: + result[k] = dict( + hit=0, log='Failed in Prefetch, no GPT-based answer matching under `exact_matching` policy.') + dump(result, result_file) + return + + res = track_progress_rich( + eval_sub_data, + tups, + nproc=nproc, + chunksize=nproc, + save=result_file, + keys=keys) + result = load(result_file) + for k, v in zip(keys, res): + if k in result: + assert result[k]['hit'] == v['hit'] and result[k]['log'] == v['log'] + else: + result[k] = v + dump(result, result_file) + + +def multiple_choice_eval(eval_file, dataset='default', **judge_kwargs): + logger = get_logger('Evaluation') + + # assert dataset is not None + if dataset == 'MMBench_TEST_CN': + dataset = 'MMBench_CN' + elif dataset == 'MMBench_TEST_EN': + dataset = 'MMBench' + nproc = judge_kwargs.pop('nproc', 4) + + if listinstr(['mmbench', 'ccbench'], dataset.lower()): + data = load(eval_file) + data['index'] = [int(x) for x in data['index']] + dump(data, eval_file) + + rd.seed(2680) + suffix = eval_file.split('.')[-1] + model = judge_kwargs['model'] + assert model in ['chatgpt-0613', 'exact_matching', 'gpt-4-0125'] + name_str_map = { + 'chatgpt-0613': 'openai', + 'gpt-4-0125': 'gpt4' + } + name_str = name_str_map[model] if model in name_str_map else model + + if model == 'exact_matching': + model = None + else: + if INTERNAL or gpt_key_set(): + model = build_judge(**judge_kwargs) + else: + logger.error('OPENAI_API_KEY is not set properly, will use exact matching for evaluation') + model = None + + logger.info(f'Evaluating {eval_file}') + result_file = eval_file.replace(f'.{suffix}', f'_{name_str}_result.pkl') + result = {} + if osp.exists(result_file): + result = load(result_file) + + data = load(eval_file) + data = data.sort_values(by='index') + data['prediction'] = [str(x) for x in data['prediction']] + for k in data.keys(): + data[k.lower() if k not in list(string.ascii_uppercase) else k] = data.pop(k) + + if dataset != 'default': + meta = TSVDataset(dataset).data + else: + logger.warning('Dataset is not provided, try to use the original `eval_file` as meta data. ') + meta = load(eval_file) + assert 'index' in meta and 'answer' in meta, 'Essentail columns missing in the eval_file.' + + answer_map = {i: c for i, c in zip(meta['index'], meta['answer'])} + cate_map = {i: c for i, c in zip(meta['index'], meta['category'])} if 'category' in meta else None + l2_cate_map = {i: c for i, c in zip(meta['index'], meta['l2-category'])} if 'l2-category' in meta else None + split_map = {i: c for i, c in zip(meta['index'], meta['split'])} if 'split' in meta else None + + if cate_map is not None and np.all([pd.isna(x) for x in cate_map.values()]): + cate_map = None + if l2_cate_map is not None and np.all([pd.isna(x) for x in l2_cate_map.values()]): + l2_cate_map = None + if split_map is not None and np.all([pd.isna(x) for x in split_map.values()]): + split_map = None + + if listinstr(['MMMU'], dataset): + data = MMMU_preproc(data) + answer_map = {k: (v if v in list(string.ascii_uppercase) else 'A') for k, v in answer_map.items()} + + data = data[data['index'].isin(answer_map)] + data_main = data[data['index'] < int(1e6)] + meta_idx_set = set(meta['index']) + data_main = data_main[data_main['index'].isin(meta_idx_set)] + + lt = len(data_main) + hit, tot = 0, 0 + + data_groups = [] + for i in tqdm(range(lt)): + # Dealing with the normal part + item_main = data_main.iloc[i] + idx = item_main['index'] + + if idx in result: + correct = result[idx]['hit'] + assert correct in [0, 1] + hit += correct + tot += 1 + continue + + sub_data = data[data['index'] % int(1e6) == idx] + data_groups.append(sub_data) + + if len(data_groups): + eval_data_groups( + model=model, + data_groups=data_groups, + answer_map=answer_map, + nproc=nproc, + result=result, + result_file=result_file) + + tmp_pth = f'/tmp/{timestr()}.xlsx' + dump(data_main, tmp_pth) + data_main = load(tmp_pth) + + res = load(result_file) + indices = data_main['index'] + + data_main['hit'] = [res[i]['hit'] for i in indices] + data_main['log'] = [res[i]['log'] for i in indices] + + main_idx = data_main['index'] + if cate_map is not None: + data_main['category'] = [cate_map[i] for i in main_idx] + if l2_cate_map is not None: + data_main['l2-category'] = [l2_cate_map[i] for i in main_idx] + if split_map is not None: + data_main['split'] = [split_map[i] for i in indices] + + # load split + dump(data_main, eval_file.replace(f'.{suffix}', f'_{name_str}_result.{suffix}')) + data_main = load(eval_file.replace(f'.{suffix}', f'_{name_str}_result.{suffix}')) + + acc = report_acc(data_main) + score_file = eval_file.replace(f'.{suffix}', '_acc.csv') + dump(acc, score_file) + logger.info(f'multiple_choice_eval successfully finished evaluating {eval_file}, results saved in {score_file}') + logger.info('Score: ') + logger.info(acc) + return acc + + +def parse_args(): + parser = argparse.ArgumentParser(description='Inference LLM Answers. ') + parser.add_argument('data', type=str, help='The question set for inference, in excel / tsv / json format. ') + parser.add_argument( + '--model', + type=str, + help='The LLM (GPT) used for inference. ', + default='chatgpt-0613', + choices=['chatgpt-0613', 'exact_matching', 'gpt-4-0125']) + parser.add_argument( + '--dataset', + type=str, + default='default', + help='The dataset to evaluate') + parser.add_argument('--nproc', type=int, default=6) + parser.add_argument('--verbose', action='store_true') + args = parser.parse_args() + return args + + +if __name__ == '__main__': + args = parse_args() + acc = multiple_choice_eval( + eval_file=args.data, model=args.model, dataset=args.dataset, nproc=args.nproc, verbose=args.verbose) diff --git a/vlmeval/evaluate/vqa_eval.py b/vlmeval/evaluate/vqa_eval.py new file mode 100644 index 0000000..33dc01d --- /dev/null +++ b/vlmeval/evaluate/vqa_eval.py @@ -0,0 +1,340 @@ +# Copyright (c) OpenMMLab. All rights reserved. +# Partly adopted from https://github.com/GT-Vision-Lab/VQA +# Copyright (c) 2014, Aishwarya Agrawal + +import re +from vlmeval.smp import * +from typing import Optional +from functools import partial + + +def _process_digit_article(inText): + outText = [] + tempText = inText.lower().split() + articles = ['a', 'an', 'the'] + manualMap = { + 'none': '0', + 'zero': '0', + 'one': '1', + 'two': '2', + 'three': '3', + 'four': '4', + 'five': '5', + 'six': '6', + 'seven': '7', + 'eight': '8', + 'nine': '9', + 'ten': '10', + } + contractions = { + 'aint': "ain't", + 'arent': "aren't", + 'cant': "can't", + 'couldve': "could've", + 'couldnt': "couldn't", + "couldn'tve": "couldn't've", + "couldnt've": "couldn't've", + 'didnt': "didn't", + 'doesnt': "doesn't", + 'dont': "don't", + 'hadnt': "hadn't", + "hadnt've": "hadn't've", + "hadn'tve": "hadn't've", + 'hasnt': "hasn't", + 'havent': "haven't", + 'hed': "he'd", + "hed've": "he'd've", + "he'dve": "he'd've", + 'hes': "he's", + 'howd': "how'd", + 'howll': "how'll", + 'hows': "how's", + "Id've": "I'd've", + "I'dve": "I'd've", + 'Im': "I'm", + 'Ive': "I've", + 'isnt': "isn't", + 'itd': "it'd", + "itd've": "it'd've", + "it'dve": "it'd've", + 'itll': "it'll", + "let's": "let's", + 'maam': "ma'am", + 'mightnt': "mightn't", + "mightnt've": "mightn't've", + "mightn'tve": "mightn't've", + 'mightve': "might've", + 'mustnt': "mustn't", + 'mustve': "must've", + 'neednt': "needn't", + 'notve': "not've", + 'oclock': "o'clock", + 'oughtnt': "oughtn't", + "ow's'at": "'ow's'at", + "'ows'at": "'ow's'at", + "'ow'sat": "'ow's'at", + 'shant': "shan't", + "shed've": "she'd've", + "she'dve": "she'd've", + "she's": "she's", + 'shouldve': "should've", + 'shouldnt': "shouldn't", + "shouldnt've": "shouldn't've", + "shouldn'tve": "shouldn't've", + "somebody'd": 'somebodyd', + "somebodyd've": "somebody'd've", + "somebody'dve": "somebody'd've", + 'somebodyll': "somebody'll", + 'somebodys': "somebody's", + 'someoned': "someone'd", + "someoned've": "someone'd've", + "someone'dve": "someone'd've", + 'someonell': "someone'll", + 'someones': "someone's", + 'somethingd': "something'd", + "somethingd've": "something'd've", + "something'dve": "something'd've", + 'somethingll': "something'll", + 'thats': "that's", + 'thered': "there'd", + "thered've": "there'd've", + "there'dve": "there'd've", + 'therere': "there're", + 'theres': "there's", + 'theyd': "they'd", + "theyd've": "they'd've", + "they'dve": "they'd've", + 'theyll': "they'll", + 'theyre': "they're", + 'theyve': "they've", + 'twas': "'twas", + 'wasnt': "wasn't", + "wed've": "we'd've", + "we'dve": "we'd've", + 'weve': "we've", + 'werent': "weren't", + 'whatll': "what'll", + 'whatre': "what're", + 'whats': "what's", + 'whatve': "what've", + 'whens': "when's", + 'whered': "where'd", + 'wheres': "where's", + 'whereve': "where've", + 'whod': "who'd", + "whod've": "who'd've", + "who'dve": "who'd've", + 'wholl': "who'll", + 'whos': "who's", + 'whove': "who've", + 'whyll': "why'll", + 'whyre': "why're", + 'whys': "why's", + 'wont': "won't", + 'wouldve': "would've", + 'wouldnt': "wouldn't", + "wouldnt've": "wouldn't've", + "wouldn'tve": "wouldn't've", + 'yall': "y'all", + "yall'll": "y'all'll", + "y'allll": "y'all'll", + "yall'd've": "y'all'd've", + "y'alld've": "y'all'd've", + "y'all'dve": "y'all'd've", + 'youd': "you'd", + "youd've": "you'd've", + "you'dve": "you'd've", + 'youll': "you'll", + 'youre': "you're", + 'youve': "you've", + } + for word in tempText: + word = manualMap.setdefault(word, word) + if word not in articles: + outText.append(word) + for wordId, word in enumerate(outText): + if word in contractions: + outText[wordId] = contractions[word] + outText = ' '.join(outText) + return outText + + +def hit_calculate(result, dataset_name, anls_threshold=0.5): + if listinstr(['TextVQA'], dataset_name): + return [np.mean(x['match']) for x in result] + elif listinstr(['DocVQA', 'InfoVQA'], dataset_name): + # return [1 - np.min(x['match']) >= anls_threshold for x in result] + return [0.0 if 1 - np.min(x['match']) < anls_threshold else 1 - np.min(x['match']) for x in result] + elif listinstr(['ChartQA', 'OCRVQA'], dataset_name): + return [np.max(x['match']) for x in result] + else: # default using vqa_score to calculate score + return [np.mean(x['match']) for x in result] + + +# https://github.com/google-research/pix2struct/blob/main/pix2struct/metrics.py#L81 +def relaxed_correctness(target: str, + prediction: str, + max_relative_change: float = 0.05) -> bool: + """Calculates relaxed correctness. + + The correctness tolerates certain error ratio defined by max_relative_change. + See https://arxiv.org/pdf/2203.10244.pdf, end of section 5.1: + “Following Methani et al. (2020), we use a relaxed accuracy measure for the + numeric answers to allow a minor inaccuracy that may result from the automatic + data extraction process. We consider an answer to be correct if it is within + 5% of the gold answer. For non-numeric answers, we still need an exact match + to consider an answer to be correct.” + + Args: + target: Target string. + prediction: Predicted string. + max_relative_change: Maximum relative change. + + Returns: + Whether the prediction was correct given the specified tolerance. + """ + + def _to_float(text: str) -> Optional[float]: + try: + if text.endswith('%'): + # Convert percentages to floats. + return float(text.rstrip('%')) / 100.0 + else: + return float(text) + except ValueError: + return None + prediction = str(prediction) + target = str(target) + prediction_float = _to_float(prediction) + target_float = _to_float(target) + if prediction_float is not None and target_float: + relative_change = abs(prediction_float - target_float) / abs(target_float) + return relative_change <= max_relative_change + else: + return prediction.lower() == target.lower() + + +def levenshtein_distance(s1, s2): + if len(s1) > len(s2): + s1, s2 = s2, s1 + + distances = range(len(s1) + 1) + for i2, c2 in enumerate(s2): + distances_ = [i2 + 1] + for i1, c1 in enumerate(s1): + if c1 == c2: + distances_.append(distances[i1]) + else: + distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1]))) + distances = distances_ + return distances[-1] + + +def anls_compute(groundtruth, prediction): + gt_answer = ' '.join(groundtruth.strip().lower().split()) + det_answer = ' '.join(prediction.strip().lower().split()) + dist = levenshtein_distance(gt_answer, det_answer) + length = max(len(groundtruth.upper()), len(prediction.upper())) + values = 0.0 if length == 0 else float(dist) / float(length) + return values + + +def process_answer(answer): + answer = answer.replace('\n', ' ') + answer = answer.replace('\t', ' ') + answer = answer.strip() + answer = process_punctuation(answer) + answer = _process_digit_article(answer) + return answer + + +def process_line(line, method='vqa_score'): + ret = {} + if istype(line['answer'], list): + answers = eval(line['answer']) + else: + answers = [line['answer']] + if method == 'vqa_score': + ret['gt'] = [process_answer(x) for x in answers] + ret['pred'] = process_answer(line['prediction']) + ret['match'] = [] + for current_idx, gtAnsDatum in enumerate(ret['gt']): + otherGTAns = [ + item for ret_gt_idx, item in enumerate(ret['gt']) + if ret_gt_idx != current_idx + ] + matchingAns = [ + item for item in otherGTAns if item == ret['pred'] + ] + acc = min(1, float(len(matchingAns)) / 3) + ret['match'].append(acc) + elif method == 'anls': + ret['gt'] = answers + ret['pred'] = line['prediction'] + ret['match'] = [anls_compute(x, ret['pred']) for x in ret['gt']] + elif method == 'relaxed_accuracy': + ret['gt'] = answers + ret['pred'] = line['prediction'].strip() + ret['match'] = [relaxed_correctness(ret['pred'], x) for x in ret['gt']] + elif method == 'accuracy': + ret['gt'] = answers + ret['pred'] = line['prediction'].strip() + ret['match'] = [(1.0 if (x.strip().lower() == ret['pred'].strip().lower()) else 0.0) for x in ret['gt']] + else: # default using vqa_score to calculate score + ret['gt'] = [process_answer(x) for x in answers] + ret['pred'] = process_answer(line['prediction']) + ret['match'] = [x == ret['pred'] for x in ret['gt']] + + return ret + + +def VQAEval(eval_file, dataset_name, **kwargs): + logger = get_logger('Evaluation') + data = load(eval_file) + assert 'answer' in data and 'prediction' in data + data['prediction'] = [str(x) for x in data['prediction']] + data['answer'] = [str(x) for x in data['answer']] + lt = len(data) + pool = mp.Pool(16) + lines = [data.iloc[i] for i in range(lt)] + if listinstr(['TextVQA'], dataset_name): + res = pool.map(partial(process_line, method='vqa_score'), lines) + elif listinstr(['ChartQA'], dataset_name): + res = pool.map(partial(process_line, method='relaxed_accuracy'), lines) + elif listinstr(['OCRVQA'], dataset_name): + res = pool.map(partial(process_line, method='accuracy'), lines) + elif listinstr(['DocVQA', 'InfoVQA'], dataset_name): + res = pool.map(partial(process_line, method='anls'), lines) + else: # default using vqa_score to calculate score + res = pool.map(process_line, lines) + # [np.mean(x['match']) >= full_score_weight for x in res] + hit = hit_calculate(res, dataset_name) + ret = dict() + if 'split' in data: + splits = set(data['split']) + for sp in splits: + sub = [r for l, r in zip(lines, res) if l['split'] == sp] + # [np.mean(x['match']) >= full_score_weight for x in sub] + hit = hit_calculate(sub, dataset_name) + ret[sp] = np.mean(hit) * 100 + sub = [r for l, r in zip(lines, res)] + hit = hit_calculate(sub, dataset_name) + ret['Overall'] = np.mean(hit) * 100 + else: + ret['Overall'] = np.mean(hit) * 100 + if 'category' in data: + cates = list(set(data['category'])) + cates.sort() + for c in cates: + sub = [r for l, r in zip(lines, res) if l['category'] == c] + # [np.mean(x['match']) >= full_score_weight for x in sub] + hit = hit_calculate(sub, dataset_name) + ret[c] = np.mean(hit) * 100 + ret = d2df(ret) + ret.round(2) + + suffix = eval_file.split('.')[-1] + result_file = eval_file.replace(f'.{suffix}', '_acc.csv') + logger.info(f'VQA Eval Finished. Saved to {result_file}. ') + logger.info(ret) + dump(ret, result_file) diff --git a/vlmeval/evaluate/yes_or_no.py b/vlmeval/evaluate/yes_or_no.py new file mode 100644 index 0000000..ef23cc6 --- /dev/null +++ b/vlmeval/evaluate/yes_or_no.py @@ -0,0 +1,247 @@ +from vlmeval.evaluate.misc import build_judge +from vlmeval.smp import * +from vlmeval.utils import track_progress_rich + +INTERNAL = os.environ.get('INTERNAL', 0) + + +def MME_rating(data_file): + data = load(data_file) + stats = defaultdict(dict) + lt = len(data) + for i in range(lt): + item = data.iloc[i] + category = item['category'] + image_path = item['image_path'] + score = item['score'] + if image_path not in stats[category]: + stats[category][image_path] = [] + stats[category][image_path].append(score) + + def acc(key, mode='normal'): + res = stats[key] + values = [] + for val in res.values(): + if mode == 'normal': + values.extend(val) + elif mode == 'plus': + values.append(val[0] * val[1]) + return np.mean(values) * 100 + + scores = {} + for k in stats: + scores[k] = acc(k) + acc(k, 'plus') + + super_cates = dict( + perception=[ + 'OCR', 'artwork', 'celebrity', 'color', 'count', 'existence', + 'landmark', 'position', 'posters', 'scene' + ], + reasoning=['code_reasoning', 'commonsense_reasoning', 'numerical_calculation', 'text_translation'] + ) + + ret = {} + for sc, cate_list in super_cates.items(): + base = 0 + for c in cate_list: + base += scores[c] + ret[sc] = base + ret.update(scores) + ret = d2df(ret) + return ret + + +def Hallusion_rating(data_file): + def calc_fAcc(data): + res = defaultdict(list) + lt = len(data) + for i in range(lt): + line = data.iloc[i] + res[f"{line['l2-category']}_{line['set_id']}_{line['figure_id']}"].append(line['score']) + return np.mean([np.all(x) for x in res.values()]) * 100 + + def calc_qAcc(data): + res = defaultdict(list) + lt = len(data) + for i in range(lt): + line = data.iloc[i] + res[f"{line['l2-category']}_{line['set_id']}_{line['question_id']}"].append(line['score']) + return np.mean([np.all(x) for x in res.values()]) * 100 + + def calc_aAcc(data): + return np.mean(data['score']) * 100 + + data = load(data_file) + data['set_id'] = [x.split('_')[3] for x in data['index']] + data['figure_id'] = [x.split('_')[4] for x in data['index']] + data['question_id'] = [x.split('_')[5] for x in data['index']] + + res = dict(split=[], aAcc=[], fAcc=[], qAcc=[]) + res['split'].append('Overall') + res['aAcc'].append(calc_aAcc(data)) + res['fAcc'].append(calc_fAcc(data)) + res['qAcc'].append(calc_qAcc(data)) + + if 'category' in data: + cates = list(set(data['category'])) + for c in cates: + sub = data[data['category'] == c] + res['split'].append(c) + res['aAcc'].append(calc_aAcc(sub)) + res['fAcc'].append(calc_fAcc(sub)) + res['qAcc'].append(calc_qAcc(sub)) + + if 'l2-category' in data: + cates = list(set(data['l2-category'])) + for c in cates: + sub = data[data['l2-category'] == c] + res['split'].append(c) + res['aAcc'].append(calc_aAcc(sub)) + res['fAcc'].append(calc_fAcc(sub)) + res['qAcc'].append(calc_qAcc(sub)) + ret = pd.DataFrame(res) + return ret + + +def default_rating(data_file): + data = load(data_file) + res = {} + res['Overall'] = np.mean(data['score']) * 100 + if 'category' in data: + cates = list(set(data['category'])) + cates = [c for c in cates if not pd.isna(c)] + cates.sort() + for c in cates: + sub = data[data['category'] == c] + res[c] = np.mean(sub['score']) * 100 + if 'l2-category' in data: + cates = list(set(data['l2-category'])) + cates = [c for c in cates if not pd.isna(c)] + cates.sort() + for c in cates: + sub = data[data['l2-category'] == c] + res[c] = np.mean(sub['score']) * 100 + ret = d2df(res) + return ret + + +def YOrN_match_prompt(line): + tmpl = ( + 'You are an AI assistant who will help me to match an answer with two options of a question. ' + 'The options are only Yes / No. ' + 'You are provided with a question and an answer, ' + 'and you need to find which option (Yes / No) is most similar to the answer. ' + 'If the meaning of all options are significantly different from the answer, output Unknown. ' + 'Your should output a single word among the following 3 choices: Yes, No, Unknown.\n' + 'Example 1: \n' + "Question: Is the word in this image 'Hello'?\nAnswer: The word in this image is 'Hello'.\nYour output: Yes\n" + 'Example 2: \n' + "Question: Is the word in this image 'Hello'?\n" + "Answer: The word in this image is not 'Hello'.\nYour output: No\n" + 'Example 3: \n' + 'Question: {}?\nAnswer: {}\nYour output: ' + ) + return tmpl.format(line['question'], line['prediction']) + + +def YOrN_Extraction(output): + s = output.lower() + words = process_punctuation(s).split() + if 'yes' in words and 'no' not in words: + return 'Yes' + if 'yes' not in words and 'no' in words: + return 'No' + return 'Unknown' + + +def YOrN_auxeval(model, line): + prompt = YOrN_match_prompt(line) + retry = 5 + for i in range(retry): + output = model.generate(prompt, temperature=0.5 * i) + ans = YOrN_Extraction(output) + if ans != 'Unknown': + return ans + return 'Unknown' + + +def YOrN_eval(eval_file, dataset=None, **judge_kwargs): + logger = get_logger('Evaluation') + data = load(eval_file) + data['prediction'] = [str(x) for x in data['prediction']] + storage = eval_file.replace('.xlsx', '_auxmatch.xlsx') + tmp_file = eval_file.replace('.xlsx', '_tmp.pkl') + nproc = judge_kwargs.pop('nproc', 4) + + if not osp.exists(storage): + ans_map = {k: YOrN_Extraction(v) for k, v in zip(data['index'], data['prediction'])} + if osp.exists(tmp_file): + tmp = load(tmp_file) + for k in tmp: + if ans_map[k] == 'Unknown' and tmp[k] != 'Unknown': + ans_map[k] = tmp[k] + + data['extracted'] = [ans_map[x] for x in data['index']] + unknown = data[data['extracted'] == 'Unknown'] + + if INTERNAL or gpt_key_set(): + model = build_judge(**judge_kwargs) + else: + logger.error('OPENAI_API_KEY is not set properly, will use exact matching for evaluation') + model = None + + if model is not None: + lt = len(unknown) + lines = [unknown.iloc[i] for i in range(lt)] + tups = [(model, line) for line in lines] + indices = list(unknown['index']) + if len(tups): + res = track_progress_rich( + YOrN_auxeval, tups, nproc=nproc, chunksize=nproc, keys=indices, save=tmp_file) + for k, v in zip(indices, res): + ans_map[k] = v + + data['extracted'] = [ans_map[x] for x in data['index']] + dump(data, storage) + else: + logger.warning(f'GPT matching file {storage} already exists, will reuse it in YOrN_eval. ') + + data = load(storage) + data['score'] = (data['answer'] == data['extracted']) + dump(data, storage) + + if dataset is not None and listinstr(['MME'], dataset): + score = MME_rating(storage) + elif dataset is not None and listinstr(['Hallusion'], dataset): + score = Hallusion_rating(storage) + else: + score = default_rating(storage) + + score_tgt = eval_file.replace('.xlsx', '_score.csv') + dump(score, score_tgt) + + logger.info(f'YOrN_eval successfully finished evaluating {eval_file}, results saved in {score_tgt}') + logger.info('Score: ') + logger.info(score) + return score + + +def parse_args(): + parser = argparse.ArgumentParser(description='Inference LLM Answers. ') + parser.add_argument('data', type=str, help='The question set for inference, in excel / tsv / json format. ') + parser.add_argument( + '--model', + type=str, + help='The LLM (GPT) used for inference. ', + default='chatgpt-0613', + choices=['chatgpt-0613']) + parser.add_argument('--nproc', type=int, default=4) + parser.add_argument('--dataset', type=str, default=None) + parser.add_argument('--verbose', action='store_true') + args = parser.parse_args() + return args + + +if __name__ == '__main__': + args = parse_args() + acc = YOrN_eval(eval_file=args.data, model=args.model, nproc=args.nproc, verbose=args.verbose, dataset=args.dataset) diff --git a/vlmeval/inference.py b/vlmeval/inference.py new file mode 100644 index 0000000..7dcf73e --- /dev/null +++ b/vlmeval/inference.py @@ -0,0 +1,183 @@ +import torch +import torch.distributed as dist +import datetime +from vlmeval.config import supported_VLM, api_models +from vlmeval.utils import TSVDataset, track_progress_rich, split_MMMU +from vlmeval.smp import * + +FAIL_MSG = 'Failed to obtain answer via API.' + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument('--data', type=str, nargs='+', required=True) + parser.add_argument('--model', type=str, nargs='+', required=True) + parser.add_argument('--nproc', type=int, default=4, required=True) + parser.add_argument('--verbose', action='store_true') + args = parser.parse_args() + return args + + +# Only API model is accepted +def infer_data_api(work_dir, model_name, dataset_name, index_set=None, api_nproc=4, ignore_failed=False): + rank, world_size = get_rank_and_world_size() + assert rank == 0 and world_size == 1 + dataset = TSVDataset(dataset_name) + data = dataset.data + if index_set is not None: + data = data[data['index'].isin(index_set)] + + model = supported_VLM[model_name]() if isinstance(model_name, str) else model_name + assert getattr(model, 'is_api', False) + + lt, indices = len(data), list(data['index']) + structs = [dataset.build_prompt(data.iloc[i]) for i in range(lt)] + + # Corner Case + if listinstr(['MMMU'], dataset_name): + structs = [split_MMMU(s) for s in structs] + + out_file = f'{work_dir}/{model_name}_{dataset_name}_supp.pkl' + res = {} + if osp.exists(out_file): + res = load(out_file) + if ignore_failed: + res = {k: v for k, v in res.items() if FAIL_MSG not in v} + + structs = [s for i, s in zip(indices, structs) if i not in res] + indices = [i for i in indices if i not in res] + + gen_func = model.generate + # For now, we do not use split_MMMU for MMMU dataset + structs = [dict(message=struct, dataset=dataset_name) for struct in structs] + + if len(structs): + track_progress_rich(gen_func, structs, nproc=api_nproc, chunksize=api_nproc, save=out_file, keys=indices) + + res = load(out_file) + if index_set is not None: + res = {k: v for k, v in res.items() if k in index_set} + os.remove(out_file) + return res + + +def infer_data(model_name, work_dir, dataset_name, out_file, verbose=False, api_nproc=4): + prev_file = f'{work_dir}/{model_name}_{dataset_name}_PREV.pkl' + res = load(prev_file) if osp.exists(prev_file) else {} + if osp.exists(out_file): + res.update(load(out_file)) + + rank, world_size = get_rank_and_world_size() + if rank == 0: + dataset = TSVDataset(dataset_name) + if world_size > 1: + dist.barrier() + dataset = TSVDataset(dataset_name) + + sheet_indices = list(range(rank, len(dataset), world_size)) + lt = len(sheet_indices) + data = dataset.data.iloc[sheet_indices] + data_indices = [i for i in data['index']] + + # If finished, will exit without building the model + all_finished = True + for i in range(lt): + idx = data.iloc[i]['index'] + if idx not in res: + all_finished = False + if all_finished: + res = {k: res[k] for k in data_indices} + dump(res, out_file) + return + + # Data need to be inferred + data = data[~data['index'].isin(res)] + lt = len(data) + + model = supported_VLM[model_name]() if isinstance(model_name, str) else model_name + + is_api = getattr(model, 'is_api', False) + if is_api: + lt, indices = len(data), list(data['index']) + supp = infer_data_api( + work_dir=work_dir, + model_name=model_name, + dataset_name=dataset_name, + index_set=set(indices), + api_nproc=api_nproc) + for idx in indices: + assert idx in supp + res.update(supp) + res = {k: res[k] for k in data_indices} + dump(res, out_file) + return model_name + + for i in tqdm(range(lt)): + idx = data.iloc[i]['index'] + if idx in res: + continue + + if hasattr(model, 'use_custom_prompt') and model.use_custom_prompt(dataset_name): + struct = model.build_prompt(data.iloc[i], dataset=dataset_name) + else: + struct = dataset.build_prompt(data.iloc[i]) + + # Corner Case + if listinstr(['MMMU'], dataset_name): + struct = split_MMMU(struct) + + # For now, we do not use split_MMMU for MMMU dataset + response = model.generate(message=struct, dataset=dataset_name) + torch.cuda.empty_cache() + + if verbose: + print(response, flush=True) + + res[idx] = response + if (i + 1) % 20 == 0: + dump(res, out_file) + + res = {k: res[k] for k in data_indices} + dump(res, out_file) + return model + + +# A wrapper for infer_data, do the pre & post processing +def infer_data_job(model, work_dir, model_name, dataset_name, verbose=False, api_nproc=4, ignore_failed=False): + rank, world_size = get_rank_and_world_size() + result_file = osp.join(work_dir, f'{model_name}_{dataset_name}.xlsx') + + prev_file = f'{work_dir}/{model_name}_{dataset_name}_PREV.pkl' + if osp.exists(result_file): + if rank == 0: + data = load(result_file) + results = {k: v for k, v in zip(data['index'], data['prediction'])} + if not ignore_failed: + results = {k: v for k, v in results.items() if FAIL_MSG not in str(v)} + dump(results, prev_file) + if world_size > 1: + dist.barrier() + + tmpl = osp.join(work_dir, '{}' + f'{world_size}_{dataset_name}.pkl') + out_file = tmpl.format(rank) + + model = infer_data( + model, work_dir=work_dir, dataset_name=dataset_name, out_file=out_file, verbose=verbose, api_nproc=api_nproc) + if world_size > 1: + dist.barrier() + + if rank == 0: + data_all = {} + for i in range(world_size): + data_all.update(load(tmpl.format(i))) + + data = TSVDataset(dataset_name).data + for x in data['index']: + assert x in data_all + data['prediction'] = [str(data_all[x]) for x in data['index']] + data.pop('image') + + dump(data, result_file) + for i in range(world_size): + os.remove(tmpl.format(i)) + return model diff --git a/vlmeval/smp/__init__.py b/vlmeval/smp/__init__.py new file mode 100644 index 0000000..46e8968 --- /dev/null +++ b/vlmeval/smp/__init__.py @@ -0,0 +1,4 @@ +from .file import * +from .vlm import * +from .misc import * +from .log import * diff --git a/vlmeval/smp/file.py b/vlmeval/smp/file.py new file mode 100644 index 0000000..50b5446 --- /dev/null +++ b/vlmeval/smp/file.py @@ -0,0 +1,214 @@ +import json +import pickle +import pandas as pd +import os +import csv +import hashlib +import os.path as osp +import time +import numpy as np +import validators +import mimetypes + + +def LMUDataRoot(): + if 'LMUData' in os.environ and osp.exists(os.environ['LMUData']): + return os.environ['LMUData'] + home = osp.expanduser('~') + root = osp.join(home, 'LMUData') + os.makedirs(root, exist_ok=True) + return root + + +def MMBenchOfficialServer(): + root = LMUDataRoot() + for dataset in ['MMBench', 'MMBench_CN', 'MMBench_TEST_EN', 'MMBench_TEST_CN']: + if osp.exists(f'{root}/{dataset}.tsv'): + data = load(f'{root}/{dataset}.tsv') + if 'answer' in data and sum([pd.isna(x) for x in data['answer']]) == 0: + return True + return False + + +class NumpyEncoder(json.JSONEncoder): + def default(self, obj): + if isinstance(obj, (np.int_, np.intc, np.intp, np.int8, + np.int16, np.int32, np.int64, np.uint8, + np.uint16, np.uint32, np.uint64)): + return int(obj) + elif isinstance(obj, (np.float_, np.float16, np.float32, np.float64)): + return float(obj) + elif isinstance(obj, (np.complex_, np.complex64, np.complex128)): + return {'real': obj.real, 'imag': obj.imag} + elif isinstance(obj, (np.ndarray,)): + return obj.tolist() + elif isinstance(obj, (np.bool_)): + return bool(obj) + elif isinstance(obj, (np.void)): + return None + return json.JSONEncoder.default(self, obj) + + +# LOAD & DUMP +def dump(data, f, **kwargs): + def dump_pkl(data, pth, **kwargs): + pickle.dump(data, open(pth, 'wb')) + + def dump_json(data, pth, **kwargs): + json.dump(data, open(pth, 'w'), indent=4, ensure_ascii=False, cls=NumpyEncoder) + + def dump_jsonl(data, f, **kwargs): + lines = [json.dumps(x, ensure_ascii=False, cls=NumpyEncoder) for x in data] + with open(f, 'w', encoding='utf8') as fout: + fout.write('\n'.join(lines)) + + def dump_xlsx(data, f, **kwargs): + data.to_excel(f, index=False, engine='xlsxwriter') + + def dump_csv(data, f, quoting=csv.QUOTE_ALL): + data.to_csv(f, index=False, encoding='utf-8', quoting=quoting) + + def dump_tsv(data, f, quoting=csv.QUOTE_ALL): + data.to_csv(f, sep='\t', index=False, encoding='utf-8', quoting=quoting) + + handlers = dict(pkl=dump_pkl, json=dump_json, jsonl=dump_jsonl, xlsx=dump_xlsx, csv=dump_csv, tsv=dump_tsv) + suffix = f.split('.')[-1] + return handlers[suffix](data, f, **kwargs) + + +def load(f): + def load_pkl(pth): + return pickle.load(open(pth, 'rb')) + + def load_json(pth): + return json.load(open(pth, 'r', encoding='utf-8')) + + def load_jsonl(f): + lines = open(f, encoding='utf-8').readlines() + lines = [x.strip() for x in lines] + if lines[-1] == '': + lines = lines[:-1] + data = [json.loads(x) for x in lines] + return data + + def load_xlsx(f): + return pd.read_excel(f) + + def load_csv(f): + return pd.read_csv(f) + + def load_tsv(f): + return pd.read_csv(f, sep='\t') + + handlers = dict(pkl=load_pkl, json=load_json, jsonl=load_jsonl, xlsx=load_xlsx, csv=load_csv, tsv=load_tsv) + suffix = f.split('.')[-1] + return handlers[suffix](f) + + +def download_file(url, filename=None): + import urllib.request + from tqdm import tqdm + + class DownloadProgressBar(tqdm): + def update_to(self, b=1, bsize=1, tsize=None): + if tsize is not None: + self.total = tsize + self.update(b * bsize - self.n) + + if filename is None: + filename = url.split('/')[-1] + + with DownloadProgressBar(unit='B', unit_scale=True, + miniters=1, desc=url.split('/')[-1]) as t: + urllib.request.urlretrieve(url, filename=filename, reporthook=t.update_to) + return filename + + +def ls(dirname='.', match=[], mode='all', level=1): + if isinstance(level, str): + assert '+' in level + level = int(level[:-1]) + res = [] + for i in range(1, level + 1): + res.extend(ls(dirname, match=match, mode='file', level=i)) + return res + + if dirname == '.': + ans = os.listdir(dirname) + else: + ans = [osp.join(dirname, x) for x in os.listdir(dirname)] + assert mode in ['all', 'dir', 'file'] + assert level >= 1 and isinstance(level, int) + if level == 1: + if isinstance(match, str): + match = [match] + for m in match: + if len(m) == 0: + continue + if m[0] != '!': + ans = [x for x in ans if m in x] + else: + ans = [x for x in ans if m[1:] not in x] + if mode == 'dir': + ans = [x for x in ans if osp.isdir(x)] + elif mode == 'file': + ans = [x for x in ans if not osp.isdir(x)] + return ans + else: + dirs = [x for x in ans if osp.isdir(x)] + res = [] + for d in dirs: + res.extend(ls(d, match=match, mode=mode, level=level - 1)) + return res + + +def mrlines(fname, sp='\n'): + f = open(fname).read().split(sp) + while f != [] and f[-1] == '': + f = f[:-1] + return f + + +def mwlines(lines, fname): + with open(fname, 'w') as fout: + fout.write('\n'.join(lines)) + + +def md5(s): + hash = hashlib.new('md5') + if osp.exists(s): + with open(s, 'rb') as f: + for chunk in iter(lambda: f.read(2**20), b''): + hash.update(chunk) + else: + hash.update(s.encode('utf-8')) + return str(hash.hexdigest()) + + +def last_modified(pth): + stamp = osp.getmtime(pth) + m_ti = time.ctime(stamp) + t_obj = time.strptime(m_ti) + t = time.strftime('%Y%m%d%H%M%S', t_obj)[2:] + return t + + +def parse_file(s): + if osp.exists(s): + assert osp.isfile(s) + suffix = osp.splitext(s)[1].lower() + mime = mimetypes.types_map.get(suffix, 'unknown') + return (mime, s) + elif validators.url(s): + suffix = osp.splitext(s)[1].lower() + if suffix in mimetypes.types_map: + mime = mimetypes.types_map[suffix] + dname = osp.join(LMUDataRoot(), 'files') + os.makedirs(dname, exist_ok=True) + tgt = osp.join(dname, md5(s) + suffix) + download_file(s, tgt) + return (mime, tgt) + else: + return ('url', s) + else: + return (None, s) diff --git a/vlmeval/smp/log.py b/vlmeval/smp/log.py new file mode 100644 index 0000000..95804d5 --- /dev/null +++ b/vlmeval/smp/log.py @@ -0,0 +1,44 @@ +import logging + +logger_initialized = {} + + +def get_logger(name, log_file=None, log_level=logging.INFO, file_mode='w'): + logger = logging.getLogger(name) + if name in logger_initialized: + return logger + + for logger_name in logger_initialized: + if name.startswith(logger_name): + return logger + + stream_handler = logging.StreamHandler() + handlers = [stream_handler] + + try: + import torch.distributed as dist + if dist.is_available() and dist.is_initialized(): + rank = dist.get_rank() + else: + rank = 0 + except ImportError: + rank = 0 + + if rank == 0 and log_file is not None: + file_handler = logging.FileHandler(log_file, file_mode) + handlers.append(file_handler) + + formatter = logging.Formatter( + '%(asctime)s - %(name)s - %(levelname)s - %(message)s') + for handler in handlers: + handler.setFormatter(formatter) + handler.setLevel(log_level) + logger.addHandler(handler) + + if rank == 0: + logger.setLevel(log_level) + else: + logger.setLevel(logging.ERROR) + + logger_initialized[name] = True + return logger diff --git a/vlmeval/smp/misc.py b/vlmeval/smp/misc.py new file mode 100644 index 0000000..7640fad --- /dev/null +++ b/vlmeval/smp/misc.py @@ -0,0 +1,191 @@ +# flake8: noqa: F401, F403 +import abc +import argparse +import csv +import multiprocessing as mp +import os +import os.path as osp +import copy as cp +import random as rd +import requests +import shutil +import subprocess +import warnings +import logging +import pandas as pd +from collections import OrderedDict, defaultdict +from multiprocessing import Pool, current_process +from tqdm import tqdm +import datetime +import matplotlib.pyplot as plt +import seaborn as sns +from tabulate import tabulate_formats, tabulate +from huggingface_hub import scan_cache_dir +from sty import fg, bg, ef, rs + +def process_punctuation(inText): + import re + outText = inText + punct = [ + ';', r'/', '[', ']', '"', '{', '}', '(', ')', '=', '+', '\\', '_', '-', + '>', '<', '@', '`', ',', '?', '!' + ] + commaStrip = re.compile('(\d)(,)(\d)') # noqa: W605 + periodStrip = re.compile('(?!<=\d)(\.)(?!\d)') # noqa: W605 + for p in punct: + if (p + ' ' in inText or ' ' + p in inText) or (re.search( + commaStrip, inText) is not None): + outText = outText.replace(p, '') + else: + outText = outText.replace(p, ' ') + outText = periodStrip.sub('', outText, re.UNICODE) + return outText + +def h2r(value): + if value[0] == '#': + value = value[1:] + assert len(value) == 6 + return tuple(int(value[i:i + 2], 16) for i in range(0, 6, 2)) + +def r2h(rgb): + return '#%02x%02x%02x' % rgb + +def colored(s, color): + if isinstance(color, str): + if hasattr(fg, color): + return getattr(fg, color) + s + fg.rs + color = h2r(color) + return fg(*color) + s + fg.rs + +def istype(s, type): + if isinstance(s, type): + return True + try: + return isinstance(eval(s), type) + except Exception as _: + return False + +def bincount(lst): + bins = defaultdict(lambda: 0) + for item in lst: + bins[item] += 1 + return bins + +def get_cache_path(repo_id): + hf_cache_info = scan_cache_dir() + repos = list(hf_cache_info.repos) + repo = None + for r in repos: + if r.repo_id == repo_id: + repo = r + break + if repo is None: + return None + revs = list(repo.revisions) + rev2keep, last_modified = None, 0 + for rev in revs: + if rev.last_modified > last_modified: + rev2keep, last_modified = rev, rev.last_modified + if rev2keep is None: + return None + return str(rev2keep.snapshot_path) + +def proxy_set(s): + import os + for key in ['http_proxy', 'HTTP_PROXY', 'https_proxy', 'HTTPS_PROXY']: + os.environ[key] = s + +def get_rank_and_world_size(): + rank = int(os.environ.get('RANK', 0)) + world_size = int(os.environ.get('WORLD_SIZE', 1)) + return rank, world_size + +def splitlen(s, sym='/'): + return len(s.split(sym)) + +def listinstr(lst, s): + assert isinstance(lst, list) + for item in lst: + if item in s: + return True + return False + +def d2df(D): + return pd.DataFrame({x: [D[x]] for x in D}) + +def cn_string(s): + import re + if re.search(u'[\u4e00-\u9fff]', s): + return True + return False + +try: + import decord +except ImportError: + pass + +def timestr(second=True, minute=False): + s = datetime.datetime.now().strftime('%Y%m%d%H%M%S')[2:] + if second: + return s + elif minute: + return s[:-2] + else: + return s[:-4] + +def dict_merge(dct, merge_dct): + for k, _ in merge_dct.items(): + if (k in dct and isinstance(dct[k], dict) and isinstance(merge_dct[k], dict)): #noqa + dict_merge(dct[k], merge_dct[k]) + else: + dct[k] = merge_dct[k] + +def youtube_dl(idx): + cmd = f'youtube-dl -f best -f mp4 "{idx}" -o {idx}.mp4' + os.system(cmd) + +def run_command(cmd): + if isinstance(cmd, str): + cmd = cmd.split() + return subprocess.check_output(cmd).decode() + +def load_env(): + logger = logging.getLogger('LOAD_ENV') + try: + import vlmeval + except ImportError: + logger.error('VLMEval is not installed. Failed to import environment variables from .env file. ') + return + pth = osp.realpath(vlmeval.__path__[0]) + pth = osp.join(pth, '../.env') + pth = osp.realpath(pth) + if not osp.exists(pth): + logger.error(f'Did not detect the .env file at {pth}, failed to load. ') + return + + from dotenv import dotenv_values + values = dotenv_values(pth) + for k, v in values.items(): + if v is not None and len(v): + os.environ[k] = v + logger.info(f'API Keys successfully loaded from {pth}') + +def pip_install_robust(package): + import sys + retry = 3 + while retry > 0: + try: + package_base = package.split('=')[0] + module = __import__(package) + return True + except ImportError: + subprocess.check_call([sys.executable, '-m', 'pip', 'install', package]) + retry -= 1 + return False + + +def version_cmp(v1, v2, op='eq'): + from packaging import version + import operator + op_func = getattr(operator, op) + return op_func(version.parse(v1), version.parse(v2)) diff --git a/vlmeval/smp/vlm.py b/vlmeval/smp/vlm.py new file mode 100644 index 0000000..fc2db50 --- /dev/null +++ b/vlmeval/smp/vlm.py @@ -0,0 +1,133 @@ +import os +import io +import pandas as pd +import numpy as np +import string +from uuid import uuid4 +import os.path as osp +import base64 +from PIL import Image +from .file import load, dump + + +def mmqa_display(question): + question = {k.lower(): v for k, v in question.items()} + keys = list(question.keys()) + keys = [k for k in keys if k not in ['index', 'image']] + + images = question['image'] + if isinstance(images, str): + images = [images] + + idx = question.pop('index', 'XXX') + print(f'INDEX: {idx}') + + for im in images: + image = decode_base64_to_image(im, target_size=512) + display(image) # noqa: F821 + + for k in keys: + try: + if not pd.isna(question[k]): + print(f'{k.upper()}. {question[k]}') + except ValueError: + if False in pd.isna(question[k]): + print(f'{k.upper()}. {question[k]}') + + +def encode_image_to_base64(img, target_size=-1): + # if target_size == -1, will not do resizing + # else, will set the max_size ot (target_size, target_size) + if img.mode in ('RGBA', 'P'): + img = img.convert('RGB') + tmp = osp.join('/tmp', str(uuid4()) + '.jpg') + if target_size > 0: + img.thumbnail((target_size, target_size)) + img.save(tmp) + with open(tmp, 'rb') as image_file: + image_data = image_file.read() + ret = base64.b64encode(image_data).decode('utf-8') + os.remove(tmp) + return ret + + +def encode_image_file_to_base64(image_path, target_size=-1): + image = Image.open(image_path) + return encode_image_to_base64(image, target_size=target_size) + + +def decode_base64_to_image(base64_string, target_size=-1): + image_data = base64.b64decode(base64_string) + image = Image.open(io.BytesIO(image_data)) + if image.mode in ('RGBA', 'P'): + image = image.convert('RGB') + if target_size > 0: + image.thumbnail((target_size, target_size)) + return image + + +def decode_base64_to_image_file(base64_string, image_path, target_size=-1): + image = decode_base64_to_image(base64_string, target_size=target_size) + image.save(image_path) + + +def build_option_str(option_dict): + s = 'There are several options: \n' + for c, content in option_dict.items(): + if not pd.isna(content): + s += f'{c}. {content}\n' + return s + + +def isimg(s): + return osp.exists(s) or s.startswith('http') + + +def read_ok(img_path): + if not osp.exists(img_path): + return False + try: + im = Image.open(img_path) + assert im.size[0] > 0 and im.size[1] > 0 + return True + except: + return False + + +def gpt_key_set(): + openai_key = os.environ.get('OPENAI_API_KEY', None) + return isinstance(openai_key, str) and openai_key.startswith('sb-') + + +def apiok(wrapper): + s = wrapper.generate('Hello!') + return wrapper.fail_msg not in s + + +def circular_pred(df, extract_func=None): + if extract_func is None: + extract_func = lambda x: x # noqa: E731 + df = df.sort_values('index') + from vlmeval.utils import can_infer_option + shift = int(1e6) + + choices = [extract_func(x) for x in df['prediction']] + pred_map = {i: c for i, c in zip(df['index'], choices)} + flag_map = {i: True for i in pred_map if i < 1e6} + valid_map = {i: True for i in pred_map if i < 1e6} + for i in df['index']: + if i >= shift and pred_map[i] and pred_map[i - shift]: + if ( + pred_map[i] not in list(string.ascii_uppercase) or # noqa: W504 + pred_map[i - shift] not in list(string.ascii_uppercase) + ): + + valid_map[i % shift] = False + continue + if (ord(pred_map[i]) - ord(pred_map[i - shift])) % 4 == 1: + continue + else: + flag_map[i % shift] = False + flag_map = {k: v for k, v in flag_map.items() if valid_map[k]} + flags = list(flag_map.values()) + return np.mean(flags) diff --git a/vlmeval/utils/__init__.py b/vlmeval/utils/__init__.py new file mode 100644 index 0000000..9303678 --- /dev/null +++ b/vlmeval/utils/__init__.py @@ -0,0 +1,12 @@ +from .matching_util import can_infer, can_infer_option, can_infer_text +from .mp_util import track_progress_rich +from .custom_prompt import CustomPrompt +from .dataset_config import dataset_URLs, img_root_map, DATASET_TYPE, abbr2full +from .dataset import TSVDataset, split_MMMU, MMMU_result_transfer + + +__all__ = [ + 'can_infer', 'can_infer_option', 'can_infer_text', 'track_progress_rich', + 'TSVDataset', 'dataset_URLs', 'img_root_map', 'DATASET_TYPE', 'CustomPrompt', + 'split_MMMU', 'abbr2full' +] diff --git a/vlmeval/utils/custom_prompt.py b/vlmeval/utils/custom_prompt.py new file mode 100644 index 0000000..5841fbc --- /dev/null +++ b/vlmeval/utils/custom_prompt.py @@ -0,0 +1,33 @@ +from ..smp import * +from .dataset_config import img_root_map +from abc import abstractmethod + + +class CustomPrompt: + + @abstractmethod + def use_custom_prompt(self, dataset): + raise NotImplementedError + + @abstractmethod + def build_prompt(self, line, dataset): + raise NotImplementedError + + def dump_image(self, line, dataset): + ROOT = LMUDataRoot() + assert isinstance(dataset, str) + img_root = osp.join(ROOT, 'images', img_root_map[dataset] if dataset in img_root_map else dataset) + os.makedirs(img_root, exist_ok=True) + if isinstance(line['image'], list): + tgt_path = [] + assert 'image_path' in line + for img, im_name in zip(line['image'], line['image_path']): + path = osp.join(img_root, im_name) + if not read_ok(path): + decode_base64_to_image_file(img, path) + tgt_path.append(path) + else: + tgt_path = osp.join(img_root, f"{line['index']}.jpg") + if not read_ok(tgt_path): + decode_base64_to_image_file(line['image'], tgt_path) + return tgt_path diff --git a/vlmeval/utils/dataset.py b/vlmeval/utils/dataset.py new file mode 100644 index 0000000..ff843d9 --- /dev/null +++ b/vlmeval/utils/dataset.py @@ -0,0 +1,179 @@ +import pandas as pd +import hashlib +from ..smp import * +from .dataset_config import dataset_URLs, dataset_md5_dict, DATASET_TYPE +from .custom_prompt import CustomPrompt +from .matching_util import can_infer + + +def isliststr(s): + return (s[0] == '[') and (s[-1] == ']') + + +def check_md5(data_path, dataset): + if dataset not in dataset_md5_dict: + warnings.warn(f'We do not have an md5 record for dataset {dataset}, skip the md5 check. ') + return True + assert osp.exists(data_path) + with open(data_path, 'rb') as f: + hash = hashlib.new('md5') + for chunk in iter(lambda: f.read(2**20), b''): + hash.update(chunk) + if str(hash.hexdigest()) == dataset_md5_dict[dataset]: + return True + else: + warnings.warn('this data file is incomplete, so it needs to be downloaded again.') + return False + + +def split_MMMU(msgs): + text, images = None, [] + for s in msgs: + if s['type'] == 'image': + images.append(s['value']) + elif s['type'] == 'text': + assert text is None + text = s['value'] + text_segs = text.split('' + image_idx = int(seg[0]) - 1 + segs.append(dict(type='image', value=images[image_idx])) + segs.append(dict(type='text', value=seg[2:])) + return segs + + +def MMMU_result_transfer(result_path): + res = {} + result_data = load(result_path) + mcq = result_data['A'].notna() + lt = len(result_data) + for i in range(lt): + line = result_data.iloc[i] + if mcq[i]: + options = { + cand: line[cand] + for cand in string.ascii_uppercase + if cand in line and not pd.isna(line[cand]) + } + prediction = line['prediction'] + infer_prediction = can_infer(prediction, options) + res[line['id']] = infer_prediction + else: + res[line['id']] = line['prediction'] + result_json = result_path.replace('.xlsx', '.json') + dump(res, result_json) + return result_json + + +class TSVDataset(CustomPrompt): + + def __init__(self, dataset='MMBench', skip_noimg=True): + + self.data_root = LMUDataRoot() + assert osp.exists(self.data_root) + + self.dataset = dataset + self.dataset_type = DATASET_TYPE(dataset) + + if dataset in dataset_URLs: + url = dataset_URLs[dataset] + file_name = url.split('/')[-1] + data_path = osp.join(self.data_root, file_name) + + if osp.exists(data_path) and check_md5(data_path, dataset): + pass + else: + # print(osp.exists(data_path), check_md5(data_path, dataset)) + warnings.warn('The dataset tsv is not downloaded') + download_file(url, data_path) + else: + data_path = osp.join(self.data_root, dataset + '.tsv') + assert osp.exists(data_path) + + data = load(data_path) + self.skip_noimg = skip_noimg + if skip_noimg: + data = data[~pd.isna(data['image'])] + + # Prompt for Captioning + if listinstr(['COCO'], dataset): + data['question'] = [( + 'Please describe this image in general. Directly provide the description, ' + 'do not include prefix like "This image depicts". ' + )] * len(data) + + data['index'] = [str(x) for x in data['index']] + 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] + + data['image'] = [ + eval(image_map[k]) if isliststr(image_map[k]) else image_map[k] + for k in data['index'] + ] + if 'image_path' in data: + data['image_path'] = [ + eval(pths) if isliststr(pths) else pths for pths in data['image_path'] + ] + if np.all([istype(x, int) for x in data['index']]): + data['index'] = [int(x) for x in data['index']] + + self.data = data + + def __len__(self): + return len(self.data) + + def build_prompt(self, line, dataset=None): + if dataset is None: + dataset = self.dataset + + if isinstance(line, int): + line = self.data.iloc[line] + + tgt_path = self.dump_image(line, dataset) + + prompt = line['question'] + if DATASET_TYPE(dataset) == 'multi-choice': + 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: {question}\n' + if len(options): + prompt += options_prompt + prompt += 'Please select the correct answer from the options above. \n' + elif DATASET_TYPE(dataset) == 'VQA': + if listinstr(['ocrvqa', 'textvqa', 'chartqa', 'docvqa'], dataset.lower()): + prompt += '\nPlease try to answer the question with short words or phrases if possible\n.' + + msgs = [] + 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 display(self, line): + if isinstance(line, int): + line = self.data.iloc[line] + mmqa_display(line) diff --git a/vlmeval/utils/dataset_config.py b/vlmeval/utils/dataset_config.py new file mode 100644 index 0000000..215cf43 --- /dev/null +++ b/vlmeval/utils/dataset_config.py @@ -0,0 +1,137 @@ +from ..smp import listinstr + +dataset_URLs = { + 'MMBench_DEV_EN': 'https://opencompass.openxlab.space/utils/VLMEval/MMBench_DEV_EN.tsv', + 'MMBench_TEST_EN': 'https://opencompass.openxlab.space/utils/VLMEval/MMBench_TEST_EN.tsv', + 'MMBench_DEV_CN': 'https://opencompass.openxlab.space/utils/VLMEval/MMBench_DEV_CN.tsv', + 'MMBench_TEST_CN': 'https://opencompass.openxlab.space/utils/VLMEval/MMBench_TEST_CN.tsv', + 'MMBench': 'https://opencompass.openxlab.space/utils/VLMEval/MMBench.tsv', # Link Invalid, Internal Only + 'MMBench_CN': 'https://opencompass.openxlab.space/utils/VLMEval/MMBench_CN.tsv', # Link Invalid, Internal Only + 'CCBench': 'https://opencompass.openxlab.space/utils/VLMEval/CCBench.tsv', + 'MME': 'https://opencompass.openxlab.space/utils/VLMEval/MME.tsv', + 'SEEDBench_IMG': 'https://opencompass.openxlab.space/utils/VLMEval/SEEDBench_IMG.tsv', + 'CORE_MM': 'https://opencompass.openxlab.space/utils/VLMEval/CORE_MM.tsv', + 'MMVet': 'https://opencompass.openxlab.space/utils/VLMEval/MMVet.tsv', + 'COCO_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/COCO_VAL.tsv', + 'OCRVQA_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/OCRVQA_TEST.tsv', + 'OCRVQA_TESTCORE': 'https://opencompass.openxlab.space/utils/VLMEval/OCRVQA_TESTCORE.tsv', + 'TextVQA_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/TextVQA_VAL.tsv', + 'MMMU_DEV_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/MMMU_DEV_VAL.tsv', + 'MMMU_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/MMMU_TEST.tsv', + 'MathVista_MINI': 'https://opencompass.openxlab.space/utils/VLMEval/MathVista_MINI.tsv', + 'ScienceQA_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/ScienceQA_VAL.tsv', + 'ScienceQA_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/ScienceQA_TEST.tsv', + 'HallusionBench': 'https://opencompass.openxlab.space/utils/VLMEval/HallusionBench.tsv', + 'DocVQA_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/DocVQA_VAL.tsv', + 'DocVQA_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/DocVQA_TEST.tsv', + 'InfoVQA_VAL': 'https://opencompass.openxlab.space/utils/VLMEval/InfoVQA_VAL.tsv', + 'InfoVQA_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/InfoVQA_TEST.tsv', + 'AI2D_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/AI2D_TEST.tsv', + 'LLaVABench': 'https://opencompass.openxlab.space/utils/VLMEval/LLaVABench.tsv', + 'OCRBench': 'https://opencompass.openxlab.space/utils/VLMEval/OCRBench.tsv', + 'ChartQA_TEST': 'https://opencompass.openxlab.space/utils/VLMEval/ChartQA_TEST.tsv', + 'MMStar': 'https://opencompass.openxlab.space/utils/VLMEval/MMStar.tsv', + 'RealWorldQA': 'https://opencompass.openxlab.space/utils/VLMEval/RealWorldQA.tsv', + 'MMT-Bench_VAL': 'LMUData/MMT-Bench_VAL.tsv', + 'MMT-Bench_TEST': 'LMUData/MMT-Bench_TEST.tsv', + 'MMT-Bench_ALL': 'LMUData/MMT-Bench_ALL.tsv' +} + +dataset_md5_dict = { + 'MMBench_DEV_EN': 'b6caf1133a01c6bb705cf753bb527ed8', + 'MMBench_TEST_EN': '6939fadb0ce626fefc0bdc9c64efc528', + 'MMBench_DEV_CN': '08b8fc3324a5ed74155350f57be69fbd', + 'MMBench_TEST_CN': '7e1239baf0ee4c8b513e19705a0f317e', + 'MMBench': '4115aea3383f3dd0083be6a633e0f820', # Link Invalid, Internal Only + 'MMBench_CN': '2e053ffc90ea598b1feae13c36dc13ee', # Link Invalid, Internal Only + 'CCBench': '1de88b4257e7eee3f60b18d45eda6f07', + 'MME': 'b36b43c3f09801f5d368627fb92187c3', + 'SEEDBench_IMG': '68017231464752261a2526d6ca3a10c0', + 'CORE_MM': '8a8da2f2232e79caf98415bfdf0a202d', + 'MMVet': '748aa6d4aa9d4de798306a63718455e3', + 'COCO_VAL': '72a5079dead060269ac222c5aa5128af', + 'OCRVQA_TEST': 'ca46a6d74b403e9d6c0b670f6fc00db9', + 'OCRVQA_TESTCORE': 'c5239fe77db8bdc1f2ad8e55e0d1fe97', + 'TextVQA_VAL': 'b233b31f551bbf4056f2f955da3a92cd', + 'MMMU_DEV_VAL': '521afc0f3bf341e6654327792781644d', + 'MMMU_TEST': 'c19875d11a2d348d07e5eb4bdf33166d', + 'MathVista_MINI': 'f199b98e178e5a2a20e7048f5dcb0464', + 'ScienceQA_VAL': '96320d05e142e585e7204e72affd29f3', + 'ScienceQA_TEST': 'e42e9e00f9c59a80d8a5db35bc32b71f', + 'HallusionBench': '0c23ac0dc9ef46832d7a24504f2a0c7c', + 'DocVQA_VAL': 'd5ee77e1926ff10690d469c56b73eabf', + 'DocVQA_TEST': '6a2f28cac26ef2d3447374e8c6f6c8e9', + 'InfoVQA_VAL': '2342e9c225222f0ef4dec545ebb126fe', + 'InfoVQA_TEST': 'df535bf51b88dc9718252c34131a6227', + 'AI2D_TEST': '0f593e0d1c7df9a3d69bf1f947e71975', + 'LLaVABench': 'd382a093f749a697820d3dadd61c8428', + 'OCRBench': 'e953d98a987cc6e26ef717b61260b778', + 'ChartQA_TEST': 'c902e0aa9be5582a7aad6dcf52734b42', + 'MMStar': 'e1ecd2140806c1b1bbf54b43372efb9e', + 'RealWorldQA': 'b7fc0bee84d301627cf37581ef139035', + 'MMT-Bench_VAL': '337effe5a0c9e9372b7fc1ce1c4cb385', + 'MMT-Bench_TEST': 'cc5ee58196ef4284d67c92cf35029bfd', + 'MMT-Bench_ALL': '8cbb9a6a3febdd72efb2c16ea5f19022' +} + +img_root_map = {k: k for k in dataset_URLs} +img_root_map.update({ + 'MMBench_DEV_EN': 'MMBench', + 'MMBench_TEST_EN': 'MMBench', + 'MMBench_DEV_CN': 'MMBench', + 'MMBench_TEST_CN': 'MMBench', + 'MMBench_CN': 'MMBench', # Link Invalid, Internal Only + 'COCO_VAL': 'COCO', + 'OCRVQA_TEST': 'OCRVQA', + 'OCRVQA_TESTCORE': 'OCRVQA', + 'TextVQA_VAL': 'TextVQA', + 'MMMU_DEV_VAL': 'MMMU', + 'MMMU_TEST': 'MMMU', + 'MathVista_MINI': 'MathVista', + 'HallusionBench': 'Hallusion', + 'DocVQA_VAL': 'DocVQA', + 'DocVQA_TEST': 'DocVQA_TEST', + 'OCRBench': 'OCRBench', + 'ChartQA_TEST': 'ChartQA_TEST', + 'InfoVQA_VAL': 'InfoVQA_VAL', + 'InfoVQA_TEST': 'InfoVQA_TEST', + 'MMStar': 'MMStar', + 'RealWorldQA': 'RealWorldQA', + 'MMT-Bench_VAL': 'MMT-Bench_VAL', + 'MMT-Bench_TEST': 'MMT-Bench_TEST', + 'MMT-Bench_ALL': 'MMT-Bench_ALL', +}) + +assert set(dataset_URLs) == set(img_root_map) + + +def DATASET_TYPE(dataset): + # Dealing with Custom Dataset + dataset = dataset.lower() + if listinstr(['mmbench', 'seedbench', 'ccbench', 'mmmu', 'scienceqa', 'ai2d', 'mmstar', 'realworldqa', 'mmt-bench_val', 'mmt-bench_test', 'mmt-bench_all'], dataset): + return 'multi-choice' + elif listinstr(['mme', 'hallusion'], dataset): + return 'Y/N' + elif 'coco' in dataset: + return 'Caption' + elif listinstr(['ocrvqa', 'textvqa', 'chartqa', 'mathvista', 'docvqa', 'infovqa', 'llavabench', + 'mmvet', 'ocrbench'], dataset): + return 'VQA' + else: + if dataset not in dataset_URLs: + import warnings + warnings.warn(f"Dataset {dataset} not found in dataset_URLs, will use 'multi-choice' as the default TYPE.") + return 'multi-choice' + else: + return 'QA' + + +def abbr2full(s): + datasets = [x for x in img_root_map] + ins = [s in d for d in datasets] + if sum(ins) == 1: + for d in datasets: + if s in d: + return d + else: + return s diff --git a/vlmeval/utils/matching_util.py b/vlmeval/utils/matching_util.py new file mode 100644 index 0000000..ccdf1b7 --- /dev/null +++ b/vlmeval/utils/matching_util.py @@ -0,0 +1,69 @@ +import string +import copy as cp +import os +from ..smp import * + + +def can_infer_option(answer, choices): + verbose = os.environ.get('VERBOSE', 0) + # Choices is a dictionary + if 'Failed to obtain answer via API' in answer: + return False + + reject_to_answer = [ + "Sorry, I can't help with images of people yet.", + "I can't process this file.", + "I'm sorry, but without the image provided", + 'Cannot determine the answer' + ] + for err in reject_to_answer: + if err in answer: + return 'Z' + + def count_choice(splits, choices, prefix='', suffix=''): + cnt = 0 + for c in choices: + if prefix + c + suffix in splits: + cnt += 1 + return cnt + + answer_mod = cp.copy(answer) + chars = '.()[],:;!*#{}' + for c in chars: + answer_mod = answer_mod.replace(c, ' ') + + splits = [x.strip() for x in answer_mod.split()] + count = count_choice(splits, choices) + + if count == 1: + for ch in choices: + if 'A' in splits and len(splits) > 3 and verbose: + logger = get_logger('Evaluation') + logger.info(f'A might be a quantifier in the string: {answer}.') + return False + if ch in splits: + return ch + elif count == 0 and count_choice(splits, {'Z', ''}) == 1: + return 'Z' + return False + + +def can_infer_text(answer, choices): + answer = answer.lower() + assert isinstance(choices, dict) + for k in choices: + assert k in string.ascii_uppercase + choices[k] = str(choices[k]).lower() + cands = [] + for k in choices: + if choices[k] in answer: + cands.append(k) + if len(cands) == 1: + return cands[0] + return False + + +def can_infer(answer, choices): + answer = str(answer) + copt = can_infer_option(answer, choices) + return copt if copt else can_infer_text(answer, choices) diff --git a/vlmeval/utils/mp_util.py b/vlmeval/utils/mp_util.py new file mode 100644 index 0000000..2322e2d --- /dev/null +++ b/vlmeval/utils/mp_util.py @@ -0,0 +1,191 @@ +from multiprocessing import Pool +import os +from typing import Callable, Iterable, Sized + +from rich.progress import (BarColumn, MofNCompleteColumn, Progress, Task, + TaskProgressColumn, TextColumn, TimeRemainingColumn) +from rich.text import Text +import os.path as osp +import portalocker +from ..smp import load, dump + + +class _Worker: + """Function wrapper for ``track_progress_rich``""" + + def __init__(self, func) -> None: + self.func = func + + def __call__(self, inputs): + inputs, idx = inputs + if not isinstance(inputs, (tuple, list, dict)): + inputs = (inputs, ) + + if isinstance(inputs, dict): + return self.func(**inputs), idx + else: + return self.func(*inputs), idx + + +class _SkipFirstTimeRemainingColumn(TimeRemainingColumn): + """Skip calculating remaining time for the first few times. + + Args: + skip_times (int): The number of times to skip. Defaults to 0. + """ + + def __init__(self, *args, skip_times=0, **kwargs): + super().__init__(*args, **kwargs) + self.skip_times = skip_times + + def render(self, task: Task) -> Text: + """Show time remaining.""" + if task.completed <= self.skip_times: + return Text('-:--:--', style='progress.remaining') + return super().render(task) + + +def _tasks_with_index(tasks): + """Add index to tasks.""" + for idx, task in enumerate(tasks): + yield task, idx + + +def track_progress_rich(func: Callable, + tasks: Iterable = tuple(), + task_num: int = None, + nproc: int = 1, + chunksize: int = 1, + description: str = 'Processing', + save=None, keys=None, + color: str = 'blue') -> list: + """Track the progress of parallel task execution with a progress bar. The + built-in :mod:`multiprocessing` module is used for process pools and tasks + are done with :func:`Pool.map` or :func:`Pool.imap_unordered`. + + Args: + func (callable): The function to be applied to each task. + tasks (Iterable or Sized): A tuple of tasks. There are several cases + for different format tasks: + - When ``func`` accepts no arguments: tasks should be an empty + tuple, and ``task_num`` must be specified. + - When ``func`` accepts only one argument: tasks should be a tuple + containing the argument. + - When ``func`` accepts multiple arguments: tasks should be a + tuple, with each element representing a set of arguments. + If an element is a ``dict``, it will be parsed as a set of + keyword-only arguments. + Defaults to an empty tuple. + task_num (int, optional): If ``tasks`` is an iterator which does not + have length, the number of tasks can be provided by ``task_num``. + Defaults to None. + nproc (int): Process (worker) number, if nuproc is 1, + use single process. Defaults to 1. + chunksize (int): Refer to :class:`multiprocessing.Pool` for details. + Defaults to 1. + description (str): The description of progress bar. + Defaults to "Process". + color (str): The color of progress bar. Defaults to "blue". + + Examples: + >>> import time + + >>> def func(x): + ... time.sleep(1) + ... return x**2 + >>> track_progress_rich(func, range(10), nproc=2) + + Returns: + list: The task results. + """ + if save is not None: + assert osp.exists(osp.dirname(save)) or osp.dirname(save) == '' + if not osp.exists(save): + dump({}, save) + if keys is not None: + assert len(keys) == len(tasks) + + if not callable(func): + raise TypeError('func must be a callable object') + if not isinstance(tasks, Iterable): + raise TypeError( + f'tasks must be an iterable object, but got {type(tasks)}') + if isinstance(tasks, Sized): + if len(tasks) == 0: + if task_num is None: + raise ValueError('If tasks is an empty iterable, ' + 'task_num must be set') + else: + tasks = tuple(tuple() for _ in range(task_num)) + else: + if task_num is not None and task_num != len(tasks): + raise ValueError('task_num does not match the length of tasks') + task_num = len(tasks) + + if nproc <= 0: + raise ValueError('nproc must be a positive number') + + skip_times = nproc * chunksize if nproc > 1 else 0 + prog_bar = Progress( + TextColumn('{task.description}'), + BarColumn(), + _SkipFirstTimeRemainingColumn(skip_times=skip_times), + MofNCompleteColumn(), + TaskProgressColumn(show_speed=True), + ) + + worker = _Worker(func) + task_id = prog_bar.add_task( + total=task_num, color=color, description=description) + tasks = _tasks_with_index(tasks) + + # Use single process when nproc is 1, else use multiprocess. + with prog_bar: + if nproc == 1: + results = [] + for task in tasks: + result, idx = worker(task) + results.append(worker(task)[0]) + if save is not None: + with portalocker.Lock(save, timeout=5) as fh: + ans = load(save) + ans[keys[idx]] = result + + if os.environ.get('VERBOSE', True): + print(keys[idx], result, flush=True) + + dump(ans, save) + fh.flush() + os.fsync(fh.fileno()) + + prog_bar.update(task_id, advance=1, refresh=True) + else: + with Pool(nproc) as pool: + results = [] + unordered_results = [] + gen = pool.imap_unordered(worker, tasks, chunksize) + try: + for result in gen: + result, idx = result + unordered_results.append((result, idx)) + + if save is not None: + with portalocker.Lock(save, timeout=5) as fh: + ans = load(save) + ans[keys[idx]] = result + + if os.environ.get('VERBOSE', False): + print(keys[idx], result, flush=True) + + dump(ans, save) + fh.flush() + os.fsync(fh.fileno()) + + results.append(None) + prog_bar.update(task_id, advance=1, refresh=True) + except Exception as e: + prog_bar.stop() + raise e + for result, idx in unordered_results: + results[idx] = result + return results diff --git a/vlmeval/vlm/__init__.py b/vlmeval/vlm/__init__.py new file mode 100644 index 0000000..8d2492c --- /dev/null +++ b/vlmeval/vlm/__init__.py @@ -0,0 +1,25 @@ +import torch + +torch.set_grad_enabled(False) +torch.manual_seed(1234) +from .base import BaseModel +from .cogvlm import CogVlm +from .emu import Emu +from .idefics import IDEFICS, IDEFICS2 +from .instructblip import InstructBLIP +from .llava import LLaVA, LLaVA_Next, LLaVA_XTuner +from .minicpm_v import MiniCPM_V +from .minigpt4 import MiniGPT4 +from .mmalaya import MMAlaya +from .monkey import Monkey, MonkeyChat +from .mplug_owl2 import mPLUG_Owl2 +from .omnilmm import OmniLMM12B +from .open_flamingo import OpenFlamingo +from .pandagpt import PandaGPT +from .qwen_vl import QwenVL, QwenVLChat +from .transcore_m import TransCoreM +from .visualglm import VisualGLM +from .xcomposer import ShareCaptioner, XComposer, XComposer2, XComposer2_4KHD +from .yi_vl import Yi_VL +from .internvl_chat import InternVLChat +from .deepseek_vl import DeepSeekVL diff --git a/vlmeval/vlm/base.py b/vlmeval/vlm/base.py new file mode 100644 index 0000000..5d9ed0a --- /dev/null +++ b/vlmeval/vlm/base.py @@ -0,0 +1,153 @@ +from ..smp import * +from ..utils.dataset_config import img_root_map +from abc import abstractmethod + + +class BaseModel: + + INTERLEAVE = False + allowed_types = ['text', 'image'] + + def use_custom_prompt(self, dataset): + """Whether to use custom prompt for the given dataset. + + Args: + dataset (str): The name of the dataset. + + Returns: + bool: Whether to use custom prompt. If True, will call `build_prompt` of the VLM to build the prompt. + Default to False. + """ + return False + + @abstractmethod + def build_prompt(self, line, dataset): + """Build custom prompts for a specific dataset. Called only if `use_custom_prompt` returns True. + + Args: + line (line of pd.DataFrame): The raw input line. + dataset (str): The name of the dataset. + + Returns: + str: The built message. + """ + raise NotImplementedError + + def dump_image(self, line, dataset): + """Dump the image(s) of the input line to the corresponding dataset folder. + + Args: + line (line of pd.DataFrame): The raw input line. + dataset (str): The name of the dataset. + + Returns: + str | list[str]: The paths of the dumped images. + """ + ROOT = LMUDataRoot() + assert isinstance(dataset, str) + img_root = osp.join(ROOT, 'images', img_root_map[dataset] if dataset in img_root_map else dataset) + os.makedirs(img_root, exist_ok=True) + if isinstance(line['image'], list): + tgt_path = [] + assert 'image_path' in line + for img, im_name in zip(line['image'], line['image_path']): + path = osp.join(img_root, im_name) + if not read_ok(path): + decode_base64_to_image_file(img, path) + tgt_path.append(path) + else: + tgt_path = osp.join(img_root, f"{line['index']}.jpg") + if not read_ok(tgt_path): + decode_base64_to_image_file(line['image'], tgt_path) + tgt_path = [tgt_path] + return tgt_path + + @abstractmethod + def generate_inner(self, message, dataset=None): + raise NotImplementedError + + def check_content(self, msgs): + """Check the content type of the input. Four types are allowed: str, dict, liststr, listdict. + """ + if isinstance(msgs, str): + return 'str' + if isinstance(msgs, dict): + return 'dict' + if isinstance(msgs, list): + types = [self.check_content(m) for m in msgs] + if all(t == 'str' for t in types): + return 'liststr' + if all(t == 'dict' for t in types): + return 'listdict' + return 'unknown' + + def preproc_content(self, inputs): + """Convert the raw input messages to a list of dicts. + + Args: + inputs: raw input messages. + + Returns: + list(dict): The preprocessed input messages. Will return None if failed to preprocess the input. + """ + if self.check_content(inputs) == 'str': + return [dict(type='text', value=inputs)] + elif self.check_content(inputs) == 'dict': + assert 'type' in inputs and 'value' in inputs + return [inputs] + elif self.check_content(inputs) == 'liststr': + res = [] + for s in inputs: + mime, pth = parse_file(s) + if mime is None or mime == 'unknown': + res.append(dict(type='text', value=s)) + else: + res.append(dict(type=mime.split('/')[0], value=pth)) + return res + elif self.check_content(inputs) == 'listdict': + for item in inputs: + assert 'type' in item and 'value' in item + mime, s = parse_file(item['value']) + if mime is None: + assert item['type'] == 'text' + else: + assert mime.split('/')[0] == item['type'] + item['value'] = s + return inputs + else: + return None + + def generate(self, message, dataset=None): + """Generate the output message. + + Args: + message (list[dict]): The input message. + dataset (str, optional): The name of the dataset. Defaults to None. + + Returns: + str: The generated message. + """ + assert self.check_content(message) in ['str', 'dict', 'liststr', 'listdict'], f'Invalid input type: {message}' + message = self.preproc_content(message) + assert message is not None and self.check_content(message) == 'listdict' + for item in message: + assert item['type'] in self.allowed_types, f'Invalid input type: {item["type"]}' + return self.generate_inner(message, dataset) + + def message_to_promptimg(self, message): + assert not self.INTERLEAVE + model_name = self.__class__.__name__ + warnings.warn( + f'Model {model_name} does not support interleaved input. ' + 'Will use the first image and aggregated texts as prompt. ') + num_images = len([x for x in message if x['type'] == 'image']) + if num_images == 0: + prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text']) + image = None + elif num_images == 1: + prompt = '\n'.join([x['value'] for x in message if x['type'] == 'text']) + image = [x['value'] for x in message if x['type'] == 'image'][0] + else: + prompt = '\n'.join([x['value'] if x['type'] == 'text' else '' for x in message]) + image = [x['value'] for x in message if x['type'] == 'image'][0] + return prompt, image diff --git a/vlmeval/vlm/cogvlm.py b/vlmeval/vlm/cogvlm.py new file mode 100644 index 0000000..5999c9c --- /dev/null +++ b/vlmeval/vlm/cogvlm.py @@ -0,0 +1,84 @@ +import torch +from PIL import Image +from .base import BaseModel +from ..smp import * +from ..utils import DATASET_TYPE +from transformers import AutoModelForCausalLM, LlamaTokenizer + + +class CogVlm(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = False + + def __init__(self, + name='cogvlm-chat', + tokenizer_name='lmsys/vicuna-7b-v1.5', + **kwargs): + self.tokenizer = LlamaTokenizer.from_pretrained(tokenizer_name) + self.kwargs = kwargs + self.model = AutoModelForCausalLM.from_pretrained( + f'THUDM/{name}-hf', + torch_dtype=torch.bfloat16, + trust_remote_code=True, + ).to('cuda').eval() + + def use_custom_prompt(self, dataset): + assert dataset is not None + if DATASET_TYPE(dataset) == 'multi-choice': + return True + 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) + + if dataset is not None and DATASET_TYPE(dataset) == 'multi-choice': + 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 + + option_candidate = string.ascii_uppercase + options = { + cand: line[cand] + for cand in option_candidate + if cand in line and not pd.isna(line[cand]) + } + for key, item in options.items(): + question += f'\n{key}. {item}' + prompt = question + + if not cn_string(prompt): + prompt = prompt + '\n' + "Answer with the option's letter from the given choices directly." + else: + prompt = prompt + '\n' + '请直接回答选项字母。' + else: + prompt = line['question'] + 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) + + image = Image.open(image_path).convert('RGB') + inputs = self.model.build_conversation_input_ids( + self.tokenizer, query=prompt, history=[], images=[image]) # chat mode + inputs = { + 'input_ids': inputs['input_ids'].unsqueeze(0).to('cuda'), + 'token_type_ids': inputs['token_type_ids'].unsqueeze(0).to('cuda'), + 'attention_mask': inputs['attention_mask'].unsqueeze(0).to('cuda'), + 'images': [[inputs['images'][0].to('cuda').to(torch.bfloat16)]], + } + gen_kwargs = {'max_length': 2048, 'do_sample': False} + gen_kwargs.update(self.kwargs) + + with torch.no_grad(): + outputs = self.model.generate(**inputs, **gen_kwargs) + outputs = outputs[:, inputs['input_ids'].shape[1]:] + response = self.tokenizer.decode(outputs[0]) + response = response.split('')[0].strip() + return response diff --git a/vlmeval/vlm/deepseek_vl.py b/vlmeval/vlm/deepseek_vl.py new file mode 100644 index 0000000..492e7d4 --- /dev/null +++ b/vlmeval/vlm/deepseek_vl.py @@ -0,0 +1,69 @@ +import sys +import torch +from transformers import AutoModelForCausalLM +import warnings +from .base import BaseModel + + +class DeepSeekVL(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = True + + def check_install(self): + try: + import deepseek_vl + except ImportError: + warnings.warn( + 'Please first install deepseek_vl from source codes in: https://github.com/deepseek-ai/DeepSeek-VL') + sys.exit(-1) + + def __init__(self, model_path='deepseek-ai/deepseek-vl-1.3b-chat', **kwargs): + self.check_install() + assert model_path is not None + self.model_path = model_path + from deepseek_vl.models import VLChatProcessor + + self.vl_chat_processor = VLChatProcessor.from_pretrained(model_path) + self.tokenizer = self.vl_chat_processor.tokenizer + + model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True) + self.model = model.to(torch.bfloat16).cuda().eval() + + torch.cuda.empty_cache() + default_kwargs = dict(max_new_tokens=512, do_sample=False, use_cache=True) + default_kwargs.update(kwargs) + self.kwargs = default_kwargs + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def prepare_inputs(self, message): + content, images = '', [] + for s in message: + if s['type'] == 'image': + images.append(s['value']) + content += '' + elif s['type'] == 'text': + content += s['value'] + conversation = [ + dict(role='User', content=content, images=images), + dict(role='Assistant', content='') + ] + return conversation + + def generate_inner(self, message, dataset=None): + conversation = self.prepare_inputs(message) + from deepseek_vl.utils.io import load_pil_images + pil_images = load_pil_images(conversation) + prepare_inputs = self.vl_chat_processor(conversations=conversation, images=pil_images, force_batchify=True) + prepare_inputs = prepare_inputs.to(self.model.device) + inputs_embeds = self.model.prepare_inputs_embeds(**prepare_inputs) + + outputs = self.model.language_model.generate( + inputs_embeds=inputs_embeds, + attention_mask=prepare_inputs.attention_mask, + pad_token_id=self.tokenizer.eos_token_id, + bos_token_id=self.tokenizer.bos_token_id, + eos_token_id=self.tokenizer.eos_token_id, + **self.kwargs) + answer = self.tokenizer.decode(outputs[0].cpu().tolist(), skip_special_tokens=True) + return answer diff --git a/vlmeval/vlm/emu.py b/vlmeval/vlm/emu.py new file mode 100644 index 0000000..1051c79 --- /dev/null +++ b/vlmeval/vlm/emu.py @@ -0,0 +1,89 @@ +import os +import torch +from PIL import Image +import os.path as osp +from .base import BaseModel +from ..smp import * + + +class Emu(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = True + + def __init__(self, + model_path='BAAI/Emu2-Chat', + **kwargs): + + self.model_path = model_path + assert osp.exists(model_path) or splitlen(model_path) == 2 + + from transformers import AutoModelForCausalLM, AutoTokenizer + from accelerate import init_empty_weights, infer_auto_device_map, dispatch_model + + local_rank = os.environ.get('LOCAL_RANK', 0) + + device_num = torch.cuda.device_count() + assert local_rank * 2 <= device_num, 'The number of devices does not match the world size' + assert device_num >= 2, 'You need at least 2 GPUs to use EMU' + + device_1 = local_rank + device_2 = local_rank + device_num // 2 + + torch.cuda.set_device(device_1) + torch.cuda.set_device(device_2) + + tokenizer = AutoTokenizer.from_pretrained(model_path) # "BAAI/Emu2-Chat" + self.tokenizer = tokenizer + with init_empty_weights(): + model = AutoModelForCausalLM.from_pretrained( + model_path, # "BAAI/Emu2-Chat" + torch_dtype=torch.bfloat16, + low_cpu_mem_usage=True, + trust_remote_code=True) + + device_map = infer_auto_device_map( + model, + max_memory={ + device_1: '38GiB', + device_2: '38GiB' + }, + no_split_module_classes=['Block', 'LlamaDecoderLayer']) + + # input and output logits should be on same device + device_map['model.decoder.lm.lm_head'] = device_1 + + model = dispatch_model( + model, + device_map=device_map).eval() + + self.model = model + kwargs_default = dict(max_new_tokens=512, length_penalty=-1) + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def generate_inner(self, message, dataset=None): + query, images = '', [] + for item in message: + if item['type'] == 'image': + images.append(Image.open(item['value']).convert('RGB')) + query += '[]' + elif item['type'] == 'text': + query += item['value'] + + inputs = self.model.build_input_ids( + text=[query], + tokenizer=self.tokenizer, + image=images + ) + + with torch.no_grad(): + outputs = self.model.generate( + input_ids=inputs['input_ids'], + attention_mask=inputs['attention_mask'], + image=inputs['image'].to(torch.bfloat16), + **self.kwargs) + + output_text = self.tokenizer.batch_decode(outputs, skip_special_tokens=True) + return output_text[0] diff --git a/vlmeval/vlm/idefics.py b/vlmeval/vlm/idefics.py new file mode 100644 index 0000000..8f1517b --- /dev/null +++ b/vlmeval/vlm/idefics.py @@ -0,0 +1,80 @@ +import torch +from PIL import Image +import os.path as osp +import warnings +from .base import BaseModel +from ..smp import splitlen, listinstr +from transformers import AutoProcessor, AutoModelForVision2Seq +from transformers.image_utils import load_image + + +class IDEFICS(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = True + + def __init__(self, + model_pth='HuggingFaceM4/idefics-9b-instruct', + **kwargs): + assert osp.exists(model_pth) or splitlen(model_pth) == 2 + from transformers import IdeficsForVisionText2Text, AutoProcessor + self.model = IdeficsForVisionText2Text.from_pretrained( + model_pth, torch_dtype=torch.bfloat16, device_map='auto') + self.processor = AutoProcessor.from_pretrained(model_pth) + kwargs_default = {'max_length': 512} + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + self.file_root = osp.dirname(__file__) + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def generate_inner(self, message, dataset=None): + prompts = ['Users:'] + [x['value'] for x in message] + ['', '\nAssistant: '] + inputs = self.processor(prompts, add_end_of_utterance_token=False, return_tensors='pt').to('cuda') + exit_condition = self.processor.tokenizer('', add_special_tokens=False).input_ids + bad_words_ids = self.processor.tokenizer( + ['', ''], + add_special_tokens=False).input_ids + + generated_ids = self.model.generate( + **inputs, eos_token_id=exit_condition, bad_words_ids=bad_words_ids, **self.kwargs) + generated_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True) + text = generated_text[0].split('\nAssistant: ')[-1] + return text + + +class IDEFICS2(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = True + + def __init__(self, + model_path='HuggingFaceM4/idefics2-8b', + **kwargs): + assert model_path is not None + self.model_path = model_path + # set size={"longest_edge": 448, "shortest_edge": 378} for limited maximum image resolution, such as MMMU. + self.processor = AutoProcessor.from_pretrained(model_path, size={'longest_edge': 448, 'shortest_edge': 378}) + self.model = AutoModelForVision2Seq.from_pretrained(model_path, device_map='cuda') + kwargs_default = {'max_new_tokens': 512} + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + torch.cuda.empty_cache() + + def generate_inner(self, message, dataset=None): + prompt, images = '', [] + for msg in message: + if msg['type'] == 'image': + img = load_image(msg['value']) + images.append(img) + prompt += '' + elif msg['type'] == 'text': + prompt += msg['value'] + prompt = f'User:{prompt}\nAssistant:' + inputs = self.processor(text=prompt, images=images, return_tensors='pt') + inputs = {k: v.to(self.model.device) for k, v in inputs.items()} + + generated_ids = self.model.generate(**inputs, **self.kwargs) + generated_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True)[0] + response = generated_text.split('\nAssistant:')[-1].strip() + return response diff --git a/vlmeval/vlm/instructblip.py b/vlmeval/vlm/instructblip.py new file mode 100644 index 0000000..6c7c3e9 --- /dev/null +++ b/vlmeval/vlm/instructblip.py @@ -0,0 +1,57 @@ +import torch +from PIL import Image +import os.path as osp +import sys +from .base import BaseModel +from ..smp import * + + +class InstructBLIP(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = False + + def __init__(self, name): + self.config_map = { + 'instructblip_7b': 'misc/blip2_instruct_vicuna7b.yaml', + 'instructblip_13b': 'misc/blip2_instruct_vicuna13b.yaml', + } + + self.file_path = __file__ + config_root = osp.dirname(self.file_path) + + try: + from lavis.models import load_preprocess + from omegaconf import OmegaConf + from lavis.common.registry import registry + except: + warnings.warn('Please install lavis before using InstructBLIP. ') + sys.exit(-1) + + assert name in self.config_map + cfg_path = osp.join(config_root, self.config_map[name]) + cfg = OmegaConf.load(cfg_path) + + model_cfg = cfg.model + assert osp.exists(model_cfg.llm_model) or splitlen(model_cfg.llm_model) == 2 + model_cls = registry.get_model_class(name='blip2_vicuna_instruct') + model = model_cls.from_config(model_cfg) + model.eval() + + self.device = torch.device('cuda') if torch.cuda.is_available() else 'cpu' + device = self.device + model.to(device) + self.model = model + self.kwargs = {'max_length': 512} + + preprocess_cfg = cfg.preprocess + vis_processors, _ = load_preprocess(preprocess_cfg) + self.vis_processors = vis_processors + + def generate_inner(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + vis_processors = self.vis_processors + raw_image = Image.open(image_path).convert('RGB') + image_tensor = vis_processors['eval'](raw_image).unsqueeze(0).to(self.device) + outputs = self.model.generate(dict(image=image_tensor, prompt=prompt)) + return outputs[0] diff --git a/vlmeval/vlm/internvl_chat.py b/vlmeval/vlm/internvl_chat.py new file mode 100644 index 0000000..6a7d4df --- /dev/null +++ b/vlmeval/vlm/internvl_chat.py @@ -0,0 +1,213 @@ +import torch +from transformers import AutoTokenizer, AutoModel, CLIPImageProcessor +import warnings +from PIL import Image +from .base import BaseModel +from ..smp import * +from ..utils import DATASET_TYPE +import pandas as pd +import string +import torchvision.transforms as T + +from torchvision.transforms.functional import InterpolationMode + + +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): + image = Image.open(image_file).convert('RGB') + 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 + + +class InternVLChat(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = False + + def __init__(self, model_path='OpenGVLab/InternVL-Chat-Chinese-V1-1', **kwargs): + assert model_path is not None + self.model_path = model_path + self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True, use_fast=False) + device = torch.cuda.current_device() + self.device = device + self.model = AutoModel.from_pretrained(model_path, torch_dtype=torch.bfloat16, + trust_remote_code=True).eval().to(device) + self.image_size = self.model.config.vision_config.image_size + + if 'V1-1' in model_path: + kwargs_default = dict(do_sample=False, max_new_tokens=1024, top_p=None, num_beams=5) + else: + kwargs_default = dict(do_sample=False, max_new_tokens=1024, top_p=None, num_beams=1) + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def use_custom_prompt(self, dataset): + return True + + def build_multi_choice_prompt(self, 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_prompt(self, line, dataset=None): + assert self.use_custom_prompt(dataset) + assert dataset is None or isinstance(dataset, str) + tgt_path = self.dump_image(line, dataset) + + if 'V1-1' in self.model_path: + kwargs_default = dict(do_sample=False, max_new_tokens=1024, top_p=None, num_beams=5) + else: + kwargs_default = dict(do_sample=False, max_new_tokens=1024, top_p=None, num_beams=1) + self.kwargs = kwargs_default + if dataset is not None and listinstr(['MME'], dataset): + question = line['question'] + prompt = question + ' Answer the question using a single word or phrase.' + if 'V1-2' not in self.model_path: + self.kwargs = dict(do_sample=True, max_new_tokens=5, top_k=50, num_beams=5, top_p=0.9) + elif dataset is not None and listinstr(['HallusionBench'], dataset): + question = line['question'] + prompt = question + ' Please answer yes or no. Answer the question using a single word or phrase.' + elif dataset is not None and DATASET_TYPE(dataset) == 'multi-choice': + prompt = self.build_multi_choice_prompt(line, dataset) + elif dataset is not None and DATASET_TYPE(dataset) == 'VQA': + if 'MathVista' in dataset: + prompt = line['question'] + elif listinstr(['LLaVABench'], dataset): + question = line['question'] + prompt = question + '\nAnswer this question in detail.' + elif listinstr(['MMVet'], dataset): + prompt = line['question'] + else: + question = line['question'] + prompt = question + '\nAnswer the question using a single word or phrase.' + else: + prompt = line['question'] + + message = [dict(type='text', value=prompt)] + message.extend([dict(type='image', value=s) for s in tgt_path]) + + return message + + def generate_v1_5(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + if dataset is not None and listinstr(['DocVQA_TEST', 'DocVQA_VAL', 'ChartQA_TEST'], dataset): + self.max_num = 12 + elif dataset is not None and listinstr(['InfoVQA_VAL', 'InfoVQA_TEST', 'OCRBench'], dataset): + self.max_num = 24 + else: + self.max_num = 6 + pixel_values = load_image(image_path, max_num=self.max_num).cuda().to(torch.bfloat16) + with torch.no_grad(): + response = self.model.chat(self.tokenizer, pixel_values=pixel_values, + question=prompt, generation_config=self.kwargs) + response = response.split('[UNUSED_TOKEN_145]')[0] + return response + + def generate_v1_2(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + image = Image.open(image_path).convert('RGB') + image = image.resize((self.image_size, self.image_size)) + image_processor = CLIPImageProcessor.from_pretrained(self.model_path) + pixel_values = image_processor(images=image, return_tensors='pt').pixel_values + pixel_values = pixel_values.to(torch.bfloat16).to(self.device) + with torch.no_grad(): + response = self.model.chat(self.tokenizer, pixel_values=pixel_values, + question=prompt, generation_config=self.kwargs) + return response + + def generate_inner(self, message, dataset=None): + if 'V1-5' in self.model_path: + return self.generate_v1_5(message, dataset) + else: + return self.generate_v1_2(message, dataset) diff --git a/vlmeval/vlm/llava/__init__.py b/vlmeval/vlm/llava/__init__.py new file mode 100644 index 0000000..edf40bb --- /dev/null +++ b/vlmeval/vlm/llava/__init__.py @@ -0,0 +1,4 @@ +from .llava import LLaVA, LLaVA_Next +from .llava_xtuner import LLaVA_XTuner + +__all__ = ['LLaVA', 'LLaVA_Next', 'LLaVA_XTuner'] diff --git a/vlmeval/vlm/llava/llava.py b/vlmeval/vlm/llava/llava.py new file mode 100644 index 0000000..958aad0 --- /dev/null +++ b/vlmeval/vlm/llava/llava.py @@ -0,0 +1,260 @@ +import torch +from PIL import Image +from abc import abstractproperty +import sys +import os.path as osp +from ..base import BaseModel +from ...smp import * +from ...utils import DATASET_TYPE + + +class LLaVA(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = True + + def __init__(self, + model_pth='liuhaotian/llava_v1.5_7b', + **kwargs): + try: + from llava.model.builder import load_pretrained_model + from llava.mm_utils import get_model_name_from_path + except: + warnings.warn('Please install llava before using LLaVA') + sys.exit(-1) + + warnings.warn('Please install the latest version of llava from github before you evaluate the LLaVA model. ') + assert osp.exists(model_pth) or splitlen(model_pth) == 2 + + if model_pth == 'Lin-Chen/ShareGPT4V-7B': + model_name = 'llava-v1.5-7b' + elif model_pth == 'Lin-Chen/ShareGPT4V-13B': + model_name = 'llava-v1.5-13b' + else: + model_name = get_model_name_from_path(model_pth) + + try: + self.tokenizer, self.model, self.image_processor, self.context_len = load_pretrained_model( + model_path=model_pth, + model_base=None, + model_name=model_name, + device='cpu', + device_map='cpu' + ) + except: + if 'ShareGPT4V' in model_pth: + import llava + warnings.warn( + 'Please manually remove the encoder type check in ' + f'{llava.__path__[0]}/model/multimodal_encoder/builder.py ' + 'Line 8 to use the ShareGPT4V model. ') + else: + warnings.warn('Unknown error when loading LLaVA model.') + exit(-1) + + self.model = self.model.cuda() + self.conv_mode = 'llava_v1' + + kwargs_default = dict(do_sample=False, temperature=0, max_new_tokens=512, top_p=None, num_beams=1) + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def use_custom_prompt(self, dataset): + assert dataset is not None + if DATASET_TYPE(dataset) == 'multi-choice': + return True + return False + + def build_prompt(self, line, dataset=None): + assert self.use_custom_prompt(dataset) + assert dataset is None or isinstance(dataset, str) + tgt_path = self.dump_image(line, dataset) + + 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.' + + message = [dict(type='image', value=s) for s in tgt_path] + message.append(dict(type='text', value=prompt)) + return message + + def generate_inner(self, message, dataset=None): + from llava.mm_utils import process_images, tokenizer_image_token, KeywordsStoppingCriteria + from llava.constants import ( + IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN) + from llava.conversation import conv_templates, SeparatorStyle + + # Support interleave text and image + conv = conv_templates[self.conv_mode].copy() + conv.append_message(conv.roles[0], 'PLACEHOLDER') + conv.append_message(conv.roles[1], None) + prompt = conv.get_prompt() + + content, images = '', [] + for msg in message: + if msg['type'] == 'text': + content += msg['value'] + elif msg['type'] == 'image': + if self.model.config.mm_use_im_start_end: + content += DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + '\n' + else: + content += DEFAULT_IMAGE_TOKEN + '\n' + images.append(msg['value']) + + images = [Image.open(s).convert('RGB') for s in images] + args = abstractproperty() + args.image_aspect_ratio = 'pad' + image_tensor = process_images(images, self.image_processor, args).to('cuda', dtype=torch.float16) + prompt = prompt.replace('PLACEHOLDER', content) + + input_ids = tokenizer_image_token( + prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).cuda() + stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2 + keywords = [stop_str] + stopping_criteria = KeywordsStoppingCriteria(keywords, self.tokenizer, input_ids) + with torch.inference_mode(): + output_ids = self.model.generate( + input_ids, images=image_tensor, stopping_criteria=[stopping_criteria], **self.kwargs) + + output = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0].strip() + return output + + +class LLaVA_Next(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = True + + def __init__(self, model_pth='llava-hf/llava-v1.6-vicuna-7b-hf', **kwargs): + import transformers + assert version_cmp(transformers.__version__, '4.39.0', 'ge') + from transformers import LlavaNextProcessor, LlavaNextForConditionalGeneration + self.model_pth = model_pth + if '34b' in model_pth.lower(): + self.processor = LlavaNextProcessor.from_pretrained(self.model_pth, use_fast=False) + else: + self.processor = LlavaNextProcessor.from_pretrained(self.model_pth) + flash_attn_flag = False + try: + import flash_attn + flash_attn_flag = True + except ImportError: + pass + + if flash_attn_flag: + model = LlavaNextForConditionalGeneration.from_pretrained( + self.model_pth, torch_dtype=torch.float16, low_cpu_mem_usage=True, use_flash_attention_2=True) + else: + model = LlavaNextForConditionalGeneration.from_pretrained( + self.model_pth, torch_dtype=torch.float16, low_cpu_mem_usage=True) + + model = model.eval() + self.model = model.cuda() + kwargs_default = dict(do_sample=False, temperature=0, max_new_tokens=512, top_p=None, num_beams=1) + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def apply_prompt_template(self, message): + model_pth = self.model_pth.lower() + if 'mistral' in model_pth: + template = '[INST] PLACEHOLDER [/INST]' + elif 'vicuna' in model_pth: + template = ( + 'A chat between a curious human and an artificial intelligence assistant. ' + "The assistant gives helpful, detailed, and polite answers to the human's questions. " + 'USER: PLACEHOLDER ASSISTANT:' + ) + elif '34b' in model_pth: + template = ( + '<|im_start|>system\nAnswer the questions.<|im_end|><|im_start|>user\nPLACEHOLDER<|im_end|>' + '<|im_start|>assistant\n' + ) + else: + raise NotImplementedError(f'Prompt template for {model_pth} not implemented.') + + prompt = template.replace('PLACEHOLDER', f'\n{prompt}') + return prompt + + def use_custom_prompt(self, dataset): + assert dataset is not None + if DATASET_TYPE(dataset) == 'multi-choice': + return True + return False + + def build_prompt(self, line, dataset=None): + assert self.use_custom_prompt(dataset) + assert dataset is None or isinstance(dataset, str) + tgt_path = self.dump_image(line, dataset) + + 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.' + message = [dict(type='image', value=s) for s in tgt_path] + message.append(dict(type='text', value=prompt)) + return message + + def generate_inner(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + prompt = prompt.replace('', '[ImageHere]') + if prompt.find('[ImageHere]') != prompt.rfind('[ImageHere]'): + prompt += '\nThere exists multiple images in the conversation, but only the first one is displayed.' + + image = Image.open(image_path).convert('RGB') + prompt = self.apply_prompt_template(prompt) + + inputs = self.processor(prompt, image, return_tensors='pt').to('cuda') + output = self.model.generate(**inputs, **self.kwargs) + answer = self.processor.decode(output[0], skip_special_token=True) + if '' in answer: + answer = answer.replace('', '').strip() + if '[/INST]' in answer: + answer = answer.split('[/INST]')[1].strip() + elif 'ASSISTANT:' in answer: + answer = answer.split('ASSISTANT:')[1].strip() + elif 'assistant\n' in answer: + answer = answer.split('assistant\n')[1].strip() + + if '' in answer: + answer = answer.split('')[0].strip() + if '<|im_end|>' in answer: + answer = answer.split('<|im_end|>')[0].strip() + + return answer diff --git a/vlmeval/vlm/llava/llava_xtuner.py b/vlmeval/vlm/llava/llava_xtuner.py new file mode 100644 index 0000000..4f41bbb --- /dev/null +++ b/vlmeval/vlm/llava/llava_xtuner.py @@ -0,0 +1,226 @@ +import os +import os.path as osp +import string +import sys +import warnings + +import pandas as pd +import torch +from huggingface_hub import snapshot_download +from PIL import Image +from transformers import (AutoModel, AutoModelForCausalLM, AutoTokenizer, + CLIPImageProcessor, CLIPVisionModel, + GenerationConfig, StoppingCriteriaList) + +from ..base import BaseModel +from ...smp import cn_string, get_cache_path +from ...utils import DATASET_TYPE + + +class LLaVA_XTuner(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = False + + def __init__(self, + llava_path, + llm_path=None, + visual_encoder_path='openai/clip-vit-large-patch14-336', + visual_select_layer=-2, + prompt_template=None, + stop_words=[], + torch_dtype=torch.float16): + try: + from peft import PeftModel + from xtuner.utils import PROMPT_TEMPLATE, StopWordStoppingCriteria + except Exception: + warnings.warn( + 'Please install xtuner with `pip install -U xtuner` before ' + 'using LLaVA_XTuner') + sys.exit(-1) + + if not osp.isdir(llava_path): + cache_path = get_cache_path(llava_path) + if cache_path is not None: + llava_path = cache_path + else: + llava_path = snapshot_download(repo_id=llava_path) + assert osp.exists(llava_path) and osp.isdir(llava_path) + + # build visual_encoder + if 'llm' in os.listdir(llava_path): + assert llm_path is None, ( + "Please don't specify the `llm_path` since passed " + '`llava_path` contains a LLM!') + llm_path = osp.join(llava_path, 'llm') + else: + assert llm_path is not None, 'Please specify the `llm_path`!' + + llm = AutoModelForCausalLM.from_pretrained(llm_path, + trust_remote_code=True, + torch_dtype=torch_dtype, + device_map='cpu') + tokenizer = AutoTokenizer.from_pretrained(llm_path, + trust_remote_code=True, + encode_special_tokens=True) + print(f'Load LLM from {llm_path}') + + # build visual_encoder + if 'visual_encoder' in os.listdir(llava_path): + assert visual_encoder_path is None, ( + "Please don't specify the `visual_encoder_path` since passed " + '`llava_path` contains a visual encoder!') + visual_encoder_path = osp.join(llava_path, 'visual_encoder') + else: + assert visual_encoder_path is not None, ( + 'Please specify the `visual_encoder_path`!') + visual_encoder = CLIPVisionModel.from_pretrained( + visual_encoder_path, torch_dtype=torch_dtype, device_map='cpu') + image_processor = CLIPImageProcessor.from_pretrained( + visual_encoder_path) + print(f'Load visual_encoder from {visual_encoder_path}') + + # load adapter + if 'llm_adapter' in os.listdir(llava_path): + adapter_path = osp.join(llava_path, 'llm_adapter') + llm = PeftModel.from_pretrained(llm, + adapter_path, + trust_remote_code=True, + device_map='cpu') + print(f'Load LLM adapter from {llava_path}') + if 'visual_encoder_adapter' in os.listdir(llava_path): + adapter_path = osp.join(llava_path, 'visual_encoder_adapter') + visual_encoder = PeftModel.from_pretrained(visual_encoder, + adapter_path, + trust_remote_code=True, + device_map='cpu') + print(f'Load visual_encoder adapter from {llava_path}') + + # build projector + projector_path = osp.join(llava_path, 'projector') + projector = AutoModel.from_pretrained(projector_path, + trust_remote_code=True, + torch_dtype=torch_dtype, + device_map='cpu') + print(f'Load projector from {llava_path}') + + llm.eval() + visual_encoder.eval() + projector.eval() + + self.llm = llm.cuda() + self.tokenizer = tokenizer + self.visual_encoder = visual_encoder.cuda() + self.image_processor = image_processor + self.projector = projector.cuda() + self.visual_select_layer = visual_select_layer + if prompt_template is not None: + self.prompt_template = PROMPT_TEMPLATE[prompt_template] + stop_words += self.prompt_template.get('STOP_WORDS', []) + else: + self.prompt_template = None + + self.stop_criteria = StoppingCriteriaList() + for word in stop_words: + self.stop_criteria.append( + StopWordStoppingCriteria(self.tokenizer, word)) + + def build_gen_config(self, dataset): + gen_kwargs = dict(max_new_tokens=512, + do_sample=True, + temperature=1, + num_beams=5, + eos_token_id=self.tokenizer.eos_token_id, + pad_token_id=self.tokenizer.pad_token_id + if self.tokenizer.pad_token_id is not None else + self.tokenizer.eos_token_id) + # For single word generation + if (dataset is not None + and DATASET_TYPE(dataset) in ['multi-choice', 'Y/N']): + gen_kwargs.update( + dict(max_new_tokens=5, do_sample=False, num_beams=1)) + return GenerationConfig(**gen_kwargs) + + def use_custom_prompt(self, dataset): + assert dataset is not None + if DATASET_TYPE(dataset) == 'multi-choice': + return True + return False + + def build_prompt(self, line, dataset=None): + assert self.use_custom_prompt(dataset) + assert dataset is None or isinstance(dataset, str) + tgt_path = self.dump_image(line, dataset) + + 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}' + + if not cn_string(question): + prompt = question + '\n' + ("Answer with the option's letter " + 'from the given choices directly.') + else: + prompt = question + '\n' + '请直接回答选项字母。' + + message = [dict(type='text', value=prompt)] + message.extend([dict(type='image', value=s) for s in tgt_path]) + return message + + def generate_inner(self, message, dataset=None): + from xtuner.dataset.utils import expand2square + from xtuner.model.utils import prepare_inputs_labels_for_multimodal + from xtuner.utils import DEFAULT_IMAGE_TOKEN, IMAGE_TOKEN_INDEX + prompt, image_path = self.message_to_promptimg(message) + image = Image.open(image_path).convert('RGB') + image = expand2square( + image, + tuple(int(x * 255) for x in self.image_processor.image_mean)) + image = self.image_processor.preprocess( + image, return_tensors='pt')['pixel_values'][0] + image = image.cuda().unsqueeze(0) + visual_outputs = self.visual_encoder(image, output_hidden_states=True) + pixel_values = self.projector( + visual_outputs.hidden_states[self.visual_select_layer][:, 1:]) + + inputs = DEFAULT_IMAGE_TOKEN + '\n' + prompt + + if self.prompt_template: + inputs = self.prompt_template['INSTRUCTION'].format(input=inputs) + + chunk_encode = [] + for idx, chunk in enumerate(inputs.split(DEFAULT_IMAGE_TOKEN)): + if idx == 0: + cur_encode = self.tokenizer(chunk) + else: + cur_encode = self.tokenizer(chunk, add_special_tokens=False) + chunk_encode.append(cur_encode) + assert len(chunk_encode) == 2 + ids = [] + for idx, cur_chunk_encode in enumerate(chunk_encode): + ids.extend(cur_chunk_encode['input_ids']) + if idx != len(chunk_encode) - 1: + ids.append(IMAGE_TOKEN_INDEX) + ids = torch.tensor(ids).cuda().unsqueeze(0) + mm_inputs = prepare_inputs_labels_for_multimodal( + llm=self.llm, input_ids=ids, pixel_values=pixel_values) + + gen_config = self.build_gen_config(dataset) + generate_output = self.llm.generate( + **mm_inputs, + generation_config=gen_config, + streamer=None, + bos_token_id=self.tokenizer.bos_token_id, + stopping_criteria=self.stop_criteria) + predict = self.tokenizer.decode(generate_output[0], + skip_special_tokens=True).strip() + return predict diff --git a/vlmeval/vlm/minicpm_v.py b/vlmeval/vlm/minicpm_v.py new file mode 100644 index 0000000..7605482 --- /dev/null +++ b/vlmeval/vlm/minicpm_v.py @@ -0,0 +1,85 @@ +import torch +from PIL import Image +from transformers import AutoModel, AutoTokenizer + +from .base import BaseModel +from ..smp import * +from ..utils import DATASET_TYPE + + +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 = 1 if self.model_path == 'openbmb/MiniCPM-V' else 3 + + def use_custom_prompt(self, dataset): + assert dataset is not None + if listinstr(['MMMU'], dataset): + return True + 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) + image = Image.open(image_path).convert('RGB') + msgs = [{'role': 'user', 'content': prompt}] + if DATASET_TYPE(dataset) == 'multi-choice': + 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 diff --git a/vlmeval/vlm/minigpt4.py b/vlmeval/vlm/minigpt4.py new file mode 100644 index 0000000..382317f --- /dev/null +++ b/vlmeval/vlm/minigpt4.py @@ -0,0 +1,85 @@ +import torch +import sys +import os.path as osp +import warnings +from transformers import StoppingCriteriaList +from .base import BaseModel + + +class MiniGPT4(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = False + + def __init__(self, + mode='v2', + root='/mnt/petrelfs/share_data/duanhaodong/MiniGPT-4/', + temperature=1, + max_out_len=512): + + if root is None: + warnings.warn( + 'Please set root to the directory of MiniGPT-4, which is cloned from here: ' + 'https://github.com/Vision-CAIR/MiniGPT-4. ' + ) + + if mode == 'v2': + cfg = 'minigptv2_eval.yaml' + elif mode == 'v1_7b': + cfg = 'minigpt4_7b_eval.yaml' + elif mode == 'v1_13b': + cfg = 'minigpt4_13b_eval.yaml' + else: + raise NotImplementedError + + self.mode = mode + self.temperature = temperature + self.max_out_len = max_out_len + self.root = root + this_dir = osp.dirname(__file__) + + self.cfg = osp.join(this_dir, 'misc', cfg) + sys.path.append(self.root) + + from omegaconf import OmegaConf + from minigpt4.common.registry import registry + from minigpt4.conversation.conversation import StoppingCriteriaSub, CONV_VISION_Vicuna0, CONV_VISION_minigptv2 + + device = torch.cuda.current_device() + self.device = device + + cfg_path = self.cfg + cfg = OmegaConf.load(cfg_path) + + model_cfg = cfg.model + model_cfg.device_8bit = device + model_cls = registry.get_model_class(model_cfg.arch) + model = model_cls.from_config(model_cfg) + model = model.to(device) + model.eval() + vis_processor_cfg = cfg.datasets.cc_sbu_align.vis_processor.train + vis_processor = registry.get_processor_class(vis_processor_cfg.name).from_config(vis_processor_cfg) + self.model = model + self.vis_processor = vis_processor + + self.CONV_VISION = CONV_VISION_minigptv2 if self.mode == 'v2' else CONV_VISION_Vicuna0 + stop_words_ids = [[835], [2277, 29937]] + stop_words_ids = [torch.tensor(ids).to(device) for ids in stop_words_ids] + self.stopping_criteria = StoppingCriteriaList([StoppingCriteriaSub(stops=stop_words_ids)]) + + def generate_inner(self, message, dataset=None): + from minigpt4.conversation.conversation import Chat + prompt, image_path = self.message_to_promptimg(message) + if self.mode == 'v2': + chat = Chat(self.model, self.vis_processor, device=self.device) + else: + chat = Chat(self.model, self.vis_processor, device=self.device, stopping_criteria=self.stopping_criteria) + + chat_state = self.CONV_VISION.copy() + img_list = [] + _ = chat.upload_img(image_path, chat_state, img_list) + chat.encode_img(img_list) + chat.ask(prompt, chat_state) + with torch.inference_mode(): + msg = chat.answer(conv=chat_state, img_list=img_list)[0] + return msg diff --git a/vlmeval/vlm/misc/000000028137.jpg b/vlmeval/vlm/misc/000000028137.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ea1f70d8956245d86aebc50550c6c9ef8f7741ed GIT binary patch literal 184441 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 z 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 LhQaH z^T|vlw)8tDKUGlTm`Zl1a8MUmfI(2%AJ802fDLnj&0Q38N0Kbv5Y<$LuAo^>sHh|r zKoiBWZH9=EP3D2kwcep1=9CSyRW4Q`xk(;hF)%Fyw`>iKWI|zm;idRevBABeIA>ERwHNf!&Ub_p5D@WzTRW>GP)@V9~kwdS4A8abid!03Uz$#ikP$WdJw< z(@&}k6B~|>c8Bxgj2#LCI$o5GjRPehKrmypU(^2p7#4Y4`3tuK)9`K&?&Zn?6}p~$ zZ9<Xv^VI2DW!qY zw@P&L1+pAbE`0J6`@J@shl1 z9YCV+lV^~Y4LbTMb6Vt2S5vc6!d6fb3m~W@T6Y6$5jMqKZftMYm^vaRf$oydpc}5L ztbR5r)j^nau8OP0Wq*X!RVg5iss8|$rf2{^%y-yw*KEUH}!SP)ReJ8<_nARrGWd zD{_?@38vR9x0lm^;EA(IOo;%d<7~i)7QO@%=a)A!Tx*u-m*Gip7eIli=1~>ZH8^s7 zy`-!M07)c7p;PPJ_Tw5jFIaYgjur?RKdn<07eVYy854#3fB-ssSNs1t}?| z0H0-USdQf*(BbjO45CLiwE&L|b@LpOg|2ia3IrU)_zK_Rfn}_%E*}kRZ~#Wjq>pla zeL1v@X=TDk-E|5Xya~Q*ChRj__QNKmr=Eh$D_5Q$60W7%aZKX2$si~skWx7(u?3u=2&$BfpDs3fSyi|6$P4DT?wc_|9d_G3h zLiI-em^H<~ZZ-($=ragwLFY?tD^kvK?%+o|SYS$1HjT&c>lnY_jX7H947NU}?6AJl z!h3QgZk4BnbVN>Gh3)}c{9vSosbrXi3m$Fe9;XCiUI_5l>a#FODLI-yaR=N&R&1#* zr7CsWXF`;qv=cH3xK}s{z&LGVr|_c1hOpa>Yksz*EV+^DJyL%0A5K|;y4`N-yb=9M)K@*m%Xo3_I-^Q zMrBUC`EY;7PD&)AVX z7(5YgPs6qHw%wz3zdr@h8`}1;n#?Tv5TLr}mhXB#tl62V*09 z0S>C>d26bbuo)z2Vbaf+uaalcfn8Zb*;9y1m2E<2Vr5PwPyYZCl0C$jxWU+_FcF)d zF9Xe3;8+^LoP}a~Xp}JHyV^pQwUJ;7l4b$){{Yf^b{NR5E5hboB<@REy>q)*&C7^@BPIR>{Ts>LEPg`#0g0< zW`CF0^u=IjdqbkAb8P5^4zScT_O{XV!EUUhFL0zb6iR`3-cKWgBe_)ejy@K(-K&~T zUHrTjmxTv5BO|uIRPo#qNlX-_xPXGMFe(ZW$QK>N-2JgQWNmSC?=U-Zq-0U|&1gC* z&+1FfS8KgY;#8-QYg{Q(kp)33DH1!F01_Z~7C3koNv)5fI(gjoF}JBs&XhLd^~RR) z+fY!gL*+n5(2%2YJ6rNN9}?HRI1~G{Mm!fcC_4>Do`|mah_4NFuBDK+(h5=ncZmQ+ zpbkCzViSgW8Lq3J=Z@%39Rtk3H%mX-{P${Vl|R*8D8W;c`(}%kZX}wd4?{c;SoF3m zq=rc_jccnZ->;Q;@>dLSb}F3h2hXRHzW%3{%DQBY@V1KQ$C{%X@2Q-Q^mDE#DZ77HT(077juJ^qtcSD2G!FVIy70Nob} zTv=O$ayaaG?Zy(~U8Z@kv=7~(NxXwHKD-PhlEYPAQr-EI4}U=&x%8V}IKoM2cA&RR z^QloKD3v4$OoW)c`yWrf5IWj(2Y4!d%5(;9v{5RpwH5gkqM;%QkR~K|B>geA!{Zvq z7Y!5)oaQ-bZO%M`b`h&J7B zexzbNW-d5GdoyR6A{g8*+h|YKbVDeu&l*ykQ&dl>pyHJq(3OtBgpUElUm8Db{5^Ig$^VV z0Y0CX7^-uuhO}xF%wdh);HAwCkR-H~H%L}W_Jr_A@`+dHi%4+}bU8uV(DFkeb8q9K zD`{z!MUphy{8DxhQWJ1VHu|5xBMgQ|G!QmTEw>=cs7qn|-K8{CA(cu;0B-c`c)!~e z_?U&Y%{D&Yb$f-3Wh8CO?pJO=%VCr$ZK@Iih2}47{(Q*AG_5_OU361$?RyAm=8hhZ z1vj88H#X~G%*pGK0K;vLdz&Am^V~h`Yn^wfMa>%v>>Ywd)Jxp^$p(DTX2RlaZ|C*J z%R$NkKXlWSj_FLKQ~f&{gu`RA=|XGs6qCrs6rpf z(6UQlDM2YFXUp7n{{T+hVmV}W=tswr^zbug1kh2xUhC6M(Jr{wONeng7dS{MAf3vi zbpTvP@!rIKScilhxVYjiA-2)+v^<64H__Xf=z_ZHiYgOYUbnBwTMP+oIbWf=udmS+$f2gIXwwy-f|CcB?fox?!6~cfvLZ>F5o5O} zbx*(IXesp0vgu=JN~#-9l+LS)P_Uihd4(M?G2F>lem?k{gvB)F_;_`gxp=nXJ(^kuH4flh=WwzkN+l9a%oKnHW}?}}^;v6?N_-(_SN_MHvdcl9oh$II!% zYbhu_z>q|q)A{`^Y+Jx{$J-OHME1TH45xl-guX8;TWhMCy`?(Z-DC<>pb$w3Qy|Ii zWuifeh)LrX7;^E5BpuJZ(ta`*Lk?itpl*#_pxHrQBGd_KqOw2`JNlow#=Vj?lo?UCEH-69+^@(U8&q*XiJSPr8W{R=30VcKBV#M?|PhORyLk{t{_*L3T_dE4s)L+ zo7rAob`bV^NRprus_+%T5#n>f;UN8oykMz|Uf~$f*gZDYXrg2@!XoB+pQ@0u1+DDI zGXYHas;E)|mXcDn5~5@gZ?C=v#4*9S#-Lu8?nJr61=gAF> zr#LbCHq?nmu=O))N)UvA3P>9PR|aQ`PaNOd84O2qKnb(?vY!;j%LB5C0*_6(qmxIY z!PB{8WEChh+-=|po)2rBeA&g{n-w8D+4-+d;F*6(8E(`UcB5QnFA!2!wDa2E-}Z1e z6}hAh>QOlPLm_jIMMxULvvyv{NJ?RAQvOn?v>EOU51|LtN2W`K8Eo&T$f*R;hZi>J zRsR4U3K4NC@UsMjinr95PV|74piii@D{rlVH^s&t2+M=x8FZ@ZYR9KlJ7sK*1S|u%DJdstouKm^SlAl5Vqhm*ASCt%UB!%QUhynr4J~!ATMZwX2h6| zZ#}Kw6|NKqfl1%%LvJ%S#k>-hlMxh7mWhCyAZkK_ zl4G6Ol>{xK>%k+vhXd^( z$>;gg@dl9bNGa&IP1M$Xl_bV zmNhbtKYaHjo&Xcu(~cR4WMqMSi9VYJslvnr4saJ~;apbMUIwYgv?1iU*Fr? z7I-i-20U$d=80oF!ywSA%GA%P?OUByE$~9$a#9rmzupnH#EbK^)x z+oY&L@KhZ}(6I-3b-yXU7D=Ce{j0DMf?Uu>+_~33;R`$sVRMM0F01pGRcJ^;H>u{( z8~x(8quNyxJIr!_Tva$~yt&tUrOI%3woO1UMeQWV@ew}1ZvFAZ)Uwl#B~o{x+osnk z^!tlk-?kD=aDuNwJg*avK5}6#344yqGWS(Y_*TDXO)q=gh z3I6~S;xW)RTsAHi*cJ=u>)@i_i9d+GmuuX^Bv()KJl*D-rzxsallc_F+(hR~1KKqjism-)RG!g)$CL1|$ni5o=kHB$CaCIqC9Ij+`s}`uZU-N6 z2n?w}0t%C0XWS5e;Noc7@W45P@Z`Mu20fw9CsgvF%AKo1H?pyEl#pbob0m8E`iu=c zh3#+}QYJ_XF-hszAGs8yd<6D_i znkNV<^EG1vxaSACHE+=*S;Bc-OmLePOA%14$yo`Qc&QR1Qn&M(=!dH(=t@szTi`?(`yrVj-4 z`agJ`_0xqCo z)U1rVM8(w=4YiWzN1R^s+yG3w3#wx+2q~?ckPc$j&u8) zrd_XH7n>Mb#x_HnyP!mOX_9z7rGRwlo=^hg#*WHNVr(Z zDha&{P95>XubPq&VYF)n)7ulihVq zBuFv@&(oh=TVio8Gdb0*>F5c+f(sd$(Xp~>&_~67xbr-^jh5+Y*zglfnw48`kR$?9 zJwW0ki1x>x@X3jgxzZep!;?TI;K$27yZ$lRC2NyER$H*hP zs5!qIJ!upc12-`W`*c$AE?4ShCKa|J{pHZG;j_3Us9Nx&g3{w0eR)v6RNl(U|iAGHCNg8a6k6bW!D#Afqm%+yY@CBo#;y zkzo=JK3&B=<#Fo0p8*y~7}1~tmnN{>GNh#?Ab}fC<%i^&YB^HH+bS zeIrh*b9=WaDpTG_B{2ia1Rm$MJrFY~FK_N7k50dut4O=2L!cS}p{E|)n#VU6i7E+N z(iEk_t|0e~$IO3IgRqhpRzv%F_*d0(b`cot$;?e(#ESS@b9B0c@tTEC?N{O3Wl&V# zh60=^2{K4OC{_K8dw}M-_;<)@rt93M%;MvEHQ@d;yC?8BDHjc~f#qK`Fu z%S8i=EtbLZ0Tu#80q7+9N#x+nGg<{*IFv+8x8|*sEVZRYNiOb5QQarrPxBVNjrkas zW;BB49%#pxfEm4&KXmzlO_NaopWi8@s0BMD9mMzb1Y6nx#a=C>NkrbiM9f)eanVR? zeaBmPNCY8D+I-uLTg*Ls99Bl%Ktr}V0Jmf$>&KMmRvBeVeMnAON{K4n2h3!fLGvVD z^B&k1YGcHVJ?>w1roa=}hj{3nxy$Hgn7k7YC8b0Ok3c5G84-&(U2)muj}I+liwGcW zt3IZoPG)r_ZZCI?R8>2-D)WD&i0%5|xiIC?7qg$`CgLAqp`=;W5d8*aM^x0-DW&X9 z8iK$wB~B!K-HF@j{---86u7n0xMc@#E_R6j08yJ#mwqoZ2N~13eJ_dowS{j~k|asm zZX@QI5^R03G&08b<#4w*^M4gC2!hbT^603aFLBzwuIYocrNgMQ)TJZHNfk{9H<9M= zF$Ci06LDb7ZU(j2$HiGS~}O6 zReS3Fo0x@$$WsL}vtkI_e_MUWyko81IfGO*Rpd-;N{UcKhyfyF(gz3m;@T;Qa3N?T z#A!hwRphjxqBhu@6o?%9dVS>L#yn%#HQK%_rw}Y=D0%C>D-=2n#}I&z{^vv@56$9O zNalV0`;1<2{7b3XdLLCg-tnjgwqKbS+@^Op){3pjA6t)AR0fvzUWZWOQ|n4fTn1Zm zR3SsLJmcN?L^3&%x)5(Q?X_}I&BRPIvCnB0l%IB^)A~#Fbk&+~O;ps=&}FVvC0Syr zscI6l_>I|;3$3Xl`&5M}ou=YuBKx2D0x(+?Pd3sCByy`CPm041E-^fB5sG0aR@apk zbKM0_TU(@aIvQGb+Gj1z9n0y^rxfnSlG7_fQl-f-7DS!|cE`%BeYMUfo}Rk;uUKIZ zYh(%CO{+6@=(60`_9Y_nI*NePOENq}f+QtUZYFLckUc=IYx8C&T2e*}!2r=CM61>9 zPfesWHloa_Ypbaj72qKyZd zYRyxib4=q=yQ}MSG*K66l*&p;5Us{if|VaBjl^30t!KjUQT9%AoGr&s9aI8x$=XA0 zgrRbmsFfMks?O+Z9?c)Bqo@o!__7M-JH(jcB%Vjp6d3sABP^s_PcNbBtRj`IcwuJ0 z(NgYLow)rpUV_a&folmn?GNAGRY;*{*{RIt<@fvWomRfvT7>U zWJ!+{ix2(2=Z@H#1`MptIr;%owrsApN=Zj9A4P$#=4i&k>vJ$tkTz!%AM;1+WPu7&GhKUz0e_ zSkDYfW z!(f%$y^;R_mOZ4x zPl&)ASqz4QMFJ@7Me0o}arhC-b3DtTO;tJO+51PgMMMfY-g`$s^ zVPchZ{5#S)n|1R*(78-jm$e>CPFK1B0=a{J_X)Rr7sT9RlEbWv+h8)f!m5}DVdG?* zw1ePvU#Om^YFd2(MUv)On-%qFs;pfiQ%uouTcJt|RFSj@xi{mJF^a&yEP@)nH1P0R z+(rvKGP7Y?^-X6wuFDiGXW6zvsi-ms3X64~0DTKPh$CW7=`bx9IKM6~0q;6Ei#}c+ z2q41gTEKNWUoHNMg!;pnWg5e)olMPhsye*aEvwAUQ(&vWQiG4wxP>T?NF@$m(jsk* zAF{Z1K4#`1mfx-OLwiQ~3r}M3*9|u1_z>f-G*(YdL0Oq;)YU1ZOOMgi0pbJ_2H<#5 z5+n~!F{{Mz{4-*6ng}fbo_=1H$zm}0#~DOV8+=s5@U=i|b;gox5(=|ixeEcZAo#$P zl}M0wp52dbYH{Vvm5;mVtT53W&T~cC_$zktgPG1+r7Lm(TEc=R+etfnf2Z^B4h|OA zb2sR&F-*xGqf1iWmq8hO%l-OVOX}L9Cf=W?*8-JXoRyvyJ9`1sbjP&uM z*G}{!4mhyCz%cTPp*|AVDhNDvX;~ks1v*d#Dm@s2i9!^y?l*nAYJ@9p|G;mx#M37{0Uj4t)=c#+;}J{K_NT| zB-(%XTK@oC2wWW9H2nMsTx=rq=F_EkU&QF2`2%IgC{UjnXbb0XBpDw|#E(J;xyE0K zyfv;a>GV~Sj@kl1IgOtqNcEsgiKL-#a=_Y@ozNF(1L$mjF^`w0HuoPAz1sxB*jUrO z50FT@;b-tog5xM?h)|d(o-bp5{{YhmaFRPwVOMe3%b+A3zcf^JuHPx9VX9)=#Z7pH zKpn{vNRb{`o;eq{2OgIJxf=I3sP!A7BMxiB+RNp&6w{?qxDkIb7Mqh` zPqboO1I}TXYB%ybD?BW2kTuSub*D?e&m|{xmYK$x%&MJ3VdCN&NdY8;!Bm66x`zk1 z0&h`|CP%e^P}b1X0vZ_Yo6GZ>Bv^e#ve_#_Q@T+AMK z$%f1t_h~|pq9!sBSYd_|TnGUu1qmZ^K;}nyxb7@t6z*vQJ5HO|iWXNoi`;Awm+Kr- zXq`jOEuqXwk;)9#+u$0LAhu2d+Br(Q@4Kv)EXkW=&=j=*-rv498-J6Jx5p3a|1M|rT=ks~H+O&02U`_zH8-YxHRO#c9kT*ae6hLob) zs7X%yEc}2KCQl?lCL@7?y(lTJwqx>r|)zf|aY0n$B3)-IxT-R(J}GLufa%AuxzX)Rte&9K*o(;vNcYIW40 zB?2Wt*h#}6#0jMhWL7}rQ{uupK-Mv!Uq2KYbx*At%P>gE{{U{~`in+>+-{Hd)jnLh zWLCI_i|IououhM3wD3V2z)3a|0h}z8IW9B-y7SxWosYwoVP4=te%_-?@+z;g-m_^9 zDCIVt&nooZZBv-|gMC8$CDRb22_;Gmsd7i5G5{f5{cFN;+&c*#Y*d|@c49n8rQ;sc zVtAG<{{Z7Q(B^|(IwD8nvo_IvIMMwTuB*$koUXp7FR6J>A*3{_w~6}ju2+i3r3aX*tF8xZH`T^9;qbtx_&oj&`slN|X zT-8G=VZ@#3URZ^a+yV)d5((s~F=)nNm}0=^IM>A<*^8SU4RqVhEi=^)kkE9qMCI&e zRgLvMy+K7&T(|RgT}SNl$y3tEXJn<+Mb;ESBuwo&Odcvsp~d=HvCg`!yc`l|Q^2N> zJ@@vs-s^6xq1GAGm6=|1O;we6Eww_Y8&X?Q0H~gsJByI zDxh#lqi}PFd!LefXkUmr%`2eMqg?6kSDw{1MroU@q}1k~6iwXloTF9lKZ;}v^Ce;U zn+-Xwp??l(l0q9!VXlL5l6)F*N2l%Dtv8;K2)c6)Prl29L^Ra z7+r5@8Cq>khQqkX9Bi7`MLX%JU0VwQE&u@9OiHKF+k?lpDEN+I;U;YkzFgGNwZvs7 zP5nQ$W!*4!EcCBU6aa*{YMdaFNfg;GU~iOzN%L;r6hD85oxuay0yHd zcxm4T;CB3=`db$+c><4Lf(A)WQeRd+MK@Y?8%(YUx7waoI8)4s7iqaAe8a>f4}EhxYR5Tg(2n&DGFBR)~-S0 zXycgnKak@N{m9tPVL)lkFm+{4?LD2XP_OxQsc9aiKpD9mf%W@=iHWw+^jDlKFrBWx zXgkhUg=dT>fFuC`i{r2cx`-rxZoLbFv& z$3~BNv9H3A`|z6cl)n%iD$Lwrx|Ol1^2&{hbHYh2sZK(a0=9xuF9)1YkY$j_PR=HU z^aDkb$6=iL;$vI|IB(^z%GJ?)SalVSp*hjaikmBAFUwiZD*Sg-T!jFow1grF@W*o( z22G~qQt-H5Twd4aXyip5f2FLRIa&{9Xr2E6fTf*NpqR`49}RtdPHC6ZwL?`~OcPyB zT5-@w01!^}6$F6`gSWAqX+Ku!B4h=i>8Pzm>u1RihKRMrjk^O)G&^bWR70OtSGk{S zCs?CfwP>uTVQr8=2@Kx+kP3$uza8;&?9)UCG;~@o-^oz%*raHCve45gJM*xjZ1`q1 zN^XNLc&f6gVWfqU07|(`#f7~O1MjBF`Q8}T)_oRZ69Y>di#i^Nh4@U$ooiodidwVb zxXxsa=x9#z+YYWr9$DIVAC?Kf7_FNO_$2I~UDMZYs@H%=C}fhh$r}Y}sR=p#I#Tb3 z+9}qul1MO95JYoh0(;De#5j1H*%udOtJbWYcKeie8I6^_o1au}kB`|)T5UlTN!$rZ zE~uy_C?salEF9 zByRbC<r?Mn(<6val}kpwW$f0JTxz9OGyool6l@#48^a^M`A5J z*GS7c>#x)D)IrV4Lv%IqU6d6C*J)c06urU_k`)km;{KieZHRF(fC&RdQI2&qH2&g1 zCzWy@^)2ZzrDs%a2GWEsr47hYJ7k^>t?wV#7(ZxU8-;tx)HI)hun_i-6{}ow`4A7y z9dyY%SRm|7T%?bCiTi$-`K8;hYG|MWWpx6iA)uDa3M!QtA|MFAslVzmbHO0ZBB0~A zg3#8FGkpT29dP1-ZGIwy>k26dQI#j=Ox^&Q_5C9rmn&G~pdf-Y>Q3QW!90#4g%T|I z_>~f^pzCUFw;w`_i*ag7O2nR4ZchO=i9Vv_I}01zBfB?i%ip)A$}t%YYlF4PReLg;Q_{;3JFn| zBXA}oxb5n1`3wdiFK%Fa!{64`j0Np$UPoU+y68RkDT{+$T9fkM;E9(G=?nGHeo;g%0^JntxDMz^ zA!!gvAYW+YeB9dO(*e1lQ%TgM{H~^ssYa>N-7#QobtLUOkVg57LG5nm>+6az){#R% zKIsC}A#fE)SI-t7>kh0!Tp+f#82NUT{^hj~S&hJs{kvnY${N~s+N}o-epp)ejZNR( zc6A!9#~~Nn#vWu5QBV@M0usW4q>whm4ZzrNKqrr;IU5J+ z8rJxHFYb)O$i~T6lx^m!OQ#`kbzi21)o*Qjmo8I^2WVVXAd+B#z&O7L^w=3YLtxnP z8Xa`=3N}gE${z3bI(g9x^gXFck5GDUl)bS5%1K&zpBW(}T1XZH)MGuu2y1oRjZpII z5WNZ4({*BrTGqOh?^2V!N=i~dDFsFhN7nxUPH-`d5C{v;gMH~@nV_H)LrElo%o+M$ z5x8V{>T zQ9GLCw7O?FezK4RlT%EJ2iEIeVh5eDw9g)Ek$raRNT-DiXJ-snCEJO7201(f}7wGCzdRr^75FF(Zv-0?$%( zKJ}^NIKb)MBx7=Jx!K(jnZHxIiSY%ca!o5w(>-0RT3hGwRMfdeU0Zcyd~Q3^v=qDXR|OpXXG}Of#|OGTUW;Dyp;2mFvvMRf-LB zr?qB=T^)YGm$67B1g`^+hR?%_mZU!~p)N%OnEr@7CTSW97RUFtBLhFob>OLT= z68OT=Rb6J$-4V+(4O3S@##NQMnFh@}ZtY8}T2zGXDI?SpA`=ivkwnmN@WvypS}dLJ zzm#*>$t8F{>8HPvhI(PB1xHNv-kPG%bB#FGR^>e_3#NPpmA6O|mk?DWYJviG5&3h1 zuvmDp5jaW#p{I!&{{RY|*yrJKQOLt&ZQ;#)Pez$uY`nWrbw5)zoCX-FZPe5TmV8F{ zqy(Fl08~ie-oy-fwlj)Dg>&*SI`km&9t+p_R5QJw<;`aF8h%=tI(en^hDTdfPfx6K z%*Z&6{{V`tu1mrs0JN0=l%n0o<<2GmM;LR6*7gKbj=AM(6w`ElZvOCI@k8KTh-ECSYM;I+5|@qHIOY*L`(R{{UHaMqQd^bWc*X zmo$d+3PhzyLP?Ua3}4f9M``SEdridSWSwkyluO+h6is<}se41$Ac_+yTF%iBAfz5W z;NveGjmSeAp#uI&96PP1^df?@Eeht&nrRfY;7C<7g&-d&{qv@MFC_ODJmT*J#|YZm zBx<>hX>5f50I~TdZgBAnaPC+_M9DBfGjYsz{IPABvJUp06-0~z+;pIjP~wu5fQ1eW zq>m^+>wGxj-LuW?ql}OXj;E)Z@2YuamiqvZW+S)c1}Y|fxMmvct>AGqIRz#3MQc}4 zlIoOvH05p)JZ>sJY5ITQ<2{Qm&ejb<2j5`*6@MIUK=E1XT>M-Y9D z_@B4FBFILI3E7Z!NYyJ=)8$nBlCytKJ#a?mkxUeFl^JU{iZteMRN9m_fOehR2H`3` zyz}emFNvgc3v6;8^`hWp98(;5AoDkMf45svEsrqVP4@Yw@%{J3Fm)2yE}ScW1+jaH z8F~|E%?{rePcV8vp3*I(u8r*LDMFiA+?6E_JmD9cOKCIPY@RWs_G%}8)L7>2e(h`C zsC}k$TYzxzA7lgkLgadNsFb0lr<3IXZkadkF&t0_lEUn_ z&#AS})EBV0fJqmpf%~gH=_SWg;pQ;-$2OfRYx2Wr+gu zGB1i=A%~I%4BENCbLC}Q@Tc~h?kEq6lJyTvw3bt|Gt2aEPO9phL3A#YP0}INt7s%0 z%mSryX5u0u1|@s+?K8M#(ywaht{)6%_P0=U{N$^Sma2jL-%!!I{$R#uU7LO$g`_eU z_}5D;pd~6vl&G5v5KLTS(tVtE9j$Yxb@Lv*O7pHe79h;y`-rRZvY1)kPMt5EBQ?|s zb($7KsR=`gan#i9+Jx*$;472I>5F){n>$9klYW1NQDU$XkVFRc7k+4#_*TiP8R|Yp zYQi2auBN>qxpQh&MCnRZ7D}O4N$v>r#ZMBOJ}kSS_uti7;2e7?8o+NiKZ>yIxz|^i zRK30S{2FD(2a- z%+5E^w3z9>KcAlE;~1<#5;zgL-8<-t!j`y!0Vi}pg_0y2NP%wnt;Eq9pUR{8$tc~K zgfMId{QOduQigmwaG$^{+*2(hHE{3%3jcbIjiz! zmXH}0Ey-1)0qp_^F>X)gj2E?+{{T;vw^Nk;5qK#oc3*XRej(TLGM5@L)J)@j_ z+P#Pc9CZk+q_r}YHv}k1pXhjr^!0;{4+3>Kn%knw`#~0R&!*NA3GoV) zT2!ZK^NAoB6aD++(c_)&w>6@P9(T;zwRDf{!8>2AD6_&>hK3N}N`ZyIP~1)Ag%cBE zE$!T3nB)!yhMR`zA5Kq$hteMVeaRUB{_FCE_RTXO|0jNV~bwc3CaKV}4 zNV)QoJ4P%p@HOl?j;E(CihLtLb4#?eg`_vsXYM$r!>*+Yb;W_gh}tCc!H;e*E+$46 z2OWX06ljgvtlb^d#3ERoGDzQvxVSd`ziia^HH;>76KBPDZ z@X%IVz5Kz=}m8joxW0nlpqiZ9F2y@ zgE4^JC=vj{L~21B-k0PR+aiBr#kmp&l{})2O_itw z`G_W^06;V9Ir{d+&lGqVR~8x+b@5f$T(6umGiT(#LHW_~I;GQ?+?DU9+#pZ=P*0ZR z-*x#g2){YVV#^sL!{noqM;J|VwP7htt=9LcX)7@t#M&db_v?sDtXozArThWZpnB^k)%jLQnrB*{Ez1#4msLK^HA_JYrYyLZSgK*>pKVBSL?nce zqLLH{oO>I%R5*~#&8W__J_oLdpZeg5;OUfnbyi2wZ}B_$kLnJ($h7vO(H$GFX)hNS znj()h%QG(v!&IfF*{oeTaYtw%HUtgCc}6n)N7=@}@N*K^9%9GCVvoe}ctb-se=U0a zbW@L2J|i^#vefk%zOd*AO7&i0v8L&BrPbHa=7r|$L$!3}K071KLL5m_N{I^q#w$+` z8B1fZJ$L4`TrZ16W$fP}Xy;m>TjEzP$m%q|OnQye-DjPvsCDb9MyJ!&uCnSfml-XZ zby2=Rb@u!+Ql+^mRHP?jn{^7g!o@i*iT?ojzyN9DH~8p-;+U*6OPm}7Y*FXF=faTf zuf8C4Fep8s_S?wb7nlIU|>{Dt@U!6+cHlZalHi$cqa!xJrSPs%K*Xq{p1?$OY z9mFuqu-9vR(oUP}7NgU-UTu-kbn(iEs#m$+5nF=FfKSV|XK3br+`#SO*&H6nQ%5A% zKMvOk9CkWaQ?(-xOl3Vm)Vj-3=emzauOy<%G@eHoT1;J$x6a@PBC|0yfA=w-H`oRrqL{tI-;jbZybqxtW?R zq2!?}N{Ry2%BRr4wWrq{W)BkB0CuOubQXR|r;K5Yk~q-2)cgrk2A#|Eo}Oe`yE&dh z)_auZG|G1@dCkGfHHh<}NiaZy3KeNlKA4As`$E!Q1X-NnLy!jd9~EmjZdN!;LbmD> z??nC$ekA@VDf68F0Hv8`S*R!|>ce#pR_AR}sfSVml91BEl%utFF%~xyi+HD%xQx^H zTcvZpr`1wp_^d`C0U3EvzkftU>TZsFLwqzjlCjr~1y`qX=W0;H8LKr7R8mwf3W5^j zW11bK7Z4l2ZeK0cwBQtMCQGEQT4TC+6t+a^rxqfw(1;dc}ow4pgk~q4&eEt#D{#v^1<_ou)!b=ckfsX781)(&Or0;7k($f3Fz0h0MHwXe;7}bd4Z_ zHe5`;m8B9E6h{^oj>I1S0NZ1yRM{ zP~GTHL|}d?VZfgaNlIiBA2E(cII2ep4aEwoDm(1s2Ae{<3?EXvymQ)MZ<;61#3qC0FJ0T&8nL@ z$x2gDq@;wdR3?3UMWendOLNKoQ>fH>@>;eFjF#$382&F>HN85@GUnf|rBz zRD~9iLtLfFNf43*8_43USHvL zI6U=DA^!l0=-y>*G_|r@HBh4KsXG##gs2r+N+2fbzUvc%d+_g(?Y98mDr5t9%QX579irI z*~}c#$V8)8SD^ggqPO;+iN`aeWDd5AH{-XtGwA*-GPZhsmTB7N^9;K;Ycg{%a<-m} z#7HV>At0s2ZBdXx5G+aUef&Ydh+5EcpNAk1E_>*)^LAnGmz{gZPkJBv&(wwL_A@O+ z)gGOurO)%ywKw|>hC_ZGEgC}U(o&^Ts060$tuhu;qEfxMv5FT)TQMX#qP^t%`Kr&? zwe6HOwLzeH)}!vYv_7Ivkgsb}yZf}Yn3q5O88rn^kO3%Hl|uIi>jxZ%3}h|@=~bz! z-2sXjgILlCI{MN+G^x5OCw>y+rN=gs_ zQMgy`=6M8q&Ntj8#6VnKo5Pm$52v|ec!o9aclgC`exGFG(s|aG)%krb6UQdY^GbR& zA=ezEFVto=3wWe~xln=wgUoHU9=J8FEp}-+f#dE}O}R~*9Q8gZkN9cRwOJ=n>uBC` ztrc{1^`T+qpsaaAWhx>>9o?k%?r~QpXrys1vs?6{4!(-$VoR*JXgU26t&!CSsPph1~QJ-uvy0JcC$za!~@on+-7 zmV=Pot&EMV8cX?0N@P=c8w|p>fMkFb$98TaYl9@~q z_5SUTp91yW6id`M6ZnnEb*<_1fLFASF#-u5+;DxP8t-Qq;!aVaSbu5V3ub0#0PaJt zms8=UnyN2$u)E51w zSyGY{x!0Ofl8J%{Dv#mdUh&`U7%o#Avlz5AiNiguZ8%>qPXu0R#>Fi=03j`*q@e*) zSG5Dm0H2rTo=538&&~s#Q5zZ$x;iO<+oD))<`kxuq$w&;D3(wON~RP6CL|r!=3;pm z2fU=`9mgo(hY8utg zC-FWDn+YHSkaqw+@emA{5&Gb%0Wk+S&?1F&@kPk;{H=F(kKnc4plQ5UD&KVwrK@67 zuy6^u9FRGl*sY!b(AI7T_KJLsvKn(A1uN6kZAxRsWx|M!$6{69)4{QiX~Z3#QcmET zq&yCwK^JSO<*UQo3S4pu6cRV4V8-QgA}6@F+ZDpI({}kOTHLe{qnEyydWEiPJVz2g zYgGA4M5Y!~+DQN>=D!{Iz^4gP7e?dG@5p==+g<)9KUyNssz>VGXMv})goV^C#}pC* z6hI&<4<6mE#9I?Y)|U+2v_;|G%)*>1ka)wTEu^Kb$RNR!xhJ3G2%o2}4s*+1F8Wuh zAW6(_-?}(@N|u_^c`Iu!c&lT?DTtlLOY-r%o_+qfs*QrIJHq_7`Kdcn=LYRxpA}s{ z7+Jt7%+iwMWyeyGW?)BfB1aK^eR;u{D2pU(oM@0ot*b0cK!wgGkUi289qV66*0mKj zbtYVuY$PZW@<)|PG6>uZ2=9MOejsE0GurJ&n)q`FP8}m1C^7G#=)XY~>I&+&PSBu8 zL)40pr2!>C5|Cy)5@5y00~t&cBsSo5DZEYK#^T;%M1G>7vQ!Eb=}L?&BuKvm3l2WR z5f&b61KCnpqH|}2fTvX1h~7ve()XXPA}kvy%boZVs}&Mk2`(v7^O14uCfDQn_MAlK z@?0X;&lK)};7JgX5O)$mxSwc|?dgd7G|tUKe-W&+oBTd?>nW@bqKdObXS8k<5*85d zUi)Wh94pRZI3!}zfxEND!yx45{L}j&HFn(B<%RzMhHU{-{Wx-~Sks~k4$Q#-4|Iaj z00fLo66Y*RU2M_U+n|tY8mpk7IJu^y_%?4}KR4^Qn6`C}5k#JIc z0q=3?7QxKo0ie79K#w!t6-W~~A(ZdyEZ@9%() zD>wN7_$f!TkVw-`cH)ie*Xq90{2z4EqcW#UnU_%(f}{)P4J4T)89oPY+jM?Pg%s~3XVBB_sH8a4p$(v|q5<+KlvoX< zL{-Pc-1kvn72)nh#q5+N*;-CvsMP(`LeIkni*U040PXF1hsfRK%oAb0b-_Qk}Y&TGU-aP+iqIiV0n=Of&=-0wR4BJH-q! zWzGQHaug7daMJm+XCPG#d8RFQLb93+-AHdx>lR;RAxK*}lZ>u5_b4f!(mQs=O!&x& zb8AuI&0JtOGaw`fovApeIt7zfri!cnE7#Rk47l3R)A^f^q`?FvhY7bJa75UQQ_aNM zOPL@8Fs(e5tUM+rfL!Nh-+e4>uZu;}uPEscOsG`hbrkx4Eo3;osw*j{P2_v-KYUiQ zHkS;&KRnjCuWO!bbjr;t#^PN-ozjs$VsG9*mtz<@7(3tN=77e!!+>0rwX50?ptUIq zDwL67?e@V@;9Tbre*zafq!cs&Cmm%{5Yo3470%R|1`W*r0DspR0{q3q&;e<%?*=^w zB>Cx{uhSYUQ|Gy^s%KHsW%U$P%u&`*Wy-8=v$*)Cp$&rSLSd*WN`x(Q8(`MP!)8eJ zqp$F*@t9}L2xMefH(wN7>Ad?+>q5GX9jdhUst5;iGWx_i<7Nex)P*U?;Q$FPV>y#^gT5LQ>jEBf~LinSo+Hv+KdZjUs@IspDum18Obm4N?C9hO3f~ z7@WxQKvt3A#rw|*<9~K0rXT(n` z9D59C{fmv!;tnSxUeUNdC*{dyJ+_I@!ZftikUjVIRl`}(on-SB6m?x~>J?irIvsz< zYs5>cK`^qC`IQ1^b>o|x)uBgpF9nDJ(b%>KaR*2@aGYEiKH{@PLKZ3Yc;2( z&5=;nMV@EWsBzXqN~;Z;M28D$DhS=+M%~0pW3=L24i)%-W(QWahQIrX`TP}$#&$4> zW49L@^*objq}mzncU?)6qP^NQt@oTO{5o9$DF8u9AOJ}hCe!bV!Hr;JoI#*<9FF>J z;-cbhd*d*d7Q2z?Iis&mXx^rLKiBEy>AshAzpm8o)2(%RZmY{r;8(d)g1U11d(@B! z+!V1TV5AWkn+?NZ#+MC12Semp`eAsA5WOJQK_*E4#>yL@9q3dlUn(1v>{v3Y> z`X-(FM=9OZc?BDkb=gu){{Rru+H-WEm8>O7QdFQMC=ziD-pk>lo3@U3yDqdwo&x;T zn15+_gQV=tG{;anowxX^#>_Josxzaesz7OZjXhOBTGRqJIaKgMzx4$)l4kI+#A5#d z2Z`(+=T*ix1IQ~bGT9v7-M5h5-9Q)bQ6W;<{7%}ZX=>?~SLIKbZ6a+X8;_L8Ff2jF zq85gX;B)scKXx>Bf;S4#s~`9_tU2altmz`D@-o_|6s4W&NmI?Fo!+t)a}o*m#UzkM z$zH;BcB8{psNv;@3>zy$t=f=|?Kqlc(r2|PMM@r1)aXx?i3KY&>HH(>xcXu&9B+6T zh&F4;bw=U9ai)r~x+U~=FXFRpCr0YtN}kMU+Vc;T7n(_lyj+;%!2$soD}=d`;zb*; zj+-O#aKs{Xfa_kHD=TI6zfqYuhFy3p5~Zv`T$OhQY>-L%iS);z%^p@Uq=8?;@%MoD zRqmG3@kKR5#iHio8&$yJASp0MGNX8p*8!H>gKoL~kHcg0_RW!1muH0jDzDcoVg zR3UpoBcG`IcK%$|;{kg}K<6>M$oFZ`^eTAh=xP0F=1%k(T1g>CBkuP{{VICg+m=de{Dm`3tMg! z6ro9300Zm@zvs^qakKVh7ZDg5U6qOUiw?%U)1Te2=UW}R-@`>o+U?bsN>Z)z%2T~o zNIQujL6b0(fAg!`8_Xk^8XrItRj+~fE1?@%O4+NzGzXmq{whaG*U;

s^7ayV|48e3tS2%4|?aE9> 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" + low_resource: True + prompt_template: '[INST] {} [/INST]' + ckpt: "please set this value to the path of pretrained checkpoint" + lora_r: 64 + lora_alpha: 16 + + # vit encoder + image_size: 448 + drop_path_rate: 0 + use_grad_checkpoint: False + vit_precision: "fp16" + freeze_vit: True + + # generation configs + prompt: "" + + # LLM + llama_model: "please set this value to the path of llama2-chat-7b" + +datasets: + cc_sbu_align: + vis_processor: + train: + name: "blip2_image_eval" + image_size: 448 + text_processor: + train: + name: "blip_caption" + +run: + task: image_text_pretrain diff --git a/vlmeval/vlm/mmalaya.py b/vlmeval/vlm/mmalaya.py new file mode 100644 index 0000000..1bd95fa --- /dev/null +++ b/vlmeval/vlm/mmalaya.py @@ -0,0 +1,64 @@ +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer +import warnings +from PIL import Image +from .base import BaseModel + + +class MMAlaya(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = False + + def __init__(self, model_path='DataCanvas/MMAlaya', **kwargs): + assert model_path is not None + self.model_path = model_path + self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) + model = AutoModelForCausalLM.from_pretrained(model_path, device_map='cpu', trust_remote_code=True).eval() + # need initialize tokenizer + model.initialize_tokenizer(self.tokenizer) + self.model = model.cuda() + + self.kwargs = kwargs + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + torch.cuda.empty_cache() + + def generate_inner(self, message, dataset=None): + # read image + prompt, image_path = self.message_to_promptimg(message) + image = Image.open(image_path).convert('RGB') + # tokenize prompt, and proprecess image + input_ids, image_tensor, stopping_criteria = self.model.prepare_for_inference( + prompt, + self.tokenizer, + image, + return_tensors='pt') + with torch.inference_mode(): + output_ids = self.model.generate( + inputs=input_ids.cuda(), + images=image_tensor.cuda(), + do_sample=False, + max_new_tokens=512, + num_beams=1, + use_cache=True, + stopping_criteria=[stopping_criteria], + ) + # truncate input_ids in generate_ids and then decode to text + input_token_len = input_ids.shape[1] + response = self.tokenizer.batch_decode( + output_ids[:, input_token_len:].cpu(), + skip_special_tokens=True, + clean_up_tokenization_spaces=False + )[0].strip() + return response + + +if __name__ == '__main__': + model = MMAlaya() + response = model.generate(['./assets/apple.jpg', '请详细描述一下这张图片。']) + print(response) + +""" +export PYTHONPATH=$PYTHONPATH:/tmp/VLMEvalKit +CUDA_VISIBLE_DEVICES=0 python vlmeval/vlm/mmalaya.py +""" diff --git a/vlmeval/vlm/monkey.py b/vlmeval/vlm/monkey.py new file mode 100644 index 0000000..6fc3a51 --- /dev/null +++ b/vlmeval/vlm/monkey.py @@ -0,0 +1,165 @@ +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer +import warnings +from .base import BaseModel +from ..utils import DATASET_TYPE + + +class Monkey(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = False + + def __init__(self, model_path='echo840/Monkey', **kwargs): + assert model_path is not None + self.model_path = model_path + self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) + model = AutoModelForCausalLM.from_pretrained(model_path, device_map='cpu', trust_remote_code=True).eval() + self.model = model.cuda() + self.kwargs = kwargs + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + torch.cuda.empty_cache() + + def generate_vanilla(self, image_path, prompt): + cur_prompt = f'{image_path} {prompt} Answer: ' + input_ids = self.tokenizer(cur_prompt, return_tensors='pt', padding='longest') + attention_mask = input_ids.attention_mask + input_ids = input_ids.input_ids + + output_ids = self.model.generate( + input_ids=input_ids.cuda(), + attention_mask=attention_mask.cuda(), + do_sample=False, + num_beams=1, + max_new_tokens=512, + min_new_tokens=1, + length_penalty=1, + num_return_sequences=1, + output_hidden_states=True, + use_cache=True, + pad_token_id=self.tokenizer.eod_id, + eos_token_id=self.tokenizer.eod_id, + ) + response = self.tokenizer.decode( + output_ids[0][input_ids.size(1):].cpu(), + skip_special_tokens=True + ).strip() + return response + + def generate_multichoice(self, image_path, prompt): + cur_prompt = f'{image_path} \n {prompt} Answer: ' + input_ids = self.tokenizer(cur_prompt, return_tensors='pt', padding='longest') + attention_mask = input_ids.attention_mask + input_ids = input_ids.input_ids + + output_ids = self.model.generate( + input_ids=input_ids.cuda(), + attention_mask=attention_mask.cuda(), + do_sample=False, + num_beams=1, + max_new_tokens=10, + min_new_tokens=1, + length_penalty=1, + num_return_sequences=1, + output_hidden_states=True, + use_cache=True, + pad_token_id=self.tokenizer.eod_id, + eos_token_id=self.tokenizer.eod_id, + ) + response = self.tokenizer.decode( + output_ids[0][input_ids.size(1):].cpu(), + skip_special_tokens=True + ).strip() + return response + + def generate_inner(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + if dataset is None: + return self.generate_vanilla(image_path, prompt) + assert isinstance(dataset, str) + if DATASET_TYPE(dataset) == 'multi-choice' or DATASET_TYPE(dataset) == 'Y/N' or dataset == 'HallusionBench': + return self.generate_multichoice(image_path, prompt) + else: + return self.generate_vanilla(image_path, prompt) + + +class MonkeyChat(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = False + + def __init__(self, model_path='echo840/Monkey-Chat', **kwargs): + assert model_path is not None + self.model_path = model_path + self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) + model = AutoModelForCausalLM.from_pretrained(model_path, device_map='cpu', trust_remote_code=True).eval() + self.model = model.cuda() + self.kwargs = kwargs + + self.tokenizer.padding_side = 'left' + self.tokenizer.pad_token_id = self.tokenizer.eod_id + + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + torch.cuda.empty_cache() + + def generate_vanilla(self, image_path, prompt): + cur_prompt = f'{image_path} {prompt} Answer: ' + input_ids = self.tokenizer(cur_prompt, return_tensors='pt', padding='longest') + attention_mask = input_ids.attention_mask + input_ids = input_ids.input_ids + + output_ids = self.model.generate( + input_ids=input_ids.cuda(), + attention_mask=attention_mask.cuda(), + do_sample=False, + num_beams=1, + max_new_tokens=512, + min_new_tokens=1, + length_penalty=1, + num_return_sequences=1, + output_hidden_states=True, + use_cache=True, + pad_token_id=self.tokenizer.eod_id, + eos_token_id=self.tokenizer.eod_id, + ) + response = self.tokenizer.decode( + output_ids[0][input_ids.size(1):].cpu(), + skip_special_tokens=True + ).strip() + return response + + def generate_multichoice(self, image_path, prompt): + cur_prompt = f'{image_path} \n {prompt} Answer: ' + input_ids = self.tokenizer(cur_prompt, return_tensors='pt', padding='longest') + attention_mask = input_ids.attention_mask + input_ids = input_ids.input_ids + + output_ids = self.model.generate( + input_ids=input_ids.cuda(), + attention_mask=attention_mask.cuda(), + do_sample=False, + num_beams=1, + max_new_tokens=10, + min_new_tokens=1, + length_penalty=1, + num_return_sequences=1, + output_hidden_states=True, + use_cache=True, + pad_token_id=self.tokenizer.eod_id, + eos_token_id=self.tokenizer.eod_id, + ) + response = self.tokenizer.decode( + output_ids[0][input_ids.size(1):].cpu(), + skip_special_tokens=True + ).strip() + return response + + def generate_inner(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + if dataset is None: + return self.generate_vanilla(image_path, prompt) + assert isinstance(dataset, str) + if DATASET_TYPE(dataset) == 'multi-choice' or DATASET_TYPE(dataset) == 'Y/N' or dataset == 'HallusionBench': + return self.generate_multichoice(image_path, prompt) + else: + return self.generate_vanilla(image_path, prompt) diff --git a/vlmeval/vlm/mplug_owl2.py b/vlmeval/vlm/mplug_owl2.py new file mode 100644 index 0000000..45a8222 --- /dev/null +++ b/vlmeval/vlm/mplug_owl2.py @@ -0,0 +1,126 @@ +import sys +import torch +from PIL import Image +from .base import BaseModel +from ..smp import * +from ..utils import DATASET_TYPE + + +class mPLUG_Owl2(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = False + + def __init__(self, model_path='MAGAer13/mplug-owl2-llama2-7b', **kwargs): + try: + from mplug_owl2.model.builder import load_pretrained_model + from mplug_owl2.mm_utils import get_model_name_from_path + except: + warnings.warn('Please install mPLUG_Owl2 before using mPLUG_Owl2. ') + sys.exit(-1) + + model_name = get_model_name_from_path(model_path) + tokenizer, model, image_processor, context_len = load_pretrained_model( + model_path, None, model_name, load_8bit=False, load_4bit=False, device='cpu') + + self.model = model.cuda() + self.device = self.model.device + self.image_processor = image_processor + tokenizer.padding_side = 'left' + tokenizer.pad_token_id = tokenizer.eos_token_id + self.tokenizer = tokenizer + self.context_len = context_len + + kwargs_default = dict( + max_new_tokens=512, do_sample=False, num_beams=1, + min_new_tokens=1, length_penalty=1, num_return_sequences=1) + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def use_custom_prompt(self, dataset): + assert dataset is not None + if listinstr(['MMMU'], dataset): + return False + if DATASET_TYPE(dataset) == 'multi-choice' or dataset == 'MMVet': + return True + 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'] + if dataset == 'MMVet': + prompt = question + '\nAnswer the question directly. ' + elif DATASET_TYPE(dataset) == 'multi-choice': + 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 + prompt = f'Hint: {hint}\n' if hint is not None else '' + prompt += f'{question}\n' + prompt += ( + f'{options_prompt}\nAnswer with the option’s letter from the given choices directly. ' + if len(options) else 'Answer the question directly. ' + ) + else: + raise NotImplementedError + + message = [dict(type='text', value=prompt)] + message.extend([dict(type='image', value=s) for s in tgt_path]) + return message + + def generate_inner(self, message, dataset=None): + from mplug_owl2.constants import IMAGE_TOKEN_INDEX + from mplug_owl2.mm_utils import process_images, tokenizer_image_token + kwargs = cp.deepcopy(self.kwargs) + if dataset in ['MMVet', 'LLaVABench']: + kwargs['length_penalty'] = 0 + elif dataset is not None and DATASET_TYPE(dataset) == 'VQA': + kwargs['length_penalty'] = 0 + elif dataset is not None and DATASET_TYPE(dataset) == 'multi-choice': + kwargs['max_new_tokens'] = 10 + num_images = len([x for x in message if x['type'] == 'image']) + assert num_images >= 0 + prompt_full = 'USER: ' + images = [] + if num_images == 1: + prompt, image = self.message_to_promptimg(message) + prompt_full += f'<|image|>{prompt} \nASSISTANT: ' + images.append(image) + else: + for msg in message: + if msg['type'] == 'image': + images.append(msg['value']) + prompt_full += '<|image|>' + elif msg['type'] == 'text': + prompt_full += msg['value'] + prompt_full += '\nASSISTANT: ' + + def preproc_image(fname): + image = Image.open(fname).convert('RGB') + max_edge = max(image.size) + image = image.resize((max_edge, max_edge)) + return image + images = [preproc_image(fname) for fname in images] + image_tensor = process_images(images, self.image_processor) + image_tensor = image_tensor.to(self.device, dtype=torch.float16) + input_ids = tokenizer_image_token( + prompt_full, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt').unsqueeze(0).to(self.device) + + with torch.inference_mode(): + output_ids = self.model.generate( + input_ids=input_ids, + images=image_tensor, + output_hidden_states=True, + use_cache=True, + **kwargs) + answer = self.tokenizer.decode(output_ids[0, input_ids.shape[1]:]).strip() + return answer.split('')[0] diff --git a/vlmeval/vlm/omnilmm.py b/vlmeval/vlm/omnilmm.py new file mode 100644 index 0000000..26f4a2e --- /dev/null +++ b/vlmeval/vlm/omnilmm.py @@ -0,0 +1,152 @@ +import sys +import torch +from PIL import Image +from transformers import AutoTokenizer + +from .base import BaseModel +from ..smp import * +from ..utils import DATASET_TYPE + + +DEFAULT_IMAGE_TOKEN = '' +DEFAULT_IMAGE_PATCH_TOKEN = '' +DEFAULT_IM_START_TOKEN = '' +DEFAULT_IM_END_TOKEN = '' + + +def init_omni_lmm(model_path): + from omnilmm.model.omnilmm import OmniLMMForCausalLM + from omnilmm.utils import disable_torch_init + from omnilmm.model.utils import build_transform + + torch.backends.cuda.matmul.allow_tf32 = True + disable_torch_init() + tokenizer = AutoTokenizer.from_pretrained(model_path, model_max_length=2048) + + model = OmniLMMForCausalLM.from_pretrained(model_path, tune_clip=True, torch_dtype=torch.bfloat16, device_map='cpu') + model = model.to(device='cuda', dtype=torch.bfloat16) + + image_processor = build_transform(is_train=False, input_size=model.model.config.image_size, std_mode='OPENAI_CLIP') + + mm_use_im_start_end = getattr(model.config, 'mm_use_im_start_end', False) + assert mm_use_im_start_end + + tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True) + + vision_config = model.model.vision_config + vision_config.im_patch_token = tokenizer.convert_tokens_to_ids( + [DEFAULT_IMAGE_PATCH_TOKEN])[0] + vision_config.use_im_start_end = mm_use_im_start_end + vision_config.im_start_token, vision_config.im_end_token = tokenizer.convert_tokens_to_ids( + [DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN]) + image_token_len = model.model.config.num_query + + return model, image_processor, image_token_len, tokenizer + + +def expand_question_into_multimodal(question_text, image_token_len, im_st_token, im_ed_token, im_patch_token): + if '' in question_text[0]['content']: + question_text[0]['content'] = question_text[0]['content'].replace( + '', im_st_token + im_patch_token * image_token_len + im_ed_token) + else: + question_text[0]['content'] = im_st_token + im_patch_token * \ + image_token_len + im_ed_token + '\n' + question_text[0]['content'] + return question_text + + +def wrap_question_for_omni_lmm(question, image_token_len, tokenizer): + from omnilmm.train.train_utils import omni_preprocess + question = expand_question_into_multimodal( + question, image_token_len, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN, DEFAULT_IMAGE_PATCH_TOKEN) + + conversation = question + data_dict = omni_preprocess(sources=[conversation], tokenizer=tokenizer, generation=True) + + data_dict = dict(input_ids=data_dict['input_ids'][0], labels=data_dict['labels'][0]) + return data_dict + + +class OmniLMM12B(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = False + + def __init__(self, model_path, root, **kwargs) -> None: + sys.path.append(root) + model, img_processor, image_token_len, tokenizer = init_omni_lmm(model_path) + self.model = model + self.image_token_len = image_token_len + self.image_transform = img_processor + self.tokenizer = tokenizer + self.model.eval() + default_kwargs = dict( + max_new_tokens=512, + do_sample=False, + output_scores=True, + return_dict_in_generate=True, + repetition_penalty=1.1) + default_kwargs.update(kwargs) + self.kwargs = default_kwargs + torch.cuda.empty_cache() + + def generate_inner(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + try: + image = Image.open(image_path).convert('RGB') + except: + logger = get_logger('OmniLMM Inference') + logger.error('Image Decode Error') + return 'Image Decode Error' + + msgs = [dict(role='user', content=prompt)] + input_ids = wrap_question_for_omni_lmm( + msgs, self.image_token_len, self.tokenizer)['input_ids'] + input_ids = torch.as_tensor(input_ids) + image = self.image_transform(image) + + with torch.inference_mode(): + output = self.model.generate_vllm( + input_ids=input_ids.unsqueeze(0).cuda(), + images=image.unsqueeze(0).half().cuda(), + **self.kwargs) + + response = self.tokenizer.decode( + output.sequences[0], skip_special_tokens=True) + response = response.strip() + return response + + def use_custom_prompt(self, dataset): + assert dataset is not None + if DATASET_TYPE(dataset) == 'multi-choice': + return True + 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=s) for s in tgt_path]) + return message diff --git a/vlmeval/vlm/open_flamingo.py b/vlmeval/vlm/open_flamingo.py new file mode 100644 index 0000000..2ac354a --- /dev/null +++ b/vlmeval/vlm/open_flamingo.py @@ -0,0 +1,99 @@ +import sys +import torch +from PIL import Image +import os.path as osp +import warnings +from .base import BaseModel +from ..smp import splitlen, get_cache_path +from huggingface_hub import snapshot_download + + +class OpenFlamingo(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = True + + def __init__(self, + name, + mpt_pth=None, + ckpt_pth=None, + **kwargs): + + if mpt_pth is None: + warnings.warn( + 'Please set `mpt_pth` to the directory of MPT-7B, which is cloned from here: ' + 'https://huggingface.co/mosaicml/mpt-7b. ' + ) + sys.exit(-1) + if ckpt_pth is None: + warnings.warn( + 'Please set `ckpt_pth` to the openflamingo ckpt, which is the `checkpoint.pt` file downloaded ' + 'from: https://huggingface.co/openflamingo/OpenFlamingo-9B-vitl-mpt7b/tree/main. ' + ) + sys.exit(-1) + else: + if osp.exists(ckpt_pth): + if ckpt_pth.endswith('checkpoint.pt'): + pass + elif osp.isdir(ckpt_pth): + ckpt_pth = osp.join(ckpt_pth, 'checkpoint.pt') + if not osp.exists(ckpt_pth): + sys.exit(-1) + elif splitlen(ckpt_pth, '/') == 2: + cache_path = get_cache_path(ckpt_pth) + if cache_path is None: + snapshot_download(ckpt_pth) + cache_path = get_cache_path(ckpt_pth) + if cache_path is None: + sys.exit(-1) + else: + ckpt_pth = osp.join(cache_path, 'checkpoint.pt') + + self.name = name + assert name in ['v2'] + self.mpt_pth = mpt_pth + try: + from open_flamingo import create_model_and_transforms + except: + raise ImportError('Please first install open_flamingo to use OpenFlamingo') + model, image_processor, tokenizer = create_model_and_transforms( + clip_vision_encoder_path='ViT-L-14', + clip_vision_encoder_pretrained='openai', + lang_encoder_path=mpt_pth, + tokenizer_path=mpt_pth, + cross_attn_every_n_layers=4) + ckpt = torch.load(ckpt_pth) + model.load_state_dict(ckpt, strict=False) + torch.cuda.empty_cache() + self.model = model.eval().cuda() + self.tokenizer = tokenizer + self.tokenizer.padding_side = 'left' + self.image_proc = image_processor + + kwargs_default = dict(max_new_tokens=512, num_beams=3) + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def generate_inner(self, message, dataset=None): + vision_x = [] + prompt = '' + for msg in message: + if msg['type'] == 'image': + img = Image.open(msg['value']) + vision_x.append(self.image_proc(img).unsqueeze(0)) + prompt += '' + elif msg['type'] == 'text': + prompt += msg['value'] + prompt += 'Answer: ' + vision_x = torch.cat(vision_x, dim=0) if len(vision_x) > 1 else vision_x[0] + vision_x = vision_x.unsqueeze(1).unsqueeze(0) + lang_x = self.tokenizer([prompt], return_tensors='pt') + generated_text = self.model.generate( + vision_x=vision_x.cuda(), + lang_x=lang_x['input_ids'].cuda(), + attention_mask=lang_x['attention_mask'].cuda(), + **self.kwargs) + generated_text = self.tokenizer.decode(generated_text[0]) + text = generated_text[len(prompt):].split('<|endofchunk|>')[0] + return text diff --git a/vlmeval/vlm/pandagpt.py b/vlmeval/vlm/pandagpt.py new file mode 100644 index 0000000..877ed9e --- /dev/null +++ b/vlmeval/vlm/pandagpt.py @@ -0,0 +1,61 @@ +import sys +import torch +import os.path as osp +import warnings +from .base import BaseModel + + +class PandaGPT(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = False + + def __init__(self, name, root=None, **kwargs): + if root is None: + warnings.warn('Please set `root` to PandaGPT code directory, which is cloned from here: ') + sys.exit(-1) + + assert name == 'PandaGPT_13B' + self.name = name + sys.path.append(osp.join(root, 'code')) + try: + from model.openllama import OpenLLAMAPEFTModel + except: + raise ImportError( + 'Please first install PandaGPT and set the root path to use PandaGPT, ' + 'which is cloned from here: https://github.com/yxuansu/PandaGPT. ' + ) + self.args = { + 'model': 'openllama_peft', + 'imagebind_ckpt_path': osp.join(root, 'pretrained_ckpt/imagebind_ckpt'), + 'vicuna_ckpt_path': osp.join(root, 'pretrained_ckpt/vicuna_ckpt/13b_v0'), + 'delta_ckpt_path': osp.join(root, 'pretrained_ckpt/pandagpt_ckpt/13b/pytorch_model.pt'), + 'stage': 2, + 'max_tgt_len': 512, + 'lora_r': 32, + 'lora_alpha': 32, + 'lora_dropout': 0.1, + } + model = OpenLLAMAPEFTModel(**self.args) + delta_ckpt = torch.load(self.args['delta_ckpt_path'], map_location=torch.device('cpu')) + model.load_state_dict(delta_ckpt, strict=False) + torch.cuda.empty_cache() + self.model = model.eval().half().cuda() + kwargs_default = {'top_p': 0.9, 'do_sample': False, 'max_tgt_len': 128, 'temperature': 0.001} + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def generate_inner(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + struct = { + 'prompt': prompt, + 'image_paths': [image_path], + 'audio_paths': [], + 'video_paths': [], + 'thermal_paths': [], + 'modality_embeds': [] + } + struct.update(self.kwargs) + resp = self.model.generate(struct) + return resp diff --git a/vlmeval/vlm/qwen_vl.py b/vlmeval/vlm/qwen_vl.py new file mode 100644 index 0000000..00334da --- /dev/null +++ b/vlmeval/vlm/qwen_vl.py @@ -0,0 +1,94 @@ +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer +import warnings +import copy as cp +from .base import BaseModel +from ..smp import isimg, listinstr +from ..utils import DATASET_TYPE + + +class QwenVL(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = True + + def __init__(self, model_path='Qwen/Qwen-VL', **kwargs): + assert model_path is not None + self.model_path = model_path + tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) + tokenizer.padding_side = 'left' + tokenizer.pad_token_id = tokenizer.eod_id + self.tokenizer = tokenizer + self.model = AutoModelForCausalLM.from_pretrained(model_path, device_map='cuda', trust_remote_code=True).eval() + default_kwargs = dict( + do_sample=False, + num_beams=1, + max_new_tokens=512, + min_new_tokens=1, + num_return_sequences=1, + use_cache=True, + output_hidden_states=True, + pad_token_id=tokenizer.eod_id, + eos_token_id=tokenizer.eod_id) + default_kwargs.update(kwargs) + self.kwargs = default_kwargs + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + torch.cuda.empty_cache() + + def adjust_kwargs(self, dataset): + kwargs = cp.deepcopy(self.kwargs) + if DATASET_TYPE(dataset) in ['multi-choice', 'Y/N']: + kwargs['max_new_tokens'] = 32 + elif DATASET_TYPE(dataset) == 'Caption' and 'COCO' in dataset: + kwargs['max_new_tokens'] = 32 + elif DATASET_TYPE(dataset) == 'VQA': + if listinstr(['OCRVQA', 'ChartQA', 'DocVQA'], dataset): + kwargs['max_new_tokens'] = 100 + elif listinstr(['TextVQA'], dataset): + kwargs['max_new_tokens'] = 10 + return kwargs + + def generate_inner(self, message, dataset=None): + if dataset is not None: + kwargs = self.adjust_kwargs(dataset) + else: + kwargs = self.kwargs + prompt = '' + for s in message: + if s['type'] == 'image': + prompt += f'{s["value"]}' + elif s['type'] == 'text': + prompt += s['value'] + if dataset is not None and DATASET_TYPE(dataset) == 'VQA': + prompt += ' Answer:' + encoded = self.tokenizer([prompt], return_tensors='pt', padding='longest') + input_ids = encoded.input_ids.to('cuda') + attention_mask = encoded.attention_mask.to('cuda') + + pred = self.model.generate( + input_ids=input_ids, + attention_mask=attention_mask, + **kwargs) + answer = self.tokenizer.decode(pred[0][input_ids.size(1):].cpu(), skip_special_tokens=True).strip() + return answer + + +class QwenVLChat(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = True + + def __init__(self, model_path='Qwen/Qwen-VL-Chat', **kwargs): + assert model_path is not None + self.model_path = model_path + self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) + self.model = AutoModelForCausalLM.from_pretrained(model_path, device_map='cuda', trust_remote_code=True).eval() + torch.cuda.empty_cache() + self.kwargs = kwargs + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def generate_inner(self, message, dataset=None): + vl_list = [{'image': s['value']} if s['type'] == 'image' else {'text': s['value']} for s in message] + query = self.tokenizer.from_list_format(vl_list) + response, _ = self.model.chat(self.tokenizer, query=query, history=None, **self.kwargs) + return response diff --git a/vlmeval/vlm/transcore_m.py b/vlmeval/vlm/transcore_m.py new file mode 100644 index 0000000..7e4b6a7 --- /dev/null +++ b/vlmeval/vlm/transcore_m.py @@ -0,0 +1,162 @@ +import sys +import torch +from abc import abstractproperty +from .base import BaseModel +from ..smp import * +from ..utils import DATASET_TYPE +from transformers import AutoTokenizer, BitsAndBytesConfig + + +class TransCoreM(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = False + + def load_pretrained_model(self, model_path, load_8bit=False, load_4bit=False, revision='main'): + from transcorem.model import TransCoreMQWenForCausalLM + from transcorem.constants import DEFAULT_IMAGE_PATCH_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN + import transcorem.config_param as config_param + kwargs = {'revision': revision} + if load_8bit: + kwargs['load_in_8bit'] = True + elif load_4bit: + kwargs['load_in_4bit'] = True + kwargs['quantization_config'] = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_compute_dtype=torch.float16, + bnb_4bit_use_double_quant=True, + bnb_4bit_quant_type='nf4' + ) + else: + kwargs['torch_dtype'] = torch.float16 + + config_param.model_path = model_path + tokenizer = AutoTokenizer.from_pretrained( + model_path, use_fast=False, revision=revision, trust_remote_code=True) + model = TransCoreMQWenForCausalLM.from_pretrained( + model_path, low_cpu_mem_usage=True, trust_remote_code=True, **kwargs) + + image_processor = None + mm_use_im_start_end = getattr(model.config, 'mm_use_im_start_end', False) + mm_use_im_patch_token = getattr(model.config, 'mm_use_im_patch_token', True) + if mm_use_im_patch_token: + tokenizer.add_tokens([DEFAULT_IMAGE_PATCH_TOKEN], special_tokens=True) + if mm_use_im_start_end: + tokenizer.add_tokens([DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN], special_tokens=True) + model.resize_token_embeddings(len(tokenizer)) + + vision_tower = model.get_vision_tower() + if not vision_tower.is_loaded: + vision_tower.load_model() + vision_tower.to(device='cpu', dtype=torch.float16) + image_processor = vision_tower.image_processor + + if hasattr(model.config, 'max_sequence_length'): + context_len = model.config.max_sequence_length + else: + context_len = 2048 + + return tokenizer, model, image_processor, context_len + + def __init__(self, + root=None, + revision='main', + **kwargs): + + self.root = root + self.revision = revision + sys.path.append(root) + + model_path = 'PCIResearch/TransCore-M' + assert osp.exists(model_path) or splitlen(model_path) == 2 + self.tokenizer, self.model, self.image_processor, self.context_len = self.load_pretrained_model( + model_path=model_path, revision=revision) + self.model = self.model.cuda() + print('==============conv_mode: transcorem_v1') + self.conv_mode = 'transcorem_v1' + + kwargs_default = dict(do_sample=False, temperature=0.0, max_new_tokens=512, top_p=None, num_beams=1) + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def use_custom_prompt(self, dataset): + assert dataset is not None + if DATASET_TYPE(dataset) == 'multi-choice': + return True + 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'] + 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.' + message = [dict(type='text', value=prompt)] + message.extend([dict(type='image', value=f) for f in tgt_path]) + return message + + def generate_inner(self, message, dataset=None): + from transcorem.mm_utils import highres_process_images, tokenizer_image_token, KeywordsStoppingCriteria + from transcorem.constants import ( + IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN) + from transcorem.conversation import conv_templates, SeparatorStyle + + prompt, image_path = self.message_to_promptimg(message) + image = Image.open(image_path).convert('RGB') + args = abstractproperty() + args.image_aspect_ratio = 'pad' + image_patches = highres_process_images(image, self.image_processor, args, base_reso=336) + image_patches = [patch.unsqueeze(0).to('cuda', dtype=torch.float16) for patch in image_patches] + if self.model.config.mm_use_im_start_end: + inp = DEFAULT_IM_START_TOKEN + DEFAULT_IMAGE_TOKEN + DEFAULT_IM_END_TOKEN + '\n' + prompt + else: + inp = DEFAULT_IMAGE_TOKEN + '\n' + prompt + + conv = conv_templates[self.conv_mode].copy() + conv.append_message(conv.roles[0], inp) + conv.append_message(conv.roles[1], None) + prompt_conv = conv.get_prompt() + input_ids = tokenizer_image_token(prompt_conv, self.tokenizer, IMAGE_TOKEN_INDEX, + return_tensors='pt').unsqueeze(0).cuda() + stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2 + keywords = [stop_str] + stopping_criteria = KeywordsStoppingCriteria(keywords, self.tokenizer, input_ids) + with torch.inference_mode(): + output_ids = self.model.generate( + input_ids, + images=image_patches, + use_cache=True, + stopping_criteria=[stopping_criteria], + **self.kwargs) + + input_token_len = input_ids.shape[1] + n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item() + if n_diff_input_output > 0: + print(f'[Warning] {n_diff_input_output} output_ids are not the same as the input_ids') + outputs = self.tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0] + outputs = outputs.strip() + if outputs.endswith(stop_str): + outputs = outputs[:-len(stop_str)] + outputs = outputs.strip() + return outputs diff --git a/vlmeval/vlm/visualglm.py b/vlmeval/vlm/visualglm.py new file mode 100644 index 0000000..76f077a --- /dev/null +++ b/vlmeval/vlm/visualglm.py @@ -0,0 +1,36 @@ +import warnings +from .base import BaseModel +from ..smp import * + + +class VisualGLM(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = False + + def __init__(self, model_path='THUDM/visualglm-6b', **kwargs): + try: + import sat + except: + warnings.warn('Please install SwissArmyTransformer to use VisualGLM') + assert model_path is not None + self.model_path = model_path + + from transformers import AutoModel + from transformers import AutoTokenizer + self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) + model = AutoModel.from_pretrained(model_path, trust_remote_code=True).half().cuda() + self.model = model + self.kwargs = kwargs + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def generate_inner(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + output, _ = self.model.chat( + image_path=image_path, + tokenizer=self.tokenizer, + query=prompt, + history=[], + **self.kwargs + ) + return output diff --git a/vlmeval/vlm/xcomposer/__init__.py b/vlmeval/vlm/xcomposer/__init__.py new file mode 100644 index 0000000..1d8237f --- /dev/null +++ b/vlmeval/vlm/xcomposer/__init__.py @@ -0,0 +1,6 @@ +from .sharecaptioner import ShareCaptioner +from .xcomposer import XComposer +from .xcomposer2 import XComposer2 +from .xcomposer2_4KHD import XComposer2_4KHD + +__all__ = ['ShareCaptioner', 'XComposer', 'XComposer2', 'XComposer2_4KHD'] diff --git a/vlmeval/vlm/xcomposer/sharecaptioner.py b/vlmeval/vlm/xcomposer/sharecaptioner.py new file mode 100644 index 0000000..8823816 --- /dev/null +++ b/vlmeval/vlm/xcomposer/sharecaptioner.py @@ -0,0 +1,92 @@ +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer +from ..base import BaseModel +from ...smp import * +from ...utils import DATASET_TYPE + + +class ShareCaptioner(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = False + + def __init__(self, model_path='Lin-Chen/ShareCaptioner', **kwargs): + assert model_path is not None + tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) + self.model = AutoModelForCausalLM.from_pretrained( + model_path, device_map='cuda', trust_remote_code=True).eval() + self.model.tokenizer = tokenizer + self.model.cuda() + self.model.half() + + def use_custom_prompt(self, dataset): + assert dataset is not None + if DATASET_TYPE(dataset) == 'multi-choice': + return True + 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) + + if dataset is not None and DATASET_TYPE(dataset) == 'multi-choice': + 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 + + option_candidate = string.ascii_uppercase + options = { + cand: line[cand] + for cand in option_candidate + if cand in line and not pd.isna(line[cand]) + } + for key, item in options.items(): + question += f'\n{key}. {item}' + prompt = question + + if not cn_string(prompt): + prompt = prompt + '\n' + "Answer with the option's letter from the given choices directly." + else: + prompt = prompt + '\n' + '请直接回答选项字母。' + else: + prompt = line['question'] + message = [dict(type='text', value=prompt)] + message.extend([dict(type='image', value=s) for s in tgt_path]) + return message + + def generate_inner(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + seg1 = '<|User|>:' + seg2 = f'{prompt}{self.model.eoh}\n<|Bot|>:' + self.seg_emb1 = self.model.encode_text(seg1, add_special_tokens=True) + self.seg_emb2 = self.model.encode_text(seg2, add_special_tokens=False) + + image = Image.open(image_path).convert('RGB') + image = self.model.vis_processor(image).unsqueeze(0) + image = image.to(self.model.device) + tmp_bs = image.shape[0] + tmp_seg_emb1 = self.seg_emb1.repeat(tmp_bs, 1, 1) + tmp_seg_emb2 = self.seg_emb2.repeat(tmp_bs, 1, 1) + with torch.cuda.amp.autocast(): + with torch.no_grad(): + image = self.model.encode_img(image) + input_emb = torch.cat( + [tmp_seg_emb1, image, tmp_seg_emb2], dim=1) + out_embeds = self.model.internlm_model.generate( + inputs_embeds=input_emb, + max_length=500, + num_beams=3, + min_length=1, + do_sample=True, + repetition_penalty=1.5, + length_penalty=1.0, + temperature=1., + eos_token_id=self.model.tokenizer.eos_token_id, + num_return_sequences=1) + + for j, out in enumerate(out_embeds): + out[out == -1] = 2 + response = self.model.decode_text([out]) + return response diff --git a/vlmeval/vlm/xcomposer/xcomposer.py b/vlmeval/vlm/xcomposer/xcomposer.py new file mode 100644 index 0000000..3a93cff --- /dev/null +++ b/vlmeval/vlm/xcomposer/xcomposer.py @@ -0,0 +1,150 @@ +import torch +from transformers import AutoModel, AutoTokenizer +from transformers import StoppingCriteria, StoppingCriteriaList +from PIL import Image +from ..base import BaseModel +from ...smp import * + + +class StoppingCriteriaSub(StoppingCriteria): + def __init__(self, stops=[], encounters=1): + super().__init__() + self.stops = stops + + def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor): + for stop in self.stops: + if torch.all((stop == input_ids[0][-len(stop):])).item(): + return True + + return False + + +from ...utils import DATASET_TYPE + + +class XComposer(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = False + + def __init__(self, model_path='internlm/internlm-xcomposer-vl-7b', **kwargs): + assert model_path is not None + self.model_path = model_path + + model = AutoModel.from_pretrained(self.model_path, device_map='cpu', trust_remote_code=True).cuda().eval() + tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True) + model.tokenizer = tokenizer + self.model = model + self.device = self.model.internlm_model.model.embed_tokens.weight.device + self.eoh = '' + self.eoa = '' + stop_words_ids = [ + torch.tensor([103027]).to(self.device), # end of human + torch.tensor([103028]).to(self.device), # end of bot + ] + default_kwargs = { + 'max_new_tokens': 512, 'num_beams': 5, 'do_sample': False, + 'min_length': 1, 'repetition_penalty': 1.5, 'length_penalty': 1.0 + } + default_kwargs.update(kwargs) + self.kwargs = default_kwargs + self.stopping_criteria = StoppingCriteriaList([StoppingCriteriaSub(stops=stop_words_ids)]) + + def generate_inner(self, message, dataset=None): + if len(message) == 2: + if message[0]['type'] == 'text' and message[1]['type'] == 'image': + message = [message[1], message[0]] + kwargs = cp.deepcopy(self.kwargs) + if dataset is not None: + if DATASET_TYPE(dataset) == 'multi-choice': + kwargs['max_new_tokens'] = 5 + kwargs['num_beams'] = 5 + + with torch.cuda.amp.autocast(): + with torch.no_grad(): + prompt_embs = self.message_to_prompt_embs(message, dataset) + outputs = self.model.internlm_model.generate( + inputs_embeds=prompt_embs, + stopping_criteria=self.stopping_criteria, + **kwargs + ) + + output_token = outputs[0] + if output_token[0] == 0: + output_token = output_token[1:] + if output_token[0] == 1: + output_token = output_token[1:] + output_text = self.model.tokenizer.decode(output_token, add_special_tokens=False) + + output_text = output_text.split(self.model.eoa)[0] + output_text = output_text.split('<|Bot|>')[-1].strip() + return output_text + + def message_to_prompt_embs(self, message, dataset=None): + assert isinstance(message, list) + img_embeds = [] + prompt_full = '<|User|>: ' + for msg in message: + if msg['type'] == 'text': + prompt_full += msg['value'] + elif msg['type'] == 'image': + image = Image.open(msg['value']).convert('RGB') + image = self.model.vis_processor(image).unsqueeze(0).to(self.device) + img_embeds.append(self.model.encode_img(image)) + prompt_full += '' + + prompt_full += self.model.eoh + ' <|Bot|>: ' + if dataset is not None and DATASET_TYPE(dataset) == 'multi-choice': + prompt_full += 'Answer: The answer is ' + elif dataset is not None and DATASET_TYPE(dataset) in ['VQA', 'QA', 'Y/N']: + prompt_full += 'Answer: ' + + prompt_segs = prompt_full.split('') + assert len(prompt_segs) == len(img_embeds) + 1 + + prompt_seg_tokens = [ + self.model.tokenizer(seg, return_tensors='pt', add_special_tokens=(i == 0)).to(self.device).input_ids + for i, seg in enumerate(prompt_segs) + ] + prompt_seg_embs = [self.model.internlm_model.model.embed_tokens(seg) for seg in prompt_seg_tokens] + all_embeddings = [] + for i in range(len(img_embeds)): + all_embeddings.extend([prompt_seg_embs[i], img_embeds[i]]) + all_embeddings.append(prompt_seg_embs[-1]) + prompt_embs = torch.cat(all_embeddings, dim=1) + return prompt_embs + + def use_custom_prompt(self, dataset): + assert dataset is not None + if DATASET_TYPE(dataset) == 'multi-choice': + return True + 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 = '' + 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 + context = 'N/A' if hint is None else hint + mid_prompt = 'Context: ' + context + '\nQuestion: ' + question + if len(options_prompt): + mid_prompt += '\nOptions: ' + options_prompt + + if len(options): + txt_prompt = 'Please answer this question by choosing the correct choice.' + else: + txt_prompt = 'Please answer this question directly. ' + prompt = txt_prompt + mid_prompt + message = [dict(type='text', value=prompt)] + message.extend([dict(type='image', value=s) for s in tgt_path]) + return message diff --git a/vlmeval/vlm/xcomposer/xcomposer2.py b/vlmeval/vlm/xcomposer/xcomposer2.py new file mode 100644 index 0000000..c2807fe --- /dev/null +++ b/vlmeval/vlm/xcomposer/xcomposer2.py @@ -0,0 +1,213 @@ +import torch +import torchvision +from transformers import AutoModel, AutoTokenizer +from PIL import Image +from ..base import BaseModel +from ...smp import * +from ...utils import DATASET_TYPE +import re +pattern = re.compile(r'[A-Z]') + + +def __padding__(image): + width, height = image.size + tar = max(width, height) + top_padding = int((tar - height) / 2) + bottom_padding = tar - height - top_padding + left_padding = int((tar - width) / 2) + right_padding = tar - width - left_padding + image = torchvision.transforms.functional.pad(image, [left_padding, top_padding, right_padding, bottom_padding]) + return image + + +meta_instruction = """ +You are an AI assistant whose name is InternLM-XComposer (浦语·灵笔). +- InternLM-XComposer (浦语·灵笔) is a multi-modality conversational language model that is developed by +Shanghai AI Laboratory (上海人工智能实验室). It is designed to be helpful, honest, and harmless. +- InternLM-XComposer (浦语·灵笔) can understand and communicate fluently in the language +chosen by the user such as English and 中文. +- InternLM-XComposer (浦语·灵笔) is capable of comprehending and articulating responses effectively +based on the provided image. +""" + + +def model_gen(model, text, images, need_bos=True, padding=False, beams=3, max_token=500): + pt1 = 0 + embeds = [] + im_mask = [] + images = [images] + images_loc = [0] + for i, pts in enumerate(images_loc + [len(text)]): + subtext = text[pt1:pts] + if need_bos or len(subtext) > 0: + text_embeds = model.encode_text(subtext, add_special_tokens=need_bos) + embeds.append(text_embeds) + im_mask.append(torch.zeros(text_embeds.shape[:2]).cuda()) + need_bos = False + if i < len(images): + try: + image = Image.open(images[i]).convert('RGB') + except: + image = images[i].convert('RGB') + if padding: + image = __padding__(image) + image = model.vis_processor(image).unsqueeze(0).cuda() + image_embeds = model.encode_img(image) + embeds.append(image_embeds) + im_mask.append(torch.ones(image_embeds.shape[:2]).cuda()) + pt1 = pts + embeds = torch.cat(embeds, dim=1) + im_mask = torch.cat(im_mask, dim=1) + im_mask = im_mask.bool() + + outputs = model.generate( + inputs_embeds=embeds, + im_mask=im_mask, + temperature=1.0, + max_new_tokens=max_token, + num_beams=beams, + do_sample=False, + repetition_penalty=1.0) + + output_token = outputs[0] + if output_token[0] == 0 or output_token[0] == 1: + output_token = output_token[1:] + output_text = model.tokenizer.decode(output_token, add_special_tokens=False) + output_text = output_text.split('[UNUSED_TOKEN_145]')[0].strip() + return output_text + + +class XComposer2(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = False + + def __init__(self, model_path='internlm/internlm-xcomposer2-vl-7b', **kwargs): + assert model_path is not None + self.model_path = model_path + + model = AutoModel.from_pretrained(self.model_path, device_map='cpu', trust_remote_code=True).cuda().eval() + model.half() + tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True) + model.tokenizer = tokenizer + self.model = model + self.device = self.model.model.tok_embeddings.weight.device + + def generate_mme(self, image_path, text): + text = text.split('Please answer')[0].strip() + text = f'{text} Answer this question briefly' + text = f'[UNUSED_TOKEN_146]user\n{text}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n' + + return model_gen(self.model, text, image_path, need_bos=True, padding=True, beams=5) + + def generate_multichoice(self, image_path, text, dataset): + out = model_gen(self.model, text, image_path, need_bos=True, padding=False, beams=5, max_token=5) + if 'mmmu' in dataset.lower(): + return out + res = pattern.findall(out) + if len(res) == 0: + print('Error:', out) + res = 'Z' + return res[0] + + def generate_vqa(self, image_path, text): + out = model_gen(self.model, text, image_path, need_bos=True) + return out + + def generate_vanilla(self, image_path, text): + text = ( + '[UNUSED_TOKEN_146]system\n{}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]user\n{}' + 'Answer this question in detail.[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n' + ).format(meta_instruction, text) + out = model_gen(self.model, text, image_path, need_bos=True, max_token=500) + return out + + def generate_brief(self, image_path, text): + text = ( + '[UNUSED_TOKEN_146]user\nAnswer the question using a single word or phrase.{}' + '[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n' + ).format(text) + out = model_gen(self.model, text, image_path, need_bos=True, max_token=10) + return out + + def generate_driectly(self, image_path, text): + text = '[UNUSED_TOKEN_146]user\n{}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'.format(text) + out = model_gen(self.model, text, image_path, need_bos=True, max_token=500) + return out + + def generate_inner(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + with torch.cuda.amp.autocast(): + if dataset is None: + return self.generate_vanilla(image_path, prompt) + assert isinstance(dataset, str) + if dataset == 'MME': + return self.generate_mme(image_path, prompt) + + elif listinstr(['hallu'], dataset.lower()): + return self.generate_brief(image_path, prompt) + + elif listinstr(['llava'], dataset.lower()): + return self.generate_vanilla(image_path, prompt) + + elif dataset is not None and DATASET_TYPE(dataset) == 'multi-choice': + return self.generate_multichoice(image_path, prompt, dataset) + + elif dataset is not None and DATASET_TYPE(dataset) == 'VQA': + return self.generate_vqa(image_path, prompt) + + else: + return self.generate_vanilla(image_path, prompt) + + def use_custom_prompt(self, dataset): + assert dataset is not None + if DATASET_TYPE(dataset) == 'multi-choice' or DATASET_TYPE(dataset) == 'VQA': + return True + return False + + def build_mcqa(self, line): + question = line['question'] + options = { + cand: line[cand] + for cand in string.ascii_uppercase + if cand in line and not pd.isna(line[cand]) + } + img_prompt = '[UNUSED_TOKEN_146]user\n' + if len(options): + options_prompt = '' + for key, item in options.items(): + options_prompt += f'{key}. {item} ' + options_prompt = options_prompt.strip() + hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None + + context = 'N/A' if hint is None else hint + mid_prompt = 'Question: ' + question + '\nContext: ' + context + '\nOptions: ' + options_prompt + ans_prompt = '[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\nThe answer is' + prompt = img_prompt + mid_prompt + ans_prompt + else: + mid_prompt = f'Answer the question using a single word or phrase.{question}' + ans_prompt = '[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n' + prompt = img_prompt + mid_prompt + ans_prompt + + return prompt + + 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) + + if DATASET_TYPE(dataset) == 'multi-choice': + prompt = self.build_mcqa(line) + elif DATASET_TYPE(dataset) == 'VQA': + if 'mathvista' in dataset.lower(): + q = line['question'] + prompt = f'[UNUSED_TOKEN_146]user\n{q}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n' + else: + q = line['question'] + prompt = ( + f'[UNUSED_TOKEN_146]user\nAnswer the question using a single word or phrase.{q}' + '[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n' + ) + message = [dict(type='text', value=prompt)] + message.extend([dict(type='image', value=s) for s in tgt_path]) + return message diff --git a/vlmeval/vlm/xcomposer/xcomposer2_4KHD.py b/vlmeval/vlm/xcomposer/xcomposer2_4KHD.py new file mode 100644 index 0000000..4af554a --- /dev/null +++ b/vlmeval/vlm/xcomposer/xcomposer2_4KHD.py @@ -0,0 +1,235 @@ +import torch +from transformers import AutoModel, AutoTokenizer +from PIL import Image +from ..base import BaseModel +from ...smp import * +from ...utils import DATASET_TYPE +import numpy as np +import torchvision.transforms as transforms + +import re +pattern = re.compile(r'[A-Z]') + + +def padding_336(b): + width, height = b.size + tar = int(np.ceil(height / 336) * 336) + top_padding = int((tar - height) / 2) + bottom_padding = tar - height - top_padding + left_padding = 0 + right_padding = 0 + b = transforms.functional.pad(b, [left_padding, top_padding, right_padding, bottom_padding], fill=[255, 255, 255]) + + return b + + +def HD_transform(img, im_num=16): + width, height = img.size + trans = False + if width < height: + img = img.transpose(Image.TRANSPOSE) + trans = True + width, height = img.size + ratio = (width / height) + scale = 1 + while scale * np.ceil(scale / ratio) <= im_num: + scale += 1 + scale -= 1 + new_w = int(scale * 336) + new_h = int(new_w / ratio) + + img = transforms.functional.resize(img, [new_h, new_w],) + img = padding_336(img) + width, height = img.size + assert width * height <= im_num * 336 * 336 + if trans: + img = img.transpose(Image.TRANSPOSE) + + return img + + +meta_instruction = """You are an AI assistant whose name is InternLM-XComposer (浦语·灵笔). +- InternLM-XComposer (浦语·灵笔) is a multi-modality conversational language model that is developed\ + by Shanghai AI Laboratory (上海人工智能实验室). It is designed to be helpful, honest, and harmless. +- InternLM-XComposer (浦语·灵笔) can understand and communicate fluently in the language chosen by\ + the user such as English and 中文. +- InternLM-XComposer (浦语·灵笔) is capable of comprehending and articulating responses\ + effectively based on the provided image.""" + + +def model_gen(model, text, images, need_bos=True, padding=False, beams=3, max_token=500): + pt1 = 0 + embeds = [] + im_mask = [] + images = [images] + images_loc = [0] + for i, pts in enumerate(images_loc + [len(text)]): + subtext = text[pt1:pts] + if need_bos or len(subtext) > 0: + text_embeds = model.encode_text(subtext, add_special_tokens=need_bos) + embeds.append(text_embeds) + im_mask.append(torch.zeros(text_embeds.shape[:2]).cuda()) + need_bos = False + if i < len(images): + try: + image = Image.open(images[i]).convert('RGB') + except: + image = images[i].convert('RGB') + + image = HD_transform(image, im_num=model.hd_num) + image = model.vis_processor(image).unsqueeze(0).cuda() + image_embeds = model.encode_img(image) + embeds.append(image_embeds) + im_mask.append(torch.ones(image_embeds.shape[:2]).cuda()) + pt1 = pts + embeds = torch.cat(embeds, dim=1) + im_mask = torch.cat(im_mask, dim=1) + im_mask = im_mask.bool() + + outputs = model.generate(inputs_embeds=embeds, im_mask=im_mask, + temperature=1.0, max_new_tokens=max_token, num_beams=beams, + do_sample=False, repetition_penalty=1.0) + output_token = outputs[0] + if output_token[0] == 0 or output_token[0] == 1: + output_token = output_token[1:] + output_text = model.tokenizer.decode(output_token, add_special_tokens=False) + output_text = output_text.split('[UNUSED_TOKEN_145]')[0].strip() + return output_text + + +class XComposer2_4KHD(BaseModel): + + INSTALL_REQ = False + INTERLEAVE = False + + def __init__(self, model_path='internlm/internlm-xcomposer2-4khd-7b', **kwargs): + assert model_path is not None + self.model_path = model_path + + model = AutoModel.from_pretrained(self.model_path, device_map='cpu', trust_remote_code=True).cuda().eval() + model.half() + tokenizer = AutoTokenizer.from_pretrained(self.model_path, trust_remote_code=True) + model.tokenizer = tokenizer + self.model = model + self.device = self.model.model.tok_embeddings.weight.device + self.model.hd_num = 25 + + def generate_mme(self, image_path, text): + text = text.split('Please answer')[0].strip() + text = f'{text} Answer this question briefly' + text = f'[UNUSED_TOKEN_146]user\n{text}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n' + + return model_gen(self.model, text, image_path, need_bos=True, padding=True, beams=5) + + def generate_multichoice(self, image_path, text, dataset): + out = model_gen(self.model, text, image_path, need_bos=True, padding=False, beams=5, max_token=5) + if 'mmmu' in dataset.lower(): + return out + res = pattern.findall(out) + if len(res) == 0: + print('Error:', out) + res = 'Z' + return res[0] + + def generate_vqa(self, image_path, text): + out = model_gen(self.model, text, image_path, need_bos=True, max_token=100) + return out + + def generate_vanilla(self, image_path, text): + out = model_gen(self.model, text, image_path, need_bos=True, max_token=500) + return out + + def generate_brief(self, image_path, text): + text = '[UNUSED_TOKEN_146]user\nAnswer the question using a single word or phrase.{}\ + [UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n'.format(text) + out = model_gen(self.model, text, image_path, need_bos=True, max_token=10) + return out + + def generate(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + if listinstr(['docvqa_test', 'infovqa_test'], dataset.lower()): + self.model.hd_num = 65 + elif listinstr(['docvqa_val', 'infovqa_val', 'OCRBench'], dataset.lower()): + self.model.hd_num = 55 + elif listinstr(['mmmu', 'mmbench', 'mmvet'], dataset.lower()): + self.model.hd_num = 16 + else: + self.model.hd_num = 25 + + with torch.cuda.amp.autocast(): + if dataset is None: + return self.generate_vanilla(image_path, prompt) + assert isinstance(dataset, str) + if dataset == 'MME': + return self.generate_mme(image_path, prompt) + + elif listinstr(['hallu'], dataset.lower()): + return self.generate_brief(image_path, prompt) + + elif listinstr(['llava', 'mmvet'], dataset.lower()): + return self.generate_vanilla(image_path, prompt) + + elif dataset is not None and DATASET_TYPE(dataset) == 'multi-choice': + return self.generate_multichoice(image_path, prompt, dataset) + + elif dataset is not None and DATASET_TYPE(dataset) == 'VQA': + return self.generate_vqa(image_path, prompt) + + else: + return self.generate_vanilla(image_path, prompt) + + def use_custom_prompt(self, dataset): + assert dataset is not None + if DATASET_TYPE(dataset) == 'multi-choice' or DATASET_TYPE(dataset) == 'VQA': + return True + return False + + def build_mcqa(self, line): + question = line['question'] + options = { + cand: line[cand] + for cand in string.ascii_uppercase + if cand in line and not pd.isna(line[cand]) + } + img_prompt = '[UNUSED_TOKEN_146]user\n' + if len(options): + options_prompt = '' + for key, item in options.items(): + options_prompt += f'{key}. {item} ' + options_prompt = options_prompt.strip() + hint = line['hint'] if ('hint' in line and not pd.isna(line['hint'])) else None + + context = 'N/A' if hint is None else hint + mid_prompt = 'Question: ' + question + '\nContext: ' + context + '\nOptions: ' + options_prompt + ans_prompt = '[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\nThe answer is' + prompt = img_prompt + mid_prompt + ans_prompt + else: + mid_prompt = f'Answer the question using a single word or phrase.{question}' + ans_prompt = '[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n' + prompt = img_prompt + mid_prompt + ans_prompt + + return prompt + + 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) + + if DATASET_TYPE(dataset) == 'multi-choice': + prompt = self.build_mcqa(line) + elif DATASET_TYPE(dataset) == 'VQA': + if 'mathvista' in dataset.lower(): + q = line['question'] + prompt = f'[UNUSED_TOKEN_146]user\n{q}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n' + elif listinstr(['llava', 'mmvet'], dataset.lower()): + q = line['question'] + prompt = '[UNUSED_TOKEN_146]system\n{}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]user\n{}\ + Answer this question in detail.[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]\ + assistant\n'.format(meta_instruction, q) + else: + q = line['question'] + prompt = f'[UNUSED_TOKEN_146]user\nAnswer the question using a single word or phrase.\ + {q}[UNUSED_TOKEN_145]\n[UNUSED_TOKEN_146]assistant\n' + ret = [dict(type='text', value=prompt)] + ret.extend([dict(type='image', value=s) for s in tgt_path]) + return ret diff --git a/vlmeval/vlm/yi_vl.py b/vlmeval/vlm/yi_vl.py new file mode 100644 index 0000000..86568a0 --- /dev/null +++ b/vlmeval/vlm/yi_vl.py @@ -0,0 +1,156 @@ +import torch +import sys +import os.path as osp +import warnings +from PIL import Image +from vlmeval.smp import get_cache_path, load, dump, splitlen +from huggingface_hub import snapshot_download +from .base import BaseModel + + +""" +You can perform inference of Yi-VL through the following steps: +1. clone the repo https://github.com/01-ai/Yi to path-to-Yi +2. set up the environment and install the required packages in path-to-Yi/VL/requirements.txt +3. set Yi_ROOT in vlmeval/config.py + Yi_ROOT = path-to-Yi + +You are all set now! To run a demo for Yi-VL: +```python +from vlmeval import * +model = supported_VLM['Yi_VL_6B']() +model.generate('apple.jpg', 'What is in this image?') +``` +To run evaluation for Yi-VL, use `python run.py --model Yi_VL_6B --data {dataset_list}` +""" + + +def edit_config(repo_id): + if not osp.exists(repo_id): + root = get_cache_path(repo_id) + else: + root = repo_id + assert root is not None and osp.exists(root) + cfg = osp.join(root, 'config.json') + data = load(cfg) + mm_vision_tower = data['mm_vision_tower'] + if mm_vision_tower.startswith('./vit/'): + data['mm_vision_tower'] = osp.join(root, mm_vision_tower) + assert osp.exists(data['mm_vision_tower']) + dump(data, cfg) + + +def disable_torch_init(): + """ + Disable the redundant torch default initialization to accelerate model creation. + """ + import torch + + setattr(torch.nn.Linear, 'reset_parameters', lambda self: None) + setattr(torch.nn.LayerNorm, 'reset_parameters', lambda self: None) + + +class Yi_VL(BaseModel): + + INSTALL_REQ = True + INTERLEAVE = False + + def __init__(self, + model_path='01-ai/Yi-VL-6B', + root=None, + **kwargs): + + if root is None: + warnings.warn( + 'Please set root to the directory of Yi, ' + 'which is cloned from here: https://github.com/01-ai/Yi.' + ) + + self.root = osp.join(root, 'VL') + sys.path.append(self.root) + + if splitlen(model_path, '/') == 2 and not osp.exists(model_path): + if get_cache_path(model_path) is None: + snapshot_download(repo_id=model_path) + edit_config(model_path) + elif osp.exists(model_path): + edit_config(model_path) + + from llava.mm_utils import get_model_name_from_path, load_pretrained_model + from llava.model.constants import key_info + + disable_torch_init() + key_info['model_path'] = model_path + get_model_name_from_path(model_path) + self.tokenizer, self.model, self.image_processor, self.context_len = load_pretrained_model( + model_path, + device_map='cpu') + self.model = self.model.cuda() + self.conv_mode = 'mm_default' + + kwargs_default = dict(temperature=0.2, + num_beams=1, + do_sample=False, + max_new_tokens=1024, + top_p=None) + kwargs_default.update(kwargs) + self.kwargs = kwargs_default + warnings.warn(f'Following kwargs received: {self.kwargs}, will use as generation config. ') + + def generate_inner(self, message, dataset=None): + prompt, image_path = self.message_to_promptimg(message) + + from llava.conversation import conv_templates + from llava.model.constants import DEFAULT_IMAGE_TOKEN, IMAGE_TOKEN_INDEX + from llava.mm_utils import KeywordsStoppingCriteria, expand2square, tokenizer_image_token + + qs = DEFAULT_IMAGE_TOKEN + '\n' + prompt + conv = conv_templates[self.conv_mode].copy() + conv.append_message(conv.roles[0], qs) + conv.append_message(conv.roles[1], None) + prompt = conv.get_prompt() + + input_ids = ( + tokenizer_image_token(prompt, self.tokenizer, IMAGE_TOKEN_INDEX, return_tensors='pt') + .unsqueeze(0) + .cuda() + ) + + image = Image.open(image_path) + if getattr(self.model.config, 'image_aspect_ratio', None) == 'pad': + if image.mode == 'L': + background_color = int(sum([int(x * 255) for x in self.image_processor.image_mean]) / 3) + else: + background_color = tuple(int(x * 255) for x in self.image_processor.image_mean) + image = expand2square(image, background_color) + image_tensor = self.image_processor.preprocess(image, return_tensors='pt')[ + 'pixel_values' + ][0] + + stop_str = conv.sep + keywords = [stop_str] + stopping_criteria = KeywordsStoppingCriteria(keywords, self.tokenizer, input_ids) + self.model = self.model.to(dtype=torch.bfloat16) + with torch.inference_mode(): + output_ids = self.model.generate( + input_ids, + images=image_tensor.unsqueeze(0).to(dtype=torch.bfloat16).cuda(), + stopping_criteria=[stopping_criteria], + use_cache=True, + **self.kwargs) + + input_token_len = input_ids.shape[1] + n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item() + if n_diff_input_output > 0: + print( + f'[Warning] {n_diff_input_output} output_ids are not the same as the input_ids' + ) + outputs = self.tokenizer.batch_decode( + output_ids[:, input_token_len:], skip_special_tokens=True + )[0] + outputs = outputs.strip() + + if outputs.endswith(stop_str): + outputs = outputs[: -len(stop_str)] + outputs = outputs.strip() + return outputs

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 literal 0 HcmV?d00001 diff --git a/vlmeval/vlm/misc/000000039769.jpg b/vlmeval/vlm/misc/000000039769.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e131e8ecdf32c3f751ab0f7b2e5f002683babda2 GIT binary patch literal 173131 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 literal 0 HcmV?d00001 diff --git a/vlmeval/vlm/misc/Idefics.jpg b/vlmeval/vlm/misc/Idefics.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3bf337e45808a7345f6ee3bfce8c6fd36df930c5 GIT binary patch literal 16414 zcmeHuWmr_-_wUdMNOv>zP=b^UAu!a?FodLZcbA|v0}P$g44uNzA+3Z;ibJP@fV2n- z7k}~n-}~l1&wYQ_dG^_#v-a9+?Y-97`_w*ni+Ae)QmC?;G5`Yu1E6}p0q!=i6O{s; z>;V8xO#lc00N?|NF^B<}_lWgAwPBF_3*+A71q{-EVaj{Fj6n{-y3aB0Hvk4b0OwyA z064~A_y=EM@cc*SUK@t+zv`0ytBS~f^AAOyAsXuh!2Y*> z4BI%)|6=UFJOJzeodAkf?jG*{-m~g>1lW1&J9_xCst61Jt$g4AzwQ5buIuMy;{tPX zvtyMIln@jKh&&P&mJ)s>B`nG+A}l2)F7@~cK-0>GRa>9cm{s`Ey^P3T9e?Ssj=TTl z5&zd?+E;o1^$%vktAc-US{(O(`VIgLrT_qV_gb(Yi3mSR!TPVSF!NHd|G^EZ82^^R zz{CQiVE_pJZ54Ac4f7wJ<7wFc@MqF+{^6t3@cv`#K5A(X{)6u$lSc55%w}55U;P;P z008EG@qgPR{OD0J#((7R`&^9q-&kO<7i0Z{WlM?ws|V|}l;j_LT}t|&y7%WpDa}84 zu_JzendE-n}g9KC#}XxBtoSvwzvK z{P!`<-2LIVzs&zn_a2a_x!+-M0C@W&?!nT1`a915`u=`wVPf8+zw^L-x{u4h&#U_} zkF9s_(f{FN|0}+K`Of#~Z(R%k^}YPR>2D1G8%qoT5hw`&c>1^GKjRtjcP_yI$Z!_? zOC#WJ37`nT#m2$K!N$eK!NtSF#U~&oAb9YAfRdPmh?ItsmX?N+nwp-8lZBpvospWF zm7kTJi<=k3OUEMcNPy=NCl4>rUnLlLcz6W(1QY}W6g>3Q^gRF1boUlOhL0hO!H$Ii z1YnY3V3A?m4Feeex&`Zg?)--^FacQi?Zv~tFNKlHq)DdZ`ER;jr6_DZO{rjK7X zQ?n1;p#el#_t7N7A_K?)zKZSIa{jQ{OZ%EH`8-d#Wo1_GO+wRS3!=lL?{k%RfO;t3 z{FrHsWp&u}0_w=4vRV0*PC&Em`QSeO7-=!*zA3#?1|Lm#z4{4^D%U=$TkNO2BdRDL zDW8=9kg=S9+h;^&^$=)j{}X8cz`9 zpJwO{ZOoKhxc$=0GwgX;{(%TW>-R|54XStjnHn~EB1}SCi~j>yg6@`Hw5E-rroyxa zkLO$jQ>$6QAduCn#ToCPhLMv!0ng?}pLAN~2|`m}MsM_qiHAtH>uvPkz^g}e4~e5q zj5XWgRvwOSH(+mcmsFtAieaYuO`fO}#JQfk6)w>-PzO*g7%$5uqfFq7gzHr1a@-`- znpwTik3MN?BQ2s2FPT8qOTP?9Ka;e#@#?Y!t>}Ayc_Ep^Q;`AM@fY|8B=ix4b_LgIc_VT=PC*@H8x!!Na0C(m&r3sH}VIr0MGY)%%(4#c2w_Fh4aq<(6 zT3{-E+=w|7)HKQtouyd~(LUi#Vx@{z^bcddte~+Dqg!b`TaO>fX?LIRxjoO@*DO1} z&NZ-P1-F3P@>;?WHFy=tQ(WQoGf&dLm;DNhgCEZosoe6Y;(}g%n5u2-Qzb$F7&%{$ z=_iSFp1c+*A}0A6wjc3E;3QxkQW$DB2Tfr}Xv_Ml4b2cxWvSY$le)sC)2ocvCvF8r z-k7h~RwB@bm?2VrjYOf}q9xNBJ~M;nW8xRhXR-~TX0=<+L0d=DeRC|{W$&*Z20hql z#SZFSlNywc&UStRMlawV(cb~~%pXpfv@M8fEfamnnHV}U;d9j%-PADPKR%GnB-^Xj z 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