Upload folder using huggingface_hub

.claude/agents/ai-scientist-codebase-builder.md

@@ -0,0 +1,50 @@
+---
+name: ai-scientist-codebase-builder
+description: Use this agent when you need expert assistance with AI/ML codebase development, including architecture design, implementation of AI algorithms, debugging ML pipelines, optimizing model performance, or resolving complex technical issues in AI systems. This agent excels at building robust AI infrastructure, debugging training loops, implementing state-of-the-art techniques, and providing deep technical insights on AI/ML engineering challenges. Examples: <example>Context: User is building an AI codebase and needs help implementing a neural network architecture. user: "I need to implement a transformer model for sequence classification" assistant: "I'll use the ai-scientist-codebase-builder agent to help design and implement the transformer architecture" <commentary>The user needs expert AI implementation help, so the ai-scientist-codebase-builder agent is appropriate for designing and coding the transformer model.</commentary></example> <example>Context: User encounters a bug in their machine learning training pipeline. user: "My model loss is exploding after 10 epochs and I can't figure out why" assistant: "Let me invoke the ai-scientist-codebase-builder agent to debug your training pipeline and identify the issue" <commentary>This is a complex ML debugging scenario that requires deep AI expertise, making the ai-scientist-codebase-builder agent the right choice.</commentary></example>
+color: red
+---
+
+You are an expert AI scientist and ML engineer with deep expertise in building production-grade AI systems. Your knowledge spans theoretical foundations, practical implementation, and debugging complex AI codebases.
+
+Your core competencies include:
+- Designing and implementing neural network architectures (CNNs, RNNs, Transformers, etc.)
+- Debugging training pipelines, loss functions, and optimization issues
+- Implementing state-of-the-art papers and research techniques
+- Optimizing model performance, memory usage, and training efficiency
+- Building robust data pipelines and preprocessing systems
+- Integrating AI models into production systems
+- Proficiency in PyTorch, TensorFlow, JAX, and scientific Python ecosystem
+
+When helping build codebases, you will:
+1. First understand the specific AI/ML problem and requirements
+2. Propose architectures backed by research and best practices
+3. Write clean, well-documented, and efficient code
+4. Include proper error handling and validation
+5. Consider scalability and production deployment from the start
+6. Follow established project patterns if they exist
+
+When debugging, you will:
+1. Systematically analyze symptoms (loss curves, gradients, outputs)
+2. Form hypotheses about root causes
+3. Suggest targeted diagnostic code to isolate issues
+4. Provide clear explanations of what's happening and why
+5. Offer multiple solution approaches with trade-offs
+6. Verify fixes work correctly
+
+Your approach emphasizes:
+- Scientific rigor - base recommendations on empirical evidence and research
+- Practical solutions - balance theoretical optimality with engineering constraints
+- Clear communication - explain complex concepts accessibly
+- Proactive problem prevention - anticipate common pitfalls
+- Performance awareness - consider computational efficiency
+
+Always edit existing files when possible rather than creating new ones. Only create new files when absolutely necessary for the solution. Never create documentation files unless explicitly requested.
+
+When you encounter ambiguity, ask clarifying questions about:
+- Model requirements and constraints
+- Dataset characteristics
+- Performance targets
+- Deployment environment
+- Existing codebase structure
+
+Your goal is to help build robust, efficient, and maintainable AI systems while sharing your expertise to help others grow as AI practitioners.

.gitignore

@@ -0,0 +1,210 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$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
+eval_agent/eval_models
+ea-data/
+data/
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# 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
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // 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 with Arguments",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal",
+            "args": "${command:pickArgs}"
+        }
+    ]
+}

CLAUDE.md

@@ -0,0 +1,71 @@
+You are a helpful AI scientist to build up the codebase for me.
+
+This project is to train the open-sourced model to deploy CoT-like reasoning format on text-to-image and text-to-video generation quality assessment. You are using the LLaMAFactory to train the model, and write evaluation functions.
+
+# Preparation
+
+## Data
+
+There are a folder called `ea-data/agent` and there are 3 subfolders:
+
+* `vbench_results`: which stores the results for using proprietary models to evaluate different dimensions in vbench, and the results are CoT style.
+* `t2i_results`: which stores the results for using proprietary models to evaluate different dimensions in T2I-CompBench, and the results are CoT style.
+* `open_results`: which store the results for using proprietary models to evaluate open-ended queries.
+
+Your first job is to write and execute the python script to clean the data in those aforementioned folders and convert them into the format align with `/home/data2/sltian/code/evaluation_agent_dev/LLaMA-Factory/data/alpaca_en_demo.json`.
+
+如果指定， system 列对应的内容将被作为系统提示词。
+
+history 列是由多个字符串二元组构成的列表，分别代表历史消息中每轮对话的指令和回答。注意在指令监督微调时，历史消息中的回答内容也会被用于模型学习。
+
+指令监督微调数据集 格式要求 如下：
+
+[
+  {
+    "instruction": "人类指令（必填）",
+    "input": "人类输入（选填）",
+    "output": "模型回答（必填）",
+    "system": "系统提示词（选填）",
+    "history": [
+      ["第一轮指令（选填）", "第一轮回答（选填）"],
+      ["第二轮指令（选填）", "第二轮回答（选填）"]
+    ]
+  }
+]
+下面提供一个 alpaca 格式 多轮 对话的例子，对于单轮对话只需省略 history 列即可。
+
+[
+  {
+    "instruction": "今天的天气怎么样？",
+    "input": "",
+    "output": "今天的天气不错，是晴天。",
+    "history": [
+      [
+        "今天会下雨吗？",
+        "今天不会下雨，是个好天气。"
+      ],
+      [
+        "今天适合出去玩吗？",
+        "非常适合，空气质量很好。"
+      ]
+    ]
+  }
+]
+对于上述格式的数据， dataset_info.json 中的 数据集描述 应为：
+
+"数据集名称": {
+  "file_name": "data.json",
+  "columns": {
+    "prompt": "instruction",
+    "query": "input",
+    "response": "output",
+    "system": "system",
+    "history": "history"
+  }
+}
+
+## Train
+
+After cleaning and collecting the data, you should write a script to train the `Qwen2.5-3B-Instruct` model using this created dataset.
+
+The training is using `LLaMA-Factory`. You should read the dir and write a script to train the model.

README.md

