README.md

metadata

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

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

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/ 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:

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:

{"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:

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:

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: