---
license: cc-by-nc-nd-4.0
configs:
  - config_name: general
    data_files:
      - split: train
        path: CPI_general_benchmark/CPI_general_benchmark-*.parquet
  - config_name: practical
    data_files:
      - split: train
        path: CPI_practical_benchmark/CPI_practical_benchmark-*.parquet
  - config_name: intelligent
    data_files:
      - split: train
        path: CPI_intelligent_benchmark/CPI_intelligent_benchmark-*.parquet
---


# CPI-Bench

[![Hugging Face Dataset](https://img.shields.io/badge/🤗-Dataset-yellow)](https://huggingface.co/datasets/TaobaoTmall-AlgorithmProducts/CPI-benchmark)
[![License](https://img.shields.io/badge/License-CC%20BY--NC--ND%204.0-lightgrey)](#license)

## Introduction

CPI-Bench is a comprehensive suite of benchmarks designed to evaluate whether an image
generation/editing model is truly capable of handling diverse, real-world, and
knowledge-intensive tasks. It consists of three complementary subsets:

| Benchmark | Description | Data Files |
|---|---|---|
| **CPI-General-Benchmark** | General-purpose image editing tasks covering a wide range of task types | `CPI_general_benchmark/CPI_general_benchmark-*.parquet` |
| **CPI-Practical-Benchmark** | Image editing tasks grounded in everyday, real-life scenarios | `CPI_practical_benchmark/CPI_practical_benchmark-*.parquet` |
| **CPI-Intelligent-Benchmark** | Image editing tasks that require domain knowledge and multi-step reasoning, with reference input image(s) | `CPI_intelligent_benchmark-*.parquet` |


Each sample provides an editing/generation instruction (and, for image-editing tasks,
one or more reference images). Models are expected to produce an output image
accordingly, which is then scored by a VLM-as-Judge (e.g., Gemini) across multiple
quality dimensions.

## ✨ Key Features

- **Three Complementary Subsets**: covers general-purpose editing, life-scenario
  editing, and knowledge-intensive reasoning for image-editing (i2i) settings.
- **Multi-Image Input Support**: `source` fields may contain one or multiple
  reference images, supporting complex multi-image editing scenarios.
- **Bilingual Instructions**: Chinese and English instructions are provided for
  every subset, enabling cross-lingual evaluation.
- **Reasoning-Aware Annotations**: the reasoning subsets additionally provide a
  `rationale` field — a reference reasoning trace from instruction to expected
  result, used as *guidance material* (not a hard ground truth) during scoring.
- **VLM-Driven Automatic Evaluation**: each subset ships with a ready-to-use,
  multi-dimension VLM-as-Judge evaluation toolkit (see below).

## ✨ Key Attributes

**CPI-General-Benchmark / CPI-Practical-Benchmark fields:**

| Field | Description |
|---|---|
| `id` | Unique sample ID |
| `task` | Task category, used to select the corresponding scoring prompt template |
| `a_to_b_instructions` | Editing instruction in Chinese |
| `a_to_b_instructions_eng` | Editing instruction in English |
| `target_resolution` | Target output resolution |
| `source` | `List[PIL.Image]` — one or more reference input images |

**CPI-Intelligent-Benchmark fields:**

| Field | Description |
|---|---|
| `id` | Unique sample ID |
| `expert_domain` | Domain category, formatted as `"<domain>-<subtask>"` |
| `a_to_b_instructions` | Editing instruction in Chinese |
| `a_to_b_instructions_eng` | Editing instruction in English |
| `rationale` | Reference reasoning trace (guidance material for scoring; may be empty) |
| `target_resolution` | Target output resolution |
| `source` | `List[PIL.Image]` — one or more reference input images |


## Loading

```python
from datasets import load_dataset

# Load a specific subset directly from the Hub (recommended)
dataset = load_dataset("TaobaoTmall-AlgorithmProducts/CPI-benchmark", "general", split="train")
print(dataset)
print(dataset[0])

# Other available configs: "practical", "intelligent"
dataset = load_dataset("TaobaoTmall-AlgorithmProducts/CPI-benchmark", "intelligent", split="train")

# Alternatively, download the repo manually and load from local parquet files
dataset = load_dataset(
    "parquet",
    data_files="/path/to/local/CPI_general_benchmark/CPI_general_benchmark-*.parquet",
    split="train",
)
```

---

# CPI-Bench - Evaluation Toolkit

An automated evaluation toolkit for image generation/editing models, powered by
VLM-as-Judge (e.g., Gemini). Given a set of model outputs, the toolkit scores each
sample across multiple quality dimensions and produces an aggregated report.

The toolkit is located under [`bench_eval_code/`](bench_eval_code) and provides one
evaluation script per subset:

| Subset | Script | Prompt Config |
|---|---|---|
| CPI-General-Benchmark | `bench_eval_code/eval_general_practical.py --benchmark general` | `bench_eval_code/prompts/general_prompts.json` |
| CPI-Practical-Benchmark | `bench_eval_code/eval_general_practical.py --benchmark practical` | `bench_eval_code/prompts/practical_prompts.json` |
| CPI-Intelligent-Benchmark | `bench_eval_code/eval_intelligent.py` | `bench_eval_code/prompts/intelligent_prompts.json` |

## Scoring Dimensions

**CPI-General-Benchmark / CPI-Practical-Benchmark**

Each `task` type is mapped to a task-specific scoring prompt template (defined in
`general_prompts.json` / `practical_prompts.json`). The judge VLM outputs a score for each
dimension in the format `DimensionName: score`, and the sample's final score is the
arithmetic mean across all dimensions returned for that task.

**CPI-Intelligent-Benchmark** — 3 dimensions, each scored 1.0–5.0:

| Dimension | Weight | What it measures |
|---|---|---|
| Knowledge Reasoning | 45% | Factual/domain-knowledge correctness, fused with `rationale` as reference guidance |
| Visual Quality | 30% | Overall visual/aesthetic quality of the generated result |
| Input Consistency | 25% | Consistency between the result and the reference input image(s) |

The final score is a weighted sum of the three dimensions above. If the Knowledge
Reasoning score is ≤ 2, the final score is additionally multiplied by 0.6 as a
penalty for factual/knowledge errors.


## How It Works

- **General / Practical**: a single VLM call per sample — sends
  `[reference image(s)..., result, scoring prompt]` and parses per-dimension scores
  from the response.
- **Intelligent**: a split-call strategy — one VLM call per dimension
  (Knowledge Reasoning, Visual Quality, and for i2i, Input Consistency), so the judge
  can focus on one aspect at a time for more reliable scoring.

## Input Format

First, generate your model's outputs for each sample. If you are not sure which row
corresponds to which image(s)/instruction, use the export helper first — it
auto-detects the dataset schema and works for all three subsets:

```bash
python bench_eval_code/export_samples.py \
    --dataset_path "/path/to/CPI_general_benchmark/CPI_general_benchmark-*.parquet" \
    --output_dir ./exported_general \
    --lang eng \
    --workers 16
```

This produces:
- `source_images/` — reference input images per sample
- `samples.jsonl` — per-sample metadata: `sample_index`, `id`, `task`, `instruction`, `rationale` (if present)
- `result_template.jsonl` — a template result file; fill in the `result` field with your model's output path after inference

Then prepare a JSONL file mapping each benchmark sample index to your model's
generated result image:

```jsonl
{"sample_index": 0, "result": "/path/to/result_0.png"}
{"sample_index": 1, "result": "/path/to/result_1.png"}
{"sample_index": 2, "result": "/path/to/result_2.png"}
```

- `sample_index`: the 0-based row index into the loaded HF dataset
- `result`: path to your model's generated image for that sample

## Usage

**CPI-General-Benchmark / CPI-Practical-Benchmark:**

```bash
python bench_eval_code/eval_general_practical.py \
    --benchmark general \
    --dataset_path "/path/to/CPI_general_benchmark/CPI_general_benchmark-*.parquet" \
    --result_jsonl "/path/to/my_results.jsonl" \
    --prompts_json bench_eval_code/prompts/general_prompts.json \
    --output_dir eval_output/my_model_general \
    --api_key "YOUR_API_KEY" \
    --lang eng \
    --workers 8
```

Use `--benchmark practical` and `bench_eval_code/prompts/practical_prompts.json` to evaluate
the Practical benchmark instead.

**CPI-Intelligent-Benchmark:**

```bash
python bench_eval_code/eval_intelligent.py \
    --dataset_path "/path/to/CPI_intelligent_benchmark/CPI_intelligent_benchmark-*.parquet" \
    --result_jsonl "/path/to/my_results_i2i.jsonl" \
    --prompts_json bench_eval_code/prompts/intelligent_prompts.json \
    --output_dir eval_output/my_model_intelligent \
    --api_key "YOUR_API_KEY" \
    --lang eng \
    --workers 8
```


## Output

Each script produces two files in `--output_dir`:

- **`cases.jsonl`** — per-sample scoring details (per-dimension scores + raw VLM responses)
- **`summary.json`** — aggregated scores, broken down by task type / domain / dimension


## Features

- **Resume support**: if evaluation is interrupted, re-running the same command
  will skip already-scored samples (found in `cases.jsonl`) and continue from
  where it left off. Use `--no_resume` to force a full re-run.
- **Multi-key rotation**: pass multiple API keys (comma-separated via `--api_key`)
  to distribute requests across keys and avoid rate limits.
- **Concurrent scoring**: use `--workers` to control parallelism for faster evaluation.
- **Custom VLM endpoint**: any OpenAI-compatible API can be used via `--base_url`
  and `--model`.

## File Structure

```
bench_eval_code/
├── bench_utils.py          # Shared utilities: API key pool, image helpers, retry-wrapped VLM caller
├── eval_general_practical.py    # Evaluation script for General / Practical benchmarks
├── eval_intelligent.py   # Evaluation script for Intelligent benchmark
├── export_samples.py       # Dataset export helper (auto-detects schema, multi-threaded)
└── prompts/
    ├── general_prompts.json
    ├── practical_prompts.json
    └── intelligent_prompts.json
```

## License

CPI-Bench is released under the Creative Commons Attribution–NonCommercial–NoDerivatives
(CC BY-NC-ND 4.0) license.

- ✅ Free for academic research purposes only
- ❌ Commercial use is prohibited

By using this dataset, you agree to comply with the applicable license terms.

## 🖊️ Citation

If you find CPI-Bench useful for your research, please consider citing:

```bibtex
@misc{zhou2026cpibenchcomprehensivepracticalintelligent,
      title={CPI-Bench: A Comprehensive, Practical and Intelligent Benchmark for Real-World Image Editing}, 
      author={Qinye Zhou and Jun Zheng and Yongchao Du and Yuan Wang and Zhengrui Chen and Zuan Gao and Taihang Hu and Chao Lin and Yefeng Shen and Xingjian Wang and Zhao Wang and Zhengtao Wu and Xiaoli Xu and Zhengze Xu and Hao Yan and Denghui Yang and Yuhang Yu and Huayu Zhang and Mingzhou Zhang and Mengting Chen},
      year={2026},
      eprint={2608.14546},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2608.14546}, 
}
```