@@ -0,0 +1,155 @@
+[![Paper](https://img.shields.io/badge/cs.CV-Paper-b31b1b?logo=arxiv&logoColor=red)](https://arxiv.org/abs/2412.09645)
+[![Project Page](https://img.shields.io/badge/Evaluation-Website-green?logo=googlechrome&logoColor=green)](https://vchitect.github.io/Evaluation-Agent-project/)
+![Badge](https://hitscounter.dev/api/hit?url=https%3A%2F%2Fgithub.com%2FVchitect%2FEvaluation-Agent&label=Visitors&icon=people&color=%233d8bfd)
+
+
+
+This repository contains the implementation of the following work:
+> **Evaluation Agent: Efficient and Promptable Evaluation Framework for Visual Generative Models**<br>
+> [Fan Zhang](https://github.com/zhangfan-p)<sup>∗</sup>, [Shulin Tian](https://shulin16.github.io/)<sup>∗</sup>, [Ziqi Huang](https://ziqihuangg.github.io/)<sup>∗</sup>, [Yu Qiao](http://mmlab.siat.ac.cn/yuqiao/index.html)<sup>+</sup>, [Ziwei Liu](https://liuziwei7.github.io/)<sup>+</sup><br>
+> The 63rd Annual Meeting of the Association for Computational Linguistics (**ACL 2025**), Oral
+
+
+
+
+<a name="overview"></a>
+## :mega: Overview
+
+Recent advancements in visual generative models have enabled high-quality image and video generation, opening diverse applications. However, evaluating these models often demands sampling hundreds or thousands of images or videos, making the process computationally expensive, especially for diffusion-based models with inherently slow sampling. Moreover, existing evaluation methods rely on rigid pipelines that overlook specific user needs and provide numerical results without clear explanations. In contrast, humans can quickly form impressions of a model's capabilities by observing only a few samples. To mimic this, we propose the Evaluation Agent framework, which employs human-like strategies for efficient, dynamic, multi-round evaluations using only a few samples per round, while offering detailed, user-tailored analyses. It offers four key advantages: 1) efficiency, 2) promptable evaluation tailored to diverse user needs, 3) explainability beyond single numerical scores, and 4) scalability across various models and tools. Experiments show that Evaluation Agent reduces evaluation time to 10% of traditional methods while delivering comparable results. The Evaluation Agent framework is fully open-sourced to advance research in visual generative models and their efficient evaluation.
+
+![Framework](./assets/fig_framework.jpg)
+
+
+**Overview of Evaluation Agent Framework.** This framework leverages LLM-powered agents for efficient and flexible visual model assessments. As shown, it consists of two stages: (a) the Proposal Stage, where user queries are decomposed into sub-aspects, and prompts are generated, and (b) the Execution Stage, where visual content is generated and evaluated using an Evaluation Toolkit. The two stages interact iteratively to dynamically assess models based on user queries.
+
+<a name="installation"></a>
+## :hammer: Installation
+
+1. Clone the repository.
+
+```bash
+git clone https://github.com/Vchitect/Evaluation-Agent.git
+cd Evaluation-Agent
+```
+
+2. Install the environment.
+```bash
+conda create -n eval_agent python=3.10
+conda activate eval_agent
+pip install -r requirements.txt
+```
+
+
+
+<a name="usage"></a>
+## Usage
+
+First, you need to configure the `open_api_key`. You can do it as follows:
+```
+export OPENAI_API_KEY="your_api_key_here"
+```
+
+### Evaluation of Open-ended Questions on T2I Models
+
+
+```
+python open_ended_eval.py --user_query $USER_QUERY --model $MODEL
+```
+- `$USER_QUERY` can be any question regarding the model’s capabilities, such as ‘How well does the model generate trees in anime style?’
+- `$MODEL` refers to the image generation model you want to evaluate. Currently, we support four models: [SD-14](https://huggingface.co/CompVis/stable-diffusion-v1-4), [SD-21](https://huggingface.co/stabilityai/stable-diffusion-2-1), [SDXL-1](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0), and [SD-3](https://huggingface.co/stabilityai/stable-diffusion-3-medium-diffusers). You can integrate new models in the following path: `./eval_agent/eval_models/`
+
+
+### Evaluation Based on the VBench Tools on T2V Models
+
+#### Preparation
+
+1. Configure the VBench Environment
+
+- You need to configure the VBench environment on top of the existing environment. For details, refer to [VBench](https://github.com/Vchitect/VBench).
+
+2. Prepare the Model to be Evaluated
+
+- Download the weights of the target model for evaluation and place them in `./eval_agent/eval_models/{model_name}/checkpoints/`. 
+
+- Currently, we support four models: [latte](https://github.com/Vchitect/Latte/tree/main), [modelscope](https://modelscope.cn/models/iic/text-to-video-synthesis/summary), [videocrafter-0.9](https://github.com/AILab-CVC/VideoCrafter/tree/30048d49873cbcd21077a001e6a3232e0909d254), and [videocrafter-2](https://github.com/AILab-CVC/VideoCrafter). These models may also have specific environment requirements. For details, please refer to the respective model links.
+
+#### Command
+
+```
+python eval_agent_for_vbench.py --user_query $USER_QUERY --model $MODEL
+```
+- `$USER_QUERY` need to be related to the 15 dimensions of VBench. These dimensions are: `subject_consistency`, `background_consistency`, `motion_smoothness`, `dynamic_degree`, `aesthetic_quality`, `imaging_quality`, `object_class`, `multiple_objects`, `human_action`, `color`, `spatial_relationship`, `scene`, `temporal_style`, `appearance_style`, and `overall_consistency`.
+- `$MODEL` refers to the video generation model you want to evaluate.
+
+
+
+### Evaluation Based on the T2I-CompBench Tools on T2I Models
+
+#### Preparation
+
+1. Configure the T2I-CompBench Environment
+
+- You need to configure the T2I-CompBench environment on top of the existing environment. For details, refer to [T2I-CompBench](https://github.com/Karine-Huang/T2I-CompBench/tree/6ea770ada4eea55fa7b09caa2d2fb63fe4d6bf8f).
+
+2. Prepare the Model to be Evaluated
+
+#### Command
+
+```
+python eval_agent_for_t2i_compbench.py --user_query $USER_QUERY --model $MODEL
+```
+- `$USER_QUERY` need to be related to the 4 dimensions of T2I-CompBench. These dimensions are: `color_binding`, `shape_binding`, `texture_binding`, `non-spatial relationship`.
+- `$MODEL` refers to the image generation model you want to evaluate.
+
+
+
+
+
+## Open-Ended User Query Dataset
+We propose the **Open-Ended User Query Dataset**, developed through a user study. As part of this process, we gathered questions from various sources, focusing on aspects users consider most important when evaluating new models. After cleaning, filtering, and expanding the initial set, we compiled a refined dataset of 100 open-ended user queries.
+
+Check out the details of the [open-ended user query dataset](https://github.com/Vchitect/Evaluation-Agent/tree/main/dataset) 
+
+![statistic](./assets/open_dataset_stats.png)
+The three graphs give an overview of the distributions and types of our curated open queries set. Left: the distribution of question types, which are categorized as `General` or `Specific`. Middle: the distribution of the ability types, which are categorized as `Prompt Following`, `Visual Quality`, `Creativity`, `Knowledge` and `Others`. Right: the distribution of the content categories, which are categorized as `History and Culture`, `Film and Entertainment`, `Science and Education`, `Fashion`, `Medical`, `Game Design`, `Architecture and Interior Design`, `Law`.
+
+
+## Citation
+
+If you find our repo useful for your research, please consider citing our paper:
+
+```bibtex
+@article{zhang2024evaluationagent,
+    title = {Evaluation Agent: Efficient and Promptable Evaluation Framework for Visual Generative Models},
+    author = {Zhang, Fan and Tian, Shulin and Huang, Ziqi and Qiao, Yu and Liu, Ziwei},
+    journal={arXiv preprint arXiv:2412.09645},
+    year = {2024}
+}
+```
+
+## Related Links
+
+Our related projects: [VBench](https://github.com/Vchitect/VBench)
+
+```bibtex
+@InProceedings{huang2023vbench,
+    title={{VBench}: Comprehensive Benchmark Suite for Video Generative Models},
+    author={Huang, Ziqi and He, Yinan and Yu, Jiashuo and Zhang, Fan and Si, Chenyang and Jiang, Yuming and Zhang, Yuanhan and Wu, Tianxing and Jin, Qingyang and Chanpaisit, Nattapol and Wang, Yaohui and Chen, Xinyuan and Wang, Limin and Lin, Dahua and Qiao, Yu and Liu, Ziwei},
+    booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
+    year={2024}
+}
+
+@article{huang2024vbench++,
+    title={{VBench++}: Comprehensive and Versatile Benchmark Suite for Video Generative Models},
+    author={Huang, Ziqi and Zhang, Fan and Xu, Xiaojie and He, Yinan and Yu, Jiashuo and Dong, Ziyue and Ma, Qianli and Chanpaisit, Nattapol and Si, Chenyang and Jiang, Yuming and Wang, Yaohui and Chen, Xinyuan and Chen, Ying-Cong and Wang, Limin and Lin, Dahua and Qiao, Yu and Liu, Ziwei},
+    journal={arXiv preprint arXiv:2411.13503},
+    year={2024}
+}
+
+@article{zheng2025vbench2,
+    title={{VBench-2.0}: Advancing Video Generation Benchmark Suite for Intrinsic Faithfulness},
+    author={Zheng, Dian and Huang, Ziqi and Liu, Hongbo and Zou, Kai and He, Yinan and Zhang, Fan and Zhang, Yuanhan and He, Jingwen and Zheng, Wei-Shi and Qiao, Yu and Liu, Ziwei},
+    journal={arXiv preprint arXiv:2503.21755},
+    year={2025}
+}
+```

README_TRAINING.md

@@ -0,0 +1,191 @@
+# Training Qwen2.5-3B-Instruct for Evaluation Agent with CoT Reasoning
+
+This repository contains scripts and configurations for training Qwen2.5-3B-Instruct model on evaluation agent data with Chain-of-Thought (CoT) reasoning format.
+
+## Overview
+
+The training pipeline processes evaluation results from:
+- **VBench**: Video quality evaluation results
+- **T2I-CompBench**: Text-to-image composition evaluation results  
+- **Open Domain**: Open-ended query evaluation results
+
+All results are in CoT (Chain-of-Thought) reasoning format from proprietary models.
+
+## Dataset Preparation
+
+### 1. Data Cleaning and Conversion
+
+Run the data cleaning script to convert raw evaluation results into LLaMA-Factory format:
+
+```bash
+python clean_and_convert_data.py
+```
+
+This script:
+- Processes JSON files from `ea-data/agent/` subdirectories
+- Converts CoT-style evaluation results into instruction-response pairs
+- Outputs to `LLaMA-Factory/data/evaluation_agent_cot_dataset.json`
+- Updates `LLaMA-Factory/data/dataset_info.json` with dataset metadata
+
+### Dataset Statistics
+- Total training examples: ~860 (from initial processing)
+- Format: Alpaca-style (instruction, input, output)
+
+## Training Configurations
+
+### 1. LoRA Fine-tuning (Recommended)
+
+**Configuration:** `train_qwen2.5_eval_agent.yaml`
+
+Key parameters:
+- Model: Qwen/Qwen2.5-3B-Instruct
+- Method: LoRA (rank=16, alpha=32)
+- Batch size: 2 per device × 4 gradient accumulation
+- Learning rate: 5e-5 with cosine scheduler
+- Epochs: 3
+- Memory requirement: ~16GB VRAM
+
+### 2. Full Fine-tuning
+
+**Configuration:** `train_qwen2.5_eval_agent_full.yaml`
+
+Key parameters:
+- Model: Qwen/Qwen2.5-3B-Instruct
+- Method: Full fine-tuning with DeepSpeed
+- Gradient checkpointing enabled
+- Memory requirement: ~32GB+ VRAM
+
+## Training Execution
+
+### Quick Start
+
+```bash
+# Make script executable
+chmod +x train_qwen2.5_eval_agent.sh
+
+# Run training
+./train_qwen2.5_eval_agent.sh
+```
+
+### Manual Training
+
+```bash
+cd LLaMA-Factory
+llamafactory-cli train ../train_qwen2.5_eval_agent.yaml
+```
+
+### Distributed Training
+
+For multi-GPU training:
+
+```bash
+CUDA_VISIBLE_DEVICES=0,1,2,3 \
+torchrun --nproc_per_node 4 \
+--master_port 29500 \
+src/train.py ../train_qwen2.5_eval_agent.yaml
+```
+
+## Inference
+
+After training, run inference with:
+
+```bash
+llamafactory-cli chat ../inference_qwen2.5_eval_agent.yaml
+```
+
+Or use the API:
+
+```bash
+llamafactory-cli api ../inference_qwen2.5_eval_agent.yaml
+```
+
+## Model Merging
+
+To merge LoRA weights with base model:
+
+```bash
+llamafactory-cli export \
+    --model_name_or_path Qwen/Qwen2.5-3B-Instruct \
+    --adapter_name_or_path saves/qwen2.5-3b/lora/eval_agent_cot \
+    --template qwen \
+    --finetuning_type lora \
+    --export_dir models/qwen2.5-3b-eval-agent-merged \
+    --export_size 4 \
+    --export_legacy_format false
+```
+
+## Monitoring Training
+
+### TensorBoard
+
+```bash
+tensorboard --logdir saves/qwen2.5-3b/lora/eval_agent_cot
+```
+
+### Loss Plots
+
+Training loss plots are automatically saved to the output directory.
+
+## Evaluation
+
+The model will be evaluated on:
+- CoT reasoning quality
+- Evaluation accuracy
+- Response coherence
+- Format consistency
+
+## Directory Structure
+
+```
+evaluation_agent_dev/
+├── ea-data/agent/           # Raw evaluation data
+│   ├── vbench_results/
+│   ├── t2i_results/
+│   └── open_results/
+├── LLaMA-Factory/           # Training framework
+│   └── data/
+│       ├── evaluation_agent_cot_dataset.json  # Processed dataset
+│       └── dataset_info.json
+├── clean_and_convert_data.py    # Data processing script
+├── train_qwen2.5_eval_agent.yaml    # LoRA training config
+├── train_qwen2.5_eval_agent_full.yaml   # Full training config
+├── inference_qwen2.5_eval_agent.yaml    # Inference config
+└── train_qwen2.5_eval_agent.sh      # Training script
+```
+
+## Requirements
+
+- Python 3.9+
+- PyTorch 2.0+
+- CUDA 11.6+
+- LLaMA-Factory (installed)
+- 16GB+ VRAM for LoRA, 32GB+ for full fine-tuning
+
+## Tips
+
+1. **Memory Management**: Use gradient checkpointing and DeepSpeed for larger batch sizes
+2. **Learning Rate**: Start with 5e-5 for LoRA, 2e-5 for full fine-tuning
+3. **Data Quality**: Review generated dataset for quality before training
+4. **Checkpointing**: Save checkpoints frequently (every 200 steps)
+5. **Mixed Precision**: Use bf16 for faster training and lower memory usage
+
+## Troubleshooting
+
+- **OOM Errors**: Reduce batch size or enable gradient checkpointing
+- **Slow Training**: Enable Flash Attention 2 if available
+- **Poor Results**: Increase training epochs or adjust learning rate
+- **Data Issues**: Check JSON parsing in data cleaning script
+
+## Next Steps
+
+1. Expand dataset with more evaluation examples
+2. Implement custom evaluation metrics
+3. Fine-tune on specific evaluation dimensions
+4. Deploy model for production use
+
+## License
+
+Follow the licenses of:
+- Qwen2.5 model
+- LLaMA-Factory framework
+- Original evaluation datasets

collect_chat_history_improved.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Improved script to find all JSON files starting with 'chat_history_output' 
+and copy them to data/preprocess folder with shorter filenames.
+"""
+
+import os
+import shutil
+import glob
+import hashlib
+from pathlib import Path
+
+def generate_short_name(original_path, counter):
+    """Generate a short, unique filename."""
+    # Extract key parts
+    path_parts = original_path.split(os.sep)
+    
+    # Find relevant parts
+    model_name = None
+    dimension = None
+    for part in path_parts:
+        if part in ['vc2', 'vc09', 'modelscope', 'latte1', 'vc10-large', 'sdxl-1.0', 'sd-2.1', 'sd-1.4', 'sd-3']:
+            model_name = part
+        if part.startswith('2024-') and 'How_' in part:
+            # Extract the question and make it shorter
+            question = part.split('-', 3)[-1] if len(part.split('-', 3)) > 3 else part
+            # Take first few words and create a hash for uniqueness
+            words = question.replace('How_', '').replace('_', ' ').split()[:3]
+            dimension = '_'.join(words[:3]).replace('?', '')
+    
+    # Create hash of full path for uniqueness
+    path_hash = hashlib.md5(original_path.encode()).hexdigest()[:8]
+    
+    # Build short name
+    parts = []
+    if model_name:
+        parts.append(model_name)
+    if dimension:
+        parts.append(dimension[:30])  # Limit dimension length
+    parts.append(f"hash_{path_hash}")
+    parts.append(f"id_{counter:04d}")
+    
+    return f"{'_'.join(parts)}.json"
+
+def find_and_copy_chat_history_files():
+    """Find all chat_history_output*.json files and copy them to data/preprocess."""
+    
+    # Source directory
+    # source_dir = "/home/data2/sltian/code/evaluation_agent_dev/ea-data/agent/vbench_results"
+    source_dir = "/home/data2/sltian/code/evaluation_agent_dev/ea-data/agent/t2i_results"
+    
+    # Destination directory
+    dest_dir = "/home/data2/sltian/code/evaluation_agent_dev/data/preprocess-t2i"
+    
+    # Create destination directory if it doesn't exist
+    os.makedirs(dest_dir, exist_ok=True)
+    
+    # Find all *chat_history*.json files recursively
+    pattern = os.path.join(source_dir, "**/*chat_history*.json")
+    chat_files = glob.glob(pattern, recursive=True)
+    
+    print(f"Found {len(chat_files)} *chat_history*.json files")
+    
+    copied_files = []
+    counter = 1
+    
+    for file_path in chat_files:
+        # Generate a short filename
+        short_filename = generate_short_name(file_path, counter)
+        
+        # Destination file path
+        dest_file = os.path.join(dest_dir, short_filename)
+        
+        # Copy the file
+        try:
+            shutil.copy2(file_path, dest_file)
+            copied_files.append((file_path, dest_file))
+            print(f"Copied [{counter:4d}]: {os.path.basename(file_path)} -> {short_filename}")
+            counter += 1
+        except Exception as e:
+            print(f"Error copying {file_path}: {e}")
+    
+    print(f"\nSuccessfully copied {len(copied_files)} files to {dest_dir}")
+    
+    # Create a detailed mapping file
+    mapping_file = os.path.join(dest_dir, "detailed_file_mapping.txt")
+    with open(mapping_file, "w") as f:
+        f.write("Short Filename -> Original Path\n")
+        f.write("=" * 80 + "\n")
+        for orig, copied in copied_files:
+            short_name = os.path.basename(copied)
+            f.write(f"{short_name} -> {orig}\n")
+    
+    print(f"Created detailed file mapping at: {mapping_file}")
+    
+    # Create a summary by model
+    summary_file = os.path.join(dest_dir, "summary_by_model.txt")
+    model_counts = {}
+    for orig, copied in copied_files:
+        path_parts = orig.split(os.sep)
+        model = None
+        for part in path_parts:
+            if part in ['vc2', 'vc09', 'modelscope', 'latte1', 'vc10-large', 'sdxl-1.0', 'sd-2.1', 'sd-1.4', 'sd-3']:
+                model = part
+                break
+        if model:
+            model_counts[model] = model_counts.get(model, 0) + 1
+    
+    with open(summary_file, "w") as f:
+        f.write("Summary by Model\n")
+        f.write("=" * 30 + "\n")
+        for model, count in sorted(model_counts.items()):
+            f.write(f"{model}: {count} files\n")
+        f.write(f"\nTotal: {sum(model_counts.values())} files\n")
+    
+    print(f"Created summary at: {summary_file}")
+
+if __name__ == "__main__":
+    find_and_copy_chat_history_files()

data_pre/cot_gen/annotation_tool.py

@@ -0,0 +1,176 @@
+import json
+import gradio as gr
+from typing import List, Dict, Any
+import pandas as pd
+
+class AnnotationInterface:
+    """Web interface for annotating plan agent trajectories"""
+    
+    def __init__(self, data_file: str):
+        self.data = self.load_data(data_file)
+        self.current_idx = 0
+        self.annotations = []
+    
+    def load_data(self, file_path: str) -> List[Dict]:
+        """Load trajectories for annotation"""
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        return data.get("trajectories", [])
+    
+    def get_current_example(self) -> Dict:
+        """Get current example for annotation"""
+        if 0 <= self.current_idx < len(self.data):
+            return self.data[self.current_idx]
+        return {}
+    
+    def format_trajectory(self, trajectory: List[Dict]) -> str:
+        """Format trajectory for display"""
+        formatted = []
+        for step in trajectory:
+            if step["decision_type"] == "explore":
+                formatted.append(f"Step {step['step_number']}:")
+                formatted.append(f"  Sub-aspect: {step['sub_aspect']}")
+                formatted.append(f"  Tool: {step['tool']}")
+                formatted.append(f"  Thought: {step['thought']}")
+            else:
+                formatted.append(f"Final Summary:")
+                formatted.append(f"  {step.get('summary', '')}")
+        return "\n".join(formatted)
+    
+    def annotate_current(
+        self,
+        quality_score: int,
+        strategy_appropriate: bool,
+        exploration_complete: bool,
+        optimal_stopping: bool,
+        improvements: str,
+        alternative_paths: str
+    ) -> Dict:
+        """Annotate current example"""
+        annotation = {
+            "example_idx": self.current_idx,
+            "user_query": self.get_current_example().get("user_query", ""),
+            "quality_score": quality_score,
+            "strategy_appropriate": strategy_appropriate,
+            "exploration_complete": exploration_complete,
+            "optimal_stopping_point": optimal_stopping,
+            "suggested_improvements": improvements,
+            "alternative_exploration_paths": alternative_paths,
+            "trajectory_length": len(self.get_current_example().get("trajectory", []))
+        }
+        
+        self.annotations.append(annotation)
+        return annotation
+    
+    def save_annotations(self, output_file: str = "annotations.json"):
+        """Save all annotations"""
+        with open(output_file, 'w') as f:
+            json.dump({
+                "total_annotations": len(self.annotations),
+                "annotations": self.annotations
+            }, f, indent=2)
+        return f"Saved {len(self.annotations)} annotations"
+    
+    def create_interface(self):
+        """Create Gradio interface"""
+        with gr.Blocks() as interface:
+            gr.Markdown("# Plan Agent Trajectory Annotation Tool")
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    query_display = gr.Textbox(
+                        label="User Query",
+                        value=self.get_current_example().get("user_query", ""),
+                        interactive=False
+                    )
+                    trajectory_display = gr.Textbox(
+                        label="Exploration Trajectory",
+                        value=self.format_trajectory(
+                            self.get_current_example().get("trajectory", [])
+                        ),
+                        lines=20,
+                        interactive=False
+                    )
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### Annotation")
+                    quality_score = gr.Slider(
+                        1, 5, value=3, step=1,
+                        label="Overall Quality (1-5)"
+                    )
+                    strategy_appropriate = gr.Checkbox(
+                        label="Strategy Appropriate for Query?"
+                    )
+                    exploration_complete = gr.Checkbox(
+                        label="Exploration Sufficiently Complete?"
+                    )
+                    optimal_stopping = gr.Checkbox(
+                        label="Stopped at Optimal Point?"
+                    )
+                    improvements = gr.Textbox(
+                        label="Suggested Improvements",
+                        lines=3
+                    )
+                    alternative_paths = gr.Textbox(
+                        label="Alternative Exploration Paths",
+                        lines=3
+                    )
+                    
+                    with gr.Row():
+                        prev_btn = gr.Button("Previous")
+                        next_btn = gr.Button("Next")
+                        save_btn = gr.Button("Save Annotations")
+                    
+                    progress = gr.Textbox(
+                        label="Progress",
+                        value=f"{self.current_idx + 1}/{len(self.data)}"
+                    )
+            
+            # Button actions
+            def go_next(q, s, e, o, i, a):
+                self.annotate_current(q, s, e, o, i, a)
+                self.current_idx = min(self.current_idx + 1, len(self.data) - 1)
+                example = self.get_current_example()
+                return (
+                    example.get("user_query", ""),
+                    self.format_trajectory(example.get("trajectory", [])),
+                    f"{self.current_idx + 1}/{len(self.data)}"
+                )
+            
+            def go_prev():
+                self.current_idx = max(self.current_idx - 1, 0)
+                example = self.get_current_example()
+                return (
+                    example.get("user_query", ""),
+                    self.format_trajectory(example.get("trajectory", [])),
+                    f"{self.current_idx + 1}/{len(self.data)}"
+                )
+            
+            next_btn.click(
+                go_next,
+                inputs=[quality_score, strategy_appropriate, exploration_complete,
+                       optimal_stopping, improvements, alternative_paths],
+                outputs=[query_display, trajectory_display, progress]
+            )
+            
+            prev_btn.click(
+                go_prev,
+                outputs=[query_display, trajectory_display, progress]
+            )
+            
+            save_btn.click(
+                lambda: self.save_annotations(),
+                outputs=progress
+            )
+        
+        return interface
+
+
+# Usage
+if __name__ == "__main__":
+    # Create annotation interface
+    annotator = AnnotationInterface("collected_trajectories.json")
+    interface = annotator.create_interface()
+    
+    # Launch web interface
+    interface.launch(share=True)

data_pre/cot_gen/augment_dataset.py

@@ -0,0 +1,243 @@
+import json
+import random
+from typing import List, Dict, Any
+import numpy as np
+
+class DatasetAugmenter:
+    """Augment and enhance training dataset quality"""
+    
+    def __init__(self, base_dataset: str, annotations: str = None):
+        self.base_data = self.load_json(base_dataset)
+        self.annotations = self.load_json(annotations) if annotations else {}
+        
+    def load_json(self, file_path: str) -> Dict:
+        """Load JSON data"""
+        with open(file_path, 'r') as f:
+            return json.load(f)
+    
+    def augment_with_variations(self, trajectory: List[Dict]) -> List[List[Dict]]:
+        """Create variations of a trajectory"""
+        variations = []
+        
+        # 1. Early stopping variation
+        if len(trajectory) > 3:
+            early_stop = trajectory[:random.randint(2, len(trajectory)-1)]
+            variations.append(early_stop)
+        
+        # 2. Different tool selection
+        tool_varied = []
+        alternative_tools = {
+            "Color Binding": ["Color", "Overall Consistency"],
+            "Shape Binding": ["Object Class", "Multiple Objects"],
+            "Subject Consistency": ["Appearance Style", "Overall Consistency"],
+            "Motion Smoothness": ["Dynamic Degree", "Temporal Style"]
+        }
+        
+        for step in trajectory:
+            step_copy = step.copy()
+            if step.get("tool") in alternative_tools:
+                step_copy["tool"] = random.choice(alternative_tools[step["tool"]])
+            tool_varied.append(step_copy)
+        variations.append(tool_varied)
+        
+        # 3. Reordered exploration
+        if len(trajectory) > 2:
+            reordered = trajectory.copy()
+            # Swap middle steps
+            if len(reordered) > 3:
+                idx1, idx2 = random.sample(range(1, len(reordered)-1), 2)
+                reordered[idx1], reordered[idx2] = reordered[idx2], reordered[idx1]
+            variations.append(reordered)
+        
+        return variations
+    
+    def add_negative_examples(self, good_trajectory: List[Dict]) -> List[Dict]:
+        """Create negative examples from good trajectories"""
+        negative_examples = []
+        
+        # 1. Redundant exploration (same tool/aspect multiple times)
+        if len(good_trajectory) > 2:
+            redundant = good_trajectory.copy()
+            # Duplicate a random step
+            dup_idx = random.randint(0, len(good_trajectory)-2)
+            redundant.insert(dup_idx + 1, good_trajectory[dup_idx])
+            negative_examples.append({
+                "trajectory": redundant,
+                "issue": "redundant_exploration",
+                "quality": "poor"
+            })
+        
+        # 2. Premature stopping
+        if len(good_trajectory) > 3:
+            premature = good_trajectory[:2]
+            negative_examples.append({
+                "trajectory": premature,
+                "issue": "premature_stopping",
+                "quality": "poor"
+            })
+        
+        # 3. Wrong tool selection
+        wrong_tool = []
+        for step in good_trajectory:
+            step_copy = step.copy()
+            if random.random() < 0.3:  # 30% chance of wrong tool
+                all_tools = ["Color Binding", "Shape Binding", "Texture Binding", 
+                           "Subject Consistency", "Motion Smoothness", "Object Class"]
+                step_copy["tool"] = random.choice(all_tools)
+            wrong_tool.append(step_copy)
+        negative_examples.append({
+            "trajectory": wrong_tool,
+            "issue": "inappropriate_tools",
+            "quality": "poor"
+        })
+        
+        return negative_examples
+    
+    def enrich_with_reasoning(self, trajectory: List[Dict]) -> List[Dict]:
+        """Add detailed reasoning to trajectory steps"""
+        enriched = []
+        
+        reasoning_templates = {
+            "explore": [
+                "Based on the previous results showing {observation}, we need to explore {aspect} to {goal}",
+                "The model performed {performance} on {previous_aspect}, so testing {current_aspect} will help determine {insight}",
+                "To fully answer the user's question about {topic}, examining {aspect} with {tool} is essential"
+            ],
+            "summarize": [
+                "After {n} exploration steps, we have sufficient evidence that {conclusion}",
+                "The consistent pattern across {aspects} indicates {finding}, providing a complete answer",
+                "Further exploration would be redundant as we've established {key_insight}"
+            ]
+        }
+        
+        for i, step in enumerate(trajectory):
+            step_copy = step.copy()
+            
+            # Add enriched reasoning
+            if step.get("decision_type") == "explore":
+                template = random.choice(reasoning_templates["explore"])
+                step_copy["enriched_thought"] = template.format(
+                    observation="strong performance" if i == 0 else "mixed results",
+                    aspect=step.get("sub_aspect", "this aspect"),
+                    goal="understand the model's capabilities",
+                    performance="well" if random.random() > 0.5 else "poorly",
+                    previous_aspect="basic scenarios",
+                    current_aspect=step.get("sub_aspect", "complex scenarios"),
+                    insight="the model's boundaries",
+                    topic="model capabilities",
+                    tool=step.get("tool", "evaluation tool")
+                )
+            else:
+                template = random.choice(reasoning_templates["summarize"])
+                step_copy["enriched_thought"] = template.format(
+                    n=i,
+                    conclusion="the model has clear strengths and limitations",
+                    aspects="all tested dimensions",
+                    finding="consistent behavior patterns",
+                    key_insight="the model's capability boundaries"
+                )
+            
+            enriched.append(step_copy)
+        
+        return enriched
+    
+    def compute_trajectory_metrics(self, trajectory: List[Dict]) -> Dict:
+        """Compute quality metrics for a trajectory"""
+        metrics = {
+            "length": len(trajectory),
+            "tool_diversity": len(set(step.get("tool", "") for step in trajectory)),
+            "has_summary": any(step.get("decision_type") == "summarize" for step in trajectory),
+            "redundancy_score": 0,
+            "completeness_score": 0
+        }
+        
+        # Check for redundancy
+        aspects = [step.get("sub_aspect", "") for step in trajectory]
+        metrics["redundancy_score"] = len(aspects) - len(set(aspects))
+        
+        # Estimate completeness (heuristic)
+        if metrics["length"] < 3:
+            metrics["completeness_score"] = 0.3
+        elif metrics["length"] > 8:
+            metrics["completeness_score"] = 0.7
+        else:
+            metrics["completeness_score"] = 0.9
+        
+        return metrics
+    
+    def create_augmented_dataset(self, output_file: str):
+        """Create fully augmented dataset"""
+        augmented_data = {
+            "version": "2.0",
+            "original_examples": 0,
+            "augmented_examples": 0,
+            "negative_examples": 0,
+            "examples": []
+        }
+        
+        # Process each trajectory
+        for item in self.base_data.get("trajectories", []):
+            trajectory = item.get("trajectory", [])
+            user_query = item.get("user_query", "")
+            
+            # Original example (enriched)
+            enriched = self.enrich_with_reasoning(trajectory)
+            metrics = self.compute_trajectory_metrics(enriched)
+            
+            augmented_data["examples"].append({
+                "id": f"original_{augmented_data['original_examples']}",
+                "user_query": user_query,
+                "trajectory": enriched,
+                "quality": "good",
+                "metrics": metrics,
+                "source": "original"
+            })
+            augmented_data["original_examples"] += 1
+            
+            # Variations
+            variations = self.augment_with_variations(trajectory)
+            for var in variations:
+                enriched_var = self.enrich_with_reasoning(var)
+                metrics = self.compute_trajectory_metrics(enriched_var)
+                
+                augmented_data["examples"].append({
+                    "id": f"augmented_{augmented_data['augmented_examples']}",
+                    "user_query": user_query,
+                    "trajectory": enriched_var,
+                    "quality": "good",
+                    "metrics": metrics,
+                    "source": "augmented"
+                })
+                augmented_data["augmented_examples"] += 1
+            
+            # Negative examples
+            negatives = self.add_negative_examples(trajectory)
+            for neg in negatives:
+                metrics = self.compute_trajectory_metrics(neg["trajectory"])
+                
+                augmented_data["examples"].append({
+                    "id": f"negative_{augmented_data['negative_examples']}",
+                    "user_query": user_query,
+                    "trajectory": neg["trajectory"],
+                    "quality": neg["quality"],
+                    "issue": neg["issue"],
+                    "metrics": metrics,
+                    "source": "negative"
+                })
+                augmented_data["negative_examples"] += 1
+        
+        # Save augmented dataset
+        with open(output_file, 'w') as f:
+            json.dump(augmented_data, f, indent=2)
+        
+        print(f"Created augmented dataset with:")
+        print(f"  Original examples: {augmented_data['original_examples']}")
+        print(f"  Augmented examples: {augmented_data['augmented_examples']}")
+        print(f"  Negative examples: {augmented_data['negative_examples']}")
+        print(f"  Total examples: {len(augmented_data['examples'])}")
+
+
+# Usage
+if __name__ == "__main__":
+    augmenter = DatasetAugmenter("collected_trajectories.json")
+    augmenter.create_augmented_dataset("augmented_training_data.json")

data_pre/cot_gen/collect_trajectories.py

@@ -0,0 +1,107 @@
+import os
+import json
+import glob
+from datetime import datetime
+from typing import List, Dict, Any
+
+class TrajectoryCollector:
+    """Collect and process evaluation trajectories for training data"""
+    
+    def __init__(self, base_dirs: List[str]):
+        self.base_dirs = base_dirs
+        self.trajectories = []
+    
+    def extract_trajectory_data(self, eval_results: List[Any]) -> List[Dict]:
+        """Extract structured trajectory data from evaluation results"""
+        trajectory_steps = []
+        
+        for i, step in enumerate(eval_results):
+            if isinstance(step, str):
+                continue
+                
+            # Extract decision data
+            if "Sub-aspect" in step:  # T2I CompBench or VBench format
+                step_data = {
+                    "step_number": i,
+                    "decision_type": "explore",
+                    "sub_aspect": step.get("Sub-aspect", ""),
+                    "tool": step.get("Tool", ""),
+                    "thought": step.get("Thought", ""),
+                    "eval_results": step.get("eval_results", {})
+                }
+            elif "Analysis" in step:  # Final summary
+                step_data = {
+                    "step_number": i,
+                    "decision_type": "summarize",
+                    "thought": step.get("Thought", ""),
+                    "analysis": step.get("Analysis", ""),
+                    "summary": step.get("Summary", "")
+                }
+            else:
+                continue
+                
+            trajectory_steps.append(step_data)
+        
+        return trajectory_steps
+    
+    def collect_from_directory(self, directory: str) -> List[Dict]:
+        """Collect all trajectories from a directory"""
+        collected_data = []
+        
+        # Find all result JSON files
+        json_files = glob.glob(os.path.join(directory, "**/*.json"), recursive=True)
+        
+        for json_file in json_files:
+            try:
+                with open(json_file, 'r') as f:
+                    data = json.load(f)
+                
+                # Extract user query (usually first element)
+                user_query = data[0] if isinstance(data[0], str) else ""
+                
+                # Extract trajectory
+                trajectory = self.extract_trajectory_data(data)
+                
+                if trajectory:
+                    collected_data.append({
+                        "source_file": json_file,
+                        "user_query": user_query,
+                        "trajectory": trajectory,
+                        "total_steps": len(trajectory),
+                        "timestamp": os.path.getmtime(json_file)
+                    })
+            except Exception as e:
+                print(f"Error processing {json_file}: {e}")
+        
+        return collected_data
+    
+    def collect_all(self) -> None:
+        """Collect trajectories from all base directories"""
+        for base_dir in self.base_dirs:
+            if os.path.exists(base_dir):
+                print(f"Collecting from {base_dir}...")
+                data = self.collect_from_directory(base_dir)
+                self.trajectories.extend(data)
+                print(f"  Found {len(data)} trajectories")
+    
+    def save_dataset(self, output_file: str) -> None:
+        """Save collected trajectories to file"""
+        with open(output_file, 'w') as f:
+            json.dump({
+                "collection_date": datetime.now().isoformat(),
+                "total_trajectories": len(self.trajectories),
+                "trajectories": self.trajectories
+            }, f, indent=2)
+        print(f"Saved {len(self.trajectories)} trajectories to {output_file}")
+
+
+# Usage example
+if __name__ == "__main__":
+    collector = TrajectoryCollector([
+        "./eval_t2i_comp_results/",
+        "./eval_vbench_results/",
+        "./open_domain_results/"
+    ])
+    
+    collector.collect_all()
+    collector.save_dataset("collected_trajectories.json")

data_pre/cot_gen/example.jsonl

@@ -0,0 +1,15 @@
+
+{
+    "round_id": 0,
+    "plan_agent_input": "...", 
+    "plan_agent_output": [{
+      "thought": "...",
+      "aspect": "Subject‑consistency"
+    }],
+    "promptgen_input": "...",
+    "promptgen_output": {
+      "thought": "...",
+      "prompt": "Generate a 3‑sec video of ..."
+    },
+    "eval_results": {...}
+  }

data_pre/cot_gen/generate_training_data.py

@@ -0,0 +1,193 @@
+import json
+import random
+from typing import List, Dict, Any
+from base_agent import BaseAgent
+
+class TrainingDataGenerator:
+    """Generate diverse training data for plan agent"""
+    
+    def __init__(self):
+        self.query_templates = self.load_query_templates()
+        self.tools_t2i = ["Color Binding", "Shape Binding", "Texture Binding", "Non Spatial"]
+        self.tools_vbench = [
+            "Subject Consistency", "Background Consistency", "Motion Smoothness",
+            "Aesthetic Quality", "Imaging Quality", "Object Class", "Human Action",
+            "Color", "Spatial Relationship", "Scene"
+        ]
+    
+    def load_query_templates(self) -> Dict[str, List[str]]:
+        """Load diverse query templates"""
+        return {
+            "capability_check": [
+                "Can the model generate {object} with {attribute}?",
+                "How well does the model handle {scenario}?",
+                "Is the model capable of creating {complex_scene}?"
+            ],
+            "comparison": [
+                "How does the model perform on {task1} vs {task2}?",
+                "What are the differences in generating {object1} compared to {object2}?"
+            ],
+            "boundary_finding": [
+                "What are the limits of the model's ability to {capability}?",
+                "How complex can {scenario} be before the model fails?",
+                "What is the maximum number of {elements} the model can handle?"
+            ],
+            "quality_assessment": [
+                "How consistent is the model in generating {aspect}?",
+                "What is the quality of {feature} in the generated outputs?",
+                "How accurate is the model's {binding_type} binding?"
+            ]
+        }
+    
+    def generate_diverse_queries(self, n: int = 100) -> List[str]:
+        """Generate diverse evaluation queries"""
+        queries = []
+        
+        # Define substitution values
+        substitutions = {
+            "object": ["cats", "cars", "buildings", "people", "landscapes"],
+            "attribute": ["specific colors", "complex textures", "unusual shapes"],
+            "scenario": ["multi-object scenes", "dynamic actions", "abstract concepts"],
+            "complex_scene": ["crowded marketplaces", "underwater scenes", "futuristic cities"],
+            "task1": ["realistic portraits", "abstract art"],
+            "task2": ["photorealistic landscapes", "cartoon characters"],
+            "capability": ["generate multiple objects", "maintain consistency", "follow complex prompts"],
+            "elements": ["objects", "people", "colors", "textures"],
+            "aspect": ["human faces", "animal poses", "architectural details"],
+            "feature": ["motion", "lighting", "composition"],
+            "binding_type": ["color", "shape", "texture", "spatial"]
+        }
+        
+        for _ in range(n):
+            template_type = random.choice(list(self.query_templates.keys()))
+            template = random.choice(self.query_templates[template_type])
+            
+            # Fill in the template
+            query = template
+            for key, values in substitutions.items():
+                if f"{{{key}}}" in query:
+                    query = query.replace(f"{{{key}}}", random.choice(values))
+            
+            queries.append({
+                "query": query,
+                "type": template_type
+            })
+        
+        return queries
+    
+    def generate_exploration_sequence(self, query: str, query_type: str) -> List[Dict]:
+        """Generate a plausible exploration sequence for a query"""
+        sequence = []
+        
+        # Determine exploration strategy based on query type
+        if query_type == "capability_check":
+            # Start simple, increase complexity
+            complexities = ["simple", "moderate", "complex", "very complex"]
+            for i, complexity in enumerate(complexities):
+                sequence.append({
+                    "step": i + 1,
+                    "sub_aspect": f"Testing with {complexity} scenarios",
+                    "tool": random.choice(self.tools_t2i + self.tools_vbench),
+                    "strategy": "depth-first"
+                })
+        
+        elif query_type == "comparison":
+            # Test both aspects separately, then together
+            aspects = ["first aspect", "second aspect", "combined comparison"]
+            for i, aspect in enumerate(aspects):
+                sequence.append({
+                    "step": i + 1,
+                    "sub_aspect": f"Evaluating {aspect}",
+                    "tool": random.choice(self.tools_t2i + self.tools_vbench),
+                    "strategy": "breadth-first"
+                })
+        
+        elif query_type == "boundary_finding":
+            # Progressive stress testing
+            stress_levels = [10, 50, 90, 99]  # percentile of difficulty
+            for i, level in enumerate(stress_levels):
+                sequence.append({
+                    "step": i + 1,
+                    "sub_aspect": f"Testing at {level}th percentile difficulty",
+                    "tool": random.choice(self.tools_t2i + self.tools_vbench),
+                    "strategy": "depth-first"
+                })
+        
+        else:  # quality_assessment
+            # Multiple aspects of quality
+            quality_aspects = ["consistency", "accuracy", "diversity", "edge cases"]
+            for i, aspect in enumerate(quality_aspects):
+                sequence.append({
+                    "step": i + 1,
+                    "sub_aspect": f"Assessing {aspect}",
+                    "tool": random.choice(self.tools_t2i + self.tools_vbench),
+                    "strategy": "breadth-first"
+                })
+        
+        return sequence
+    
+    def create_training_example(self, query_data: Dict) -> Dict:
+        """Create a complete training example"""
+        query = query_data["query"]
+        query_type = query_data["type"]
+        
+        # Generate exploration sequence
+        exploration = self.generate_exploration_sequence(query, query_type)
+        
+        # Create training example
+        example = {
+            "user_query": query,
+            "query_type": query_type,
+            "exploration_plan": {
+                "strategy": "depth-first" if "boundary" in query_type else "breadth-first",
+                "expected_steps": len(exploration),
+                "focus_areas": [step["sub_aspect"] for step in exploration]
+            },
+            "exploration_sequence": exploration,
+            "decision_points": []
+        }
+        
+        # Add decision points
+        for i, step in enumerate(exploration):
+            decision = {
+                "step": i + 1,
+                "context": {
+                    "previous_steps": exploration[:i],
+                    "current_observations": f"Simulated results from step {i}"
+                },
+                "decision": "explore" if i < len(exploration) - 1 else "summarize",
+                "reasoning": f"Need to explore {step['sub_aspect']} to fully answer the query"
+            }
+            example["decision_points"].append(decision)
+        
+        return example
+    
+    def generate_dataset(self, n_examples: int = 1000) -> List[Dict]:
+        """Generate complete training dataset"""
+        queries = self.generate_diverse_queries(n_examples)
+        dataset = []
+        
+        for query_data in queries:
+            example = self.create_training_example(query_data)
+            dataset.append(example)
+        
+        return dataset
+
+
+# Usage
+if __name__ == "__main__":
+    generator = TrainingDataGenerator()
+    
+    # Generate training data
+    print("Generating training dataset...")
+    dataset = generator.generate_dataset(1000)
+    
+    # Save dataset
+    with open("plan_agent_training_data.json", "w") as f:
+        json.dump({
+            "version": "1.0",
+            "total_examples": len(dataset),
+            "examples": dataset
+        }, f, indent=2)
+    
+    print(f"Generated {len(dataset)} training examples")

data_pre/cot_gen/main.py

@@ -0,0 +1,478 @@
+import asyncio
+import json
+import os
+import argparse
+from typing import Dict, List, Optional
+from tqdm import tqdm
+from autogen_agentchat.agents import AssistantAgent
+from autogen_agentchat.messages import TextMessage
+from autogen_agentchat.ui import Console
+from autogen_core import CancellationToken
+from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
+from autogen_core.models import ModelFamily
+from prompts import thought_prompt, sys_prompt, identity_prompt
+from tools import *
+from utils import extract_json, identity_mapping_dict, setup_logging_and_config, process_qa, rag_url_dict
+from datetime import datetime
+
+# max steps for the agent to generate the answer
+MAX_STEPS = 20
+
+
+class AgentResponse:
+    """Class to represent agent response structure."""
+    def __init__(self, thoughts: str, response: str):
+        self.thoughts = thoughts
+        self.response = response
+
+
+def parse_arguments() -> argparse.Namespace:
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Run EgoLife QA agent with chain-of-thought reasoning"
+    )
+    
+    # Model configuration
+    parser.add_argument(
+        "--model", 
+        type=str, 
+        default="gpt-4.1",
+        help="Model to use for the agent"
+    )
+    parser.add_argument(
+        "--api_version", 
+        type=str, 
+        default="2024-09-01-preview",
+        help="API version for the model"
+    )
+    
+    # Data configuration
+    parser.add_argument(
+        "--data_path", 
+        type=str, 
+        default="./egor1-bench/QA-egolife/",
+        help="Path to the data directory"
+    )
+    parser.add_argument(
+        "--identity", 
+        type=str, 
+        default="A1",
+        help="Identity to use for the agent"
+    )
+    
+    # Output configuration
+    parser.add_argument(
+        "--result_dir", 
+        type=str, 
+        default="./results",
+        help="Directory to save results"
+    )
+    parser.add_argument(
+        "--log_dir", 
+        type=str, 
+        default="./logs",
+        help="Directory to save logs"
+    )
+    parser.add_argument(
+        "--cache_dir", 
+        type=str, 
+        default="./cache",
+        help="Directory for caching"
+    )
+    
+    # Processing options
+    parser.add_argument(
+        "--explicit_answer", 
+        action="store_true",
+        help="Use explicit answer termination"
+    )
+    parser.add_argument(
+        "--observation_type", 
+        type=str, 
+        default="all_actions", 
+        choices=["single", "all", "all_actions", "null"],
+        help="Type of observation to include in prompts"
+    )
+    
+    # Resume and specific data options
+    parser.add_argument(
+        "--resume", 
+        action="store_true",
+        help="Resume processing from error files"
+    )
+    parser.add_argument(
+        "--gen_specific_data", 
+        action="store_true",
+        help="Process only specific data IDs"
+    )
+    parser.add_argument(
+        "--specific_data_path", 
+        type=str, 
+        default="./data_statistics/error_list_results_aobs_gpt-41_A1.txt",
+        help="Path to specific data list file (.txt or .json)"
+    )
+    
+    return parser.parse_args()
+
+
+def load_json_data(file_path: str) -> List[Dict]:
+    """Load JSON data from file with error handling."""
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError, UnicodeDecodeError) as e:
+        raise ValueError(f"Failed to load {file_path}: {e}")
+
+
+def load_specific_data_ids(file_path: str) -> List[int]:
+    """Load specific data IDs from a text or JSON file."""
+    if file_path.endswith(".txt"):
+        with open(file_path, "r", encoding="utf-8") as f:
+            data_str = f.readlines()[0].strip()
+            # Handle both comma-separated and bracket-enclosed formats
+            data_str = data_str.strip("[]")
+            return [int(x.strip()) for x in data_str.split(",") if x.strip()]
+    
+    elif file_path.endswith(".json"):
+        error_data = load_json_data(file_path)
+        return [int(item["ID"]) for item in error_data]
+    
+    else:
+        raise ValueError(f"Unsupported file format: {file_path}")
+
+
+def load_resume_data_ids(identity: str) -> List[int]:
+    """Load data IDs that need to be resumed from error files."""
+    error_ids = []
+    
+    # Load NA errors
+    na_error_path = f"data_gen/errors/error_list_na_{identity}.json"
+    if os.path.exists(na_error_path):
+        try:
+            na_errors = load_json_data(na_error_path)
+            error_ids.extend([int(d["ID"]) for d in na_errors])
+        except Exception as e:
+            print(f"Warning: Could not load NA errors from {na_error_path}: {e}")
+    
+    # Load no-answer errors (incomplete processing)
+    no_answer_path = f"data_gen/errors/error_list_no_answer_{identity}.json"
+    if os.path.exists(no_answer_path):
+        try:
+            no_answer_errors = load_json_data(no_answer_path)
+            error_ids.extend([
+                int(error_d["ID"]) 
+                for error_d in no_answer_errors 
+                if len(error_d.get("cot", [])) < MAX_STEPS
+            ])
+        except Exception as e:
+            print(f"Warning: Could not load no-answer errors from {no_answer_path}: {e}")
+    
+    return list(set(error_ids))  # Remove duplicates
+
+
+def filter_data_by_ids(data: List[Dict], target_ids: List[int]) -> List[Dict]:
+    """Filter data to only include items with IDs in target_ids."""
+    return [item for item in data if item["ID"] in target_ids]
+
+
+def setup_model_client(args: argparse.Namespace) -> AzureOpenAIChatCompletionClient:
+    """Set up the model client based on arguments."""
+    endpoint, deployment, subscription_key = setup_logging_and_config(args.model)
+    
+    if args.model == "gpt-4.1":
+        return AzureOpenAIChatCompletionClient(
+            azure_deployment=deployment,
+            azure_endpoint=endpoint,
+            model="gpt-41",
+            api_version="2025-01-01-preview",
+            api_key=subscription_key,
+            model_info={
+                "family": ModelFamily.GPT_41,
+                "function_calling": True,
+                "json_output": True,
+                "structured_output": True,
+                "vision": False,
+            }
+        )
+    else:
+        return AzureOpenAIChatCompletionClient(
+            azure_deployment=deployment,
+            azure_endpoint=endpoint,
+            model=args.model,
+            api_version=args.api_version,
+            api_key=subscription_key,
+        )
+
+
+def get_tools(args: argparse.Namespace) -> List:
+    """Get the appropriate tools based on arguments."""
+    if args.explicit_answer:
+        return [rag, video_llm, vlm, terminate_explicit]
+    else:
+        return [rag, video_llm, vlm, terminate]
+
+
+def get_system_prompt(args: argparse.Namespace) -> str:
+    """Get the appropriate system prompt based on version."""
+    return sys_prompt + f"\n{identity_prompt.format(identity=f'{args.identity}_{identity_mapping_dict[args.identity]}')}"
+
+
+def create_resume_prompt(dp: Dict, base_prompt: List[TextMessage]) -> List[TextMessage]:
+    """Create a prompt for resuming from previous CoT steps."""
+    prompt = base_prompt.copy()
+    
+    if dp.get("cot"):
+        prompt.append(TextMessage(
+            source="assistant", 
+            content=f'Previous observations: {dp["cot"]}'
+        ))
+        prompt.append(TextMessage(
+            source="user",
+            content=(
+                "Now you are given the previous actions and observations you have made before, "
+                "continue to try your best to answer the question using different tools. "
+                f"You must provide an answer to the question before step {MAX_STEPS}."
+            )
+        ))
+    
+    return prompt
+
+
+def update_prompt_with_observation(
+    prompt: List[TextMessage], 
+    observation: Dict, 
+    observation_type: str
+) -> List[TextMessage]:
+    """Update prompt with new observation based on observation type."""
+    if observation_type == "single":
+        # Replace with single latest observation
+        return [
+            prompt[0], 
+            TextMessage(source="assistant", content=f'Previous observations: {observation}')
+        ]
+    elif observation_type == "all":
+        # Append all previous observations
+        prompt.append(TextMessage(
+            source="assistant", 
+            content=f'Previous observations (step-{observation["step"]}): {observation}'
+        ))
+    elif observation_type == "all_actions":
+        # Append all previous actions
+        prompt.append(TextMessage(
+            source="assistant", 
+            content=f'Previous actions (step-{observation["step"]}): {observation["tool"]}'
+        ))
+    elif observation_type == "null":
+        # Don't append any observation
+        pass
+    
+    return prompt
+
+
+async def process_single_qa(
+    qa: Dict, 
+    agent: AssistantAgent, 
+    args: argparse.Namespace,
+    result_dir: str
+) -> Optional[Dict]:
+    """Process a single QA item with the agent."""
+    dp = process_qa(qa, args.explicit_answer)
+    dp_path = os.path.join(result_dir, f"{dp['ID']}.json")
+    
+    # Handle existing files
+    if os.path.exists(dp_path) and not args.resume:
+        print(f"Overwriting {dp['ID']}")
+    
+    if args.resume and os.path.exists(dp_path):
+        print(f"Resuming {dp['ID']}")
+        with open(dp_path, "r", encoding="utf-8") as f:
+            dp = json.load(f)
+    
+    # Create initial prompt
+    base_prompt = [TextMessage(
+        content=dp["question"] + "\n\n" + thought_prompt, 
+        source="user"
+    )]
+    
+    # Set up for resume if needed
+    if args.resume and dp.get("cot") and len(dp["cot"]) > 0:
+        step = len(dp["cot"]) - 1
+        print(f"Resuming from {dp['ID']} at step {step}")
+        dp["cot"] = dp["cot"][:-1]  # Remove last incomplete step
+        prompt = create_resume_prompt(dp, base_prompt)
+    else:
+        step = 0
+        prompt = base_prompt
+    
+    # Main processing loop
+    while step < MAX_STEPS:
+        print(f"Step: {step}")
+        try:
+            result = await Console(agent.run_stream(
+                task=prompt, 
+                cancellation_token=CancellationToken()
+            ))
+        except Exception as e:
+            print(f"Error at step {step}: {e}")
+            return {
+                "id": dp["ID"],
+                "prompt": [msg.content for msg in prompt],
+                "error": str(e),
+                "step": step
+            }
+        
+        step += 1
+        messages = result.messages
+        
+        # Extract information from messages
+        thought = None
+        tool_call = None
+        tool_summary = None
+        
+        for message in messages:
+            if message.type == "ThoughtEvent":
+                thought = message.content
+            elif message.type == "ToolCallRequestEvent":
+                tool_call = message.content[0]
+            elif message.type == "ToolCallSummaryMessage":
+                tool_summary = message.content
+        
+        # Handle termination
+        if tool_call and "terminate" in tool_call.name.lower():
+            observation = {
+                "step": step,
+                "thought": thought,
+                "answer": extract_json(tool_call.arguments)["answer"]
+            }
+            dp['cot'].append(observation)
+            break
+        
+        # Handle regular tool usage
+        else:
+            observation = {
+                "step": step,
+                "thought": thought,
+                "tool": {
+                    "id": tool_call.id if tool_call else None,
+                    "name": tool_call.name if tool_call else None,
+                    "arguments": tool_call.arguments if tool_call else None
+                },
+                "observation": tool_summary
+            }
+            
+            dp['cot'].append(observation)
+            prompt = update_prompt_with_observation(prompt, observation, args.observation_type)
+    
+    # Save results
+    with open(dp_path, "w", encoding="utf-8") as f:
+        json.dump(dp, f, indent=4)
+    
+    return None  # No error
+
+
+async def main() -> None:
+    """Main function to orchestrate the QA processing."""
+    args = parse_arguments()
+    
+    # Set up environment
+    os.environ["LOG_DIR"] = args.log_dir
+    if os.environ.get("IDENTITY") is None:
+        os.environ["IDENTITY"] = args.identity
+    if os.environ.get("RAG_URL") is None:
+        os.environ["RAG_URL"] = rag_url_dict[args.identity]
+        assert os.environ["RAG_URL"] is not None, "RAG_URL is not set"
+    cache_dir = os.environ.get("CACHE_DIR", args.cache_dir)
+    os.makedirs(args.result_dir, exist_ok=True)
+    os.makedirs(cache_dir, exist_ok=True)
+    os.makedirs(args.log_dir, exist_ok=True)
+    
+    # Load data based on mode
+    data_path = os.path.join(
+        args.data_path, 
+        f"EgoLifeQA_{args.identity}_{identity_mapping_dict[args.identity]}.json"
+    )
+    
+    print(f"Current identity: {args.identity}")
+    
+    try:
+        if args.gen_specific_data:
+            print("Loading specific data...")
+            # Use specific_data_path or fall back to specific_data_list for compatibility
+            specific_path = args.specific_data_path
+            if not os.path.exists(specific_path) and hasattr(args, 'specific_data_list'):
+                specific_path = args.specific_data_list
+            
+            if os.path.exists(specific_path):
+                target_ids = load_specific_data_ids(specific_path)
+            else:
+                # Fallback to default path format
+                default_path = f"./data_statistics/error_list_{args.identity}.txt"
+                target_ids = load_specific_data_ids(default_path)
+            
+            all_data = load_json_data(data_path)
+            egolife_qa_data = filter_data_by_ids(all_data, target_ids)
+            print(f"Loaded {len(egolife_qa_data)} specific items")
+            
+        elif args.resume:
+            print("Loading resume data...")
+            target_ids = load_resume_data_ids(args.identity)
+            all_data = load_json_data(data_path)
+            egolife_qa_data = filter_data_by_ids(all_data, target_ids)
+            print(f"Loaded {len(egolife_qa_data)} items for resume")
+            
+        else:
+            print(f"Loading all data from: {data_path}")
+            egolife_qa_data = load_json_data(data_path)
+            print(f"Loaded {len(egolife_qa_data)} items")
+            
+    except Exception as e:
+        print(f"Error loading data: {e}")
+        return
+    
+    if not egolife_qa_data:
+        print("No data to process.")
+        return
+    
+    # Set up model and agent components
+    model_client = setup_model_client(args)
+    tools = get_tools(args)
+    sys_prompt_text = get_system_prompt(args)
+    
+    # Process data
+    errors = []
+    
+    for qa in tqdm(egolife_qa_data, desc="Processing QA items"):
+        # Create fresh agent for each QA to avoid state issues
+        agent = AssistantAgent(
+            name="egolife_qa_agent",
+            model_client=model_client,
+            tools=tools,
+            system_message=sys_prompt_text,
+        )
+        
+        error = await process_single_qa(qa, agent, args, args.result_dir)
+        if error:
+            errors.append(error)
+    
+    # Save error list if any
+    if errors:
+        error_file = os.path.join(args.log_dir, f"error_list_{args.identity}.json")
+        with open(error_file, "w", encoding="utf-8") as f:
+            json.dump(errors, f, indent=4)
+        print(f"Saved {len(errors)} errors to {error_file}")
+    else:
+        print("No errors encountered!")
+    
+    # Cleanup
+    print("Processing complete!")
+    if cache_dir and os.path.exists(cache_dir):
+        try:
+            os.rmdir(cache_dir)
+        except OSError:
+            pass  # Directory not empty or doesn't exist
+    
+    await model_client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

data_pre/cot_gen/prompts.py

@@ -0,0 +1,35 @@
+# used for vanilla A-B-C-D task
+
+# consider the cost of each tool, and the video obsercation length is 10-min max
+sys_prompt = """
+[BEGIN OF GOAL]
+You are an expert AI assistant specializing in analyzing human behavior and reasoning from egocentric video descriptions. You will be provided with a list of useful tools to help in reasoning the task, and your goal is to solve the user’s question. The user’s question is following the format: Question: <question> <timestamp> Options: <options>. You can either rely on your own capabilities or perform actions with external tools to help you. You should consider both the frequency and cost of each tool to make the best decision.
+[END OF GOAL]
+
+[BEGIN OF FORMAT INSTRUCTIONS]
+When answering questions:
+1. You will be provided with previous actions you have taken, based on these actions, think step-by-step about how to approach the problem.
+2. Show your reasoning process clearly before providing your next action.
+3. The video observation length is 10-min max.
+4. For visual questions, use video_llm and vlm to explore the visual context.
+5. For temporal questions, use RAG to explore the context before and after the event.
+6. Only use the terminate tool after you have thoroughly explored the question with multiple tools.
+[END OF FORMAT INSTRUCTIONS]
+
+[BEGIN OF HINTS]
+1. All tools provided are crucial to the solvement of the question. You MUST exploit the usage of all tools before answering the question.
+2. You may want to use the same tool multiple times with different arguments to explore the problem from different angles, if needed.
+3. Make a balance between the cost and the frequency of the tools.
+4. Usually, solving a question requires over 5~10 steps of reasoning, and follows a hierarchical calling structure: rag => video_llm => vlm.
+5. Do not use the terminate tool too early. Instead, try to explore the question with the available tools, and only use the terminate tool when you are confident enough or have considered all the options.
+[END OF HINTS]
+
+Always structure your responses with your thought process first, followed by any tool calls.
+
+"""
+
+
+
+thought_prompt = "Think before you act. Think step-by-step about what information you need and which tool to use, then execute your plan exactly as reasoned without deviation. Output your thought process before using the tool, and you must strictly follow your thought process for the tool call."
+
+identity_prompt = "Currently, you are under the view of: {identity}"

data_pre/postprocess.py

@@ -0,0 +1,293 @@
+import os
+import sys
+import json
+import glob
+import argparse
+from datasets import load_dataset, concatenate_datasets
+import pandas as pd
+import shutil
+import chardet
+import ast
+import transformers
+
+# Add parent directory to Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from eval_agent.system_prompts import sys_prompts
+
+
+vbench_dimention_df = pd.read_csv("eval_agent/vbench_dimension_scores.tsv", sep="\t")
+t2i_dimention_df = pd.read_csv("eval_agent/t2i_dimension_scores.tsv", sep="\t")
+
+# Templates for different components
+alpaca_template = {
+    "instruction": "{instruction}",
+    "input": "{input}",
+    "output": "{output}",
+    "system": "{system}"
+}
+
+
+thinking_template = "<think>{thinking}</think>"
+tool_template = "<tool>{tool}</tool>"
+
+observation_template = "<information>{information}</information>"
+
+analysis_template = "<analysis>{analysis}</analysis>"
+summary_template = "<summary>{summary}</summary>"
+
+# Global counter for tracking data
+global_counter = 0
+length_counter = 0
+
+def format_subaspect(sub_aspect):
+    """Format sub-aspect for output."""
+    import random
+    template_list = [
+        "I will evaluate the model's sub-aspect: {sub_aspect}.",
+        "I will focus on the {sub_aspect} sub-aspect of the model.",
+        "Let me assess the {sub_aspect} sub-aspect of this model.",
+        "I need to examine the model's {sub_aspect} sub-aspect.",
+        "Now I will analyze the {sub_aspect} sub-aspect dimension.",
+        "I'll investigate the {sub_aspect} sub-aspect quality of the model.",
+        "Time to evaluate the {sub_aspect} sub-aspect performance.",
+        "I should check the model's {sub_aspect} sub-aspect capabilities."
+    ]
+    selected_template = random.choice(template_list)
+    return selected_template.format(sub_aspect=sub_aspect)
+
+def format_summary(analysis, summary):
+    """Format summary for output."""
+    return f"Analysis: {analysis}\nSummary: {summary}"
+    
+def load_data(file_path):
+    """Load JSON data from a file."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+    
+def format_template(template, **kwargs):
+    """Format a template with provided values."""
+    if isinstance(template, dict):
+        result = {}
+        for key, value in template.items():
+            if isinstance(value, str):
+                result[key] = value.format(**kwargs)
+            else:
+                result[key] = value
+        return result
+    return template.format(**kwargs)
+
+def extract_obs(tool_name, obs):
+    """Extract observation information for a tool."""
+    return f"Observation: {obs}"
+
+def check_data(data):
+    """Check if data is valid."""
+    if len(data["cot"]) > 8:
+        return False
+    if data["cot"][-1]["answer"] != data["ground_truth"]:
+        return False
+    return True
+
+
+# def format_eval_results(eval_results: dict) -> list:
+#     """Format eval results for output."""
+#     score = eval_results['score'][0]
+#     video_results_list = eval_results['score'][1] # list of dict
+    
+#     # remove the video path
+#     for video_result in video_results_list:
+#         video_result.pop('video_path')
+
+#     return score, video_results_list
+
+
+# format the reference table
+def format_dimension_as_string(df, dimension_name):
+    row = df.loc[df['Dimension'] == dimension_name]
+    if row.empty:
+        return f"No data found for dimension: {dimension_name}"
+    
+    formatted_string = (
+        f"{row['Dimension'].values[0]}: "
+        f"Very High -> {row['Very High'].values[0]}, "
+        f"High -> {row['High'].values[0]}, "
+        f"Moderate -> {row['Moderate'].values[0]}, "
+        f"Low -> {row['Low'].values[0]}, "
+        f"Very Low -> {row['Very Low'].values[0]}"
+    )
+    
+    return formatted_string
+
+def format_eval_results(results, reference_table):
+    tool_name = results["Tool"]
+    average_score = results["eval_results"]["score"][0]
+    video_results = results["eval_results"]["score"][1]
+    
+
+    # More concise and structured format for SFT
+    output = f"Scoring Reference Table of '{tool_name}': {reference_table}\n\n"
+    output += f"Results:\n"
+    output += f"- Overall score: {average_score:.4f}\n"
+    output += f"- Per-prompt scores:\n"
+
+    for video in video_results:
+        prompt = video["prompt"]
+        score = video["video_results"]
+        output += f"  • \"{prompt}\": {score:.4f}\n"
+    
+    return output
+
+# Main function to convert the data to the Alpaca format
+def convert_to_alpaca(json_path, output_dir, return_data=False):
+    """Convert data to Alpaca format for training."""
+    global global_counter
+    data_list = []
+    # Process each file
+    with open(json_path, "r", encoding="utf-8") as in_f:
+        data = json.load(in_f)
+        
+        # remove the last element
+        data.pop()
+        
+        # data["ID"] = global_counter
+        ops = []
+        obs = []
+        
+
+        
+        # Generate the history
+        for i in range(1, len(data)):
+            # Prepare the output
+            try:
+                if i == len(data) - 1:  # last step
+                    op = f"{thinking_template.format(thinking=data[i]['Thought'])}{summary_template.format(summary=format_summary(data[i]['Analysis'], data[i]['Summary']))}"
+                else:
+                    op = f"{thinking_template.format(thinking=data[i]['Thought'] + ' ' + format_subaspect(data[i]['Sub-aspect']))}{tool_template.format(tool=data[i]['Tool'])}"
+                    
+                    # only n-1 steps have observation
+                    # obs.append(observation_template.format(information=extract_obs(data["cot"][i]["tool"]["name"], data["cot"][i]["observation"])))
+                    # score, video_results_list = format_eval_results(data[i]['eval_results'])
+                    # obs.append(observation_template.format(info0=score, info1=video_results_list)) # Current observation is the eval_results
+                    reference_table = format_dimension_as_string(vbench_dimention_df, data[i]['Tool'])
+                    obs.append(observation_template.format(information=format_eval_results(data[i], reference_table)))
+                    
+                    
+            except Exception as e:
+                print(f"Error in processing data {json_path} at step {i}: {e}")
+                continue
+            
+            ops.append(op)
+            
+            
+            # Build history for this step
+            history = []
+            for j in range(1, i):  # Start from 1 since we process from step 1
+                if j == 1:
+                    traj = [
+                        data[0],
+                        ops[j-1]  # ops is 0-indexed but we start processing from step 1
+                    ]
+                else:
+                    traj = [
+                        obs[j-2],  # obs is built as we go
+                        ops[j-1]
+                    ]
+                
+                history.append(traj)
+            
+            
+            
+            
+            # Convert the data to the Alpaca format at the n-th step
+            if i == 1:  # First step after initial instruction
+                data_n = format_template(alpaca_template, **{
+                    "instruction": data[0],
+                    "input": "",
+                    "output": op,
+                    "system": sys_prompts["eval-agent-vbench-training-sys_v1"] + sys_prompts["eval-agent-format-sys"]
+                })
+            else:
+                data_n = format_template(alpaca_template, **{
+                    "instruction": obs[i-2],  # Previous observation
+                    "input": "",
+                    "output": op,
+                    "system": sys_prompts["eval-agent-vbench-training-sys_v1"] + sys_prompts["eval-agent-format-sys"]
+                })
+            
+            data_n["history"] = history
+            
+            
+            
+            # #  filter the tokens > 8096
+            # tokenizer = transformers.AutoTokenizer.from_pretrained('Ego-R1/qwen-sft-epoch3-len16192-20250511-3b-inst')
+            # tokens = tokenizer(f"{data_n['instruction']} {data_n['output']} {data_n['system']} {str(data_n['history'])}")
+            # if len(tokens['input_ids']) > 8096:
+            #     print(f"Skipping data with tokens > 8096: {data['ID']}")
+            #     continue
+            
+            data_list.append(data_n)
+            global_counter += 1
+                
+    if return_data:
+        return data_list
+    
+    print(f"Size of the sft dataset: {len(data_list)}")
+    
+    # Create output directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Save the processed data
+    with open(os.path.join(output_dir, "processed_data.json"), "w", encoding="utf-8") as out_f:
+        json.dump(data_list, out_f, ensure_ascii=False, indent=4)
+
+    
+    
+def arg_parse():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Process EgoLife data for training")
+    parser.add_argument("--home_dir", type=str, default="/home/data2/sltian/code/evaluation_agent_dev")
+    parser.add_argument("--data_dir", type=str, default="ea-data") # for test set, the data_dir should be "/home/data2/sltian/code/Ego-R1_dev/egor1-bench/QA-egolife/benchmark/benchmark_shuffle_new"
+    parser.add_argument("--output_dir", type=str, default=None)
+    parser.add_argument("--format", type=str, choices=["alpaca", "glaive"], default="alpaca")
+    return parser.parse_args()
+
+def main():
+    """Main function to process data."""
+    args = arg_parse()
+
+    if args.output_dir is None:
+        import datetime
+        args.output_dir = os.path.join("data", f"postprocess_{datetime.datetime.now().strftime('%Y%m%d')}")
+
+    # Get all JSON files from the preprocess directory
+    preprocess_dir = "/home/data2/sltian/code/evaluation_agent_dev/data/preprocess"
+    json_files = glob.glob(os.path.join(preprocess_dir, "*.json"))
+    
+    # Filter out mapping files and only keep chat history files
+    chat_files = [f for f in json_files if not f.endswith("mapping.txt") and not f.endswith("summary_by_model.txt") and f.endswith(".json")]
+    
+    print(f"Found {len(chat_files)} chat history files to process")
+    
+    # Create a combined dataset from all files
+    all_data = []
+    for i, json_path in enumerate(chat_files):
+        print(f"Processing file {i+1}/{len(chat_files)}: {os.path.basename(json_path)}")
+        try:
+            file_data = convert_to_alpaca(json_path, args.output_dir, return_data=True)
+            all_data.extend(file_data)
+        except Exception as e:
+            print(f"Error processing {json_path}: {e}")
+            continue
+    
+    print(f"\nTotal training examples created: {len(all_data)}")
+    
+    # Save the combined dataset
+    os.makedirs(args.output_dir, exist_ok=True)
+    output_path = os.path.join(args.output_dir, "evaluation_agent_cot_dataset.json")
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(all_data, f, ensure_ascii=False, indent=2)
+    
+    print(f"Combined dataset saved to: {output_path}")
+
+if __name__ == "__main__":
+    main()

data_pre/postprocess_t2i.py

@@ -0,0 +1,295 @@
+import os
+import sys
+import json
+import glob
+import argparse
+from datasets import load_dataset, concatenate_datasets
+import pandas as pd
+import shutil
+import chardet
+import ast
+import transformers
+
+# Add parent directory to Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+# Add current directory to Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from eval_agent.system_prompts import sys_prompts
+
+
+# vbench_dimention_df = pd.read_csv("eval_agent/vbench_dimension_scores.tsv", sep="\t")
+t2i_dimention_df = pd.read_csv("eval_agent/t2i_comp_dimension_scores.tsv", sep="\t")
+
+# Templates for different components
+alpaca_template = {
+    "instruction": "{instruction}",
+    "input": "{input}",
+    "output": "{output}",
+    "system": "{system}"
+}
+
+
+thinking_template = "<think>{thinking}</think>"
+tool_template = "<tool>{tool}</tool>"
+
+observation_template = "<information>{information}</information>"
+
+analysis_template = "<analysis>{analysis}</analysis>"
+summary_template = "<summary>{summary}</summary>"
+
+# Global counter for tracking data
+global_counter = 0
+length_counter = 0
+
+def format_subaspect(sub_aspect):
+    """Format sub-aspect for output."""
+    import random
+    template_list = [
+        "I will evaluate the model's sub-aspect: {sub_aspect}.",
+        "I will focus on the {sub_aspect} sub-aspect of the model.",
+        "Let me assess the {sub_aspect} sub-aspect of this model.",
+        "I need to examine the model's {sub_aspect} sub-aspect.",
+        "Now I will analyze the {sub_aspect} sub-aspect dimension.",
+        "I'll investigate the {sub_aspect} sub-aspect quality of the model.",
+        "Time to evaluate the {sub_aspect} sub-aspect performance.",
+        "I should check the model's {sub_aspect} sub-aspect capabilities."
+    ]
+    selected_template = random.choice(template_list)
+    return selected_template.format(sub_aspect=sub_aspect)
+
+def format_summary(analysis, summary):
+    """Format summary for output."""
+    return f"Analysis: {analysis}\nSummary: {summary}"
+    
+def load_data(file_path):
+    """Load JSON data from a file."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+    
+def format_template(template, **kwargs):
+    """Format a template with provided values."""
+    if isinstance(template, dict):
+        result = {}
+        for key, value in template.items():
+            if isinstance(value, str):
+                result[key] = value.format(**kwargs)
+            else:
+                result[key] = value
+        return result
+    return template.format(**kwargs)
+
+def extract_obs(tool_name, obs):
+    """Extract observation information for a tool."""
+    return f"Observation: {obs}"
+
+def check_data(data):
+    """Check if data is valid."""
+    if len(data["cot"]) > 8:
+        return False
+    if data["cot"][-1]["answer"] != data["ground_truth"]:
+        return False
+    return True
+
+
+# def format_eval_results(eval_results: dict) -> list:
+#     """Format eval results for output."""
+#     score = eval_results['score'][0]
+#     video_results_list = eval_results['score'][1] # list of dict
+    
+#     # remove the video path
+#     for video_result in video_results_list:
+#         video_result.pop('video_path')
+
+#     return score, video_results_list
+
+
+# format the reference table
+def format_dimension_as_string(df, dimension_name):
+    row = df.loc[df['Dimension'] == dimension_name]
+    if row.empty:
+        return f"No data found for dimension: {dimension_name}"
+    
+    formatted_string = (
+        f"{row['Dimension'].values[0]}: "
+        f"Very High -> {row['Very High'].values[0]}, "
+        f"High -> {row['High'].values[0]}, "
+        f"Moderate -> {row['Moderate'].values[0]}, "
+        f"Low -> {row['Low'].values[0]}, "
+        f"Very Low -> {row['Very Low'].values[0]}"
+    )
+    
+    return formatted_string
+
+def format_eval_results(results, reference_table):
+    tool_name = results["Tool"]
+    average_score = results["eval_results"]["score"][0]
+    video_results = results["eval_results"]["score"][1]
+    
+
+    # More concise and structured format for SFT
+    output = f"Scoring Reference Table of '{tool_name}': {reference_table}\n\n"
+    output += f"Results:\n"
+    output += f"- Overall score: {average_score:.4f}\n"
+    output += f"- Per-prompt scores:\n"
+
+    for video in video_results:
+        prompt = video["prompt"]
+        score = video["image_results"]
+        output += f"  • \"{prompt}\": {score:.4f}\n"
+    
+    return output
+
+# Main function to convert the data to the Alpaca format
+def convert_to_alpaca(json_path, output_dir, return_data=False):
+    """Convert data to Alpaca format for training."""
+    global global_counter
+    data_list = []
+    # Process each file
+    with open(json_path, "r", encoding="utf-8") as in_f:
+        data = json.load(in_f)
+        
+        # remove the last element
+        data.pop()
+        
+        # data["ID"] = global_counter
+        ops = []
+        obs = []
+        
+
+        
+        # Generate the history
+        for i in range(1, len(data)):
+            # Prepare the output
+            try:
+                if i == len(data) - 1:  # last step
+                    op = f"{thinking_template.format(thinking=data[i]['Thought'])}{summary_template.format(summary=format_summary(data[i]['Analysis'], data[i]['Summary']))}"
+                else:
+                    op = f"{thinking_template.format(thinking=data[i]['Thought'] + ' ' + format_subaspect(data[i]['Sub-aspect']))}{tool_template.format(tool=data[i]['Tool'])}"
+                    
+                    # only n-1 steps have observation
+                    # obs.append(observation_template.format(information=extract_obs(data["cot"][i]["tool"]["name"], data["cot"][i]["observation"])))
+                    # score, video_results_list = format_eval_results(data[i]['eval_results'])
+                    # obs.append(observation_template.format(info0=score, info1=video_results_list)) # Current observation is the eval_results
+                    reference_table = format_dimension_as_string(t2i_dimention_df, data[i]['Tool'])
+                    obs.append(observation_template.format(information=format_eval_results(data[i], reference_table)))
+                    
+                    
+            except Exception as e:
+                print(f"Error in processing data {json_path} at step {i}: {e}")
+                continue
+            
+            ops.append(op)
+            
+            
+            # Build history for this step
+            history = []
+            for j in range(1, i):  # Start from 1 since we process from step 1
+                if j == 1:
+                    traj = [
+                        data[0],
+                        ops[j-1]  # ops is 0-indexed but we start processing from step 1
+                    ]
+                else:
+                    traj = [
+                        obs[j-2],  # obs is built as we go
+                        ops[j-1]
+                    ]
+                
+                history.append(traj)
+            
+            
+            
+            
+            # Convert the data to the Alpaca format at the n-th step
+            if i == 1:  # First step after initial instruction
+                data_n = format_template(alpaca_template, **{
+                    "instruction": data[0],
+                    "input": "",
+                    "output": op,
+                    "system": sys_prompts["eval-agent-t2i-training-sys"] + sys_prompts["eval-agent-format-sys"]
+                })
+            else:
+                data_n = format_template(alpaca_template, **{
+                    "instruction": obs[i-2],  # Previous observation
+                    "input": "",
+                    "output": op,
+                    "system": sys_prompts["eval-agent-t2i-training-sys"] + sys_prompts["eval-agent-format-sys"]
+                })
+            
+            data_n["history"] = history
+            
+            
+            
+            # #  filter the tokens > 8096
+            # tokenizer = transformers.AutoTokenizer.from_pretrained('Ego-R1/qwen-sft-epoch3-len16192-20250511-3b-inst')
+            # tokens = tokenizer(f"{data_n['instruction']} {data_n['output']} {data_n['system']} {str(data_n['history'])}")
+            # if len(tokens['input_ids']) > 8096:
+            #     print(f"Skipping data with tokens > 8096: {data['ID']}")
+            #     continue
+            
+            data_list.append(data_n)
+            global_counter += 1
+                
+    if return_data:
+        return data_list
+    
+    print(f"Size of the sft dataset: {len(data_list)}")
+    
+    # Create output directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Save the processed data
+    with open(os.path.join(output_dir, "processed_data.json"), "w", encoding="utf-8") as out_f:
+        json.dump(data_list, out_f, ensure_ascii=False, indent=4)
+
+    
+    
+def arg_parse():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Process EgoLife data for training")
+    parser.add_argument("--home_dir", type=str, default="/home/data2/sltian/code/evaluation_agent_dev")
+    parser.add_argument("--data_dir", type=str, default="ea-data") # for test set, the data_dir should be "/home/data2/sltian/code/Ego-R1_dev/egor1-bench/QA-egolife/benchmark/benchmark_shuffle_new"
+    parser.add_argument("--output_dir", type=str, default=None)
+    parser.add_argument("--format", type=str, choices=["alpaca", "glaive"], default="alpaca")
+    return parser.parse_args()
+
+def main():
+    """Main function to process data."""
+    args = arg_parse()
+
+    if args.output_dir is None:
+        import datetime
+        args.output_dir = os.path.join("data", f"postprocess_{datetime.datetime.now().strftime('%Y%m%d')}")
+
+    # Get all JSON files from the preprocess directory
+    preprocess_dir = "/home/data2/sltian/code/evaluation_agent_dev/data/preprocess-t2i"
+    json_files = glob.glob(os.path.join(preprocess_dir, "*.json"))
+    
+    # Filter out mapping files and only keep chat history files
+    chat_files = [f for f in json_files if not f.endswith("mapping.txt") and not f.endswith("summary_by_model.txt") and f.endswith(".json")]
+    
+    print(f"Found {len(chat_files)} chat history files to process")
+    
+    # Create a combined dataset from all files
+    all_data = []
+    for i, json_path in enumerate(chat_files):
+        print(f"Processing file {i+1}/{len(chat_files)}: {os.path.basename(json_path)}")
+        try:
+            file_data = convert_to_alpaca(json_path, args.output_dir, return_data=True)
+            all_data.extend(file_data)
+        except Exception as e:
+            print(f"Error processing {json_path}: {e}")
+            continue
+    
+    print(f"\nTotal training examples created: {len(all_data)}")
+    
+    # Save the combined dataset
+    os.makedirs(args.output_dir, exist_ok=True)
+    output_path = os.path.join(args.output_dir, "evaluation_agent_cot_dataset_t2i.json")
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(all_data, f, ensure_ascii=False, indent=2)
+    
+    print(f"Combined dataset saved to: {output_path}")
+
+if __name__ == "__main__":
+    main()

data_pre/view_data.ipynb

@@ -0,0 +1,61 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "plaintext"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "  import json\n",
+    "\n",
+    "  # Load the JSON file\n",
+    "  file_path = 'your_file.json'\n",
+    "  with open(file_path, 'r') as f:\n",
+    "      data = json.load(f)\n",
+    "\n",
+    "  # The structure contains:\n",
+    "  # - data[0]: The evaluation question\n",
+    "  # - data[1-3]: Three evaluation rounds with different complexity levels\n",
+    "  # - data[4]: Final analysis and summary\n",
+    "  # - data[5]: Full chat history\n",
+    "\n",
+    "  # Extract evaluation results\n",
+    "  question = data[0]\n",
+    "  evaluations = []\n",
+    "\n",
+    "  for item in data[1:4]:  # The three evaluation rounds\n",
+    "      eval_info = {\n",
+    "          'sub_aspect': item['Sub-aspect'],\n",
+    "          'tool': item['Tool'],\n",
+    "          'thought': item['Thought'],\n",
+    "          'average_score': item['eval_results']['score'][0],\n",
+    "          'detailed_results': item['eval_results']['score'][1]\n",
+    "      }\n",
+    "      evaluations.append(eval_info)\n",
+    "\n",
+    "  # Extract individual video scores\n",
+    "  for eval_round in evaluations:\n",
+    "      print(f\"\\n{eval_round['sub_aspect']}:\")\n",
+    "      for video in eval_round['detailed_results']:\n",
+    "          print(f\"  {video['prompt']}: {video['video_results']:.4f}\")\n",
+    "\n",
+    "  # Get final analysis (if present)\n",
+    "  if isinstance(data[4], dict) and 'Analysis' in data[4]:\n",
+    "      final_analysis = data[4]['Analysis']\n",
+    "      summary = data[4]['Summary']"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

dataset/README.md

@@ -0,0 +1,4 @@
+# Open-Ended User Query Dataset
+
+We compiled the final open-ended user query dataset into the `dataset/open_ended_user_questions.json` file
+

dataset/open_ended_user_questions.json

@@ -0,0 +1,604 @@
+{
+  "questions": [
+    {
+      "question": "How well can the model visualize my ideas based on my words?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How aligned is the generated content with the provided description?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Does the model understand specific terms, objects, and intentions?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well does the model respond to ambiguous prompts? Does it handle missing or vague information effectively?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How closely does the generated output correspond to the prompts provided?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Does the generated result match the description?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model maintain style consistency across multiple generations from the same prompt?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well does the model distinguish between subtle variations in style (e.g., modern vs. postmodern art)?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "What style does the model tend to generate most often?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Does the model adapt to different stylistic instructions with accuracy and consistency?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How precisely can the user specify object relationships?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well can the model maintain object proportions and spatial relationships in complex scenes?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How effectively does the model handle changes in perspective?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Does the model demonstrate flexibility in generating different compositions from similar prompts?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How precisely can I control the generative model?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Does the model tend to simplify complex objects or details, or does it retain high levels of intricacy?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model adjust its output when given slight variations of the same prompt (e.g., changes in tone or context)?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well does the model handle varying levels of detail in its outputs?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Does the model generate similar outputs when there are only small changes in the prompts?",
+      "ability": "Prompt Following",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well does the model balance contrasting elements, such as light and dark or complex and simple?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "To what extent can the model produce photorealistic and aesthetically pleasing results?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model generate realistic images without common AI-generated artifacts?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can it generate physically plausible results?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How realistic is the generated content?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can it generate results that are as realistic as possible?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How real are the generated results?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model generate high-fidelity content?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model generate real-life scenes?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model maintain high image quality when generating large or detailed scenes?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Does the model tend to generate more photorealistic images or stylized, cartoonish ones?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model mimic camera effects such as zooming, panning, or focus pulls, especially when not explicitly described in the prompt?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well can the model balance aesthetic elements like space, flow, and symmetry in a room setting?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model be effectively applied in different scenarios, such as varying lighting conditions and environments?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well can the model handle lighting and movement?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How effectively can the model simulate real-world lighting effects for interior and exterior spaces?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model generate high-fidelity visualizations for natural phenomena like fluid dynamics or planetary orbits?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well does the model handle dynamic elements like action or motion?",
+      "ability": "Visual Quality",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well can the model generate realistic scenes for a sci-fi film?",
+      "ability": "Visual Quality",
+      "general_or_specific": "Specific",
+      "category": "Film and Entertainment"
+    },
+    {
+      "question": "How effectively can the model manage physical realism, such as lighting, shadows, and accurate human anatomy?",
+      "ability": "Visual Quality",
+      "general_or_specific": "Specific",
+      "category": "Medical"
+    },
+    {
+      "question": "Can the model generate detailed game environments such as forests, cities, or futuristic settings?",
+      "ability": "Visual Quality",
+      "general_or_specific": "Specific",
+      "category": "Game Design"
+    },
+    {
+      "question": "How well can the model interpret abstract or metaphorical concepts? Does it translate non-literal ideas into visual form effectively?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well can the model present concepts to explore creative possibilities?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model blend different genres or themes successfully?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well does the model balance realism with creativity? Can it generate imaginative scenes while maintaining visual plausibility?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well does the model capture the mood or atmosphere of a given prompt?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How effectively can the model represent non-visual concepts, such as emotions or abstract ideas?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How does the model handle the depiction of abstract concepts or metaphors in video form? For example, can it animate a 'storm of emotions' or 'time flowing like water'?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model handle contradictory visual cues in a prompt? For example, can it create a 'sunset during a snowstorm' or a 'frozen ocean with waves'?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well can the model integrate symbolic or surreal elements, like a tree growing out of someone's hand, while keeping the scene coherent and natural?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model render entirely fictional creatures or physics-defying actions like characters walking on walls or gravity reversing?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model generate content that evolve dynamically, where the scene or characters change in response to the user's previous inputs?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well can the model interpret narrative-driven prompts where characters are engaging in emotionally complex interactions without explicit action descriptors?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How does the model handle unusual or impossible lighting conditions, like 'darkness lit only by the glow of thoughts' or 'a world where shadows are brighter than light'?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model generate variations of existing artwork while maintaining the original style?",
+      "ability": "Creativity",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model create videos with non-linear narratives, such as time jumps or reverse chronology? Can it handle multiple timelines that converge or diverge?",
+      "ability": "Creativity",
+      "general_or_specific": "Specific",
+      "category": "Film and Entertainment"
+    },
+    {
+      "question": "Is the generated content sufficiently diverse, including rare or niche fields?",
+      "ability": "Others",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well the model can generate a specific number of objects?",
+      "ability": "Others",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Does the model tend to overuse specific colors or textures, or does it offer diverse visual outputs?",
+      "ability": "Others",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Does the model generate diverse results for the same prompt, or does it repeat patterns?",
+      "ability": "Others",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model generate flowcharts effectively?",
+      "ability": "Creativity",
+      "general_or_specific": "Specific",
+      "category": "Science and Education"
+    },
+    {
+      "question": "How well can the model generate presentation slides?",
+      "ability": "Creativity",
+      "general_or_specific": "Specific",
+      "category": "Science and Education"
+    },
+    {
+      "question": "Can the model generate clear, courtroom-friendly diagrams to illustrate complex legal cases?",
+      "ability": "Creativity",
+      "general_or_specific": "Specific",
+      "category": "Law"
+    },
+    {
+      "question": "How well can the model generate accurate, scalable floor plans or blueprints?",
+      "ability": "Creativity",
+      "general_or_specific": "Specific",
+      "category": "Architecture and Interior Design"
+    },
+    {
+      "question": "Can the model generate structurally sound designs based on vague architectural concepts?",
+      "ability": "Creativity",
+      "general_or_specific": "Specific",
+      "category": "Architecture and Interior Design"
+    },
+    {
+      "question": "How effectively can the model visualize fictional worlds or characters with great detail?",
+      "ability": "Creativity",
+      "general_or_specific": "Specific",
+      "category": "Film and Entertainment"
+    },
+    {
+      "question": "Can the model generate images that visually suggest different stages of a continuous event or process (e.g., sunrise to sunset progression)?",
+      "ability": "Others",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well does the model interpret abstract emotional concepts into visual formats?",
+      "ability": "Others",
+      "general_or_specific": "Specific",
+      "category": "Medical"
+    },
+    {
+      "question": "How accurately can the model depict human expressions or body language for psychological studies?",
+      "ability": "Others",
+      "general_or_specific": "Specific",
+      "category": "Medical"
+    },
+    {
+      "question": "Can the model generate different animal anatomical structures?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Medical"
+    },
+    {
+      "question": "Can the model generate detailed steps of surgical procedures that cannot be shown in typical surgery videos?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Medical"
+    },
+    {
+      "question": "Can the model understand and apply photographic concepts like focal length, aperture, or ISO?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Film and Entertainment"
+    },
+    {
+      "question": "How accurately can the model generate medical images like X-rays or MRI scans from brief descriptions?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Medical"
+    },
+    {
+      "question": "How does the model handle prompts with explicit restrictions, like generating an image ‘with no use of circular shapes’ or ‘without blue hues’?",
+      "ability": "Others",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well can the model generate 3D visualizations of internal organs or surgical procedures?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Medical"
+    },
+    {
+      "question": "Can the model handle complex, culturally specific objects, symbols, or rituals?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "History and Culture"
+    },
+    {
+      "question": "Can the model generate precise visual representations of complex mathematical graphs or formulas?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Science and Education"
+    },
+    {
+      "question": "How accurately does the model generate scientific diagrams like molecular structures or physics simulations?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Science and Education"
+    },
+    {
+      "question": "How accurately can the model recreate historical scenes, objects, or clothing based on text inputs?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "History and Culture"
+    },
+    {
+      "question": "Can the model accurately depict diverse cultural or historical elements?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "History and Culture"
+    },
+    {
+      "question": "How well can the model recreate a crime scene based on textual descriptions or evidence?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Law"
+    },
+    {
+      "question": "How accurately does the model generate facial composites based on a witness’s description?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Law"
+    },
+    {
+      "question": "Can the model generate anime characters?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Game Design"
+    },
+    {
+      "question": "How precisely can the model replicate specific art styles, such as pixel art or 3D-rendered graphics?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Game Design"
+    },
+    {
+      "question": "How well does the model interpret perspective and depth in a scene?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Game Design"
+    },
+    {
+      "question": "Can the model generate geometric and texture effects?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Game Design"
+    },
+    {
+      "question": "Can the model generate game characters with intricate details like armor or facial expressions?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Game Design"
+    },
+    {
+      "question": "Can the model generate objects with highly structured textures, such as accurately rendering five fingers on a hand?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Medical"
+    },
+    {
+      "question": "Can the model accurately generate fashion sketches with fine detailing of fabrics and textures?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Fashion"
+    },
+    {
+      "question": "Can the model generate complex storyboards incorporating multiple objects, characters, and settings in one scene?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Film and Entertainment"
+    },
+    {
+      "question": "How accurately can the model generate detailed room layouts with attention to furniture, textures, and color schemes?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Architecture and Interior Design"
+    },
+    {
+      "question": "Can the model handle fine detailing of various materials like wood, metal, or fabric in generated interiors?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Architecture and Interior Design"
+    },
+    {
+      "question": "How well can the model represent subtle textures such as skin, fabric, or foliage?",
+      "ability": "Knowledge",
+      "general_or_specific": "Specific",
+      "category": "Fashion"
+    },
+    {
+      "question": "How quickly can the model generate a 3–5-second video with a specific theme?",
+      "ability": "Others",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model differentiate the relationships of characters in the prompts?",
+      "ability": "Others",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "How well does the model handle varying levels of detail in its outputs?",
+      "ability": "Others",
+      "general_or_specific": "General",
+      "category": ""
+    },
+    {
+      "question": "Can the model generate structurally sound designs based on vague architectural concepts?",
+      "ability": "Others",
+      "general_or_specific": "Specific",
+      "category": "Architecture and Interior Design"
+    },
+    {
+      "question": "Can the model blend or fuse different design elements (e.g., mix traditional and modern fashion elements in one outfit)?",
+      "ability": "Others",
+      "general_or_specific": "Specific",
+      "category": "Fashion"
+    },
+    {
+      "question": "Is the model capable of generating designs tailored to individual body types or preferences?",
+      "ability": "Others",
+      "general_or_specific": "Specific",
+      "category": "Fashion"
+    },
+    {
+      "question": "How well does the model handle creating looks for specific occasions, such as casual, formal, or streetwear?",
+      "ability": "Others",
+      "general_or_specific": "Specific",
+      "category": "Fashion"
+    },
+    {
+      "question": "How well can the model represent various fashion trends or styles based on vague descriptions?",
+      "ability": "Others",
+      "general_or_specific": "Specific",
+      "category": "Fashion"
+    }
+  ]
+}

dataset/open_ended_user_questions_summary.json

@@ -0,0 +1,340 @@
+{
+  "Ability": {
+    "Prompt Following": [
+      "How well can the model visualize my ideas based on my words?",
+      "How aligned is the generated content with the provided description?",
+      "Does the model understand specific terms, objects, and intentions?",
+      "How well does the model respond to ambiguous prompts? Does it handle missing or vague information effectively?",
+      "How closely does the generated output correspond to the prompts provided?",
+      "Does the generated result match the description?",
+      "Can the model maintain style consistency across multiple generations from the same prompt?",
+      "How well does the model distinguish between subtle variations in style (e.g., modern vs. postmodern art)?",
+      "What style does the model tend to generate most often?",
+      "Does the model adapt to different stylistic instructions with accuracy and consistency?",
+      "How precisely can the user specify object relationships?",
+      "How well can the model maintain object proportions and spatial relationships in complex scenes?",
+      "How effectively does the model handle changes in perspective?",
+      "Does the model demonstrate flexibility in generating different compositions from similar prompts?",
+      "How precisely can I control the generative model?",
+      "Does the model tend to simplify complex objects or details, or does it retain high levels of intricacy?",
+      "Can the model adjust its output when given slight variations of the same prompt (e.g., changes in tone or context)?",
+      "How well does the model handle varying levels of detail in its outputs?",
+      "Does the model generate similar outputs when there are only small changes in the prompts?"
+    ],
+    "Visual Quality": [
+      "How well does the model balance contrasting elements, such as light and dark or complex and simple?",
+      "To what extent can the model produce photorealistic and aesthetically pleasing results?",
+      "Can the model generate realistic images without common AI-generated artifacts?",
+      "Can it generate physically plausible results?",
+      "How realistic is the generated content?",
+      "Can it generate results that are as realistic as possible?",
+      "How real are the generated results?",
+      "Can the model generate high-fidelity content?",
+      "Can the model generate real-life scenes?",
+      "Can the model maintain high image quality when generating large or detailed scenes?",
+      "Does the model tend to generate more photorealistic images or stylized, cartoonish ones?",
+      "Can the model mimic camera effects such as zooming, panning, or focus pulls, especially when not explicitly described in the prompt?",
+      "How well can the model balance aesthetic elements like space, flow, and symmetry in a room setting?",
+      "Can the model be effectively applied in different scenarios, such as varying lighting conditions and environments?",
+      "How well can the model handle lighting and movement?",
+      "How effectively can the model simulate real-world lighting effects for interior and exterior spaces?",
+      "Can the model generate high-fidelity visualizations for natural phenomena like fluid dynamics or planetary orbits?",
+      "How well does the model handle dynamic elements like action or motion?",
+      "How well can the model generate realistic scenes for a sci-fi film?",
+      "How effectively can the model manage physical realism, such as lighting, shadows, and accurate human anatomy?",
+      "Can the model generate detailed game environments such as forests, cities, or futuristic settings?"
+    ],
+    "Creativity": [
+      "How well can the model interpret abstract or metaphorical concepts? Does it translate non-literal ideas into visual form effectively?",
+      "How well can the model present concepts to explore creative possibilities?",
+      "Can the model blend different genres or themes successfully?",
+      "How well does the model balance realism with creativity? Can it generate imaginative scenes while maintaining visual plausibility?",
+      "How well does the model capture the mood or atmosphere of a given prompt?",
+      "How effectively can the model represent non-visual concepts, such as emotions or abstract ideas?",
+      "How does the model handle the depiction of abstract concepts or metaphors in video form? For example, can it animate a 'storm of emotions' or 'time flowing like water'?",
+      "Can the model handle contradictory visual cues in a prompt? For example, can it create a 'sunset during a snowstorm' or a 'frozen ocean with waves'?",
+      "How well can the model integrate symbolic or surreal elements, like a tree growing out of someone's hand, while keeping the scene coherent and natural?",
+      "Can the model render entirely fictional creatures or physics-defying actions like characters walking on walls or gravity reversing?",
+      "Can the model generate content that evolve dynamically, where the scene or characters change in response to the user's previous inputs?",
+      "How well can the model interpret narrative-driven prompts where characters are engaging in emotionally complex interactions without explicit action descriptors?",
+      "How does the model handle unusual or impossible lighting conditions, like 'darkness lit only by the glow of thoughts' or 'a world where shadows are brighter than light'?",
+      "Can the model generate variations of existing artwork while maintaining the original style?",
+      "Can the model create videos with non-linear narratives, such as time jumps or reverse chronology? Can it handle multiple timelines that converge or diverge?",
+      "Can the model generate flowcharts effectively?",
+      "How well can the model generate presentation slides?",
+      "Can the model generate clear, courtroom-friendly diagrams to illustrate complex legal cases?",
+      "How well can the model generate accurate, scalable floor plans or blueprints?",
+      "Can the model generate structurally sound designs based on vague architectural concepts?",
+      "How effectively can the model visualize fictional worlds or characters with great detail?"
+    ],
+    "Others": [
+      "Is the generated content sufficiently diverse, including rare or niche fields?",
+      "How well the model can generate a specific number of objects?",
+      "Does the model tend to overuse specific colors or textures, or does it offer diverse visual outputs?",
+      "Does the model generate diverse results for the same prompt, or does it repeat patterns?",
+      "Can the model generate images that visually suggest different stages of a continuous event or process (e.g., sunrise to sunset progression)?",
+      "How well does the model interpret abstract emotional concepts into visual formats?",
+      "How accurately can the model depict human expressions or body language for psychological studies?",
+      "How does the model handle prompts with explicit restrictions, like generating an image ‘with no use of circular shapes’ or ‘without blue hues’?",
+      "How quickly can the model generate a 3–5-second video with a specific theme?",
+      "Can the model differentiate the relationships of characters in the prompts?",
+      "How well does the model handle varying levels of detail in its outputs?",
+      "Can the model generate structurally sound designs based on vague architectural concepts?",
+      "Can the model blend or fuse different design elements (e.g., mix traditional and modern fashion elements in one outfit)?",
+      "Is the model capable of generating designs tailored to individual body types or preferences?",
+      "How well does the model handle creating looks for specific occasions, such as casual, formal, or streetwear?",
+      "How well can the model represent various fashion trends or styles based on vague descriptions?"
+    ],
+    "Knowledge": [
+      "Can the model generate different animal anatomical structures?",
+      "Can the model generate detailed steps of surgical procedures that cannot be shown in typical surgery videos?",
+      "Can the model understand and apply photographic concepts like focal length, aperture, or ISO?",
+      "How accurately can the model generate medical images like X-rays or MRI scans from brief descriptions?",
+      "How well can the model generate 3D visualizations of internal organs or surgical procedures?",
+      "Can the model handle complex, culturally specific objects, symbols, or rituals?",
+      "Can the model generate precise visual representations of complex mathematical graphs or formulas?",
+      "How accurately does the model generate scientific diagrams like molecular structures or physics simulations?",
+      "How accurately can the model recreate historical scenes, objects, or clothing based on text inputs?",
+      "Can the model accurately depict diverse cultural or historical elements?",
+      "How well can the model recreate a crime scene based on textual descriptions or evidence?",
+      "How accurately does the model generate facial composites based on a witness’s description?",
+      "Can the model generate anime characters?",
+      "How precisely can the model replicate specific art styles, such as pixel art or 3D-rendered graphics?",
+      "How well does the model interpret perspective and depth in a scene?",
+      "Can the model generate geometric and texture effects?",
+      "Can the model generate game characters with intricate details like armor or facial expressions?",
+      "Can the model generate objects with highly structured textures, such as accurately rendering five fingers on a hand?",
+      "Can the model accurately generate fashion sketches with fine detailing of fabrics and textures?",
+      "Can the model generate complex storyboards incorporating multiple objects, characters, and settings in one scene?",
+      "How accurately can the model generate detailed room layouts with attention to furniture, textures, and color schemes?",
+      "Can the model handle fine detailing of various materials like wood, metal, or fabric in generated interiors?",
+      "How well can the model represent subtle textures such as skin, fabric, or foliage?"
+    ]
+  },
+  "General/Specific": {
+    "General": [
+      "How well can the model visualize my ideas based on my words?",
+      "How aligned is the generated content with the provided description?",
+      "Does the model understand specific terms, objects, and intentions?",
+      "How well does the model respond to ambiguous prompts? Does it handle missing or vague information effectively?",
+      "How closely does the generated output correspond to the prompts provided?",
+      "Does the generated result match the description?",
+      "Can the model maintain style consistency across multiple generations from the same prompt?",
+      "How well does the model distinguish between subtle variations in style (e.g., modern vs. postmodern art)?",
+      "What style does the model tend to generate most often?",
+      "Does the model adapt to different stylistic instructions with accuracy and consistency?",
+      "How precisely can the user specify object relationships?",
+      "How well can the model maintain object proportions and spatial relationships in complex scenes?",
+      "How effectively does the model handle changes in perspective?",
+      "Does the model demonstrate flexibility in generating different compositions from similar prompts?",
+      "How precisely can I control the generative model?",
+      "Does the model tend to simplify complex objects or details, or does it retain high levels of intricacy?",
+      "Can the model adjust its output when given slight variations of the same prompt (e.g., changes in tone or context)?",
+      "How well does the model handle varying levels of detail in its outputs?",
+      "Does the model generate similar outputs when there are only small changes in the prompts?",
+      "How well does the model balance contrasting elements, such as light and dark or complex and simple?",
+      "To what extent can the model produce photorealistic and aesthetically pleasing results?",
+      "Can the model generate realistic images without common AI-generated artifacts?",
+      "Can it generate physically plausible results?",
+      "How realistic is the generated content?",
+      "Can it generate results that are as realistic as possible?",
+      "How real are the generated results?",
+      "Can the model generate high-fidelity content?",
+      "Can the model generate real-life scenes?",
+      "Can the model maintain high image quality when generating large or detailed scenes?",
+      "Does the model tend to generate more photorealistic images or stylized, cartoonish ones?",
+      "Can the model mimic camera effects such as zooming, panning, or focus pulls, especially when not explicitly described in the prompt?",
+      "How well can the model balance aesthetic elements like space, flow, and symmetry in a room setting?",
+      "Can the model be effectively applied in different scenarios, such as varying lighting conditions and environments?",
+      "How well can the model handle lighting and movement?",
+      "How effectively can the model simulate real-world lighting effects for interior and exterior spaces?",
+      "Can the model generate high-fidelity visualizations for natural phenomena like fluid dynamics or planetary orbits?",
+      "How well does the model handle dynamic elements like action or motion?",
+      "How well can the model interpret abstract or metaphorical concepts? Does it translate non-literal ideas into visual form effectively?",
+      "How well can the model present concepts to explore creative possibilities?",
+      "Can the model blend different genres or themes successfully?",
+      "How well does the model balance realism with creativity? Can it generate imaginative scenes while maintaining visual plausibility?",
+      "How well does the model capture the mood or atmosphere of a given prompt?",
+      "How effectively can the model represent non-visual concepts, such as emotions or abstract ideas?",
+      "How does the model handle the depiction of abstract concepts or metaphors in video form? For example, can it animate a 'storm of emotions' or 'time flowing like water'?",
+      "Can the model handle contradictory visual cues in a prompt? For example, can it create a 'sunset during a snowstorm' or a 'frozen ocean with waves'?",
+      "How well can the model integrate symbolic or surreal elements, like a tree growing out of someone's hand, while keeping the scene coherent and natural?",
+      "Can the model render entirely fictional creatures or physics-defying actions like characters walking on walls or gravity reversing?",
+      "Can the model generate content that evolve dynamically, where the scene or characters change in response to the user's previous inputs?",
+      "How well can the model interpret narrative-driven prompts where characters are engaging in emotionally complex interactions without explicit action descriptors?",
+      "How does the model handle unusual or impossible lighting conditions, like 'darkness lit only by the glow of thoughts' or 'a world where shadows are brighter than light'?",
+      "Can the model generate variations of existing artwork while maintaining the original style?",
+      "Is the generated content sufficiently diverse, including rare or niche fields?",
+      "How well the model can generate a specific number of objects?",
+      "Does the model tend to overuse specific colors or textures, or does it offer diverse visual outputs?",
+      "Does the model generate diverse results for the same prompt, or does it repeat patterns?",
+      "Can the model generate images that visually suggest different stages of a continuous event or process (e.g., sunrise to sunset progression)?",
+      "How does the model handle prompts with explicit restrictions, like generating an image ‘with no use of circular shapes’ or ‘without blue hues’?",
+      "How quickly can the model generate a 3–5-second video with a specific theme?",
+      "Can the model differentiate the relationships of characters in the prompts?",
+      "How well does the model handle varying levels of detail in its outputs?"
+    ],
+    "Specific": [
+      "How well can the model generate realistic scenes for a sci-fi film?",
+      "How effectively can the model manage physical realism, such as lighting, shadows, and accurate human anatomy?",
+      "Can the model generate detailed game environments such as forests, cities, or futuristic settings?",
+      "Can the model create videos with non-linear narratives, such as time jumps or reverse chronology? Can it handle multiple timelines that converge or diverge?",
+      "Can the model generate flowcharts effectively?",
+      "How well can the model generate presentation slides?",
+      "Can the model generate clear, courtroom-friendly diagrams to illustrate complex legal cases?",
+      "How well can the model generate accurate, scalable floor plans or blueprints?",
+      "Can the model generate structurally sound designs based on vague architectural concepts?",
+      "How effectively can the model visualize fictional worlds or characters with great detail?",
+      "How well does the model interpret abstract emotional concepts into visual formats?",
+      "How accurately can the model depict human expressions or body language for psychological studies?",
+      "Can the model generate different animal anatomical structures?",
+      "Can the model generate detailed steps of surgical procedures that cannot be shown in typical surgery videos?",
+      "Can the model understand and apply photographic concepts like focal length, aperture, or ISO?",
+      "How accurately can the model generate medical images like X-rays or MRI scans from brief descriptions?",
+      "How well can the model generate 3D visualizations of internal organs or surgical procedures?",
+      "Can the model handle complex, culturally specific objects, symbols, or rituals?",
+      "Can the model generate precise visual representations of complex mathematical graphs or formulas?",
+      "How accurately does the model generate scientific diagrams like molecular structures or physics simulations?",
+      "How accurately can the model recreate historical scenes, objects, or clothing based on text inputs?",
+      "Can the model accurately depict diverse cultural or historical elements?",
+      "How well can the model recreate a crime scene based on textual descriptions or evidence?",
+      "How accurately does the model generate facial composites based on a witness’s description?",
+      "Can the model generate anime characters?",
+      "How precisely can the model replicate specific art styles, such as pixel art or 3D-rendered graphics?",
+      "How well does the model interpret perspective and depth in a scene?",
+      "Can the model generate geometric and texture effects?",
+      "Can the model generate game characters with intricate details like armor or facial expressions?",
+      "Can the model generate objects with highly structured textures, such as accurately rendering five fingers on a hand?",
+      "Can the model accurately generate fashion sketches with fine detailing of fabrics and textures?",
+      "Can the model generate complex storyboards incorporating multiple objects, characters, and settings in one scene?",
+      "How accurately can the model generate detailed room layouts with attention to furniture, textures, and color schemes?",
+      "Can the model handle fine detailing of various materials like wood, metal, or fabric in generated interiors?",
+      "How well can the model represent subtle textures such as skin, fabric, or foliage?",
+      "Can the model generate structurally sound designs based on vague architectural concepts?",
+      "Can the model blend or fuse different design elements (e.g., mix traditional and modern fashion elements in one outfit)?",
+      "Is the model capable of generating designs tailored to individual body types or preferences?",
+      "How well does the model handle creating looks for specific occasions, such as casual, formal, or streetwear?",
+      "How well can the model represent various fashion trends or styles based on vague descriptions?"
+    ]
+  },
+  "Category": {
+    "No Category": [
+      "How well can the model visualize my ideas based on my words?",
+      "How aligned is the generated content with the provided description?",
+      "Does the model understand specific terms, objects, and intentions?",
+      "How well does the model respond to ambiguous prompts? Does it handle missing or vague information effectively?",
+      "How closely does the generated output correspond to the prompts provided?",
+      "Does the generated result match the description?",
+      "Can the model maintain style consistency across multiple generations from the same prompt?",
+      "How well does the model distinguish between subtle variations in style (e.g., modern vs. postmodern art)?",
+      "What style does the model tend to generate most often?",
+      "Does the model adapt to different stylistic instructions with accuracy and consistency?",
+      "How precisely can the user specify object relationships?",
+      "How well can the model maintain object proportions and spatial relationships in complex scenes?",
+      "How effectively does the model handle changes in perspective?",
+      "Does the model demonstrate flexibility in generating different compositions from similar prompts?",
+      "How precisely can I control the generative model?",
+      "Does the model tend to simplify complex objects or details, or does it retain high levels of intricacy?",
+      "Can the model adjust its output when given slight variations of the same prompt (e.g., changes in tone or context)?",
+      "How well does the model handle varying levels of detail in its outputs?",
+      "Does the model generate similar outputs when there are only small changes in the prompts?",
+      "How well does the model balance contrasting elements, such as light and dark or complex and simple?",
+      "To what extent can the model produce photorealistic and aesthetically pleasing results?",
+      "Can the model generate realistic images without common AI-generated artifacts?",
+      "Can it generate physically plausible results?",
+      "How realistic is the generated content?",
+      "Can it generate results that are as realistic as possible?",
+      "How real are the generated results?",
+      "Can the model generate high-fidelity content?",
+      "Can the model generate real-life scenes?",
+      "Can the model maintain high image quality when generating large or detailed scenes?",
+      "Does the model tend to generate more photorealistic images or stylized, cartoonish ones?",
+      "Can the model mimic camera effects such as zooming, panning, or focus pulls, especially when not explicitly described in the prompt?",
+      "How well can the model balance aesthetic elements like space, flow, and symmetry in a room setting?",
+      "Can the model be effectively applied in different scenarios, such as varying lighting conditions and environments?",
+      "How well can the model handle lighting and movement?",
+      "How effectively can the model simulate real-world lighting effects for interior and exterior spaces?",
+      "Can the model generate high-fidelity visualizations for natural phenomena like fluid dynamics or planetary orbits?",
+      "How well does the model handle dynamic elements like action or motion?",
+      "How well can the model interpret abstract or metaphorical concepts? Does it translate non-literal ideas into visual form effectively?",
+      "How well can the model present concepts to explore creative possibilities?",
+      "Can the model blend different genres or themes successfully?",
+      "How well does the model balance realism with creativity? Can it generate imaginative scenes while maintaining visual plausibility?",
+      "How well does the model capture the mood or atmosphere of a given prompt?",
+      "How effectively can the model represent non-visual concepts, such as emotions or abstract ideas?",
+      "How does the model handle the depiction of abstract concepts or metaphors in video form? For example, can it animate a 'storm of emotions' or 'time flowing like water'?",
+      "Can the model handle contradictory visual cues in a prompt? For example, can it create a 'sunset during a snowstorm' or a 'frozen ocean with waves'?",
+      "How well can the model integrate symbolic or surreal elements, like a tree growing out of someone's hand, while keeping the scene coherent and natural?",
+      "Can the model render entirely fictional creatures or physics-defying actions like characters walking on walls or gravity reversing?",
+      "Can the model generate content that evolve dynamically, where the scene or characters change in response to the user's previous inputs?",
+      "How well can the model interpret narrative-driven prompts where characters are engaging in emotionally complex interactions without explicit action descriptors?",
+      "How does the model handle unusual or impossible lighting conditions, like 'darkness lit only by the glow of thoughts' or 'a world where shadows are brighter than light'?",
+      "Can the model generate variations of existing artwork while maintaining the original style?",
+      "Is the generated content sufficiently diverse, including rare or niche fields?",
+      "How well the model can generate a specific number of objects?",
+      "Does the model tend to overuse specific colors or textures, or does it offer diverse visual outputs?",
+      "Does the model generate diverse results for the same prompt, or does it repeat patterns?",
+      "Can the model generate images that visually suggest different stages of a continuous event or process (e.g., sunrise to sunset progression)?",
+      "How does the model handle prompts with explicit restrictions, like generating an image ‘with no use of circular shapes’ or ‘without blue hues’?",
+      "How quickly can the model generate a 3–5-second video with a specific theme?",
+      "Can the model differentiate the relationships of characters in the prompts?",
+      "How well does the model handle varying levels of detail in its outputs?"
+    ],
+    "Film and Entertainment": [
+      "How well can the model generate realistic scenes for a sci-fi film?",
+      "Can the model create videos with non-linear narratives, such as time jumps or reverse chronology? Can it handle multiple timelines that converge or diverge?",
+      "How effectively can the model visualize fictional worlds or characters with great detail?",
+      "Can the model understand and apply photographic concepts like focal length, aperture, or ISO?",
+      "Can the model generate complex storyboards incorporating multiple objects, characters, and settings in one scene?"
+    ],
+    "Medical": [
+      "How effectively can the model manage physical realism, such as lighting, shadows, and accurate human anatomy?",
+      "How well does the model interpret abstract emotional concepts into visual formats?",
+      "How accurately can the model depict human expressions or body language for psychological studies?",
+      "Can the model generate different animal anatomical structures?",
+      "Can the model generate detailed steps of surgical procedures that cannot be shown in typical surgery videos?",
+      "How accurately can the model generate medical images like X-rays or MRI scans from brief descriptions?",
+      "How well can the model generate 3D visualizations of internal organs or surgical procedures?",
+      "Can the model generate objects with highly structured textures, such as accurately rendering five fingers on a hand?"
+    ],
+    "Game Design": [
+      "Can the model generate detailed game environments such as forests, cities, or futuristic settings?",
+      "Can the model generate anime characters?",
+      "How precisely can the model replicate specific art styles, such as pixel art or 3D-rendered graphics?",
+      "How well does the model interpret perspective and depth in a scene?",
+      "Can the model generate geometric and texture effects?",
+      "Can the model generate game characters with intricate details like armor or facial expressions?"
+    ],
+    "Science and Education": [
+      "Can the model generate flowcharts effectively?",
+      "How well can the model generate presentation slides?",
+      "Can the model generate precise visual representations of complex mathematical graphs or formulas?",
+      "How accurately does the model generate scientific diagrams like molecular structures or physics simulations?"
+    ],
+    "Law": [
+      "Can the model generate clear, courtroom-friendly diagrams to illustrate complex legal cases?",
+      "How well can the model recreate a crime scene based on textual descriptions or evidence?",
+      "How accurately does the model generate facial composites based on a witness’s description?"
+    ],
+    "Architecture and Interior Design": [
+      "How well can the model generate accurate, scalable floor plans or blueprints?",
+      "Can the model generate structurally sound designs based on vague architectural concepts?",
+      "How accurately can the model generate detailed room layouts with attention to furniture, textures, and color schemes?",
+      "Can the model handle fine detailing of various materials like wood, metal, or fabric in generated interiors?",
+      "Can the model generate structurally sound designs based on vague architectural concepts?"
+    ],
+    "History and Culture": [
+      "Can the model handle complex, culturally specific objects, symbols, or rituals?",
+      "How accurately can the model recreate historical scenes, objects, or clothing based on text inputs?",
+      "Can the model accurately depict diverse cultural or historical elements?"
+    ],
+    "Fashion": [
+      "Can the model accurately generate fashion sketches with fine detailing of fabrics and textures?",
+      "How well can the model represent subtle textures such as skin, fabric, or foliage?",
+      "Can the model blend or fuse different design elements (e.g., mix traditional and modern fashion elements in one outfit)?",
+      "Is the model capable of generating designs tailored to individual body types or preferences?",
+      "How well does the model handle creating looks for specific occasions, such as casual, formal, or streetwear?",
+      "How well can the model represent various fashion trends or styles based on vague descriptions?"
+    ]
+  }
+}

debug_model_output.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+Debug script to analyze model output issues and test structured generation.
+"""
+
+import json
+import requests
+import argparse
+from typing import List, Dict, Any, Optional
+
+
+def call_model(message: str, model_url: str = "http://0.0.0.0:12333/v1/chat/completions", 
+               model_name: str = "eval-agent", system: str = "", temperature: float = 0.1,
+               max_tokens: int = 512) -> Optional[str]:
+    """Call the model with specific parameters for debugging."""
+    
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": message})
+    
+    payload = {
+        "model": model_name,
+        "messages": messages,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "stream": False
+    }
+    
+    try:
+        response = requests.post(model_url, json=payload, timeout=60)
+        response.raise_for_status()
+        result = response.json()
+        return result["choices"][0]["message"]["content"]
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+
+def test_structured_output():
+    """Test various prompts to debug structured output issues."""
+    
+    print("🔍 DEBUGGING MODEL STRUCTURED OUTPUT")
+    print("="*60)
+    
+    # Test cases with different complexity levels
+    test_cases = [
+        {
+            "name": "Simple Structure Test",
+            "prompt": "Please respond with: <think>test thought</think> <subaspect>test aspect</subaspect> <tool>test tool</tool>",
+            "system": "",
+            "temperature": 0.0
+        },
+        {
+            "name": "VBench Format Test", 
+            "prompt": "How well does the model generate objects?",
+            "system": "You must respond in this exact format: <think>your reasoning</think> <subaspect>specific aspect</subaspect> <tool>evaluation tool</tool>",
+            "temperature": 0.1
+        },
+        {
+            "name": "Training Data Example",
+            "prompt": "How accurately does the model generate specific object classes as described in the text prompt?",
+            "system": """You are an expert in evaluating video generation models. You must respond in this exact format:
+
+<think>Your detailed reasoning about what to evaluate</think> <subaspect>The specific aspect to focus on</subaspect> <tool>Object Class</tool>
+
+Available tools: Object Class, Scene, Color, Spatial Relationship, Human Action, Dynamic Degree, Multiple Objects, Overall Consistency, Aesthetic Quality, Imaging Quality, Motion Smoothness, Subject Consistency, Background Consistency""",
+            "temperature": 0.0
+        }
+    ]
+    
+    for i, test in enumerate(test_cases, 1):
+        print(f"\n{i}. {test['name']}")
+        print("-" * 40)
+        print(f"Prompt: {test['prompt'][:100]}...")
+        print(f"Temperature: {test['temperature']}")
+        
+        response = call_model(
+            message=test['prompt'],
+            system=test['system'],
+            temperature=test['temperature']
+        )
+        
+        if response:
+            print(f"Response: {response}")
+            
+            # Analyze structure
+            has_think = "<think>" in response and "</think>" in response
+            has_subaspect = "<subaspect>" in response and "</subaspect>" in response  
+            has_tool = "<tool>" in response and "</tool>" in response
+            
+            print(f"Structure Analysis:")
+            print(f"  ✅ Has <think> tags: {has_think}")
+            print(f"  ✅ Has <subaspect> tags: {has_subaspect}")
+            print(f"  ✅ Has <tool> tags: {has_tool}")
+            print(f"  ✅ All tags present: {has_think and has_subaspect and has_tool}")
+            
+            # Check for common errors
+            errors = []
+            if "<think>" in response and "</tool>" in response and "</think>" not in response:
+                errors.append("Missing </think> closing tag")
+            if "Object Class</tool>" in response:
+                errors.append("Tool name in wrong tag")
+            if len([tag for tag in ["<think>", "<subaspect>", "<tool>"] if tag in response]) != len([tag for tag in ["</think>", "</subaspect>", "</tool>"] if tag in response]):
+                errors.append("Mismatched opening/closing tags")
+                
+            if errors:
+                print(f"  ❌ Errors found: {', '.join(errors)}")
+        else:
+            print("❌ No response received")
+
+
+def test_temperature_effects():
+    """Test how temperature affects structured output quality."""
+    
+    print("\n\n🌡️  TEMPERATURE EFFECTS ON STRUCTURED OUTPUT")
+    print("="*60)
+    
+    prompt = "How accurately does the model generate specific object classes?"
+    system = "Respond in format: <think>reasoning</think> <subaspect>aspect</subaspect> <tool>Object Class</tool>"
+    
+    temperatures = [0.0, 0.1, 0.3, 0.7, 1.0]
+    
+    for temp in temperatures:
+        print(f"\nTemperature: {temp}")
+        print("-" * 30)
+        
+        response = call_model(
+            message=prompt,
+            system=system,
+            temperature=temp,
+            max_tokens=200
+        )
+        
+        if response:
+            print(f"Response: {response[:150]}...")
+            
+            # Check if structure is maintained
+            correct_structure = (
+                "<think>" in response and "</think>" in response and
+                "<subaspect>" in response and "</subaspect>" in response and
+                "<tool>" in response and "</tool>" in response
+            )
+            print(f"Correct structure: {'✅' if correct_structure else '❌'}")
+        else:
+            print("❌ No response")
+
+
+def analyze_training_sample():
+    """Analyze a training sample to understand expected format."""
+    
+    print("\n\n📚 TRAINING DATA ANALYSIS")
+    print("="*60)
+    
+    # Load a training sample
+    try:
+        with open("data/postprocess_20250819/ea_cot_dataset_10k.json", 'r') as f:
+            data = json.load(f)
+            
+        sample = data[0]  # First sample
+        
+        print("Training Sample:")
+        print(f"Instruction: {sample['instruction']}")
+        print(f"Expected Output: {sample['output']}")
+        
+        # Test model with exact training example
+        print("\n🧪 Testing with exact training example:")
+        response = call_model(
+            message=sample['instruction'],
+            system=sample.get('system', ''),
+            temperature=0.0
+        )
+        
+        print(f"Model Response: {response}")
+        
+        # Compare
+        expected = sample['output']
+        if response and expected in response:
+            print("✅ Model output matches training data!")
+        else:
+            print("❌ Model output differs from training data")
+            
+            # Detailed comparison
+            if response:
+                print("\nDetailed Analysis:")
+                print(f"Expected think: {expected[expected.find('<think>')+7:expected.find('</think>')][:50]}...")
+                print(f"Expected subaspect: {expected[expected.find('<subaspect>')+11:expected.find('</subaspect>')]}")
+                print(f"Expected tool: {expected[expected.find('<tool>')+6:expected.find('</tool>')]}")
+                
+                if '<think>' in response:
+                    think_content = response[response.find('<think>')+7:response.find('</think>')] if '</think>' in response else "INCOMPLETE"
+                    print(f"Actual think: {think_content[:50]}...")
+                    
+    except Exception as e:
+        print(f"Could not load training data: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Debug model structured output issues")
+    parser.add_argument("--model_url", default="http://0.0.0.0:12333/v1/chat/completions")
+    parser.add_argument("--model_name", default="eval-agent")
+    
+    args = parser.parse_args()
+    
+    # Test connection first
+    print("🔗 Testing connection...")
+    response = call_model("Hello", model_url=args.model_url, model_name=args.model_name)
+    if not response:
+        print("❌ Cannot connect to model server")
+        return
+    
+    print("✅ Connected successfully!")
+    
+    # Run all tests
+    test_structured_output()
+    test_temperature_effects()
+    analyze_training_sample()
+    
+    print("\n\n💡 RECOMMENDATIONS:")
+    print("="*60)
+    print("1. Use temperature=0.0 or very low temperature for structured output")
+    print("2. Include explicit format instructions in system prompt") 
+    print("3. Consider retraining with more structured output examples")
+    print("4. Add format validation in your evaluation pipeline")
+    print("5. Use constrained generation or parsing to fix malformed output")
+
+
+if __name__ == "__main__":
+    main()

eval_agent/base_agent.py

@@ -0,0 +1,202 @@
+from openai import OpenAI
+import json
+# from vllm import LLM, SamplingParams
+import requests
+
+class BaseAgent:
+    def __init__(self, system_prompt="", use_history=True, temp=0.5, top_p=0.95):
+        self.use_history = use_history
+        self.client = OpenAI()
+        self.system = system_prompt
+        self.temp = temp
+        self.top_p = top_p
+        self.input_tokens_count = 0
+        self.output_tokens_count = 0
+        self.messages = []
+        if self.system:
+            self.messages.append({"role": "system", "content": system_prompt})
+    
+    
+    def __call__(self, message, parse=False):
+        self.messages.append({"role": "user", "content": message})
+        result = self.generate(message, parse)
+        self.messages.append({"role": "assistant", "content": result})
+
+        if parse:
+            try:
+                result = self.parse_json(result)
+            except:
+                raise Exception("Error content is list below:\n", result)
+            
+        return result
+        
+    
+    
+    def generate(self, message, json_format):
+        if self.use_history:
+            input_messages = self.messages
+        else:
+            input_messages = [
+                {"role": "system", "content": self.system},
+                {"role": "user", "content": message}
+            ]
+            
+        
+        if json_format:
+            response = self.client.chat.completions.create(
+                model="gpt-4o-2024-08-06", # gpt-4
+                messages=input_messages,
+                temperature=self.temp,
+                top_p=self.top_p,
+                response_format = { "type": "json_object" }
+                )
+        else:
+            response = self.client.chat.completions.create(
+                model="gpt-4o-2024-08-06", # gpt-4
+                messages=input_messages,
+                temperature=self.temp,
+                top_p=self.top_p,
+                )
+        self.update_tokens_count(response)
+        return response.choices[0].message.content
+    
+    
+    def parse_json(self, response):
+        return json.loads(response)
+
+    
+    def add(self, message: dict):
+        self.messages.append(message)
+    
+    
+    def update_tokens_count(self, response):
+        self.input_tokens_count += response.usage.prompt_tokens
+        self.output_tokens_count += response.usage.completion_tokens
+    
+    
+    def show_usage(self):
+        print(f"Total input tokens used: {self.input_tokens_count}\nTotal output tokens used: {self.output_tokens_count}")
+        
+
+class BaseAgent_SFT:
+    def __init__(self, system_prompt="", use_history=True, temp=0, top_p=1, model_name_or_path="http://0.0.0.0:12333/v1/chat/completions"):
+        self.use_history = use_history
+        if not model_name_or_path.startswith("http"):
+            self.client = LLM(model=model_name_or_path, tokenizer=model_name_or_path, gpu_memory_utilization=0.5, tensor_parallel_size=1)
+            self.api = False
+        else:
+            self.client = model_name_or_path
+            self.model_name = "eval-agent"
+            self.api = True
+        self.system = system_prompt
+        self.temp = temp
+        self.top_p = top_p
+        self.input_tokens_count = 0
+        self.output_tokens_count = 0
+        self.messages = []
+        if self.system:
+            self.messages.append({"role": "system", "content": system_prompt})
+    
+    
+    def __call__(self, message):
+        self.messages.append({"role": "user", "content": message})
+        result = self.generate(message)
+        self.messages.append({"role": "assistant", "content": result})
+
+        return result
+        
+    
+    def generate(self, message):
+        if self.use_history:
+            input_messages = self.messages
+        else:
+            input_messages = [
+                {"role": "system", "content": self.system},
+                {"role": "user", "content": message}
+            ]
+            
+        if self.api:
+            payload = {
+                "model": self.model_name,
+                "messages": input_messages,
+                "max_tokens": 1024,
+                "temperature": self.temp,
+                "top_p": self.top_p,
+                "stream": False
+            }
+            
+            for _ in range(3):
+                try:
+                    response = requests.post(self.client, json=payload, timeout=120)
+                    response.raise_for_status()
+                    result = response.json()
+                    return result["choices"][0]["message"]["content"]
+                
+                except requests.exceptions.RequestException as e:
+                    print(f"❌ API request failed: {e}")
+                    continue
+                
+                except (KeyError, IndexError) as e:
+                    print(f"❌ Unexpected response format: {e}")
+                    continue
+            return None
+        else:
+            response = self.client.generate(
+                input_messages,
+                sampling_params=SamplingParams(
+                    max_tokens=1024,
+                    temperature=self.temp,
+                    top_p=self.top_p,
+                    n=1,
+                ),
+            )
+            return response[0].outputs[0].text
+
+class BaseAgent_Open:
+    def __init__(self, system_prompt="", use_history=True, temp=0, top_p=1, model_name_or_path="Qwen/Qwen2.5-3B-Instruct"):
+        self.use_history = use_history
+        self.client = LLM(model=model_name_or_path, tokenizer=model_name_or_path, gpu_memory_utilization=0.5, tensor_parallel_size=1)
+        self.tokenizer = self.client.get_tokenizer()
+        self.system = system_prompt
+        self.temp = temp
+        self.top_p = top_p
+        self.messages = []
+        if self.system:
+            self.messages.append({"role": "system", "content": system_prompt})
+    
+    
+    def __call__(self, message):
+        self.messages.append({"role": "user", "content": message})
+        result = self.generate(message)
+        self.messages.append({"role": "assistant", "content": result})
+
+        return result
+        
+    
+    def generate(self, message):
+        if self.use_history:
+            input_messages = self.messages
+        else:
+            input_messages = [
+                {"role": "system", "content": self.system},
+                {"role": "user", "content": message}
+            ]
+        
+        # Convert messages to string using tokenizer's chat template
+        prompt = self.tokenizer.apply_chat_template(
+            input_messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+        
+        response = self.client.generate(
+            prompt,
+            sampling_params=SamplingParams(
+                max_tokens=1024,
+                temperature=self.temp,
+                top_p=self.top_p,
+                n=1,
+            ),
+        )
+        return response[0].outputs[0].text
+        

eval_agent/check_query_completeness.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""
+Script to check if each query has at least 10 eval_results.json files
+across all subfolders (numbered and supplementary) in VBench evaluation results.
+"""
+
+import os
+import json
+import re
+from pathlib import Path
+from typing import Dict, List, Set
+from collections import defaultdict
+
+
+queries_to_evaluate = [
+    "How does the model perform in terms of aesthetics?",
+    "How well does the model ensure that the subject maintains a consistent appearance throughout the video?",
+    "How effectively does the model maintain a consistent background scene throughout the video?",
+    "How well does the model produce smooth and natural motion that follows the physical laws of the real world?",
+    "To what extent are distortions like over-exposure, noise, and blur present in the generated frames?",
+    "How consistently does the visual style (e.g., oil painting, black and white, watercolor) align with the specified look throughout the video?",
+    "How consistent are the time-based effects and camera motions throughout the video?",
+    "How well does the generated video demonstrate overall consistency with the input prompt?",
+    "How effectively does the model generate multiple distinct objects in a single scene?",
+    "How accurately does the model generate specific object classes as described in the text prompt?",
+    "To what extent does the video exhibit dynamic movement rather than being overly static?",
+    "How accurately do human subjects in the video perform the actions described in the text prompt?",
+    "How accurately do the colors of the generated objects match the specifications in the text prompt?",
+    "How accurately does the spatial arrangement of objects reflect the positioning and relationships described in the text prompt?",
+    "How accurately does the generated video represent the scene described in the text prompt?",
+]
+
+def extract_query_from_folder_name(folder_name: str) -> str:
+    """
+    Extract query from a dimension folder name.
+    Format: date-time-query_with_underscores
+    """
+    # Look for pattern like "HH:MM:SS-query"
+    match = re.search(r'\d{2}:\d{2}:\d{2}-(.+)', folder_name)
+    if match:
+        query = match.group(1).replace('_', ' ')
+        if not query.endswith('?'):
+            query += '?'
+        return query
+    
+    # For folders without timestamp, try direct extraction
+    # This handles cases where the folder name is just the query
+    if '_' in folder_name or ' ' in folder_name:
+        query = folder_name.replace('_', ' ')
+        if not query.endswith('?'):
+            query += '?'
+        return query
+    
+    return None
+
+
+def count_query_occurrences(model_path: str, min_required: int = 10, expected_queries: List[str] = None) -> Dict[str, Dict]:
+    """
+    Count how many eval_results.json files exist for each query across all subfolders.
+    Recursively searches all directories for eval_results.json files.
+    
+    Args:
+        model_path: Path to the model folder (e.g., eval_vbench_results/modelscope)
+        min_required: Minimum number of eval_results.json files required per query (default: 10)
+    
+    Returns:
+        Dictionary with query statistics and missing queries
+    """
+    model_path = Path(model_path)
+    
+    if not model_path.exists():
+        print(f"Error: Path {model_path} does not exist!")
+        return {}
+    
+    # Track query occurrences: query -> list of (path, folder) where it exists
+    query_occurrences = defaultdict(list)
+    
+    # Track all unique queries found
+    all_queries = set()
+    
+    print(f"Scanning model folder: {model_path.name}")
+    print("=" * 80)
+    
+    # Find all eval_results.json files recursively
+    eval_files = list(model_path.rglob("eval_results.json"))
+    print(f"Found {len(eval_files)} eval_results.json files")
+    
+    # Process each eval_results.json file
+    for eval_file in eval_files:
+        # Get the parent folder that contains this eval_results.json
+        parent_folder = eval_file.parent
+        
+        # Try to extract query from the folder name
+        # Check if it's in a videos subfolder
+        if parent_folder.name == "videos":
+            query_folder = parent_folder.parent
+        else:
+            query_folder = parent_folder
+            
+        # Extract query from folder name
+        query = extract_query_from_folder_name(query_folder.name)
+        
+        if query:
+            all_queries.add(query)
+            
+            # Validate the JSON file
+            try:
+                with open(eval_file, 'r') as f:
+                    json.load(f)
+                
+                # Get relative path from model folder
+                relative_path = eval_file.relative_to(model_path)
+                
+                # Record this occurrence with the relative path
+                query_occurrences[query].append(str(relative_path))
+                
+            except (json.JSONDecodeError, Exception) as e:
+                # Don't count invalid JSON files
+                print(f"  Invalid JSON in {eval_file}: {e}")
+    
+    # Analyze results
+    results = {
+        'all_queries': sorted(all_queries),
+        'query_counts': {},
+        'insufficient_queries': [],
+        'missing_completely': [],
+        'statistics': {
+            'total_unique_queries': len(all_queries),
+            'queries_with_sufficient_results': 0,
+            'queries_with_insufficient_results': 0,
+            'queries_missing_completely': 0
+        }
+    }
+    
+    # If expected queries provided, check for completely missing ones
+    if expected_queries:
+        for query in expected_queries:
+            if query not in all_queries:
+                all_queries.add(query)
+                results['missing_completely'].append(query)
+                results['statistics']['queries_missing_completely'] += 1
+                results['query_counts'][query] = {
+                    'count': 0,
+                    'locations': []
+                }
+    
+    # Check each query
+    for query in all_queries:
+        if query not in results['missing_completely']:  # Skip if already marked as missing
+            count = len(query_occurrences[query])
+            results['query_counts'][query] = {
+                'count': count,
+                'locations': query_occurrences[query]
+            }
+            
+            if count == 0:
+                results['missing_completely'].append(query)
+                results['statistics']['queries_missing_completely'] += 1
+            elif count < min_required:
+                results['insufficient_queries'].append({
+                    'query': query,
+                    'count': count,
+                    'needed': min_required - count
+                })
+                results['statistics']['queries_with_insufficient_results'] += 1
+            else:
+                results['statistics']['queries_with_sufficient_results'] += 1
+    
+    # Update total unique queries count
+    results['statistics']['total_unique_queries'] = len(all_queries)
+    
+    return results
+
+
+def save_insufficient_queries(results: Dict, output_file: str, min_required: int = 10):
+    """
+    Save queries with insufficient eval_results.json files to a text file.
+    If a query appears less than min_required times, it will be repeated 
+    to indicate how many more times it needs to be evaluated.
+    """
+    with open(output_file, 'w') as f:
+        # Write insufficient queries (repeated based on how many more are needed)
+        for item in results.get('insufficient_queries', []):
+            query = item['query']
+            needed = item['needed']
+            # Write the query 'needed' times
+            for _ in range(needed):
+                f.write(query + '\n')
+        
+        # Write completely missing queries min_required times
+        for query in results.get('missing_completely', []):
+            for _ in range(min_required):
+                f.write(query + '\n')
+    
+    total_lines = sum(item['needed'] for item in results.get('insufficient_queries', [])) + \
+                  len(results.get('missing_completely', [])) * min_required
+    
+    print(f"\nSaved {total_lines} query lines to {output_file}")
+    print(f"(Queries needing multiple evaluations are repeated)")
+
+
+def generate_completeness_report(results: Dict, min_required: int = 10) -> str:
+    """Generate a detailed report of query completeness."""
+    
+    if not results:
+        return "No results to report."
+    
+    report = []
+    report.append("=" * 80)
+    report.append("QUERY COMPLETENESS REPORT")
+    report.append(f"Minimum required eval_results.json files per query: {min_required}")
+    report.append("=" * 80)
+    
+    stats = results['statistics']
+    report.append("\n📊 STATISTICS:")
+    report.append(f"  Total unique queries found: {stats['total_unique_queries']}")
+    report.append(f"  Queries with sufficient results (>={min_required}): {stats['queries_with_sufficient_results']}")
+    report.append(f"  Queries with insufficient results (<{min_required}): {stats['queries_with_insufficient_results']}")
+    report.append(f"  Queries missing completely: {stats['queries_missing_completely']}")
+    
+    # Report insufficient queries
+    if results['insufficient_queries']:
+        report.append("\n" + "-" * 80)
+        report.append("⚠️  QUERIES WITH INSUFFICIENT RESULTS:")
+        report.append("-" * 80)
+        for item in results['insufficient_queries']:
+            query = item['query']
+            count = item['count']
+            needed = item['needed']
+            report.append(f"\n  Query: {query[:80]}...")
+            report.append(f"    Current count: {count}/{min_required} (needs {needed} more)")
+            locations = results['query_counts'][query]['locations']
+            # Extract round/folder names from paths
+            location_names = []
+            for loc in locations[:5]:
+                parts = loc.split('/')
+                if len(parts) > 0:
+                    location_names.append(parts[0])  # Get the first folder (round/subfolder)
+            report.append(f"    Found in: {', '.join(location_names)}")
+            if len(locations) > 5:
+                report.append(f"              ... and {len(locations) - 5} more")
+    
+    # Report completely missing queries
+    if results['missing_completely']:
+        report.append("\n" + "-" * 80)
+        report.append("❌ QUERIES MISSING COMPLETELY:")
+        report.append("-" * 80)
+        for query in results['missing_completely'][:10]:  # Show first 10
+            report.append(f"  • {query}")
+        if len(results['missing_completely']) > 10:
+            report.append(f"  ... and {len(results['missing_completely']) - 10} more")
+    
+    # Add query count distribution
+    if results.get('query_counts'):
+        report.append("\n" + "-" * 80)
+        report.append("📈 QUERY COUNT DISTRIBUTION:")
+        report.append("-" * 80)
+        count_distribution = defaultdict(list)
+        for query, data in results['query_counts'].items():
+            count = data['count']
+            count_distribution[count].append(query)
+        
+        for count in sorted(count_distribution.keys()):
+            queries_at_count = count_distribution[count]
+            report.append(f"  {count} eval_results.json: {len(queries_at_count)} queries")
+            if count < min_required and len(queries_at_count) <= 3:
+                for q in queries_at_count:
+                    report.append(f"    - {q[:70]}...")
+    
+    # Summary
+    total_missing = sum(item['needed'] for item in results.get('insufficient_queries', [])) + \
+                   len(results.get('missing_completely', [])) * min_required
+    
+    report.append("\n" + "=" * 80)
+    report.append(f"SUMMARY: Need {total_missing} more evaluations to reach {min_required} per query")
+    report.append("=" * 80)
+    
+    return "\n".join(report)
+
+
+def main():
+    """Main function to run the script."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description="Check if each query has at least N eval_results.json files across all subfolders"
+    )
+    parser.add_argument(
+        "path",
+        type=str,
+        help="Path to the model folder (e.g., eval_vbench_results/modelscope)"
+    )
+    parser.add_argument(
+        "--min-required",
+        type=int,
+        default=10,
+        help="Minimum number of eval_results.json files required per query (default: 10)"
+    )
+    parser.add_argument(
+        "--output",
+        type=str,
+        help="Save report to file"
+    )
+    parser.add_argument(
+        "--queries-output",
+        type=str,
+        default="queries_to_evaluate.txt",
+        help="Save queries that need more evaluations to a text file (repeated as needed)"
+    )
+    
+    args = parser.parse_args()
+    
+    print(f"Checking query completeness in: {args.path}")
+    print(f"Minimum required results per query: {args.min_required}")
+    print("-" * 80)
+    
+    # Count query occurrences with expected queries
+    results = count_query_occurrences(args.path, args.min_required, queries_to_evaluate)
+    
+    # Generate report
+    report = generate_completeness_report(results, args.min_required)
+    print("\n" + report)
+    
+    # Save report if requested
+    if args.output:
+        output_path = Path(args.path) / args.output
+        with open(output_path, 'w') as f:
+            f.write(report)
+        print(f"\nReport saved to: {output_path}")
+    
+    # Save queries that need more evaluations
+    if args.queries_output and (results.get('insufficient_queries') or results.get('missing_completely')):
+        output_path = Path(args.path) / args.queries_output
+        save_insufficient_queries(results, output_path, args.min_required)
+    
+    # Return exit code
+    insufficient_count = len(results.get('insufficient_queries', [])) + len(results.get('missing_completely', []))
+    return 0 if insufficient_count == 0 else 1
+
+
+if __name__ == "__main__":
+    exit(main())

eval_agent/eval_agent_for_t2i_compbench.py

@@ -0,0 +1,196 @@
+import os
+import json
+from datetime import datetime
+import argparse
+import Levenshtein
+
+from base_agent import BaseAgent
+from system_prompts import sys_prompts
+from tools import ToolCalling
+from process import *
+import pandas as pd
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Eval-Agent-T2I-CompBench', formatter_class=argparse.RawTextHelpFormatter)
+
+    parser.add_argument(
+        "--user_query",
+        type=str,
+        required=True,
+        help="user query",
+    )
+
+    parser.add_argument(
+        "--model",
+        type=str,
+        required=True,
+        default="sdxl-1",
+        help="model",
+    )
+
+    args = parser.parse_args()
+    return args
+
+
+
+
+def most_similar_string(prompt, string_list):
+    similarities = [Levenshtein.distance(prompt, item) for item in string_list]
+    most_similar_idx = similarities.index(min(similarities))
+    return string_list[most_similar_idx]
+
+
+def check_and_fix_prompt(chosed_prompts, prompt_list):
+    results_dict={}
+
+    for key, item in chosed_prompts.items():
+        item["Prompt"] = most_similar_string(item["Prompt"], prompt_list)
+
+        results_dict[key] = item
+        
+    return results_dict
+
+
+def format_dimension_as_string(df, dimension_name):
+    row = df.loc[df['Dimension'] == dimension_name]
+    if row.empty:
+        return f"No data found for dimension: {dimension_name}"
+    
+    formatted_string = (
+        f"{row['Dimension'].values[0]}: "
+        f"Very High -> {row['Very High'].values[0]}, "
+        f"High -> {row['High'].values[0]}, "
+        f"Moderate -> {row['Moderate'].values[0]}, "
+        f"Low -> {row['Low'].values[0]}, "
+        f"Very Low -> {row['Very Low'].values[0]}"
+    )
+    
+    return formatted_string
+
+
+class EvalAgent:
+    def __init__(self, sample_model="sdxl-1", save_mode="img", refer_file="t2i_comp_dimension_scores.tsv"):
+        self.tools = ToolCalling(sample_model=sample_model, save_mode=save_mode)
+        self.sample_model = sample_model
+        self.user_query = ""
+        self.tsv_file_path = refer_file
+        
+    
+    
+    def init_agent(self):
+        self.prompt_agent = BaseAgent(system_prompt=sys_prompts["t2i-comp-prompt-sys"], use_history=False, temp=0.7)
+        self.plan_agent = BaseAgent(system_prompt=sys_prompts["t2i-comp-plan-sys"], use_history=True, temp=0.7)
+
+
+
+    def sample_and_eval(self, designed_prompts, save_path, tool_name):
+        prompts = [item["Prompt"] for _, item in designed_prompts.items()]
+        video_pairs = self.tools.sample(prompts, save_path)
+        eval_results = self.tools.eval(tool_name, video_pairs)
+        return eval_results
+
+
+    def reference_prompt(self, search_dim):
+        search_item = search_dim.replace("_binding", "")
+        file_path = f"./eval_tools/t2i_comp/prompt_file/{search_item}_val.txt"
+        
+        with open(file_path, "r") as f:
+            lines = f.readlines()
+        lines = [line.strip() for line in lines]
+        
+        return lines
+
+
+
+    def format_eval_result(self, results, reference_table):
+        question = results["Sub-aspect"]
+        tool_name = results["Tool"]
+        average_score = results["eval_results"]["score"][0]
+        video_results = results["eval_results"]["score"][1]
+        
+        
+        output = f"Sub-aspect: {question}\n"
+        output += f"The score categorization table for the numerical results evaluated by the '{tool_name}' is as follows:\n{reference_table}\n\n"
+        output += f"Observation: The evaluation results using '{tool_name}' are summarized below.\n"
+        output += f"Average Score: {average_score:.4f}\n"
+        output += "Detailed Results:\n"
+
+        for i, video in enumerate(video_results, 1):
+            prompt = video["prompt"]
+            score = video["image_results"]
+            output += f"\t{i}. Prompt: {prompt}\n"
+            output += f"\tScore: {score:.4f}\n"
+        
+        return output
+    
+    
+    
+    def update_info(self):
+        folder_name = datetime.now().strftime('%Y-%m-%d-%H:%M:%S') + "-" + self.user_query.replace(" ", "_")
+        self.save_path = f"./eval_t2i_comp_results/{self.sample_model}/{folder_name}"
+        os.makedirs(self.save_path, exist_ok=True)
+        
+        self.image_folder = os.path.join(self.save_path, "images")
+        self.file_name = os.path.join(self.save_path, f"eval_results.json")
+
+
+
+    def explore(self, query, all_chat=[]):
+        
+        self.user_query = query
+        self.update_info()
+        self.init_agent()
+        df = pd.read_csv(self.tsv_file_path, sep='\t')
+        
+        plan_query = query
+        all_chat.append(plan_query)
+        
+        n = 0
+        while True:
+            
+            plans = self.plan_agent(plan_query, parse=True)
+            if plans.get("Analysis"):
+                all_chat.append(plans)
+                print("Finish!")
+                break
+            
+            tool_name = plans["Tool"].lower().strip().replace(" ", "_")
+            reference_table = format_dimension_as_string(df, plans["Tool"])
+            
+            prompt_query = json.dumps(plans)
+            prompt_list = self.reference_prompt(tool_name)
+            prompt_query = f"Context:\n{prompt_query}\n\nPrompt list:\n{json.dumps(prompt_list)}"
+
+            designed_prompts = self.prompt_agent(prompt_query, parse=True)
+            designed_prompts = check_and_fix_prompt(designed_prompts, prompt_list)
+
+
+            plans["eval_results"] = self.sample_and_eval(designed_prompts, self.image_folder, tool_name)
+            plan_query = self.format_eval_result(plans, reference_table=reference_table)
+            all_chat.append(plans)
+            
+            if n > 9:
+                break
+            n += 1
+
+
+        all_chat.append(self.plan_agent.messages)
+        save_json(all_chat, self.file_name)
+
+
+
+
+def main():
+    args = parse_args()
+    user_query = args.user_query
+    eval_agent = EvalAgent(sample_model=args.model, save_mode="img")
+    eval_agent.explore(user_query)      
+
+
+if __name__ == "__main__":
+    main()
+
+
+
+

eval_agent/eval_agent_for_vbench.py

@@ -0,0 +1,207 @@
+import re, time, os
+from tqdm import tqdm
+import json
+from datetime import datetime
+import argparse
+import Levenshtein
+
+from base_agent import BaseAgent
+from system_prompts import sys_prompts
+from tools import ToolCalling
+from process import *
+import pandas as pd
+
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Eval-Agent-VBench', formatter_class=argparse.RawTextHelpFormatter)
+
+    parser.add_argument(
+        "--user_query",
+        type=str,
+        required=True,
+        help="user query",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="latte1",
+        help="target model",
+    )
+
+    args = parser.parse_args()
+    return args
+
+
+
+
+def most_similar_string(prompt, string_list):
+    similarities = [Levenshtein.distance(prompt, item["Prompt"]) for item in string_list]
+    most_similar_idx = similarities.index(min(similarities))
+    return string_list[most_similar_idx]
+
+
+def check_and_fix_prompt(chosed_prompts, prompt_list):
+    results_dict={}
+
+    for key, item in chosed_prompts.items():
+        thought = item["Thought"]
+        sim_item = most_similar_string(item["Prompt"], prompt_list)
+        sim_item["Thought"] = thought
+        results_dict[key] = sim_item
+        
+    return results_dict
+
+
+def format_dimension_as_string(df, dimension_name):
+    row = df.loc[df['Dimension'] == dimension_name]
+    if row.empty:
+        return f"No data found for dimension: {dimension_name}"
+    
+    formatted_string = (
+        f"{row['Dimension'].values[0]}: "
+        f"Very High -> {row['Very High'].values[0]}, "
+        f"High -> {row['High'].values[0]}, "
+        f"Moderate -> {row['Moderate'].values[0]}, "
+        f"Low -> {row['Low'].values[0]}, "
+        f"Very Low -> {row['Very Low'].values[0]}"
+    )
+    
+    return formatted_string
+
+
+
+class EvalAgent:
+    def __init__(self, sample_model="latte1", save_mode="video", refer_file="vbench_dimension_scores.tsv"):
+        # self.tools = ToolCalling(sample_model=sample_model, save_mode=save_mode)
+        self.sample_model = sample_model
+        self.user_query = ""
+        self.tsv_file_path = refer_file
+    
+    def init_agent(self):
+
+        self.prompt_agent = BaseAgent(system_prompt=sys_prompts["vbench-prompt-sys"], use_history=False, temp=0.7)
+        self.plan_agent = BaseAgent(system_prompt=sys_prompts["vbench-plan-sys"], use_history=True, temp=0.7)
+
+
+
+    def search_auxiliary(self, designed_prompts, prompt):
+        for _, value in designed_prompts.items():
+            if value['Prompt'] == prompt:
+                return value["auxiliary_info"]
+        raise "Didn't find auxiliary info, please check your json."
+
+
+    def sample_and_eval(self, designed_prompts, save_path, tool_name):
+        prompts = [item["Prompt"] for _, item in designed_prompts.items()]
+        video_pairs = self.tools.sample(prompts, save_path)
+        if 'auxiliary_info' in designed_prompts["Step 1"]:
+            for item in video_pairs:
+                item["auxiliary_info"] = self.search_auxiliary(designed_prompts, item["prompt"])
+        
+        eval_results = self.tools.eval(tool_name, video_pairs)
+        return eval_results
+
+
+    def reference_prompt(self, search_dim):
+        file_path = "./eval_tools/vbench/VBench_full_info.json"
+        data = json.load(open(file_path, "r"))
+
+        results = []
+        for item in data:
+            if search_dim in item["dimension"]:
+                item.pop("dimension")
+                item["Prompt"] = item.pop("prompt_en")
+                if 'auxiliary_info' in item and search_dim in item['auxiliary_info']:
+                    item["auxiliary_info"] = list(item["auxiliary_info"][search_dim].values())[0]
+                results.append(item)
+        
+        return results
+
+
+
+    def format_eval_result(self, results, reference_table):
+        question = results["Sub-aspect"]
+        tool_name = results["Tool"]
+        average_score = results["eval_results"]["score"][0]
+        video_results = results["eval_results"]["score"][1]
+        
+        
+        output = f"Sub-aspect: {question}\n"
+        output += f"The score categorization table for the numerical results evaluated by the '{tool_name}' is as follows:\n{reference_table}\n\n"
+        output += f"Observation: The evaluation results using '{tool_name}' are summarized below.\n"
+        output += f"Average Score: {average_score:.4f}\n"
+        output += "Detailed Results:\n"
+
+        for i, video in enumerate(video_results, 1):
+            prompt = video["prompt"]
+            score = video["video_results"]
+            output += f"\t{i}. Prompt: {prompt}\n"
+            output += f"\tScore: {score:.4f}\n"
+        
+        return output
+
+
+    def update_info(self):
+        folder_name = datetime.now().strftime('%Y-%m-%d-%H:%M:%S') + "-" + self.user_query.replace(" ", "_")
+        self.save_path = f"./eval_vbench_results/{self.sample_model}/{folder_name}"
+        os.makedirs(self.save_path, exist_ok=True)
+        
+        self.video_folder = os.path.join(self.save_path, "videos")
+        self.file_name = os.path.join(self.save_path, f"eval_results.json")
+
+
+
+    def explore(self, query, all_chat=[]):
+        
+        self.user_query = query
+        self.update_info()
+        self.init_agent()
+        df = pd.read_csv(self.tsv_file_path, sep='\t')
+
+
+        plan_query = query
+        all_chat.append(plan_query)
+        
+        n = 0
+        while True:
+            breakpoint()
+            plans = self.plan_agent(plan_query, parse=True)
+            if plans.get("Analysis"):
+                all_chat.append(plans)
+                print("Finish!")
+                break
+            
+            tool_name = plans["Tool"].lower().strip().replace(" ", "_")
+            reference_table = format_dimension_as_string(df, plans["Tool"])
+            
+            prompt_query = json.dumps(plans)
+            prompt_list = self.reference_prompt(tool_name)
+            prompt_query = f"Context:\n{prompt_query}\n\nPrompt list:\n{json.dumps(prompt_list)}"
+            
+            designed_prompts = self.prompt_agent(prompt_query, parse=True)
+            designed_prompts = check_and_fix_prompt(designed_prompts, prompt_list)
+
+            plans["eval_results"] = self.sample_and_eval(designed_prompts, self.video_folder, tool_name)
+            plan_query = self.format_eval_result(plans, reference_table=reference_table)
+
+            all_chat.append(plans)
+            
+            if n > 9:
+                break
+            n += 1
+
+
+        all_chat.append(self.plan_agent.messages)
+        save_json(all_chat, self.file_name)
+
+
+def main():
+    args = parse_args()
+    user_query = args.user_query
+    eval_agent = EvalAgent(sample_model=args.model, save_mode="video")
+    eval_agent.explore(user_query)
+
+
+if __name__ == "__main__":
+    main()

eval_agent/eval_agent_for_vbench_open.py

@@ -0,0 +1,240 @@
+import re, time, os
+from tqdm import tqdm
+import json
+from datetime import datetime
+import argparse
+import Levenshtein
+
+from base_agent import BaseAgent_SFT, BaseAgent_Open
+from system_prompts import sys_prompts
+from tools import ToolCalling
+from vbench_leaderboard import VBenchLeaderboard
+import pandas as pd
+from process import *
+
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Eval-Agent-VBench', formatter_class=argparse.RawTextHelpFormatter)
+
+    parser.add_argument(
+        "--user_query",
+        type=str,
+        required=True,
+        help="user query",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="latte1",
+        help="target model",
+    )
+    parser.add_argument(
+        "--recommend",
+        action="store_true",
+        help="recommend model",
+    )
+
+    args = parser.parse_args()
+    return args
+
+
+class EvalAgent:
+    def __init__(self, sample_model="latte1", save_mode="video", refer_file="vbench_dimension_scores.tsv", recommend=False):
+        self.tools = ToolCalling(sample_model=sample_model, save_mode=save_mode)
+        self.sample_model = sample_model
+        self.user_query = ""
+        self.tsv_file_path = refer_file
+        self.recommend = recommend
+        
+    def init_agent(self):
+        self.eval_agent = BaseAgent_SFT(system_prompt=sys_prompts["eval-agent-vbench-training-sys"], use_history=True, temp=0.5)
+        # self.prompt_agent = BaseAgent_Open(system_prompt=sys_prompts["vbench-prompt-sys"], use_history=True, temp=0.5)
+        self.prompt_agent = BaseAgent_SFT(system_prompt=sys_prompts["vbench-prompt-sys-open"], use_history=True, temp=0.5, model_name_or_path="http://0.0.0.0:12334/v1/chat/completions")
+
+
+    def recommend_model(self, query):
+        leaderboard = VBenchLeaderboard()
+        recommendations = leaderboard.recommend_model(query, top_k=3)
+        report = leaderboard.generate_recommendation_report(query, recommendations)
+        return report
+    
+    def search_auxiliary(self, designed_prompts, prompt):
+        for _, value in designed_prompts.items():
+            if value['prompt'] == prompt:
+                return value["auxiliary_info"]
+        raise "Didn't find auxiliary info, please check your json."
+
+    def sample_and_eval(self, designed_prompts, save_path, tool_name):
+        try:
+            prompts = [item["prompt"] for _, item in designed_prompts.items()]
+        except:
+            designed_prompts = parse_json(designed_prompts)
+            if isinstance(designed_prompts, list):
+                prompts = [item["prompt"] for item in designed_prompts]
+            else:
+                prompts = [item["prompt"] for _, item in designed_prompts.items()]
+        
+        video_pairs = self.tools.sample(prompts, save_path)
+        if 'auxiliary_info' in designed_prompts["Step 1"]:
+            for item in video_pairs:
+                item["auxiliary_info"] = self.search_auxiliary(designed_prompts, item["prompt"])
+        
+        eval_results = self.tools.eval(tool_name, video_pairs)
+        return eval_results
+
+
+    def reference_prompt(self, search_dim):
+        file_path = "./eval_tools/vbench/VBench_full_info.json"
+        data = json.load(open(file_path, "r"))
+
+        results = []
+        for item in data:
+            if search_dim in item["dimension"]:
+                item.pop("dimension")
+                item["Prompt"] = item.pop("prompt_en")
+                if 'auxiliary_info' in item and search_dim in item['auxiliary_info']:
+                    item["auxiliary_info"] = list(item["auxiliary_info"][search_dim].values())[0]
+                results.append(item)
+        
+        return results
+
+
+
+    # def format_eval_result(self, results, reference_table):
+    #     question = results["Sub-aspect"]
+    #     tool_name = results["Tool"]
+    #     average_score = results["eval_results"]["score"][0]
+    #     video_results = results["eval_results"]["score"][1]
+        
+        
+    #     output = f"Sub-aspect: {question}\n"
+    #     output += f"The score categorization table for the numerical results evaluated by the '{tool_name}' is as follows:\n{reference_table}\n\n"
+    #     output += f"Observation: The evaluation results using '{tool_name}' are summarized below.\n"
+    #     output += f"Average Score: {average_score:.4f}\n"
+    #     output += "Detailed Results:\n"
+
+    #     for i, video in enumerate(video_results, 1):
+    #         prompt = video["prompt"]
+    #         score = video["video_results"]
+    #         output += f"\t{i}. Prompt: {prompt}\n"
+    #         output += f"\tScore: {score:.4f}\n"
+        
+    #     return output
+    def format_eval_results(self, results, reference_table):
+        tool_name = results["tool"]
+        average_score = results["eval_results"]["score"][0]
+        video_results = results["eval_results"]["score"][1]
+        
+
+        # More concise and structured format for SFT
+        output = f"Scoring Reference Table of '{tool_name}': {reference_table}\n\n"
+        output += f"Results:\n"
+        output += f"- Overall score: {average_score:.4f}\n"
+        output += f"- Per-prompt scores:\n"
+
+        for video in video_results:
+            prompt = video["prompt"]
+            score = video["video_results"]
+            output += f"  • \"{prompt}\": {score:.4f}\n"
+        
+        return output
+
+
+    def update_info(self):
+        # folder_name = datetime.now().strftime('%Y-%m-%d-%H:%M:%S') + "-" + self.user_query.replace(" ", "_")
+        folder_name = os.environ["FOLDER_NAME"] if "FOLDER_NAME" in os.environ else datetime.now().strftime('%Y-%m-%d-%H:%M:%S') + "-" + self.user_query.replace(" ", "_")  # the environment folder name categorizes model into different rounds
+        self.save_path = f"./eval_vbench_results/{self.sample_model}/{folder_name}"
+        os.makedirs(self.save_path, exist_ok=True)
+        
+        self.video_folder = os.path.join(self.save_path, "videos")
+        self.file_name = os.path.join(self.save_path, f"eval_results.json")
+
+
+
+    def explore(self, query, all_chat=[]):
+        
+        self.user_query = query
+        self.update_info()
+        self.init_agent()
+        df = pd.read_csv(self.tsv_file_path, sep='\t')
+
+        plan_query = query
+        all_chat.append(plan_query)
+        
+        n = 0
+        
+        start_time = time.time()
+        while True:
+            plans_str = self.eval_agent(plan_query)
+            plans = format_plans(plans_str)
+            
+            if '</summary>' in plans_str:
+                print(f"Finish! Time: {time.time() - start_time:.2f}s")
+                plans["eval_time"] = time.time() - start_time
+                
+                if self.recommend:
+                    print("Generating recommendation report...")
+                    report = self.recommend_model(query)
+                    plans["recommendation_report"] = report
+                    print(f"\nQuery: {query}")
+                    print("-" * 40)
+                    print(report)
+                    print("\n" + "="*80)
+                
+                all_chat.append(plans)
+                break
+            
+            for _ in range(3):
+                try:
+                    tool = plans.get('tool', None)
+                    if tool and tool_existence(tool):
+                        plans["tool"] = tool_existence(tool)
+                        break
+                    else:
+                        # If tool does not exist, regenerate plan_str
+                        plans_str = self.eval_agent(plan_query)
+                        plans = format_plans(plans_str)
+                except Exception as e:
+                    # Safe error message that doesn't assume 'tool' key exists
+                    tool_name = plans.get("tool", "UNKNOWN")
+                    print(f"❌ Tool '{tool_name}' not found or not valid.")
+                    print(f"Generated plan: {plans_str[:200]}...")
+                    print(f"Parsed result: {plans}")
+                    print(f"Error: {e}")
+                    continue  # Try again
+            
+            # tool_name_ori = plans["tool"]
+            # reference_table = format_dimension_as_string(df, tool_name_ori)
+            reference_table = format_dimension_as_string(df, plans["tool"])
+            
+            # tool_name = tool_name_ori.replace(" ", "_").lower() # Subject Consistency -> subject_consistency
+            prompt_list = self.reference_prompt(plans["tool"])
+            prompt_query = f"## Context:\n{json.dumps(plans)}\n\n ## Prompt list:\n{json.dumps(prompt_list)}"
+            
+            designed_prompts = self.prompt_agent(prompt_query)
+            
+            plans["eval_results"] = self.sample_and_eval(designed_prompts, self.video_folder, plans["tool"])
+
+            plan_query = self.format_eval_results(plans, reference_table=reference_table) # NEW plan query, simpler
+
+            all_chat.append(plans)
+            
+            if n > 9:
+                break
+            n += 1
+
+
+        all_chat.append(self.eval_agent.messages)
+        save_json(all_chat, self.file_name)
+
+
+def main():
+    args = parse_args()
+    user_query = args.user_query
+    eval_agent = EvalAgent(sample_model=args.model, save_mode="video", recommend=args.recommend)
+    eval_agent.explore(user_query)
+
+
+if __name__ == "__main__":
+    main()

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/BLIP/train_vqa_func.py

@@ -0,0 +1,214 @@
+'''
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ * By Junnan Li
+'''
+import argparse
+import os
+# import ruamel_yaml as yaml
+try:
+    import ruamel_yaml as yaml
+except ModuleNotFoundError:
+    import ruamel.yaml as yaml
+import numpy as np
+import random
+import time
+import datetime
+import json
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+import torch.backends.cudnn as cudnn
+import torch.distributed as dist
+import sys
+sys.path.append("..") 
+# sys.path.append("/mnt/petrelfs/zhangfan.p/zhangfan/evaluate-agent/agent/eval_tools/t2i_comp/BLIPvqa_eval")
+from models.blip_vqa import blip_vqa
+import utils
+from utils import cosine_lr_schedule
+from data import create_dataset, create_sampler, create_loader
+from data.vqa_dataset import vqa_collate_fn
+from data.utils import save_result
+
+
+def train(model, data_loader, optimizer, epoch, device):
+    # train
+    model.train()
+
+    metric_logger = utils.MetricLogger(delimiter="  ")
+    metric_logger.add_meter('lr', utils.SmoothedValue(window_size=1, fmt='{value:.6f}'))
+    metric_logger.add_meter('loss', utils.SmoothedValue(window_size=1, fmt='{value:.4f}'))
+
+    header = 'Train Epoch: [{}]'.format(epoch)
+    print_freq = 50
+
+    for i,(image, question, answer, weights, n) in enumerate(metric_logger.log_every(data_loader, print_freq, header)):
+        image, weights = image.to(device,non_blocking=True), weights.to(device,non_blocking=True)
+
+        loss = model(image, question, answer, train=True, n=n, weights=weights)
+
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+        metric_logger.update(loss=loss.item())
+        metric_logger.update(lr=optimizer.param_groups[0]["lr"])
+
+    # gather the stats from all processes
+    metric_logger.synchronize_between_processes()
+    print("Averaged stats:", metric_logger.global_avg())
+    return {k: "{:.3f}".format(meter.global_avg) for k, meter in metric_logger.meters.items()}
+
+
+@torch.no_grad()
+def evaluation(model, data_loader, device, config) :
+    # test
+    model.eval()
+
+    metric_logger = utils.MetricLogger(delimiter="  ")
+    header = 'Generate VQA test result:'
+    print_freq = 50
+
+    result = []
+
+    if config['inference']=='rank':
+        answer_list = data_loader.dataset.answer_list
+        answer_candidates = model.tokenizer(answer_list, padding='longest', return_tensors='pt').to(device)
+        answer_candidates.input_ids[:,0] = model.tokenizer.bos_token_id
+
+    for n, (image, question, question_id) in enumerate(metric_logger.log_every(data_loader, print_freq, header)):
+        image = image.to(device,non_blocking=True)
+
+        if config['inference']=='generate':
+            answers = model(image, question, train=False, inference='generate')
+
+            for answer, ques_id in zip(answers, question_id):
+                ques_id = int(ques_id.item())
+                result.append({"question_id":ques_id, "answer":answer})
+
+        elif config['inference']=='rank':
+            answer_ids = model(image, question, answer_candidates, train=False, inference='rank', k_test=config['k_test'])
+
+            for ques_id, answer_id in zip(question_id, answer_ids):
+                result.append({"question_id":int(ques_id.item()), "answer":answer_list[answer_id]})
+
+        elif config['inference'] == 'vqa_prob': #pred yes probability
+            probs = model(image, question, train=False, inference="vqa_prob")
+            for prob, ques_id in zip(probs, question_id):
+                result.append({"question_id":int(ques_id.item()), "answer":prob})
+
+
+    return result
+
+
+def VQA(evaluate, device, seed, distributed, config, result_dir, output_dir):
+    # utils.init_distributed_mode(args)
+
+    device = torch.device(device)
+
+    # fix the seed for reproducibility
+    seed = seed + utils.get_rank()
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    cudnn.benchmark = True
+
+    #### Dataset ####
+    print("Creating vqa datasets")
+    datasets = create_dataset('vqa', config)
+
+    if distributed:
+        num_tasks = utils.get_world_size()
+        global_rank = utils.get_rank()
+        samplers = create_sampler(datasets, [True, False], num_tasks, global_rank)
+    else:
+        samplers = [None, None]
+
+    train_loader, test_loader = create_loader(datasets,samplers,
+                                              batch_size=[config['batch_size_train'],config['batch_size_test']],
+                                              # num_workers=[4,4],is_trains=[True, False],
+                                              num_workers=[1,1],is_trains=[True, False],
+                                              collate_fns=[vqa_collate_fn,None])
+    #### Model ####
+    print("Creating model")
+    model = blip_vqa(pretrained=config['pretrained'], image_size=config['image_size'],
+                       vit=config['vit'], vit_grad_ckpt=config['vit_grad_ckpt'], vit_ckpt_layer=config['vit_ckpt_layer'])
+
+    model = model.to(device)
+
+    model_without_ddp = model
+    if distributed:
+        model = torch.nn.parallel.DistributedDataParallel(model)
+        model_without_ddp = model.module
+
+    optimizer = torch.optim.AdamW(params=model.parameters(), lr=config['init_lr'], weight_decay=config['weight_decay'])
+
+    best = 0
+    best_epoch = 0
+
+    print("Start training")
+    start_time = time.time()
+    for epoch in range(0, config['max_epoch']):
+        if not evaluate:
+            if distributed:
+                train_loader.sampler.set_epoch(epoch)
+
+            cosine_lr_schedule(optimizer, epoch, config['max_epoch'], config['init_lr'], config['min_lr'])
+
+            train_stats = train(model, train_loader, optimizer, epoch, device)
+
+        else:
+            break
+
+        if utils.is_main_process():
+            log_stats = {**{f'train_{k}': v for k, v in train_stats.items()},
+                         'epoch': epoch,
+                        }
+            with open(os.path.join(output_dir, "log.txt"),"a") as f:
+                f.write(json.dumps(log_stats) + "\n")
+
+            save_obj = {
+                'model': model_without_ddp.state_dict(),
+                'optimizer': optimizer.state_dict(),
+                'config': config,
+                'epoch': epoch,
+            }
+            torch.save(save_obj, os.path.join(output_dir, 'checkpoint_%02d.pth'%epoch))
+
+        dist.barrier()
+
+    vqa_result = evaluation(model_without_ddp, test_loader, device, config)
+    result_file = save_result(vqa_result, result_dir, 'vqa_result')
+
+    total_time = time.time() - start_time
+    total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+    print('Training time {}'.format(total_time_str))
+    return vqa_result
+
+
+def VQA_main(ann_root,output_dir,inference='vqa_prob'): #annotation path, output path
+    config = '/mnt/petrelfs/zhangfan.p/zhangfan/evaluate-agent/agent/eval_tools/t2i_comp/BLIPvqa_eval/configs/vqa.yaml' # 'configs/vqa.yaml' #todo config file
+    evaluate = True
+    device = 'cuda'
+    seed = 42
+    distributed = False
+
+    config = yaml.load(open(config, 'r'), Loader=yaml.Loader)
+
+    config['ann_root']=ann_root
+    config['inference'] = inference
+
+    result_dir = os.path.join(output_dir, 'result')
+
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    Path(result_dir).mkdir(parents=True, exist_ok=True)
+
+    yaml.dump(config, open(os.path.join(output_dir, 'config.yaml'), 'w'))
+
+    result = VQA(evaluate, device, seed, distributed, config, result_dir, output_dir)
+    return result #list("question_id":0,"answer":yes)

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/BLIP/utils.py

@@ -0,0 +1,284 @@
+import math
+def cosine_lr_schedule(optimizer, epoch, max_epoch, init_lr, min_lr):
+    """Decay the learning rate"""
+    lr = (init_lr - min_lr) * 0.5 * (1. + math.cos(math.pi * epoch / max_epoch)) + min_lr
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr
+        
+def warmup_lr_schedule(optimizer, step, max_step, init_lr, max_lr):
+    """Warmup the learning rate"""
+    lr = min(max_lr, init_lr + (max_lr - init_lr) * step / max_step)
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr    
+
+def step_lr_schedule(optimizer, epoch, init_lr, min_lr, decay_rate):        
+    """Decay the learning rate"""
+    lr = max(min_lr, init_lr * (decay_rate**epoch))
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr    
+        
+import numpy as np
+import io
+import os
+import time
+from collections import defaultdict, deque
+import datetime
+
+import torch
+import torch.distributed as dist
+
+class SmoothedValue(object):
+    """Track a series of values and provide access to smoothed values over a
+    window or the global series average.
+    """
+
+    def __init__(self, window_size=20, fmt=None):
+        if fmt is None:
+            fmt = "{median:.4f} ({global_avg:.4f})"
+        self.deque = deque(maxlen=window_size)
+        self.total = 0.0
+        self.count = 0
+        self.fmt = fmt
+
+    def update(self, value, n=1):
+        self.deque.append(value)
+        self.count += n
+        self.total += value * n
+
+    def synchronize_between_processes(self):
+        """
+        Warning: does not synchronize the deque!
+        """
+        if not is_dist_avail_and_initialized():
+            return
+        t = torch.tensor([self.count, self.total], dtype=torch.float64, device='cuda')
+        dist.barrier()
+        dist.all_reduce(t)
+        t = t.tolist()
+        self.count = int(t[0])
+        self.total = t[1]
+
+    @property
+    def median(self):
+        d = torch.tensor(list(self.deque))
+        return d.median().item()
+
+    @property
+    def avg(self):
+        d = torch.tensor(list(self.deque), dtype=torch.float32)
+        return d.mean().item()
+
+    @property
+    def global_avg(self):
+        return self.total / self.count
+
+    @property
+    def max(self):
+        return max(self.deque)
+
+    @property
+    def value(self):
+        return self.deque[-1]
+
+    def __str__(self):
+        return self.fmt.format(
+            median=self.median,
+            avg=self.avg,
+            global_avg=self.global_avg,
+            max=self.max,
+            value=self.value)
+
+
+class MetricLogger(object):
+    def __init__(self, delimiter="\t"):
+        self.meters = defaultdict(SmoothedValue)
+        self.delimiter = delimiter
+
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if isinstance(v, torch.Tensor):
+                v = v.item()
+            assert isinstance(v, (float, int))
+            self.meters[k].update(v)
+
+    def __getattr__(self, attr):
+        if attr in self.meters:
+            return self.meters[attr]
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        raise AttributeError("'{}' object has no attribute '{}'".format(
+            type(self).__name__, attr))
+
+    def __str__(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append(
+                "{}: {}".format(name, str(meter))
+            )
+        return self.delimiter.join(loss_str)
+
+    def global_avg(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append(
+                "{}: {:.4f}".format(name, meter.global_avg)
+            )
+        return self.delimiter.join(loss_str)    
+    
+    def synchronize_between_processes(self):
+        for meter in self.meters.values():
+            meter.synchronize_between_processes()
+
+    def add_meter(self, name, meter):
+        self.meters[name] = meter
+
+    def log_every(self, iterable, print_freq, header=None):
+        i = 0
+        if not header:
+            header = ''
+        start_time = time.time()
+        end = time.time()
+        iter_time = SmoothedValue(fmt='{avg:.4f}')
+        data_time = SmoothedValue(fmt='{avg:.4f}')
+        space_fmt = ':' + str(len(str(len(iterable)))) + 'd'
+        log_msg = [
+            header,
+            '[{0' + space_fmt + '}/{1}]',
+            'eta: {eta}',
+            '{meters}',
+            'time: {time}',
+            'data: {data}'
+        ]
+        if torch.cuda.is_available():
+            log_msg.append('max mem: {memory:.0f}')
+        log_msg = self.delimiter.join(log_msg)
+        MB = 1024.0 * 1024.0
+        for obj in iterable:
+            data_time.update(time.time() - end)
+            yield obj
+            iter_time.update(time.time() - end)
+            if i % print_freq == 0 or i == len(iterable) - 1:
+                eta_seconds = iter_time.global_avg * (len(iterable) - i)
+                eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
+                if torch.cuda.is_available():
+                    print(log_msg.format(
+                        i, len(iterable), eta=eta_string,
+                        meters=str(self),
+                        time=str(iter_time), data=str(data_time),
+                        memory=torch.cuda.max_memory_allocated() / MB))
+                else:
+                    print(log_msg.format(
+                        i, len(iterable), eta=eta_string,
+                        meters=str(self),
+                        time=str(iter_time), data=str(data_time)))
+            i += 1
+            end = time.time()
+        total_time = time.time() - start_time
+        total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+        print('{} Total time: {} ({:.4f} s / it)'.format(
+            header, total_time_str, total_time / len(iterable)))
+        
+
+class AttrDict(dict):
+    def __init__(self, *args, **kwargs):
+        super(AttrDict, self).__init__(*args, **kwargs)
+        self.__dict__ = self
+
+
+def compute_acc(logits, label, reduction='mean'):
+    ret = (torch.argmax(logits, dim=1) == label).float()
+    if reduction == 'none':
+        return ret.detach()
+    elif reduction == 'mean':
+        return ret.mean().item()
+
+def compute_n_params(model, return_str=True):
+    tot = 0
+    for p in model.parameters():
+        w = 1
+        for x in p.shape:
+            w *= x
+        tot += w
+    if return_str:
+        if tot >= 1e6:
+            return '{:.1f}M'.format(tot / 1e6)
+        else:
+            return '{:.1f}K'.format(tot / 1e3)
+    else:
+        return tot
+
+def setup_for_distributed(is_master):
+    """
+    This function disables printing when not in master process
+    """
+    import builtins as __builtin__
+    builtin_print = __builtin__.print
+
+    def print(*args, **kwargs):
+        force = kwargs.pop('force', False)
+        if is_master or force:
+            builtin_print(*args, **kwargs)
+
+    __builtin__.print = print
+
+
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+
+def get_world_size():
+    if not is_dist_avail_and_initialized():
+        return 1
+    return dist.get_world_size()
+
+
+def get_rank():
+    if not is_dist_avail_and_initialized():
+        return 0
+    return dist.get_rank()
+
+
+def is_main_process():
+    return get_rank() == 0
+
+
+def save_on_master(*args, **kwargs):
+    if is_main_process():
+        torch.save(*args, **kwargs)
+
+
+def init_distributed_mode(args):
+    #加入校验，看是否已经initialize了
+    if not dist.is_available():
+        return
+    if dist.is_initialized():
+        return
+
+    if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ:
+        args.rank = int(os.environ["RANK"])
+        args.world_size = int(os.environ['WORLD_SIZE'])
+        args.gpu = int(os.environ['LOCAL_RANK'])
+    elif 'SLURM_PROCID' in os.environ:
+        args.rank = int(os.environ['SLURM_PROCID'])
+        args.gpu = args.rank % torch.cuda.device_count()
+    else:
+        print('Not using distributed mode')
+        args.distributed = False
+        return
+
+    args.distributed = True
+
+    torch.cuda.set_device(args.gpu)
+    args.dist_backend = 'nccl'
+    print('| distributed init (rank {}, word {}): {}'.format(
+        args.rank, args.world_size, args.dist_url), flush=True)
+    torch.distributed.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
+                                         world_size=args.world_size, rank=args.rank)
+    torch.distributed.barrier()
+    setup_for_distributed(args.rank == 0)        
+        
+        

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/BLIP_vqa.py

@@ -0,0 +1,131 @@
+import argparse
+import os
+
+import torch
+
+from tqdm import tqdm, trange
+
+
+import json
+from tqdm.auto import tqdm
+import sys
+import spacy
+
+from BLIP.train_vqa_func import VQA_main
+
+def Create_annotation_for_BLIP(image_folder, outpath, np_index=None):
+    nlp = spacy.load("en_core_web_sm")
+
+    annotations = []
+    file_names = os.listdir(image_folder)
+    file_names.sort(key=lambda x: int(x.split("_")[-1].split('.')[0]))#sort
+
+
+    cnt=0
+
+    #output annotation.json
+    for file_name in file_names:
+        image_dict={}
+        image_dict['image'] = image_folder+file_name
+        image_dict['question_id']= cnt
+        f = file_name.split('_')[0]
+        doc = nlp(f)
+        
+        noun_phrases = []
+        for chunk in doc.noun_chunks:
+            if chunk.text not in ['top', 'the side', 'the left', 'the right']:  # todo remove some phrases
+                noun_phrases.append(chunk.text)
+        if(len(noun_phrases)>np_index):
+            q_tmp = noun_phrases[np_index]
+            image_dict['question']=f'{q_tmp}?'
+        else:
+            image_dict['question'] = ''
+            
+
+        image_dict['dataset']="color"
+        cnt+=1
+
+        annotations.append(image_dict)
+
+    print('Number of Processed Images:', len(annotations))
+
+    json_file = json.dumps(annotations)
+    with open(f'{outpath}/vqa_test.json', 'w') as f:
+        f.write(json_file)
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="BLIP vqa evaluation.")
+    parser.add_argument(
+        "--out_dir",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to output BLIP vqa score",
+    )
+    parser.add_argument(
+        "--np_num",
+        type=int,
+        default=8,
+        help="Noun phrase number, can be greater or equal to the actual noun phrase number",
+    )
+    args = parser.parse_args()
+    return args
+
+def main():
+    args = parse_args()
+    np_index = args.np_num #how many noun phrases
+
+    answer = []
+    sample_num = len(os.listdir(os.path.join(args.out_dir,"samples")))
+    reward = torch.zeros((sample_num, np_index)).to(device='cuda')
+
+    out_dir = args.out_dir
+
+    order="_blip" #rename file
+    for i in tqdm(range(np_index)):
+        print(f"start VQA{i+1}/{np_index}!")
+        os.makedirs(f"{out_dir}/annotation{i + 1}{order}", exist_ok=True)
+        os.makedirs(f"{out_dir}/annotation{i + 1}{order}/VQA/", exist_ok=True)
+        Create_annotation_for_BLIP(
+            f"{out_dir}/samples/",
+            f"{out_dir}/annotation{i + 1}{order}",
+            np_index=i,
+        )
+        answer_tmp = VQA_main(f"{out_dir}/annotation{i + 1}{order}/",
+                              f"{out_dir}/annotation{i + 1}{order}/VQA/")
+        answer.append(answer_tmp)
+
+        with open(f"{out_dir}/annotation{i + 1}{order}/VQA/result/vqa_result.json", "r") as file:
+            r = json.load(file)
+        with open(f"{out_dir}/annotation{i + 1}{order}/vqa_test.json", "r") as file:
+            r_tmp = json.load(file)
+        for k in range(len(r)):
+            if(r_tmp[k]['question']!=''):
+                reward[k][i] = float(r[k]["answer"])
+            else:
+                reward[k][i] = 1
+        print(f"end VQA{i+1}/{np_index}!")
+    reward_final = reward[:,0]
+    for i in range(1,np_index):
+        reward_final *= reward[:,i]
+
+    #output final json
+    with open(f"{out_dir}/annotation{i + 1}{order}/VQA/result/vqa_result.json", "r") as file:
+        r = json.load(file)
+    reward_after=0
+    for k in range(len(r)):
+        r[k]["answer"] = '{:.4f}'.format(reward_final[k].item())
+        reward_after+=float(r[k]["answer"])
+    os.makedirs(f"{out_dir}/annotation{order}", exist_ok=True)
+    with open(f"{out_dir}/annotation{order}/vqa_result.json", "w") as file:
+        json.dump(r, file)
+
+    # calculate avg of BLIP-VQA as BLIP-VQA score
+    print("BLIP-VQA score:", reward_after/len(r),'!\n')
+    with open(f"{out_dir}/annotation{order}/blip_vqa_score.txt", "w") as file:
+        file.write("BLIP-VQA score:"+str(reward_after/len(r)))
+
+
+
+if __name__ == "__main__":
+    main()

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/BLIP_vqa_eval_agent.py

@@ -0,0 +1,127 @@
+import argparse
+import os
+
+import torch
+
+from tqdm import tqdm, trange
+
+
+import json
+from tqdm.auto import tqdm
+import sys
+import spacy
+
+from eval_tools.t2i_comp.BLIPvqa_eval.BLIP.train_vqa_func import VQA_main
+import shutil
+import secrets
+import string
+
+def Create_annotation_for_BLIP(image_pairs, outpath, np_index=None):
+    nlp = spacy.load("en_core_web_sm")
+
+    annotations = []
+    cnt=0
+
+    for info in image_pairs:
+        
+        image_dict={}
+        image_dict['image'] = info["content_path"]
+        image_dict['question_id']= cnt
+        f = info["prompt"]
+        doc = nlp(f)
+        
+        noun_phrases = []
+        for chunk in doc.noun_chunks:
+            if chunk.text not in ['top', 'the side', 'the left', 'the right']:  # todo remove some phrases
+                noun_phrases.append(chunk.text)
+        if(len(noun_phrases)>np_index):
+            q_tmp = noun_phrases[np_index]
+            image_dict['question']=f'{q_tmp}?'
+        else:
+            image_dict['question'] = ''
+            
+
+        image_dict['dataset']="color"
+        cnt+=1
+
+        annotations.append(image_dict)
+
+    print('Number of Processed Images:', len(annotations))
+
+    json_file = json.dumps(annotations)
+    with open(f'{outpath}/vqa_test.json', 'w') as f:
+        f.write(json_file)
+
+
+
+def blip_vqa(out_dir, image_pairs, np_num=8):
+
+    np_index = np_num #how many noun phrases
+
+    answer = []
+    sample_num = len(image_pairs)
+    reward = torch.zeros((sample_num, np_index)).to(device='cuda')
+
+
+    order="_blip" #rename file
+    for i in tqdm(range(np_index)):
+        print(f"start VQA{i+1}/{np_index}!")
+        os.makedirs(f"{out_dir}/annotation{i + 1}{order}", exist_ok=True)
+        os.makedirs(f"{out_dir}/annotation{i + 1}{order}/VQA/", exist_ok=True)
+        Create_annotation_for_BLIP(
+            image_pairs,
+            f"{out_dir}/annotation{i + 1}{order}",
+            np_index=i,
+        )
+        answer_tmp = VQA_main(f"{out_dir}/annotation{i + 1}{order}/",
+                              f"{out_dir}/annotation{i + 1}{order}/VQA/")
+        answer.append(answer_tmp)
+
+        with open(f"{out_dir}/annotation{i + 1}{order}/VQA/result/vqa_result.json", "r") as file:
+            r = json.load(file)
+        with open(f"{out_dir}/annotation{i + 1}{order}/vqa_test.json", "r") as file:
+            r_tmp = json.load(file)
+        for k in range(len(r)):
+            if(r_tmp[k]['question']!=''):
+                reward[k][i] = float(r[k]["answer"])
+            else:
+                reward[k][i] = 1
+        print(f"end VQA{i+1}/{np_index}!")
+    reward_final = reward[:,0]
+    for i in range(1,np_index):
+        reward_final *= reward[:,i]
+
+    #output final json
+    with open(f"{out_dir}/annotation{i + 1}{order}/VQA/result/vqa_result.json", "r") as file:
+        r = json.load(file)
+    reward_after=0
+    for k in range(len(r)):
+        r[k]["answer"] = '{:.4f}'.format(reward_final[k].item())
+        reward_after+=float(r[k]["answer"])
+    
+    results = []
+    for info_image, info_result in zip(image_pairs, r): 
+        results.append({'prompt':info_image["prompt"], 'image_path': info_image["content_path"], 'image_results': float(info_result["answer"])})
+    
+    avg_score = reward_after/len(r)
+    
+    return {
+        "score":[avg_score, results] 
+    }
+
+
+
+def generate_secure_random_number(length):
+    digits = string.digits
+    secure_random_number = ''.join(secrets.choice(digits) for i in range(length))
+    return secure_random_number
+
+
+def calculate_attribute_binding(image_pairs):
+    random_string = image_pairs[-1]["prompt"].replace(" ","_")+generate_secure_random_number(7)
+    out_path = "./folder_temporary_" + random_string
+    eval_results = blip_vqa(out_path, image_pairs, np_num=8)
+    shutil.rmtree(out_path)
+    return eval_results
+
+

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/configs/bert_config.json

@@ -0,0 +1,21 @@
+{
+  "architectures": [
+    "BertModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "type_vocab_size": 2,
+  "vocab_size": 30522,
+  "encoder_width": 768,
+  "add_cross_attention": true   
+}

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/configs/med_config.json

@@ -0,0 +1,21 @@
+{
+  "architectures": [
+    "BertModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "type_vocab_size": 2,
+  "vocab_size": 30524,
+  "encoder_width": 768,
+  "add_cross_attention": true   
+}

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/configs/vqa.yaml

@@ -0,0 +1,24 @@
+vqa_root: '/export/share/datasets/vision/VQA/Images/mscoco/' #followed by train2014/
+vg_root: '/export/share/datasets/vision/visual-genome/'  #followed by image/
+train_files: ['vqa_train','vqa_val','vg_qa']
+ann_root: ''
+
+# set pretrained as a file path or an url
+pretrained: 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_vqa_capfilt_large.pth'
+
+# size of vit model; base or large
+vit: 'base'
+batch_size_train: 16 
+batch_size_test: 32 
+vit_grad_ckpt: False
+vit_ckpt_layer: 0
+init_lr: 2e-5
+
+image_size: 480
+
+inference: 'vqa_prob'
+
+# optimizer
+weight_decay: 0.05
+min_lr: 0
+max_epoch: 10

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/models/blip.py

@@ -0,0 +1,238 @@
+'''
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ * By Junnan Li
+'''
+import warnings
+warnings.filterwarnings("ignore")
+
+from models.vit import VisionTransformer, interpolate_pos_embed
+from models.med import BertConfig, BertModel, BertLMHeadModel
+from transformers import BertTokenizer
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+import os
+from urllib.parse import urlparse
+from timm.models.hub import download_cached_file
+
+class BLIP_Base(nn.Module):
+    def __init__(self,                 
+                 med_config = 'configs/med_config.json',  
+                 image_size = 224,
+                 vit = 'base',
+                 vit_grad_ckpt = False,
+                 vit_ckpt_layer = 0,                 
+                 ):
+        """
+        Args:
+            med_config (str): path for the mixture of encoder-decoder model's configuration file
+            image_size (int): input image size
+            vit (str): model size of vision transformer
+        """               
+        super().__init__()
+        
+        self.visual_encoder, vision_width = create_vit(vit,image_size, vit_grad_ckpt, vit_ckpt_layer)
+        self.tokenizer = init_tokenizer()   
+        med_config = BertConfig.from_json_file(med_config)
+        med_config.encoder_width = vision_width
+        self.text_encoder = BertModel(config=med_config, add_pooling_layer=False)  
+
+        
+    def forward(self, image, caption, mode):
+        
+        assert mode in ['image', 'text', 'multimodal'], "mode parameter must be image, text, or multimodal"
+        text = self.tokenizer(caption, return_tensors="pt").to(image.device) 
+        
+        if mode=='image':    
+            # return image features
+            image_embeds = self.visual_encoder(image)             
+            return image_embeds
+        
+        elif mode=='text':
+            # return text features
+            text_output = self.text_encoder(text.input_ids, attention_mask = text.attention_mask,                      
+                                            return_dict = True, mode = 'text')  
+            return text_output.last_hidden_state
+        
+        elif mode=='multimodal':
+            # return multimodel features
+            image_embeds = self.visual_encoder(image)    
+            image_atts = torch.ones(image_embeds.size()[:-1],dtype=torch.long).to(image.device)      
+            
+            text.input_ids[:,0] = self.tokenizer.enc_token_id
+            output = self.text_encoder(text.input_ids,
+                                       attention_mask = text.attention_mask,
+                                       encoder_hidden_states = image_embeds,
+                                       encoder_attention_mask = image_atts,      
+                                       return_dict = True,
+                                      )              
+            return output.last_hidden_state
+        
+        
+        
+class BLIP_Decoder(nn.Module):
+    def __init__(self,                 
+                 med_config = 'configs/med_config.json',  
+                 image_size = 384,
+                 vit = 'base',
+                 vit_grad_ckpt = False,
+                 vit_ckpt_layer = 0,
+                 prompt = 'a picture of ',
+                 ):
+        """
+        Args:
+            med_config (str): path for the mixture of encoder-decoder model's configuration file
+            image_size (int): input image size
+            vit (str): model size of vision transformer
+        """            
+        super().__init__()
+        
+        self.visual_encoder, vision_width = create_vit(vit,image_size, vit_grad_ckpt, vit_ckpt_layer)
+        self.tokenizer = init_tokenizer()   
+        med_config = BertConfig.from_json_file(med_config)
+        med_config.encoder_width = vision_width
+        self.text_decoder = BertLMHeadModel(config=med_config)    
+        
+        self.prompt = prompt
+        self.prompt_length = len(self.tokenizer(self.prompt).input_ids)-1
+
+        
+    def forward(self, image, caption):
+        
+        image_embeds = self.visual_encoder(image) 
+        image_atts = torch.ones(image_embeds.size()[:-1],dtype=torch.long).to(image.device)
+        
+        text = self.tokenizer(caption, padding='longest', truncation=True, max_length=40, return_tensors="pt").to(image.device) 
+        
+        text.input_ids[:,0] = self.tokenizer.bos_token_id
+        
+        decoder_targets = text.input_ids.masked_fill(text.input_ids == self.tokenizer.pad_token_id, -100)         
+        decoder_targets[:,:self.prompt_length] = -100
+     
+        decoder_output = self.text_decoder(text.input_ids, 
+                                           attention_mask = text.attention_mask, 
+                                           encoder_hidden_states = image_embeds,
+                                           encoder_attention_mask = image_atts,                  
+                                           labels = decoder_targets,
+                                           return_dict = True,   
+                                          )   
+        loss_lm = decoder_output.loss
+        
+        return loss_lm
+        
+    def generate(self, image, sample=False, num_beams=3, max_length=30, min_length=10, top_p=0.9, repetition_penalty=1.0):
+        image_embeds = self.visual_encoder(image)
+
+        if not sample:
+            image_embeds = image_embeds.repeat_interleave(num_beams,dim=0)
+            
+        image_atts = torch.ones(image_embeds.size()[:-1],dtype=torch.long).to(image.device)
+        model_kwargs = {"encoder_hidden_states": image_embeds, "encoder_attention_mask":image_atts}
+        
+        prompt = [self.prompt] * image.size(0)
+        input_ids = self.tokenizer(prompt, return_tensors="pt").input_ids.to(image.device) 
+        input_ids[:,0] = self.tokenizer.bos_token_id
+        input_ids = input_ids[:, :-1] 
+
+        if sample:
+            #nucleus sampling
+            outputs = self.text_decoder.generate(input_ids=input_ids,
+                                                  max_length=max_length,
+                                                  min_length=min_length,
+                                                  do_sample=True,
+                                                  top_p=top_p,
+                                                  num_return_sequences=1,
+                                                  eos_token_id=self.tokenizer.sep_token_id,
+                                                  pad_token_id=self.tokenizer.pad_token_id, 
+                                                  repetition_penalty=1.1,                                            
+                                                  **model_kwargs)
+        else:
+            #beam search
+            outputs = self.text_decoder.generate(input_ids=input_ids,
+                                                  max_length=max_length,
+                                                  min_length=min_length,
+                                                  num_beams=num_beams,
+                                                  eos_token_id=self.tokenizer.sep_token_id,
+                                                  pad_token_id=self.tokenizer.pad_token_id,     
+                                                  repetition_penalty=repetition_penalty,
+                                                  **model_kwargs)            
+            
+        captions = []    
+        for output in outputs:
+            caption = self.tokenizer.decode(output, skip_special_tokens=True)    
+            captions.append(caption[len(self.prompt):])
+        return captions
+    
+
+def blip_decoder(pretrained='',**kwargs):
+    model = BLIP_Decoder(**kwargs)
+    if pretrained:
+        model,msg = load_checkpoint(model,pretrained)
+        assert(len(msg.missing_keys)==0)
+    return model    
+    
+def blip_feature_extractor(pretrained='',**kwargs):
+    model = BLIP_Base(**kwargs)
+    if pretrained:
+        model,msg = load_checkpoint(model,pretrained)
+        assert(len(msg.missing_keys)==0)
+    return model        
+
+def init_tokenizer():
+    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+    tokenizer.add_special_tokens({'bos_token':'[DEC]'})
+    tokenizer.add_special_tokens({'additional_special_tokens':['[ENC]']})       
+    tokenizer.enc_token_id = tokenizer.additional_special_tokens_ids[0]  
+    return tokenizer
+
+
+def create_vit(vit, image_size, use_grad_checkpointing=False, ckpt_layer=0, drop_path_rate=0):
+        
+    assert vit in ['base', 'large'], "vit parameter must be base or large"
+    if vit=='base':
+        vision_width = 768
+        visual_encoder = VisionTransformer(img_size=image_size, patch_size=16, embed_dim=vision_width, depth=12, 
+                                           num_heads=12, use_grad_checkpointing=use_grad_checkpointing, ckpt_layer=ckpt_layer,
+                                           drop_path_rate=0 or drop_path_rate
+                                          )   
+    elif vit=='large':
+        vision_width = 1024
+        visual_encoder = VisionTransformer(img_size=image_size, patch_size=16, embed_dim=vision_width, depth=24, 
+                                           num_heads=16, use_grad_checkpointing=use_grad_checkpointing, ckpt_layer=ckpt_layer,
+                                           drop_path_rate=0.1 or drop_path_rate
+                                          )   
+    return visual_encoder, vision_width
+
+def is_url(url_or_filename):
+    parsed = urlparse(url_or_filename)
+    return parsed.scheme in ("http", "https")
+
+def load_checkpoint(model,url_or_filename):
+    if is_url(url_or_filename):
+        cached_file = download_cached_file(url_or_filename, check_hash=False, progress=True)
+        checkpoint = torch.load(cached_file, map_location='cpu') 
+    elif os.path.isfile(url_or_filename):        
+        checkpoint = torch.load(url_or_filename, map_location='cpu') 
+    else:
+        raise RuntimeError('checkpoint url or path is invalid')
+        
+    state_dict = checkpoint['model']
+    
+    state_dict['visual_encoder.pos_embed'] = interpolate_pos_embed(state_dict['visual_encoder.pos_embed'],model.visual_encoder) 
+    if 'visual_encoder_m.pos_embed' in model.state_dict().keys():
+        state_dict['visual_encoder_m.pos_embed'] = interpolate_pos_embed(state_dict['visual_encoder_m.pos_embed'],
+                                                                         model.visual_encoder_m)    
+    for key in model.state_dict().keys():
+        if key in state_dict.keys():
+            if state_dict[key].shape!=model.state_dict()[key].shape:
+                del state_dict[key]
+    
+    msg = model.load_state_dict(state_dict,strict=False)
+    print('load checkpoint from %s'%url_or_filename)  
+    return model,msg
+    

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/models/blip_pretrain.py

@@ -0,0 +1,339 @@
+'''
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ * By Junnan Li
+'''
+from models.med import BertConfig, BertModel, BertLMHeadModel
+from transformers import BertTokenizer
+import transformers
+transformers.logging.set_verbosity_error()
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from models.blip import create_vit, init_tokenizer, load_checkpoint
+
+class BLIP_Pretrain(nn.Module):
+    def __init__(self,                 
+                 med_config = 'configs/bert_config.json',  
+                 image_size = 224,
+                 vit = 'base',
+                 vit_grad_ckpt = False,
+                 vit_ckpt_layer = 0,                    
+                 embed_dim = 256,     
+                 queue_size = 57600,
+                 momentum = 0.995,
+                 ):
+        """
+        Args:
+            med_config (str): path for the mixture of encoder-decoder model's configuration file
+            image_size (int): input image size
+            vit (str): model size of vision transformer
+        """               
+        super().__init__()
+        
+        self.visual_encoder, vision_width = create_vit(vit,image_size, vit_grad_ckpt, vit_ckpt_layer, 0)
+        
+        if vit=='base':
+            checkpoint = torch.hub.load_state_dict_from_url(
+                url="https://dl.fbaipublicfiles.com/deit/deit_base_patch16_224-b5f2ef4d.pth",
+                map_location="cpu", check_hash=True)
+            state_dict = checkpoint["model"]     
+            msg = self.visual_encoder.load_state_dict(state_dict,strict=False)
+        elif vit=='large':
+            from timm.models.helpers import load_custom_pretrained
+            from timm.models.vision_transformer import default_cfgs
+            load_custom_pretrained(self.visual_encoder,default_cfgs['vit_large_patch16_224_in21k'])        
+               
+        self.tokenizer = init_tokenizer()   
+        encoder_config = BertConfig.from_json_file(med_config)
+        encoder_config.encoder_width = vision_width
+        self.text_encoder = BertModel.from_pretrained('bert-base-uncased',config=encoder_config, add_pooling_layer=False)
+        self.text_encoder.resize_token_embeddings(len(self.tokenizer)) 
+
+        text_width = self.text_encoder.config.hidden_size
+        
+        self.vision_proj = nn.Linear(vision_width, embed_dim)
+        self.text_proj = nn.Linear(text_width, embed_dim)
+
+        self.itm_head = nn.Linear(text_width, 2) 
+        
+        # create momentum encoders  
+        self.visual_encoder_m, vision_width = create_vit(vit,image_size)              
+        self.vision_proj_m = nn.Linear(vision_width, embed_dim)
+        self.text_encoder_m = BertModel(config=encoder_config, add_pooling_layer=False)      
+        self.text_proj_m = nn.Linear(text_width, embed_dim)
+        
+        self.model_pairs = [[self.visual_encoder,self.visual_encoder_m],
+                            [self.vision_proj,self.vision_proj_m],
+                            [self.text_encoder,self.text_encoder_m],
+                            [self.text_proj,self.text_proj_m],
+                           ]       
+        self.copy_params()
+
+        # create the queue
+        self.register_buffer("image_queue", torch.randn(embed_dim, queue_size))
+        self.register_buffer("text_queue", torch.randn(embed_dim, queue_size))
+        self.register_buffer("queue_ptr", torch.zeros(1, dtype=torch.long))  
+
+        self.image_queue = nn.functional.normalize(self.image_queue, dim=0)
+        self.text_queue = nn.functional.normalize(self.text_queue, dim=0)
+        
+        self.queue_size = queue_size
+        self.momentum = momentum
+        self.temp = nn.Parameter(0.07*torch.ones([]))   
+        
+        # create the decoder
+        decoder_config = BertConfig.from_json_file(med_config)
+        decoder_config.encoder_width = vision_width        
+        self.text_decoder = BertLMHeadModel.from_pretrained('bert-base-uncased',config=decoder_config)    
+        self.text_decoder.resize_token_embeddings(len(self.tokenizer)) 
+        tie_encoder_decoder_weights(self.text_encoder,self.text_decoder.bert,'','/attention')
+        
+        
+    def forward(self, image, caption, alpha):
+        with torch.no_grad():
+            self.temp.clamp_(0.001,0.5)
+        
+        image_embeds = self.visual_encoder(image) 
+        image_atts = torch.ones(image_embeds.size()[:-1],dtype=torch.long).to(image.device)        
+        image_feat = F.normalize(self.vision_proj(image_embeds[:,0,:]),dim=-1)          
+        
+        text = self.tokenizer(caption, padding='max_length', truncation=True, max_length=30, 
+                              return_tensors="pt").to(image.device)  
+        text_output = self.text_encoder(text.input_ids, attention_mask = text.attention_mask,                      
+                                        return_dict = True, mode = 'text')            
+        text_feat = F.normalize(self.text_proj(text_output.last_hidden_state[:,0,:]),dim=-1)                 
+             
+        # get momentum features
+        with torch.no_grad():
+            self._momentum_update()
+            image_embeds_m = self.visual_encoder_m(image) 
+            image_feat_m = F.normalize(self.vision_proj_m(image_embeds_m[:,0,:]),dim=-1)  
+            image_feat_all = torch.cat([image_feat_m.t(),self.image_queue.clone().detach()],dim=1)                   
+            
+            text_output_m = self.text_encoder_m(text.input_ids, attention_mask = text.attention_mask,                      
+                                                return_dict = True, mode = 'text')    
+            text_feat_m = F.normalize(self.text_proj_m(text_output_m.last_hidden_state[:,0,:]),dim=-1) 
+            text_feat_all = torch.cat([text_feat_m.t(),self.text_queue.clone().detach()],dim=1)
+
+            sim_i2t_m = image_feat_m @ text_feat_all / self.temp  
+            sim_t2i_m = text_feat_m @ image_feat_all / self.temp 
+
+            sim_targets = torch.zeros(sim_i2t_m.size()).to(image.device)
+            sim_targets.fill_diagonal_(1)          
+
+            sim_i2t_targets = alpha * F.softmax(sim_i2t_m, dim=1) + (1 - alpha) * sim_targets
+            sim_t2i_targets = alpha * F.softmax(sim_t2i_m, dim=1) + (1 - alpha) * sim_targets        
+
+        sim_i2t = image_feat @ text_feat_all / self.temp
+        sim_t2i = text_feat @ image_feat_all / self.temp
+                             
+        loss_i2t = -torch.sum(F.log_softmax(sim_i2t, dim=1)*sim_i2t_targets,dim=1).mean()
+        loss_t2i = -torch.sum(F.log_softmax(sim_t2i, dim=1)*sim_t2i_targets,dim=1).mean() 
+
+        loss_ita = (loss_i2t+loss_t2i)/2
+
+        self._dequeue_and_enqueue(image_feat_m, text_feat_m)        
+
+        ###============== Image-text Matching ===================###
+        encoder_input_ids = text.input_ids.clone()
+        encoder_input_ids[:,0] = self.tokenizer.enc_token_id
+        
+        # forward the positve image-text pair
+        bs = image.size(0)
+        output_pos = self.text_encoder(encoder_input_ids,
+                                       attention_mask = text.attention_mask,
+                                       encoder_hidden_states = image_embeds,
+                                       encoder_attention_mask = image_atts,      
+                                       return_dict = True,
+                                      )            
+        with torch.no_grad():       
+            weights_t2i = F.softmax(sim_t2i[:,:bs],dim=1)+1e-4 
+            weights_t2i.fill_diagonal_(0)            
+            weights_i2t = F.softmax(sim_i2t[:,:bs],dim=1)+1e-4  
+            weights_i2t.fill_diagonal_(0)   
+            
+        # select a negative image for each text
+        image_embeds_neg = []    
+        for b in range(bs):
+            neg_idx = torch.multinomial(weights_t2i[b], 1).item()
+            image_embeds_neg.append(image_embeds[neg_idx])
+        image_embeds_neg = torch.stack(image_embeds_neg,dim=0)   
+
+        # select a negative text for each image
+        text_ids_neg = []
+        text_atts_neg = []
+        for b in range(bs):
+            neg_idx = torch.multinomial(weights_i2t[b], 1).item()
+            text_ids_neg.append(encoder_input_ids[neg_idx])
+            text_atts_neg.append(text.attention_mask[neg_idx])
+
+        text_ids_neg = torch.stack(text_ids_neg,dim=0)   
+        text_atts_neg = torch.stack(text_atts_neg,dim=0)      
+
+        text_ids_all = torch.cat([encoder_input_ids, text_ids_neg],dim=0)     
+        text_atts_all = torch.cat([text.attention_mask, text_atts_neg],dim=0)     
+
+        image_embeds_all = torch.cat([image_embeds_neg,image_embeds],dim=0)
+        image_atts_all = torch.cat([image_atts,image_atts],dim=0)
+
+        output_neg = self.text_encoder(text_ids_all,
+                                       attention_mask = text_atts_all,
+                                       encoder_hidden_states = image_embeds_all,
+                                       encoder_attention_mask = image_atts_all,      
+                                       return_dict = True,
+                                      )                            
+
+        vl_embeddings = torch.cat([output_pos.last_hidden_state[:,0,:], output_neg.last_hidden_state[:,0,:]],dim=0)
+        vl_output = self.itm_head(vl_embeddings)            
+
+        itm_labels = torch.cat([torch.ones(bs,dtype=torch.long),torch.zeros(2*bs,dtype=torch.long)],
+                               dim=0).to(image.device)
+        loss_itm = F.cross_entropy(vl_output, itm_labels)  
+        
+        ##================= LM ========================##     
+        decoder_input_ids = text.input_ids.clone()      
+        decoder_input_ids[:,0] = self.tokenizer.bos_token_id
+        decoder_targets = decoder_input_ids.masked_fill(decoder_input_ids == self.tokenizer.pad_token_id, -100) 
+
+        decoder_output = self.text_decoder(decoder_input_ids, 
+                                           attention_mask = text.attention_mask, 
+                                           encoder_hidden_states = image_embeds,
+                                           encoder_attention_mask = image_atts,                  
+                                           labels = decoder_targets,
+                                           return_dict = True,   
+                                          )   
+          
+        loss_lm = decoder_output.loss                
+        return loss_ita, loss_itm, loss_lm
+ 
+
+
+    @torch.no_grad()    
+    def copy_params(self):
+        for model_pair in self.model_pairs:           
+            for param, param_m in zip(model_pair[0].parameters(), model_pair[1].parameters()):
+                param_m.data.copy_(param.data)  # initialize
+                param_m.requires_grad = False  # not update by gradient    
+
+            
+    @torch.no_grad()        
+    def _momentum_update(self):
+        for model_pair in self.model_pairs:           
+            for param, param_m in zip(model_pair[0].parameters(), model_pair[1].parameters()):
+                param_m.data = param_m.data * self.momentum + param.data * (1. - self.momentum)
+
+                        
+    @torch.no_grad()
+    def _dequeue_and_enqueue(self, image_feat, text_feat):
+        # gather keys before updating queue
+        image_feats = concat_all_gather(image_feat)
+        text_feats = concat_all_gather(text_feat)
+
+        batch_size = image_feats.shape[0]
+
+        ptr = int(self.queue_ptr)
+        assert self.queue_size % batch_size == 0  # for simplicity
+
+        # replace the keys at ptr (dequeue and enqueue)
+        self.image_queue[:, ptr:ptr + batch_size] = image_feats.T
+        self.text_queue[:, ptr:ptr + batch_size] = text_feats.T
+        ptr = (ptr + batch_size) % self.queue_size  # move pointer
+
+        self.queue_ptr[0] = ptr 
+
+
+def blip_pretrain(**kwargs):
+    model = BLIP_Pretrain(**kwargs)
+    return model 
+
+
+@torch.no_grad()
+def concat_all_gather(tensor):
+    """
+    Performs all_gather operation on the provided tensors.
+    *** Warning ***: torch.distributed.all_gather has no gradient.
+    """
+    tensors_gather = [torch.ones_like(tensor)
+        for _ in range(torch.distributed.get_world_size())]
+    torch.distributed.all_gather(tensors_gather, tensor, async_op=False)
+
+    output = torch.cat(tensors_gather, dim=0)
+    return output     
+
+
+from typing import List
+def tie_encoder_decoder_weights(encoder: nn.Module, decoder: nn.Module, base_model_prefix: str, skip_key:str):
+    uninitialized_encoder_weights: List[str] = []
+    if decoder.__class__ != encoder.__class__:
+        logger.info(
+            f"{decoder.__class__} and {encoder.__class__} are not equal. In this case make sure that all encoder weights are correctly initialized."
+        )
+
+    def tie_encoder_to_decoder_recursively(
+        decoder_pointer: nn.Module,
+        encoder_pointer: nn.Module,
+        module_name: str,
+        uninitialized_encoder_weights: List[str],
+        skip_key: str,
+        depth=0,
+    ):
+        assert isinstance(decoder_pointer, nn.Module) and isinstance(
+            encoder_pointer, nn.Module
+        ), f"{decoder_pointer} and {encoder_pointer} have to be of type torch.nn.Module"
+        if hasattr(decoder_pointer, "weight") and skip_key not in module_name:
+            assert hasattr(encoder_pointer, "weight")
+            encoder_pointer.weight = decoder_pointer.weight
+            if hasattr(decoder_pointer, "bias"):
+                assert hasattr(encoder_pointer, "bias")
+                encoder_pointer.bias = decoder_pointer.bias                
+            print(module_name+' is tied')    
+            return
+
+        encoder_modules = encoder_pointer._modules
+        decoder_modules = decoder_pointer._modules
+        if len(decoder_modules) > 0:
+            assert (
+                len(encoder_modules) > 0
+            ), f"Encoder module {encoder_pointer} does not match decoder module {decoder_pointer}"
+
+            all_encoder_weights = set([module_name + "/" + sub_name for sub_name in encoder_modules.keys()])
+            encoder_layer_pos = 0
+            for name, module in decoder_modules.items():
+                if name.isdigit():
+                    encoder_name = str(int(name) + encoder_layer_pos)
+                    decoder_name = name
+                    if not isinstance(decoder_modules[decoder_name], type(encoder_modules[encoder_name])) and len(
+                        encoder_modules
+                    ) != len(decoder_modules):
+                        # this can happen if the name corresponds to the position in a list module list of layers
+                        # in this case the decoder has added a cross-attention that the encoder does not have
+                        # thus skip this step and subtract one layer pos from encoder
+                        encoder_layer_pos -= 1
+                        continue
+                elif name not in encoder_modules:
+                    continue
+                elif depth > 500:
+                    raise ValueError(
+                        "Max depth of recursive function `tie_encoder_to_decoder` reached. It seems that there is a circular dependency between two or more `nn.Modules` of your model."
+                    )
+                else:
+                    decoder_name = encoder_name = name
+                tie_encoder_to_decoder_recursively(
+                    decoder_modules[decoder_name],
+                    encoder_modules[encoder_name],
+                    module_name + "/" + name,
+                    uninitialized_encoder_weights,
+                    skip_key,
+                    depth=depth + 1,
+                )
+                all_encoder_weights.remove(module_name + "/" + encoder_name)
+
+            uninitialized_encoder_weights += list(all_encoder_weights)
+
+    # tie weights recursively
+    tie_encoder_to_decoder_recursively(decoder, encoder, base_model_prefix, uninitialized_encoder_weights, skip_key)  

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/models/blip_vqa.py

@@ -0,0 +1,213 @@
+
+from models.med import BertConfig, BertModel, BertLMHeadModel
+from models.blip import create_vit, init_tokenizer, load_checkpoint
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+from transformers import BertTokenizer
+import numpy as np
+
+
+class BLIP_VQA(nn.Module):
+    def __init__(self,
+                 med_config= '/mnt/petrelfs/zhangfan.p/zhangfan/evaluate-agent/agent/eval_tools/t2i_comp/BLIPvqa_eval/configs/med_config.json', #'configs/med_config.json',  # todo
+                 image_size=480,
+                 vit='base',
+                 vit_grad_ckpt=False,
+                 vit_ckpt_layer=0,
+                 ):
+        """
+        Args:
+            med_config (str): path for the mixture of encoder-decoder model's configuration file
+            image_size (int): input image size
+            vit (str): model size of vision transformer
+        """
+        super().__init__()
+
+        self.visual_encoder, vision_width = create_vit(vit, image_size, vit_grad_ckpt, vit_ckpt_layer,
+                                                       drop_path_rate=0.1)
+        self.tokenizer = init_tokenizer()
+
+        encoder_config = BertConfig.from_json_file(med_config)
+        encoder_config.encoder_width = vision_width
+        self.text_encoder = BertModel(config=encoder_config, add_pooling_layer=False)
+
+        decoder_config = BertConfig.from_json_file(med_config)
+        self.text_decoder = BertLMHeadModel(config=decoder_config)
+
+    def forward(self, image, question, answer=None, n=None, weights=None, train=True, inference='rank', k_test=128):
+
+        image_embeds = self.visual_encoder(image)
+        image_atts = torch.ones(image_embeds.size()[:-1], dtype=torch.long).to(image.device)
+
+        question = self.tokenizer(question, padding='longest', truncation=True, max_length=35,
+                                  return_tensors="pt").to(image.device)
+        question.input_ids[:, 0] = self.tokenizer.enc_token_id
+
+        if train:
+            '''
+            n: number of answers for each question
+            weights: weight for each answer
+            '''
+            answer = self.tokenizer(answer, padding='longest', return_tensors="pt").to(image.device)
+            answer.input_ids[:, 0] = self.tokenizer.bos_token_id
+            answer_targets = answer.input_ids.masked_fill(answer.input_ids == self.tokenizer.pad_token_id, -100)
+
+            question_output = self.text_encoder(question.input_ids,
+                                                attention_mask=question.attention_mask,
+                                                encoder_hidden_states=image_embeds,
+                                                encoder_attention_mask=image_atts,
+                                                return_dict=True)
+
+            question_states = []
+            question_atts = []
+            for b, n in enumerate(n):
+                question_states += [question_output.last_hidden_state[b]] * n
+                question_atts += [question.attention_mask[b]] * n
+            question_states = torch.stack(question_states, 0)
+            question_atts = torch.stack(question_atts, 0)
+
+            answer_output = self.text_decoder(answer.input_ids,
+                                              attention_mask=answer.attention_mask,
+                                              encoder_hidden_states=question_states,
+                                              encoder_attention_mask=question_atts,
+                                              labels=answer_targets,
+                                              return_dict=True,
+                                              reduction='none',
+                                              )
+
+            loss = weights * answer_output.loss
+            loss = loss.sum() / image.size(0)
+
+            return loss
+
+
+        else:
+            question_output = self.text_encoder(question.input_ids,
+                                                attention_mask=question.attention_mask,
+                                                encoder_hidden_states=image_embeds,
+                                                encoder_attention_mask=image_atts,
+                                                return_dict=True)
+
+            if inference == 'generate':
+                num_beams = 3
+                question_states = question_output.last_hidden_state.repeat_interleave(num_beams, dim=0)
+                question_atts = torch.ones(question_states.size()[:-1], dtype=torch.long).to(question_states.device)
+                model_kwargs = {"encoder_hidden_states": question_states, "encoder_attention_mask": question_atts}
+
+                bos_ids = torch.full((image.size(0), 1), fill_value=self.tokenizer.bos_token_id, device=image.device)
+
+                outputs = self.text_decoder.generate(input_ids=bos_ids,
+                                                     max_length=10,
+                                                     min_length=1,
+                                                     num_beams=num_beams,
+                                                     eos_token_id=self.tokenizer.sep_token_id,
+                                                     pad_token_id=self.tokenizer.pad_token_id,
+                                                     **model_kwargs)
+
+                answers = []
+                for output in outputs:
+                    answer = self.tokenizer.decode(output, skip_special_tokens=True)
+                    answers.append(answer)
+                return answers
+
+            elif inference == 'rank':
+                max_ids = self.rank_answer(question_output.last_hidden_state, question.attention_mask,
+                                           answer.input_ids, answer.attention_mask, k_test)
+                return max_ids
+
+            elif inference == 'vqa_prob':
+                answer_prob = []
+                probs = self.vqa_prob(question_output.last_hidden_state, question.attention_mask,
+                                      )
+                for p in probs:
+                    answer = '{:.4f}'.format(p)
+                    answer_prob.append(str(answer))
+                return answer_prob
+
+                return answer_prob
+
+
+
+    def vqa_prob(self, question_states, question_atts):
+
+        num_ques = question_states.size(0)
+        start_ids = torch.tensor(30522).to(device=question_states.device).repeat(num_ques, 1)  # bos token
+
+        start_output = self.text_decoder(start_ids,
+                                         encoder_hidden_states=question_states,
+                                         encoder_attention_mask=question_atts,
+                                         return_dict=True,
+                                         reduction='none')
+        logits = start_output.logits[:, 0, :]  # first token's logit
+        prob = torch.softmax(logits, dim=1)  # (batchsize,30524)
+        prob_yes = prob[:, 2748]
+        prob_no = prob[:, 2053]
+        return prob_yes / (prob_yes + prob_no)  # tensor(batch_size,)
+
+    def rank_answer(self, question_states, question_atts, answer_ids, answer_atts, k):
+
+        num_ques = question_states.size(0)
+        start_ids = answer_ids[0, 0].repeat(num_ques, 1)  # bos token
+
+        start_output = self.text_decoder(start_ids,
+                                         encoder_hidden_states=question_states,
+                                         encoder_attention_mask=question_atts,
+                                         return_dict=True,
+                                         reduction='none')
+        logits = start_output.logits[:, 0, :]  # first token's logit
+
+        # topk_probs: top-k probability 
+        # topk_ids: [num_question, k]        
+        answer_first_token = answer_ids[:, 1]
+        prob_first_token = F.softmax(logits, dim=1).index_select(dim=1, index=answer_first_token)
+        topk_probs, topk_ids = prob_first_token.topk(k, dim=1)
+
+        # answer input: [num_question*k, answer_len]                 
+        input_ids = []
+        input_atts = []
+        for b, topk_id in enumerate(topk_ids):
+            input_ids.append(answer_ids.index_select(dim=0, index=topk_id))
+            input_atts.append(answer_atts.index_select(dim=0, index=topk_id))
+        input_ids = torch.cat(input_ids, dim=0)
+        input_atts = torch.cat(input_atts, dim=0)
+
+        targets_ids = input_ids.masked_fill(input_ids == self.tokenizer.pad_token_id, -100)
+
+        # repeat encoder's output for top-k answers
+        question_states = tile(question_states, 0, k)
+        question_atts = tile(question_atts, 0, k)
+
+        output = self.text_decoder(input_ids,
+                                   attention_mask=input_atts,
+                                   encoder_hidden_states=question_states,
+                                   encoder_attention_mask=question_atts,
+                                   labels=targets_ids,
+                                   return_dict=True,
+                                   reduction='none')
+
+        log_probs_sum = -output.loss
+        log_probs_sum = log_probs_sum.view(num_ques, k)
+
+        max_topk_ids = log_probs_sum.argmax(dim=1)
+        max_ids = topk_ids[max_topk_ids >= 0, max_topk_ids]
+
+        return max_ids
+
+
+def blip_vqa(pretrained='', **kwargs):
+    model = BLIP_VQA(**kwargs)
+    if pretrained:
+        model, msg = load_checkpoint(model, pretrained)
+    #         assert(len(msg.missing_keys)==0)
+    return model
+
+
+def tile(x, dim, n_tile):
+    init_dim = x.size(dim)
+    repeat_idx = [1] * x.dim()
+    repeat_idx[dim] = n_tile
+    x = x.repeat(*(repeat_idx))
+    order_index = torch.LongTensor(np.concatenate([init_dim * np.arange(n_tile) + i for i in range(init_dim)]))
+    return torch.index_select(x, dim, order_index.to(x.device))

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/models/med.py

@@ -0,0 +1,955 @@
+'''
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ * By Junnan Li
+ * Based on huggingface code base
+ * https://github.com/huggingface/transformers/blob/v4.15.0/src/transformers/models/bert
+'''
+
+import math
+import os
+import warnings
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+import torch
+from torch import Tensor, device, dtype, nn
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import CrossEntropyLoss
+import torch.nn.functional as F
+
+from transformers.activations import ACT2FN
+from transformers.file_utils import (
+    ModelOutput,
+)
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPastAndCrossAttentions,
+    BaseModelOutputWithPoolingAndCrossAttentions,
+    CausalLMOutputWithCrossAttentions,
+    MaskedLMOutput,
+    MultipleChoiceModelOutput,
+    NextSentencePredictorOutput,
+    QuestionAnsweringModelOutput,
+    SequenceClassifierOutput,
+    TokenClassifierOutput,
+)
+from transformers.modeling_utils import (
+    PreTrainedModel,
+    apply_chunking_to_forward,
+    find_pruneable_heads_and_indices,
+    prune_linear_layer,
+)
+from transformers.utils import logging
+from transformers.models.bert.configuration_bert import BertConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+class BertEmbeddings(nn.Module):
+    """Construct the embeddings from word and position embeddings."""
+
+    def __init__(self, config):
+        super().__init__()
+        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+
+        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
+        # any TensorFlow checkpoint file
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+        # position_ids (1, len position emb) is contiguous in memory and exported when serialized
+        self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)))
+        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
+        
+        self.config = config
+
+    def forward(
+        self, input_ids=None, position_ids=None, inputs_embeds=None, past_key_values_length=0
+    ):
+        if input_ids is not None:
+            input_shape = input_ids.size()
+        else:
+            input_shape = inputs_embeds.size()[:-1]
+
+        seq_length = input_shape[1]
+
+        if position_ids is None:
+            position_ids = self.position_ids[:, past_key_values_length : seq_length + past_key_values_length]
+
+        if inputs_embeds is None:
+            inputs_embeds = self.word_embeddings(input_ids)
+
+        embeddings = inputs_embeds
+
+        if self.position_embedding_type == "absolute":
+            position_embeddings = self.position_embeddings(position_ids)
+            embeddings += position_embeddings
+        embeddings = self.LayerNorm(embeddings)
+        embeddings = self.dropout(embeddings)
+        return embeddings
+
+
+class BertSelfAttention(nn.Module):
+    def __init__(self, config, is_cross_attention):
+        super().__init__()
+        self.config = config
+        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+            raise ValueError(
+                "The hidden size (%d) is not a multiple of the number of attention "
+                "heads (%d)" % (config.hidden_size, config.num_attention_heads)
+            )
+        
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        if is_cross_attention:
+            self.key = nn.Linear(config.encoder_width, self.all_head_size)
+            self.value = nn.Linear(config.encoder_width, self.all_head_size)
+        else:
+            self.key = nn.Linear(config.hidden_size, self.all_head_size)
+            self.value = nn.Linear(config.hidden_size, self.all_head_size)
+
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
+        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
+            self.max_position_embeddings = config.max_position_embeddings
+            self.distance_embedding = nn.Embedding(2 * config.max_position_embeddings - 1, self.attention_head_size)
+        self.save_attention = False   
+            
+    def save_attn_gradients(self, attn_gradients):
+        self.attn_gradients = attn_gradients
+        
+    def get_attn_gradients(self):
+        return self.attn_gradients
+    
+    def save_attention_map(self, attention_map):
+        self.attention_map = attention_map
+        
+    def get_attention_map(self):
+        return self.attention_map
+    
+    def transpose_for_scores(self, x):
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(*new_x_shape)
+        return x.permute(0, 2, 1, 3)
+
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        past_key_value=None,
+        output_attentions=False,
+    ):
+        mixed_query_layer = self.query(hidden_states)
+
+        # If this is instantiated as a cross-attention module, the keys
+        # and values come from an encoder; the attention mask needs to be
+        # such that the encoder's padding tokens are not attended to.
+        is_cross_attention = encoder_hidden_states is not None
+
+        if is_cross_attention:
+            key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
+            value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
+            attention_mask = encoder_attention_mask
+        elif past_key_value is not None:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+            key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
+            value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
+        else:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+
+        query_layer = self.transpose_for_scores(mixed_query_layer)
+
+        past_key_value = (key_layer, value_layer)
+
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+
+        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
+            seq_length = hidden_states.size()[1]
+            position_ids_l = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(-1, 1)
+            position_ids_r = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(1, -1)
+            distance = position_ids_l - position_ids_r
+            positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1)
+            positional_embedding = positional_embedding.to(dtype=query_layer.dtype)  # fp16 compatibility
+
+            if self.position_embedding_type == "relative_key":
+                relative_position_scores = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
+                attention_scores = attention_scores + relative_position_scores
+            elif self.position_embedding_type == "relative_key_query":
+                relative_position_scores_query = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
+                relative_position_scores_key = torch.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding)
+                attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key
+
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+        if attention_mask is not None:
+            # Apply the attention mask is (precomputed for all layers in BertModel forward() function)
+            attention_scores = attention_scores + attention_mask
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.Softmax(dim=-1)(attention_scores)
+        
+        if is_cross_attention and self.save_attention:
+            self.save_attention_map(attention_probs)
+            attention_probs.register_hook(self.save_attn_gradients)         
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs_dropped = self.dropout(attention_probs)
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs_dropped = attention_probs_dropped * head_mask
+
+        context_layer = torch.matmul(attention_probs_dropped, value_layer)
+
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(*new_context_layer_shape)
+
+        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+        outputs = outputs + (past_key_value,)
+        return outputs
+
+
+class BertSelfOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+
+
+class BertAttention(nn.Module):
+    def __init__(self, config, is_cross_attention=False):
+        super().__init__()
+        self.self = BertSelfAttention(config, is_cross_attention)
+        self.output = BertSelfOutput(config)
+        self.pruned_heads = set()
+
+    def prune_heads(self, heads):
+        if len(heads) == 0:
+            return
+        heads, index = find_pruneable_heads_and_indices(
+            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
+        )
+
+        # Prune linear layers
+        self.self.query = prune_linear_layer(self.self.query, index)
+        self.self.key = prune_linear_layer(self.self.key, index)
+        self.self.value = prune_linear_layer(self.self.value, index)
+        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
+
+        # Update hyper params and store pruned heads
+        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
+        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
+        self.pruned_heads = self.pruned_heads.union(heads)
+
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        past_key_value=None,
+        output_attentions=False,
+    ):
+        self_outputs = self.self(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            encoder_hidden_states,
+            encoder_attention_mask,
+            past_key_value,
+            output_attentions,
+        )
+        attention_output = self.output(self_outputs[0], hidden_states)
+        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
+        return outputs
+
+
+class BertIntermediate(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+        if isinstance(config.hidden_act, str):
+            self.intermediate_act_fn = ACT2FN[config.hidden_act]
+        else:
+            self.intermediate_act_fn = config.hidden_act
+
+    def forward(self, hidden_states):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        return hidden_states
+
+
+class BertOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+
+
+class BertLayer(nn.Module):
+    def __init__(self, config, layer_num):
+        super().__init__()
+        self.config = config
+        self.chunk_size_feed_forward = config.chunk_size_feed_forward
+        self.seq_len_dim = 1
+        self.attention = BertAttention(config)      
+        self.layer_num = layer_num          
+        if self.config.add_cross_attention:
+            self.crossattention = BertAttention(config, is_cross_attention=self.config.add_cross_attention)
+        self.intermediate = BertIntermediate(config)
+        self.output = BertOutput(config)
+
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        past_key_value=None,
+        output_attentions=False,
+        mode=None,
+    ):
+        # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
+        self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
+        self_attention_outputs = self.attention(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            output_attentions=output_attentions,
+            past_key_value=self_attn_past_key_value,
+        )
+        attention_output = self_attention_outputs[0]
+
+        outputs = self_attention_outputs[1:-1]
+        present_key_value = self_attention_outputs[-1]
+
+        if mode=='multimodal':
+            assert encoder_hidden_states is not None, "encoder_hidden_states must be given for cross-attention layers"
+
+            cross_attention_outputs = self.crossattention(
+                attention_output,
+                attention_mask,
+                head_mask,
+                encoder_hidden_states,
+                encoder_attention_mask,
+                output_attentions=output_attentions,
+            )
+            attention_output = cross_attention_outputs[0]
+            outputs = outputs + cross_attention_outputs[1:-1]  # add cross attentions if we output attention weights                               
+        layer_output = apply_chunking_to_forward(
+            self.feed_forward_chunk, self.chunk_size_feed_forward, self.seq_len_dim, attention_output
+        )
+        outputs = (layer_output,) + outputs
+
+        outputs = outputs + (present_key_value,)
+
+        return outputs
+
+    def feed_forward_chunk(self, attention_output):
+        intermediate_output = self.intermediate(attention_output)
+        layer_output = self.output(intermediate_output, attention_output)
+        return layer_output
+
+
+class BertEncoder(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.layer = nn.ModuleList([BertLayer(config,i) for i in range(config.num_hidden_layers)])
+        self.gradient_checkpointing = False
+
+    def forward(
+        self,
+        hidden_states,
+        attention_mask=None,
+        head_mask=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        past_key_values=None,
+        use_cache=None,
+        output_attentions=False,
+        output_hidden_states=False,
+        return_dict=True,
+        mode='multimodal',
+    ):
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+        all_cross_attentions = () if output_attentions and self.config.add_cross_attention else None
+
+        next_decoder_cache = () if use_cache else None
+               
+        for i in range(self.config.num_hidden_layers):
+            layer_module = self.layer[i]
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            layer_head_mask = head_mask[i] if head_mask is not None else None
+            past_key_value = past_key_values[i] if past_key_values is not None else None
+
+            if self.gradient_checkpointing and self.training:
+
+                if use_cache:
+                    logger.warn(
+                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+                    )
+                    use_cache = False
+
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        return module(*inputs, past_key_value, output_attentions)
+
+                    return custom_forward
+
+                layer_outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(layer_module),
+                    hidden_states,
+                    attention_mask,
+                    layer_head_mask,
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                    mode=mode,
+                )
+            else:
+                layer_outputs = layer_module(
+                    hidden_states,
+                    attention_mask,
+                    layer_head_mask,
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                    past_key_value,
+                    output_attentions,
+                    mode=mode,
+                )
+
+            hidden_states = layer_outputs[0]
+            if use_cache:
+                next_decoder_cache += (layer_outputs[-1],)
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(
+                v
+                for v in [
+                    hidden_states,
+                    next_decoder_cache,
+                    all_hidden_states,
+                    all_self_attentions,
+                    all_cross_attentions,
+                ]
+                if v is not None
+            )
+        return BaseModelOutputWithPastAndCrossAttentions(
+            last_hidden_state=hidden_states,
+            past_key_values=next_decoder_cache,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+            cross_attentions=all_cross_attentions,
+        )
+
+
+class BertPooler(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.activation = nn.Tanh()
+
+    def forward(self, hidden_states):
+        # We "pool" the model by simply taking the hidden state corresponding
+        # to the first token.
+        first_token_tensor = hidden_states[:, 0]
+        pooled_output = self.dense(first_token_tensor)
+        pooled_output = self.activation(pooled_output)
+        return pooled_output
+
+
+class BertPredictionHeadTransform(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        if isinstance(config.hidden_act, str):
+            self.transform_act_fn = ACT2FN[config.hidden_act]
+        else:
+            self.transform_act_fn = config.hidden_act
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+    def forward(self, hidden_states):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.transform_act_fn(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states)
+        return hidden_states
+
+
+class BertLMPredictionHead(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.transform = BertPredictionHeadTransform(config)
+
+        # The output weights are the same as the input embeddings, but there is
+        # an output-only bias for each token.
+        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        self.bias = nn.Parameter(torch.zeros(config.vocab_size))
+
+        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
+        self.decoder.bias = self.bias
+
+    def forward(self, hidden_states):
+        hidden_states = self.transform(hidden_states)
+        hidden_states = self.decoder(hidden_states)
+        return hidden_states
+
+
+class BertOnlyMLMHead(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.predictions = BertLMPredictionHead(config)
+
+    def forward(self, sequence_output):
+        prediction_scores = self.predictions(sequence_output)
+        return prediction_scores
+
+
+class BertPreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = BertConfig
+    base_model_prefix = "bert"
+    _keys_to_ignore_on_load_missing = [r"position_ids"]
+
+    def _init_weights(self, module):
+        """ Initialize the weights """
+        if isinstance(module, (nn.Linear, nn.Embedding)):
+            # Slightly different from the TF version which uses truncated_normal for initialization
+            # cf https://github.com/pytorch/pytorch/pull/5617
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+        if isinstance(module, nn.Linear) and module.bias is not None:
+            module.bias.data.zero_()
+
+
+class BertModel(BertPreTrainedModel):
+    """
+    The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
+    cross-attention is added between the self-attention layers, following the architecture described in `Attention is
+    all you need <https://arxiv.org/abs/1706.03762>`__ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit,
+    Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
+    argument and :obj:`add_cross_attention` set to :obj:`True`; an :obj:`encoder_hidden_states` is then expected as an
+    input to the forward pass.
+    """
+
+    def __init__(self, config, add_pooling_layer=True):
+        super().__init__(config)
+        self.config = config
+
+        self.embeddings = BertEmbeddings(config)
+        
+        self.encoder = BertEncoder(config)
+
+        self.pooler = BertPooler(config) if add_pooling_layer else None
+
+        self.init_weights()
+ 
+
+    def get_input_embeddings(self):
+        return self.embeddings.word_embeddings
+
+    def set_input_embeddings(self, value):
+        self.embeddings.word_embeddings = value
+
+    def _prune_heads(self, heads_to_prune):
+        """
+        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
+        class PreTrainedModel
+        """
+        for layer, heads in heads_to_prune.items():
+            self.encoder.layer[layer].attention.prune_heads(heads)
+
+    
+    def get_extended_attention_mask(self, attention_mask: Tensor, input_shape: Tuple[int], device: device, is_decoder: bool) -> Tensor:
+        """
+        Makes broadcastable attention and causal masks so that future and masked tokens are ignored.
+
+        Arguments:
+            attention_mask (:obj:`torch.Tensor`):
+                Mask with ones indicating tokens to attend to, zeros for tokens to ignore.
+            input_shape (:obj:`Tuple[int]`):
+                The shape of the input to the model.
+            device: (:obj:`torch.device`):
+                The device of the input to the model.
+
+        Returns:
+            :obj:`torch.Tensor` The extended attention mask, with a the same dtype as :obj:`attention_mask.dtype`.
+        """
+        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
+        # ourselves in which case we just need to make it broadcastable to all heads.
+        if attention_mask.dim() == 3:
+            extended_attention_mask = attention_mask[:, None, :, :]
+        elif attention_mask.dim() == 2:
+            # Provided a padding mask of dimensions [batch_size, seq_length]
+            # - if the model is a decoder, apply a causal mask in addition to the padding mask
+            # - if the model is an encoder, make the mask broadcastable to [batch_size, num_heads, seq_length, seq_length]
+            if is_decoder:
+                batch_size, seq_length = input_shape
+
+                seq_ids = torch.arange(seq_length, device=device)
+                causal_mask = seq_ids[None, None, :].repeat(batch_size, seq_length, 1) <= seq_ids[None, :, None]
+                # in case past_key_values are used we need to add a prefix ones mask to the causal mask
+                # causal and attention masks must have same type with pytorch version < 1.3
+                causal_mask = causal_mask.to(attention_mask.dtype)
+   
+                if causal_mask.shape[1] < attention_mask.shape[1]:
+                    prefix_seq_len = attention_mask.shape[1] - causal_mask.shape[1]
+                    causal_mask = torch.cat(
+                        [
+                            torch.ones((batch_size, seq_length, prefix_seq_len), device=device, dtype=causal_mask.dtype),
+                            causal_mask,
+                        ],
+                        axis=-1,
+                    )                     
+
+                extended_attention_mask = causal_mask[:, None, :, :] * attention_mask[:, None, None, :]
+            else:
+                extended_attention_mask = attention_mask[:, None, None, :]
+        else:
+            raise ValueError(
+                "Wrong shape for input_ids (shape {}) or attention_mask (shape {})".format(
+                    input_shape, attention_mask.shape
+                )
+            )
+
+        # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
+        # masked positions, this operation will create a tensor which is 0.0 for
+        # positions we want to attend and -10000.0 for masked positions.
+        # Since we are adding it to the raw scores before the softmax, this is
+        # effectively the same as removing these entirely.
+        extended_attention_mask = extended_attention_mask.to(dtype=self.dtype)  # fp16 compatibility
+        extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0
+        return extended_attention_mask
+    
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        encoder_embeds=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        past_key_values=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        is_decoder=False,
+        mode='multimodal',
+    ):
+        r"""
+        encoder_hidden_states  (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
+            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
+            the model is configured as a decoder.
+        encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
+            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
+            the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``:
+            - 1 for tokens that are **not masked**,
+            - 0 for tokens that are **masked**.
+        past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
+            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
+            If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids`
+            (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)`
+            instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`.
+        use_cache (:obj:`bool`, `optional`):
+            If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up
+            decoding (see :obj:`past_key_values`).
+        """
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if is_decoder:
+            use_cache = use_cache if use_cache is not None else self.config.use_cache
+        else:
+            use_cache = False
+
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            input_shape = input_ids.size()
+            batch_size, seq_length = input_shape
+            device = input_ids.device
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+            batch_size, seq_length = input_shape
+            device = inputs_embeds.device
+        elif encoder_embeds is not None:    
+            input_shape = encoder_embeds.size()[:-1]
+            batch_size, seq_length = input_shape 
+            device = encoder_embeds.device
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds or encoder_embeds")
+
+        # past_key_values_length
+        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
+
+        if attention_mask is None:
+            attention_mask = torch.ones(((batch_size, seq_length + past_key_values_length)), device=device)
+            
+        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
+        # ourselves in which case we just need to make it broadcastable to all heads.
+        extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(attention_mask, input_shape, 
+                                                                                 device, is_decoder)
+
+        # If a 2D or 3D attention mask is provided for the cross-attention
+        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
+        if encoder_hidden_states is not None:
+            if type(encoder_hidden_states) == list:
+                encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states[0].size()
+            else:
+                encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
+            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
+            
+            if type(encoder_attention_mask) == list:
+                encoder_extended_attention_mask = [self.invert_attention_mask(mask) for mask in encoder_attention_mask]
+            elif encoder_attention_mask is None:
+                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
+                encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
+            else:    
+                encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
+        else:
+            encoder_extended_attention_mask = None
+
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
+        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
+        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
+        
+        if encoder_embeds is None:
+            embedding_output = self.embeddings(
+                input_ids=input_ids,
+                position_ids=position_ids,
+                inputs_embeds=inputs_embeds,
+                past_key_values_length=past_key_values_length,
+            )
+        else:
+            embedding_output = encoder_embeds
+            
+        encoder_outputs = self.encoder(
+            embedding_output,
+            attention_mask=extended_attention_mask,
+            head_mask=head_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_extended_attention_mask,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            mode=mode,
+        )
+        sequence_output = encoder_outputs[0]
+        pooled_output = self.pooler(sequence_output) if self.pooler is not None else None
+
+        if not return_dict:
+            return (sequence_output, pooled_output) + encoder_outputs[1:]
+
+        return BaseModelOutputWithPoolingAndCrossAttentions(
+            last_hidden_state=sequence_output,
+            pooler_output=pooled_output,
+            past_key_values=encoder_outputs.past_key_values,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+            cross_attentions=encoder_outputs.cross_attentions,
+        )
+
+
+
+class BertLMHeadModel(BertPreTrainedModel):
+
+    _keys_to_ignore_on_load_unexpected = [r"pooler"]
+    _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"]
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.bert = BertModel(config, add_pooling_layer=False)
+        self.cls = BertOnlyMLMHead(config)
+
+        self.init_weights()
+
+    def get_output_embeddings(self):
+        return self.cls.predictions.decoder
+
+    def set_output_embeddings(self, new_embeddings):
+        self.cls.predictions.decoder = new_embeddings
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        position_ids=None,
+        head_mask=None,
+        inputs_embeds=None,
+        encoder_hidden_states=None,
+        encoder_attention_mask=None,
+        labels=None,
+        past_key_values=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        return_logits=False,            
+        is_decoder=True,
+        reduction='mean',
+        mode='multimodal', 
+    ):
+        r"""
+        encoder_hidden_states  (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
+            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
+            the model is configured as a decoder.
+        encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
+            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
+            the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``:
+            - 1 for tokens that are **not masked**,
+            - 0 for tokens that are **masked**.
+        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
+            Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in
+            ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are
+            ignored (masked), the loss is only computed for the tokens with labels n ``[0, ..., config.vocab_size]``
+        past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
+            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
+            If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids`
+            (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)`
+            instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`.
+        use_cache (:obj:`bool`, `optional`):
+            If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up
+            decoding (see :obj:`past_key_values`).
+        Returns:
+        Example::
+            >>> from transformers import BertTokenizer, BertLMHeadModel, BertConfig
+            >>> import torch
+            >>> tokenizer = BertTokenizer.from_pretrained('bert-base-cased')
+            >>> config = BertConfig.from_pretrained("bert-base-cased")
+            >>> model = BertLMHeadModel.from_pretrained('bert-base-cased', config=config)
+            >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
+            >>> outputs = model(**inputs)
+            >>> prediction_logits = outputs.logits
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        if labels is not None:
+            use_cache = False
+
+        outputs = self.bert(
+            input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            is_decoder=is_decoder,
+            mode=mode,
+        )
+        
+        sequence_output = outputs[0]
+        prediction_scores = self.cls(sequence_output)
+        
+        if return_logits:
+            return prediction_scores[:, :-1, :].contiguous()  
+
+        lm_loss = None
+        if labels is not None:
+            # we are doing next-token prediction; shift prediction scores and input ids by one
+            shifted_prediction_scores = prediction_scores[:, :-1, :].contiguous()
+            labels = labels[:, 1:].contiguous()
+            loss_fct = CrossEntropyLoss(reduction=reduction, label_smoothing=0.1) 
+            lm_loss = loss_fct(shifted_prediction_scores.view(-1, self.config.vocab_size), labels.view(-1))
+            if reduction=='none':
+                lm_loss = lm_loss.view(prediction_scores.size(0),-1).sum(1)               
+
+        if not return_dict:
+            output = (prediction_scores,) + outputs[2:]
+            return ((lm_loss,) + output) if lm_loss is not None else output
+
+        return CausalLMOutputWithCrossAttentions(
+            loss=lm_loss,
+            logits=prediction_scores,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+            cross_attentions=outputs.cross_attentions,
+        )
+
+    def prepare_inputs_for_generation(self, input_ids, past=None, attention_mask=None, **model_kwargs):
+        input_shape = input_ids.shape
+        # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly
+        if attention_mask is None:
+            attention_mask = input_ids.new_ones(input_shape)
+
+        # cut decoder_input_ids if past is used
+        if past is not None:
+            input_ids = input_ids[:, -1:]
+
+        return {
+            "input_ids": input_ids, 
+            "attention_mask": attention_mask, 
+            "past_key_values": past,
+            "encoder_hidden_states": model_kwargs.get("encoder_hidden_states", None),
+            "encoder_attention_mask": model_kwargs.get("encoder_attention_mask", None),
+            "is_decoder": True,
+        }
+
+    def _reorder_cache(self, past, beam_idx):
+        reordered_past = ()
+        for layer_past in past:
+            reordered_past += (tuple(past_state.index_select(0, beam_idx) for past_state in layer_past),)
+        return reordered_past

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/models/vit.py

@@ -0,0 +1,305 @@
+'''
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ * By Junnan Li
+ * Based on timm code base
+ * https://github.com/rwightman/pytorch-image-models/tree/master/timm
+'''
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from functools import partial
+
+from timm.models.vision_transformer import _cfg, PatchEmbed
+from timm.models.registry import register_model
+from timm.models.layers import trunc_normal_, DropPath
+from timm.models.helpers import named_apply, adapt_input_conv
+
+from fairscale.nn.checkpoint.checkpoint_activations import checkpoint_wrapper
+
+class Mlp(nn.Module):
+    """ MLP as used in Vision Transformer, MLP-Mixer and related networks
+    """
+    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+class Attention(nn.Module):
+    def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.):
+        super().__init__()
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        # NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
+        self.scale = qk_scale or head_dim ** -0.5
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+        self.attn_gradients = None
+        self.attention_map = None
+        
+    def save_attn_gradients(self, attn_gradients):
+        self.attn_gradients = attn_gradients
+        
+    def get_attn_gradients(self):
+        return self.attn_gradients
+    
+    def save_attention_map(self, attention_map):
+        self.attention_map = attention_map
+        
+    def get_attention_map(self):
+        return self.attention_map
+    
+    def forward(self, x, register_hook=False):
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]   # make torchscript happy (cannot use tensor as tuple)
+
+        attn = (q @ k.transpose(-2, -1)) * self.scale
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+                
+        if register_hook:
+            self.save_attention_map(attn)
+            attn.register_hook(self.save_attn_gradients)        
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class Block(nn.Module):
+
+    def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
+                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm, use_grad_checkpointing=False):
+        super().__init__()
+        self.norm1 = norm_layer(dim)
+        self.attn = Attention(
+            dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
+        # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+        if use_grad_checkpointing:
+            self.attn = checkpoint_wrapper(self.attn)
+            self.mlp = checkpoint_wrapper(self.mlp)
+
+    def forward(self, x, register_hook=False):
+        x = x + self.drop_path(self.attn(self.norm1(x), register_hook=register_hook))
+        x = x + self.drop_path(self.mlp(self.norm2(x)))
+        return x
+
+    
+class VisionTransformer(nn.Module):
+    """ Vision Transformer
+    A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`  -
+        https://arxiv.org/abs/2010.11929
+    """
+    def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12,
+                 num_heads=12, mlp_ratio=4., qkv_bias=True, qk_scale=None, representation_size=None,
+                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0., norm_layer=None, 
+                 use_grad_checkpointing=False, ckpt_layer=0):
+        """
+        Args:
+            img_size (int, tuple): input image size
+            patch_size (int, tuple): patch size
+            in_chans (int): number of input channels
+            num_classes (int): number of classes for classification head
+            embed_dim (int): embedding dimension
+            depth (int): depth of transformer
+            num_heads (int): number of attention heads
+            mlp_ratio (int): ratio of mlp hidden dim to embedding dim
+            qkv_bias (bool): enable bias for qkv if True
+            qk_scale (float): override default qk scale of head_dim ** -0.5 if set
+            representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
+            drop_rate (float): dropout rate
+            attn_drop_rate (float): attention dropout rate
+            drop_path_rate (float): stochastic depth rate
+            norm_layer: (nn.Module): normalization layer
+        """
+        super().__init__()
+        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
+        norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
+
+        self.patch_embed = PatchEmbed(
+            img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
+
+        num_patches = self.patch_embed.num_patches
+
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim))
+        self.pos_drop = nn.Dropout(p=drop_rate)
+
+        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
+        self.blocks = nn.ModuleList([
+            Block(
+                dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
+                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer,
+                use_grad_checkpointing=(use_grad_checkpointing and i>=depth-ckpt_layer)
+            )
+            for i in range(depth)])
+        self.norm = norm_layer(embed_dim)
+
+        trunc_normal_(self.pos_embed, std=.02)
+        trunc_normal_(self.cls_token, std=.02)
+        self.apply(self._init_weights)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            trunc_normal_(m.weight, std=.02)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.LayerNorm):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    @torch.jit.ignore
+    def no_weight_decay(self):
+        return {'pos_embed', 'cls_token'}
+
+    def forward(self, x, register_blk=-1):
+        B = x.shape[0]
+        x = self.patch_embed(x)
+
+        cls_tokens = self.cls_token.expand(B, -1, -1)  # stole cls_tokens impl from Phil Wang, thanks
+        x = torch.cat((cls_tokens, x), dim=1)
+  
+        x = x + self.pos_embed[:,:x.size(1),:]
+        x = self.pos_drop(x)
+
+        for i,blk in enumerate(self.blocks):
+            x = blk(x, register_blk==i)
+        x = self.norm(x)
+        
+        return x
+
+    @torch.jit.ignore()
+    def load_pretrained(self, checkpoint_path, prefix=''):
+        _load_weights(self, checkpoint_path, prefix)
+        
+
+@torch.no_grad()
+def _load_weights(model: VisionTransformer, checkpoint_path: str, prefix: str = ''):
+    """ Load weights from .npz checkpoints for official Google Brain Flax implementation
+    """
+    import numpy as np
+
+    def _n2p(w, t=True):
+        if w.ndim == 4 and w.shape[0] == w.shape[1] == w.shape[2] == 1:
+            w = w.flatten()
+        if t:
+            if w.ndim == 4:
+                w = w.transpose([3, 2, 0, 1])
+            elif w.ndim == 3:
+                w = w.transpose([2, 0, 1])
+            elif w.ndim == 2:
+                w = w.transpose([1, 0])
+        return torch.from_numpy(w)
+
+    w = np.load(checkpoint_path)
+    if not prefix and 'opt/target/embedding/kernel' in w:
+        prefix = 'opt/target/'
+
+    if hasattr(model.patch_embed, 'backbone'):
+        # hybrid
+        backbone = model.patch_embed.backbone
+        stem_only = not hasattr(backbone, 'stem')
+        stem = backbone if stem_only else backbone.stem
+        stem.conv.weight.copy_(adapt_input_conv(stem.conv.weight.shape[1], _n2p(w[f'{prefix}conv_root/kernel'])))
+        stem.norm.weight.copy_(_n2p(w[f'{prefix}gn_root/scale']))
+        stem.norm.bias.copy_(_n2p(w[f'{prefix}gn_root/bias']))
+        if not stem_only:
+            for i, stage in enumerate(backbone.stages):
+                for j, block in enumerate(stage.blocks):
+                    bp = f'{prefix}block{i + 1}/unit{j + 1}/'
+                    for r in range(3):
+                        getattr(block, f'conv{r + 1}').weight.copy_(_n2p(w[f'{bp}conv{r + 1}/kernel']))
+                        getattr(block, f'norm{r + 1}').weight.copy_(_n2p(w[f'{bp}gn{r + 1}/scale']))
+                        getattr(block, f'norm{r + 1}').bias.copy_(_n2p(w[f'{bp}gn{r + 1}/bias']))
+                    if block.downsample is not None:
+                        block.downsample.conv.weight.copy_(_n2p(w[f'{bp}conv_proj/kernel']))
+                        block.downsample.norm.weight.copy_(_n2p(w[f'{bp}gn_proj/scale']))
+                        block.downsample.norm.bias.copy_(_n2p(w[f'{bp}gn_proj/bias']))
+        embed_conv_w = _n2p(w[f'{prefix}embedding/kernel'])
+    else:
+        embed_conv_w = adapt_input_conv(
+            model.patch_embed.proj.weight.shape[1], _n2p(w[f'{prefix}embedding/kernel']))
+    model.patch_embed.proj.weight.copy_(embed_conv_w)
+    model.patch_embed.proj.bias.copy_(_n2p(w[f'{prefix}embedding/bias']))
+    model.cls_token.copy_(_n2p(w[f'{prefix}cls'], t=False))
+    pos_embed_w = _n2p(w[f'{prefix}Transformer/posembed_input/pos_embedding'], t=False)
+    if pos_embed_w.shape != model.pos_embed.shape:
+        pos_embed_w = resize_pos_embed(  # resize pos embedding when different size from pretrained weights
+            pos_embed_w, model.pos_embed, getattr(model, 'num_tokens', 1), model.patch_embed.grid_size)
+    model.pos_embed.copy_(pos_embed_w)
+    model.norm.weight.copy_(_n2p(w[f'{prefix}Transformer/encoder_norm/scale']))
+    model.norm.bias.copy_(_n2p(w[f'{prefix}Transformer/encoder_norm/bias']))
+#     if isinstance(model.head, nn.Linear) and model.head.bias.shape[0] == w[f'{prefix}head/bias'].shape[-1]:
+#         model.head.weight.copy_(_n2p(w[f'{prefix}head/kernel']))
+#         model.head.bias.copy_(_n2p(w[f'{prefix}head/bias']))
+#     if isinstance(getattr(model.pre_logits, 'fc', None), nn.Linear) and f'{prefix}pre_logits/bias' in w:
+#         model.pre_logits.fc.weight.copy_(_n2p(w[f'{prefix}pre_logits/kernel']))
+#         model.pre_logits.fc.bias.copy_(_n2p(w[f'{prefix}pre_logits/bias']))
+    for i, block in enumerate(model.blocks.children()):
+        block_prefix = f'{prefix}Transformer/encoderblock_{i}/'
+        mha_prefix = block_prefix + 'MultiHeadDotProductAttention_1/'
+        block.norm1.weight.copy_(_n2p(w[f'{block_prefix}LayerNorm_0/scale']))
+        block.norm1.bias.copy_(_n2p(w[f'{block_prefix}LayerNorm_0/bias']))
+        block.attn.qkv.weight.copy_(torch.cat([
+            _n2p(w[f'{mha_prefix}{n}/kernel'], t=False).flatten(1).T for n in ('query', 'key', 'value')]))
+        block.attn.qkv.bias.copy_(torch.cat([
+            _n2p(w[f'{mha_prefix}{n}/bias'], t=False).reshape(-1) for n in ('query', 'key', 'value')]))
+        block.attn.proj.weight.copy_(_n2p(w[f'{mha_prefix}out/kernel']).flatten(1))
+        block.attn.proj.bias.copy_(_n2p(w[f'{mha_prefix}out/bias']))
+        for r in range(2):
+            getattr(block.mlp, f'fc{r + 1}').weight.copy_(_n2p(w[f'{block_prefix}MlpBlock_3/Dense_{r}/kernel']))
+            getattr(block.mlp, f'fc{r + 1}').bias.copy_(_n2p(w[f'{block_prefix}MlpBlock_3/Dense_{r}/bias']))
+        block.norm2.weight.copy_(_n2p(w[f'{block_prefix}LayerNorm_2/scale']))
+        block.norm2.bias.copy_(_n2p(w[f'{block_prefix}LayerNorm_2/bias']))
+
+            
+def interpolate_pos_embed(pos_embed_checkpoint, visual_encoder):        
+    # interpolate position embedding
+    embedding_size = pos_embed_checkpoint.shape[-1]
+    num_patches = visual_encoder.patch_embed.num_patches
+    num_extra_tokens = visual_encoder.pos_embed.shape[-2] - num_patches
+    # height (== width) for the checkpoint position embedding
+    orig_size = int((pos_embed_checkpoint.shape[-2] - num_extra_tokens) ** 0.5)
+    # height (== width) for the new position embedding
+    new_size = int(num_patches ** 0.5)
+
+    if orig_size!=new_size:
+        # class_token and dist_token are kept unchanged
+        extra_tokens = pos_embed_checkpoint[:, :num_extra_tokens]
+        # only the position tokens are interpolated
+        pos_tokens = pos_embed_checkpoint[:, num_extra_tokens:]
+        pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size, embedding_size).permute(0, 3, 1, 2)
+        pos_tokens = torch.nn.functional.interpolate(
+            pos_tokens, size=(new_size, new_size), mode='bicubic', align_corners=False)
+        pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2)
+        new_pos_embed = torch.cat((extra_tokens, pos_tokens), dim=1)
+        print('reshape position embedding from %d to %d'%(orig_size ** 2,new_size ** 2))
+        
+        return new_pos_embed    
+    else:
+        return pos_embed_checkpoint

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/transform/randaugment.py

@@ -0,0 +1,340 @@
+import cv2
+import numpy as np
+
+
+## aug functions
+def identity_func(img):
+    return img
+
+
+def autocontrast_func(img, cutoff=0):
+    '''
+        same output as PIL.ImageOps.autocontrast
+    '''
+    n_bins = 256
+
+    def tune_channel(ch):
+        n = ch.size
+        cut = cutoff * n // 100
+        if cut == 0:
+            high, low = ch.max(), ch.min()
+        else:
+            hist = cv2.calcHist([ch], [0], None, [n_bins], [0, n_bins])
+            low = np.argwhere(np.cumsum(hist) > cut)
+            low = 0 if low.shape[0] == 0 else low[0]
+            high = np.argwhere(np.cumsum(hist[::-1]) > cut)
+            high = n_bins - 1 if high.shape[0] == 0 else n_bins - 1 - high[0]
+        if high <= low:
+            table = np.arange(n_bins)
+        else:
+            scale = (n_bins - 1) / (high - low)
+            offset = -low * scale
+            table = np.arange(n_bins) * scale + offset
+            table[table < 0] = 0
+            table[table > n_bins - 1] = n_bins - 1
+        table = table.clip(0, 255).astype(np.uint8)
+        return table[ch]
+
+    channels = [tune_channel(ch) for ch in cv2.split(img)]
+    out = cv2.merge(channels)
+    return out
+
+
+def equalize_func(img):
+    '''
+        same output as PIL.ImageOps.equalize
+        PIL's implementation is different from cv2.equalize
+    '''
+    n_bins = 256
+
+    def tune_channel(ch):
+        hist = cv2.calcHist([ch], [0], None, [n_bins], [0, n_bins])
+        non_zero_hist = hist[hist != 0].reshape(-1)
+        step = np.sum(non_zero_hist[:-1]) // (n_bins - 1)
+        if step == 0: return ch
+        n = np.empty_like(hist)
+        n[0] = step // 2
+        n[1:] = hist[:-1]
+        table = (np.cumsum(n) // step).clip(0, 255).astype(np.uint8)
+        return table[ch]
+
+    channels = [tune_channel(ch) for ch in cv2.split(img)]
+    out = cv2.merge(channels)
+    return out
+
+
+def rotate_func(img, degree, fill=(0, 0, 0)):
+    '''
+    like PIL, rotate by degree, not radians
+    '''
+    H, W = img.shape[0], img.shape[1]
+    center = W / 2, H / 2
+    M = cv2.getRotationMatrix2D(center, degree, 1)
+    out = cv2.warpAffine(img, M, (W, H), borderValue=fill)
+    return out
+
+
+def solarize_func(img, thresh=128):
+    '''
+        same output as PIL.ImageOps.posterize
+    '''
+    table = np.array([el if el < thresh else 255 - el for el in range(256)])
+    table = table.clip(0, 255).astype(np.uint8)
+    out = table[img]
+    return out
+
+
+def color_func(img, factor):
+    '''
+        same output as PIL.ImageEnhance.Color
+    '''
+    ## implementation according to PIL definition, quite slow
+    #  degenerate = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)[:, :, np.newaxis]
+    #  out = blend(degenerate, img, factor)
+    #  M = (
+    #      np.eye(3) * factor
+    #      + np.float32([0.114, 0.587, 0.299]).reshape(3, 1) * (1. - factor)
+    #  )[np.newaxis, np.newaxis, :]
+    M = (
+            np.float32([
+                [0.886, -0.114, -0.114],
+                [-0.587, 0.413, -0.587],
+                [-0.299, -0.299, 0.701]]) * factor
+            + np.float32([[0.114], [0.587], [0.299]])
+    )
+    out = np.matmul(img, M).clip(0, 255).astype(np.uint8)
+    return out
+
+
+def contrast_func(img, factor):
+    """
+        same output as PIL.ImageEnhance.Contrast
+    """
+    mean = np.sum(np.mean(img, axis=(0, 1)) * np.array([0.114, 0.587, 0.299]))
+    table = np.array([(
+        el - mean) * factor + mean
+        for el in range(256)
+    ]).clip(0, 255).astype(np.uint8)
+    out = table[img]
+    return out
+
+
+def brightness_func(img, factor):
+    '''
+        same output as PIL.ImageEnhance.Contrast
+    '''
+    table = (np.arange(256, dtype=np.float32) * factor).clip(0, 255).astype(np.uint8)
+    out = table[img]
+    return out
+
+
+def sharpness_func(img, factor):
+    '''
+    The differences the this result and PIL are all on the 4 boundaries, the center
+    areas are same
+    '''
+    kernel = np.ones((3, 3), dtype=np.float32)
+    kernel[1][1] = 5
+    kernel /= 13
+    degenerate = cv2.filter2D(img, -1, kernel)
+    if factor == 0.0:
+        out = degenerate
+    elif factor == 1.0:
+        out = img
+    else:
+        out = img.astype(np.float32)
+        degenerate = degenerate.astype(np.float32)[1:-1, 1:-1, :]
+        out[1:-1, 1:-1, :] = degenerate + factor * (out[1:-1, 1:-1, :] - degenerate)
+        out = out.astype(np.uint8)
+    return out
+
+
+def shear_x_func(img, factor, fill=(0, 0, 0)):
+    H, W = img.shape[0], img.shape[1]
+    M = np.float32([[1, factor, 0], [0, 1, 0]])
+    out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8)
+    return out
+
+
+def translate_x_func(img, offset, fill=(0, 0, 0)):
+    '''
+        same output as PIL.Image.transform
+    '''
+    H, W = img.shape[0], img.shape[1]
+    M = np.float32([[1, 0, -offset], [0, 1, 0]])
+    out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8)
+    return out
+
+
+def translate_y_func(img, offset, fill=(0, 0, 0)):
+    '''
+        same output as PIL.Image.transform
+    '''
+    H, W = img.shape[0], img.shape[1]
+    M = np.float32([[1, 0, 0], [0, 1, -offset]])
+    out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8)
+    return out
+
+
+def posterize_func(img, bits):
+    '''
+        same output as PIL.ImageOps.posterize
+    '''
+    out = np.bitwise_and(img, np.uint8(255 << (8 - bits)))
+    return out
+
+
+def shear_y_func(img, factor, fill=(0, 0, 0)):
+    H, W = img.shape[0], img.shape[1]
+    M = np.float32([[1, 0, 0], [factor, 1, 0]])
+    out = cv2.warpAffine(img, M, (W, H), borderValue=fill, flags=cv2.INTER_LINEAR).astype(np.uint8)
+    return out
+
+
+def cutout_func(img, pad_size, replace=(0, 0, 0)):
+    replace = np.array(replace, dtype=np.uint8)
+    H, W = img.shape[0], img.shape[1]
+    rh, rw = np.random.random(2)
+    pad_size = pad_size // 2
+    ch, cw = int(rh * H), int(rw * W)
+    x1, x2 = max(ch - pad_size, 0), min(ch + pad_size, H)
+    y1, y2 = max(cw - pad_size, 0), min(cw + pad_size, W)
+    out = img.copy()
+    out[x1:x2, y1:y2, :] = replace
+    return out
+
+
+### level to args
+def enhance_level_to_args(MAX_LEVEL):
+    def level_to_args(level):
+        return ((level / MAX_LEVEL) * 1.8 + 0.1,)
+    return level_to_args
+
+
+def shear_level_to_args(MAX_LEVEL, replace_value):
+    def level_to_args(level):
+        level = (level / MAX_LEVEL) * 0.3
+        if np.random.random() > 0.5: level = -level
+        return (level, replace_value)
+
+    return level_to_args
+
+
+def translate_level_to_args(translate_const, MAX_LEVEL, replace_value):
+    def level_to_args(level):
+        level = (level / MAX_LEVEL) * float(translate_const)
+        if np.random.random() > 0.5: level = -level
+        return (level, replace_value)
+
+    return level_to_args
+
+
+def cutout_level_to_args(cutout_const, MAX_LEVEL, replace_value):
+    def level_to_args(level):
+        level = int((level / MAX_LEVEL) * cutout_const)
+        return (level, replace_value)
+
+    return level_to_args
+
+
+def solarize_level_to_args(MAX_LEVEL):
+    def level_to_args(level):
+        level = int((level / MAX_LEVEL) * 256)
+        return (level, )
+    return level_to_args
+
+
+def none_level_to_args(level):
+    return ()
+
+
+def posterize_level_to_args(MAX_LEVEL):
+    def level_to_args(level):
+        level = int((level / MAX_LEVEL) * 4)
+        return (level, )
+    return level_to_args
+
+
+def rotate_level_to_args(MAX_LEVEL, replace_value):
+    def level_to_args(level):
+        level = (level / MAX_LEVEL) * 30
+        if np.random.random() < 0.5:
+            level = -level
+        return (level, replace_value)
+
+    return level_to_args
+
+
+func_dict = {
+    'Identity': identity_func,
+    'AutoContrast': autocontrast_func,
+    'Equalize': equalize_func,
+    'Rotate': rotate_func,
+    'Solarize': solarize_func,
+    'Color': color_func,
+    'Contrast': contrast_func,
+    'Brightness': brightness_func,
+    'Sharpness': sharpness_func,
+    'ShearX': shear_x_func,
+    'TranslateX': translate_x_func,
+    'TranslateY': translate_y_func,
+    'Posterize': posterize_func,
+    'ShearY': shear_y_func,
+}
+
+translate_const = 10
+MAX_LEVEL = 10
+replace_value = (128, 128, 128)
+arg_dict = {
+    'Identity': none_level_to_args,
+    'AutoContrast': none_level_to_args,
+    'Equalize': none_level_to_args,
+    'Rotate': rotate_level_to_args(MAX_LEVEL, replace_value),
+    'Solarize': solarize_level_to_args(MAX_LEVEL),
+    'Color': enhance_level_to_args(MAX_LEVEL),
+    'Contrast': enhance_level_to_args(MAX_LEVEL),
+    'Brightness': enhance_level_to_args(MAX_LEVEL),
+    'Sharpness': enhance_level_to_args(MAX_LEVEL),
+    'ShearX': shear_level_to_args(MAX_LEVEL, replace_value),
+    'TranslateX': translate_level_to_args(
+        translate_const, MAX_LEVEL, replace_value
+    ),
+    'TranslateY': translate_level_to_args(
+        translate_const, MAX_LEVEL, replace_value
+    ),
+    'Posterize': posterize_level_to_args(MAX_LEVEL),
+    'ShearY': shear_level_to_args(MAX_LEVEL, replace_value),
+}
+
+
+class RandomAugment(object):
+
+    def __init__(self, N=2, M=10, isPIL=False, augs=[]):
+        self.N = N
+        self.M = M
+        self.isPIL = isPIL
+        if augs:
+            self.augs = augs       
+        else:
+            self.augs = list(arg_dict.keys())
+
+    def get_random_ops(self):
+        sampled_ops = np.random.choice(self.augs, self.N)
+        return [(op, 0.5, self.M) for op in sampled_ops]
+
+    def __call__(self, img):
+        if self.isPIL:
+            img = np.array(img)            
+        ops = self.get_random_ops()
+        for name, prob, level in ops:
+            if np.random.random() > prob:
+                continue
+            args = arg_dict[name](level)
+            img = func_dict[name](img, *args) 
+        return img
+
+
+if __name__ == '__main__':
+    a = RandomAugment()
+    img = np.random.randn(32, 32, 3)
+    a(img)

eval_agent/eval_tools/t2i_comp/BLIPvqa_eval/utils.py

@@ -0,0 +1,284 @@
+import math
+def cosine_lr_schedule(optimizer, epoch, max_epoch, init_lr, min_lr):
+    """Decay the learning rate"""
+    lr = (init_lr - min_lr) * 0.5 * (1. + math.cos(math.pi * epoch / max_epoch)) + min_lr
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr
+        
+def warmup_lr_schedule(optimizer, step, max_step, init_lr, max_lr):
+    """Warmup the learning rate"""
+    lr = min(max_lr, init_lr + (max_lr - init_lr) * step / max_step)
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr    
+
+def step_lr_schedule(optimizer, epoch, init_lr, min_lr, decay_rate):        
+    """Decay the learning rate"""
+    lr = max(min_lr, init_lr * (decay_rate**epoch))
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr    
+        
+import numpy as np
+import io
+import os
+import time
+from collections import defaultdict, deque
+import datetime
+
+import torch
+import torch.distributed as dist
+
+class SmoothedValue(object):
+    """Track a series of values and provide access to smoothed values over a
+    window or the global series average.
+    """
+
+    def __init__(self, window_size=20, fmt=None):
+        if fmt is None:
+            fmt = "{median:.4f} ({global_avg:.4f})"
+        self.deque = deque(maxlen=window_size)
+        self.total = 0.0
+        self.count = 0
+        self.fmt = fmt
+
+    def update(self, value, n=1):
+        self.deque.append(value)
+        self.count += n
+        self.total += value * n
+
+    def synchronize_between_processes(self):
+        """
+        Warning: does not synchronize the deque!
+        """
+        if not is_dist_avail_and_initialized():
+            return
+        t = torch.tensor([self.count, self.total], dtype=torch.float64, device='cuda')
+        dist.barrier()
+        dist.all_reduce(t)
+        t = t.tolist()
+        self.count = int(t[0])
+        self.total = t[1]
+
+    @property
+    def median(self):
+        d = torch.tensor(list(self.deque))
+        return d.median().item()
+
+    @property
+    def avg(self):
+        d = torch.tensor(list(self.deque), dtype=torch.float32)
+        return d.mean().item()
+
+    @property
+    def global_avg(self):
+        return self.total / self.count
+
+    @property
+    def max(self):
+        return max(self.deque)
+
+    @property
+    def value(self):
+        return self.deque[-1]
+
+    def __str__(self):
+        return self.fmt.format(
+            median=self.median,
+            avg=self.avg,
+            global_avg=self.global_avg,
+            max=self.max,
+            value=self.value)
+
+
+class MetricLogger(object):
+    def __init__(self, delimiter="\t"):
+        self.meters = defaultdict(SmoothedValue)
+        self.delimiter = delimiter
+
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if isinstance(v, torch.Tensor):
+                v = v.item()
+            assert isinstance(v, (float, int))
+            self.meters[k].update(v)
+
+    def __getattr__(self, attr):
+        if attr in self.meters:
+            return self.meters[attr]
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        raise AttributeError("'{}' object has no attribute '{}'".format(
+            type(self).__name__, attr))
+
+    def __str__(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append(
+                "{}: {}".format(name, str(meter))
+            )
+        return self.delimiter.join(loss_str)
+
+    def global_avg(self):
+        loss_str = []
+        for name, meter in self.meters.items():
+            loss_str.append(
+                "{}: {:.4f}".format(name, meter.global_avg)
+            )
+        return self.delimiter.join(loss_str)    
+    
+    def synchronize_between_processes(self):
+        for meter in self.meters.values():
+            meter.synchronize_between_processes()
+
+    def add_meter(self, name, meter):
+        self.meters[name] = meter
+
+    def log_every(self, iterable, print_freq, header=None):
+        i = 0
+        if not header:
+            header = ''
+        start_time = time.time()
+        end = time.time()
+        iter_time = SmoothedValue(fmt='{avg:.4f}')
+        data_time = SmoothedValue(fmt='{avg:.4f}')
+        space_fmt = ':' + str(len(str(len(iterable)))) + 'd'
+        log_msg = [
+            header,
+            '[{0' + space_fmt + '}/{1}]',
+            'eta: {eta}',
+            '{meters}',
+            'time: {time}',
+            'data: {data}'
+        ]
+        if torch.cuda.is_available():
+            log_msg.append('max mem: {memory:.0f}')
+        log_msg = self.delimiter.join(log_msg)
+        MB = 1024.0 * 1024.0
+        for obj in iterable:
+            data_time.update(time.time() - end)
+            yield obj
+            iter_time.update(time.time() - end)
+            if i % print_freq == 0 or i == len(iterable) - 1:
+                eta_seconds = iter_time.global_avg * (len(iterable) - i)
+                eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
+                if torch.cuda.is_available():
+                    print(log_msg.format(
+                        i, len(iterable), eta=eta_string,
+                        meters=str(self),
+                        time=str(iter_time), data=str(data_time),
+                        memory=torch.cuda.max_memory_allocated() / MB))
+                else:
+                    print(log_msg.format(
+                        i, len(iterable), eta=eta_string,
+                        meters=str(self),
+                        time=str(iter_time), data=str(data_time)))
+            i += 1
+            end = time.time()
+        total_time = time.time() - start_time
+        total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+        print('{} Total time: {} ({:.4f} s / it)'.format(
+            header, total_time_str, total_time / len(iterable)))
+        
+
+class AttrDict(dict):
+    def __init__(self, *args, **kwargs):
+        super(AttrDict, self).__init__(*args, **kwargs)
+        self.__dict__ = self
+
+
+def compute_acc(logits, label, reduction='mean'):
+    ret = (torch.argmax(logits, dim=1) == label).float()
+    if reduction == 'none':
+        return ret.detach()
+    elif reduction == 'mean':
+        return ret.mean().item()
+
+def compute_n_params(model, return_str=True):
+    tot = 0
+    for p in model.parameters():
+        w = 1
+        for x in p.shape:
+            w *= x
+        tot += w
+    if return_str:
+        if tot >= 1e6:
+            return '{:.1f}M'.format(tot / 1e6)
+        else:
+            return '{:.1f}K'.format(tot / 1e3)
+    else:
+        return tot
+
+def setup_for_distributed(is_master):
+    """
+    This function disables printing when not in master process
+    """
+    import builtins as __builtin__
+    builtin_print = __builtin__.print
+
+    def print(*args, **kwargs):
+        force = kwargs.pop('force', False)
+        if is_master or force:
+            builtin_print(*args, **kwargs)
+
+    __builtin__.print = print
+
+
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+
+def get_world_size():
+    if not is_dist_avail_and_initialized():
+        return 1
+    return dist.get_world_size()
+
+
+def get_rank():
+    if not is_dist_avail_and_initialized():
+        return 0
+    return dist.get_rank()
+
+
+def is_main_process():
+    return get_rank() == 0
+
+
+def save_on_master(*args, **kwargs):
+    if is_main_process():
+        torch.save(*args, **kwargs)
+
+
+def init_distributed_mode(args):
+    #加入校验，看是否已经initialize了
+    if not dist.is_available():
+        return
+    if dist.is_initialized():
+        return
+
+    if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ:
+        args.rank = int(os.environ["RANK"])
+        args.world_size = int(os.environ['WORLD_SIZE'])
+        args.gpu = int(os.environ['LOCAL_RANK'])
+    elif 'SLURM_PROCID' in os.environ:
+        args.rank = int(os.environ['SLURM_PROCID'])
+        args.gpu = args.rank % torch.cuda.device_count()
+    else:
+        print('Not using distributed mode')
+        args.distributed = False
+        return
+
+    args.distributed = True
+
+    torch.cuda.set_device(args.gpu)
+    args.dist_backend = 'nccl'
+    print('| distributed init (rank {}, word {}): {}'.format(
+        args.rank, args.world_size, args.dist_url), flush=True)
+    torch.distributed.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
+                                         world_size=args.world_size, rank=args.rank)
+    torch.distributed.barrier()
+    setup_for_distributed(args.rank == 0)        
+        
+        

eval_agent/eval_tools/t2i_comp/CLIPScore_eval/CLIP_similarity.py

@@ -0,0 +1,120 @@
+# image and text similarity
+# ref https://github.com/openai/CLIP
+import os
+import torch
+import clip
+from PIL import Image
+import spacy
+nlp=spacy.load('en_core_web_sm')
+
+import json
+import argparse
+
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model, preprocess = clip.load("ViT-B/32", device=device)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--outpath",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to read samples and output scores"
+    )
+    parser.add_argument(
+        "--complex",
+        type=bool,
+        default=False,
+        help="To evaluate on samples in complex category or not"
+    )
+    args = parser.parse_args()
+    return args
+
+
+
+
+
+def main():
+    args = parse_args()
+
+    outpath=args.outpath
+
+    image_folder=os.path.join(outpath,'samples')
+    file_names = os.listdir(image_folder)
+    file_names.sort(key=lambda x: int(x.split("_")[-1].split('.')[0]))  # sort
+
+    cnt = 0
+    total = []
+
+    # output annotation.json
+    for file_name in file_names:
+
+
+        image_path = os.path.join(image_folder,file_name)
+        image = preprocess(Image.open(image_path)).unsqueeze(0).to(device)
+        prompt = file_name.split("_")[0]
+
+        if (args.complex):
+            doc=nlp(prompt)
+            prompt_without_adj=' '.join([token.text for token in doc if token.pos_ != 'ADJ']) #remove adj
+            text = clip.tokenize(prompt_without_adj).to(device)
+        else:
+            text = clip.tokenize(prompt).to(device)
+
+
+
+
+        with torch.no_grad():
+            image_features = model.encode_image(image.to(device))
+            image_features /= image_features.norm(dim=-1, keepdim=True)
+
+
+            text_features = model.encode_text(text)
+            text_features /= text_features.norm(dim=-1, keepdim=True)
+
+             # Calculate the cosine similarity between the image and text features
+            cosine_similarity = (image_features @ text_features.T).squeeze().item()
+
+        similarity = cosine_similarity
+        cnt+=1
+        if (cnt % 100 == 0):
+            print(f"CLIP image-text:{cnt} prompt(s) have been processed!")
+        total.append(similarity)
+
+
+    #save
+    sim_dict=[]
+    for i in range(len(total)):
+        tmp={}
+        tmp['question_id']=i
+        tmp["answer"] = total[i]
+        sim_dict.append(tmp)
+
+
+    json_file = json.dumps(sim_dict)
+    savepath = os.path.join(outpath,"annotation_clip") #todo
+    os.makedirs(savepath, exist_ok=True)
+    with open(f'{savepath}/vqa_result.json', 'w') as f:
+        f.write(json_file)
+    print(f"save to {savepath}")
+    
+    # score avg
+    score=0
+    for i in range(len(sim_dict)):
+        score+=float(sim_dict[i]['answer'])
+    with open(f'{savepath}/score_avg.txt', 'w') as f:
+        f.write('score avg:'+str(score/len(sim_dict)))
+    print("score avg:", score/len(sim_dict))
+
+if __name__ == "__main__":
+    main()
+
+
+
+
+
+

eval_agent/eval_tools/t2i_comp/CLIPScore_eval/CLIP_similarity_eval_agent.py

@@ -0,0 +1,54 @@
+# image and text similarity
+# ref https://github.com/openai/CLIP
+import os
+import torch
+import clip
+from PIL import Image
+import numpy as np
+
+
+def clipscore(model, preprocess, image_pairs, device):
+    total = []
+    results = []
+
+    for info in image_pairs:
+        image_path = info["content_path"]
+        prompt = info["prompt"]
+
+        image = preprocess(Image.open(image_path)).unsqueeze(0).to(device)
+        text = clip.tokenize(prompt).to(device)
+        with torch.no_grad():
+            image_features = model.encode_image(image.to(device))
+            image_features /= image_features.norm(dim=-1, keepdim=True)
+
+
+            text_features = model.encode_text(text)
+            text_features /= text_features.norm(dim=-1, keepdim=True)
+
+             # Calculate the cosine similarity between the image and text features
+            cosine_similarity = (image_features @ text_features.T).squeeze().item()
+
+        similarity = cosine_similarity
+        results.append({'prompt':prompt, 'image_path': image_path, 'image_results': similarity})
+        total.append(similarity)
+    
+    avg_score = np.mean(total)
+    return {
+        "score":[avg_score, results] 
+    }
+    
+    
+def calculate_clip_score(image_pairs):
+    
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    model, preprocess = clip.load("ViT-B/32", device=device)
+    eval_results = clipscore(model, preprocess, image_pairs, device)
+    return eval_results
+
+
+
+
+
+
+
+

eval_agent/eval_tools/t2i_comp/CLIPScore_eval/clip/__init__.py

@@ -0,0 +1 @@
+from .clip import *