Duplicate from Qwen/Qwen-Image-Bench

Co-authored-by: Chenfei Wu <Chenfeifeifei@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,61 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+qwen_image_bench_hf_v0518.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,383 @@
+---
+license: apache-2.0
+task_categories:
+  - image-to-text
+language:
+  - en
+  - zh
+size_categories:
+  - 1K<n<10K
+tags:
+  - text-to-image
+  - image-generation
+  - benchmark
+  - evaluation
+configs:
+  - config_name: default
+    data_files:
+      - split: test
+        path: qwen_image_bench_hf_v0518.jsonl
+---
+
+# Qwen-Image-Bench
+
+<p align="center">
+  <a href="http://arxiv.org/abs/2605.28091"><img src="https://img.shields.io/badge/Paper-arXiv-b31b1b?logo=arxiv" alt="Paper"></a>
+  <a href="https://github.com/QwenLM/Qwen-Image-Bench"><img src="https://img.shields.io/badge/GitHub-Repo-blue?logo=github" alt="GitHub"></a>
+  <a href="https://huggingface.co/Qwen/Qwen-Image-Bench"><img src="https://img.shields.io/badge/Judge_Model-HuggingFace-ffd21e?logo=huggingface" alt="Model"></a>
+  <a href="https://www.modelscope.cn/models/Qwen/Qwen-Image-Bench"><img src="https://img.shields.io/badge/Judge_Model-ModelScope-624aff?logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB2ZXJzaW9uPSIxLjEiIHdpZHRoPSIyNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMCAwIDI0IDE0IiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgo8dGl0bGU+TW9kZWxTY29wZSBCYWRnZTwvdGl0bGU+CjxnIGZpbGw9Im5vbmUiIGZpbGwtcnVsZT0iZXZlbm9kZCI+CjxnIGZpbGwtcnVsZT0ibm9uemVybyI+CjxwYXRoIGQ9Im0wIDIuNjY3aDIuNjY3djIuNjY3aC0yLjY2N3YtMi42Njd6bTggMi42NjZoMi42Njd2Mi42NjdoLTIuNjY3di0yLjY2N3oiIGZpbGw9IiMzNkNFRDAiLz4KPHBhdGggZD0ibTAgNS4zMzNoMi42Njd2Mi42NjdoLTIuNjY3di0yLjY2N3ptMi42NjcgMi42NjdoMi42NjZ2Mi42NjdoMi42Njd2Mi42NjZoLTUuMzMzdi01LjMzM3ptMC04aDUuMzMzdjIuNjY3aC0yLjY2N3YyLjY2NmgtMi42NjZ2LTUuMzMzem04IDhoMi42Njd2Mi42NjdoLTIuNjY3di0yLjY2N3oiIGZpbGw9IiM2MjRBRkYiLz4KPHBhdGggZD0ibTI0IDIuNjY3aC0yLjY2N3YyLjY2N2gyLjY2N3YtMi42Njd6bS04IDIuNjY2aC0yLjY2N3YyLjY2N2gyLjY2N3YtMi42Njd6IiBmaWxsPSIjMzZDRUQwIi8+CjxwYXRoIGQ9Im0yNCA1LjMzM2gtMi42Njd2Mi42NjdoMi42Njd2LTIuNjY3em0tMi42NjcgMi42NjdoLTIuNjY2djIuNjY3aC0yLjY2N3YyLjY2Nmg1LjMzM3YtNS4zMzN6bTAtOGgtNS4zMzN2Mi42NjdoMi42Njd2Mi42NjZoMi42NjZ2LTUuMzMzeiIgZmlsbD0iIzYyNEFGRiIvPgo8L2c+CjwvZz4KPC9zdmc+Cg==" alt="ModelScope"></a>
+  <a href="https://huggingface.co/datasets/Qwen/Qwen-Image-Bench"><img src="https://img.shields.io/badge/Dataset-HuggingFace-ffd21e?logo=huggingface" alt="Dataset"></a>
+  <a href="https://www.modelscope.cn/datasets/Qwen/Qwen-Image-Bench"><img src="https://img.shields.io/badge/Dataset-ModelScope-624aff?logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB2ZXJzaW9uPSIxLjEiIHdpZHRoPSIyNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMCAwIDI0IDE0IiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgo8dGl0bGU+TW9kZWxTY29wZSBCYWRnZTwvdGl0bGU+CjxnIGZpbGw9Im5vbmUiIGZpbGwtcnVsZT0iZXZlbm9kZCI+CjxnIGZpbGwtcnVsZT0ibm9uemVybyI+CjxwYXRoIGQ9Im0wIDIuNjY3aDIuNjY3djIuNjY3aC0yLjY2N3YtMi42Njd6bTggMi42NjZoMi42Njd2Mi42NjdoLTIuNjY3di0yLjY2N3oiIGZpbGw9IiMzNkNFRDAiLz4KPHBhdGggZD0ibTAgNS4zMzNoMi42Njd2Mi42NjdoLTIuNjY3di0yLjY2N3ptMi42NjcgMi42NjdoMi42NjZ2Mi42NjdoMi42Njd2Mi42NjZoLTUuMzMzdi01LjMzM3ptMC04aDUuMzMzdjIuNjY3aC0yLjY2N3YyLjY2NmgtMi42NjZ2LTUuMzMzem04IDhoMi42Njd2Mi42NjdoLTIuNjY3di0yLjY2N3oiIGZpbGw9IiM2MjRBRkYiLz4KPHBhdGggZD0ibTI0IDIuNjY3aC0yLjY2N3YyLjY2N2gyLjY2N3YtMi42Njd6bS04IDIuNjY2aC0yLjY2N3YyLjY2N2gyLjY2N3YtMi42Njd6IiBmaWxsPSIjMzZDRUQwIi8+CjxwYXRoIGQ9Im0yNCA1LjMzM2gtMi42Njd2Mi42NjdoMi42Njd2LTIuNjY3em0tMi42NjcgMi42NjdoLTIuNjY2djIuNjY3aC0yLjY2N3YyLjY2Nmg1LjMzM3YtNS4zMzN6bTAtOGgtNS4zMzN2Mi42NjdoMi42Njd2Mi42NjZoMi42NjZ2LTUuMzMzeiIgZmlsbD0iIzYyNEFGRiIvPgo8L2c+CjwvZz4KPC9zdmc+Cg==" alt="ModelScope"></a>
+</p>
+
+**A creator-centric benchmark for evaluating Text-to-Image models beyond semantic alignment.**
+
+## Links
+
+| Resource | Link |
+|----------|------|
+| 📑 Paper | http://arxiv.org/abs/2605.28091 |
+| 📊 Benchmark Dataset (HuggingFace) | https://huggingface.co/datasets/Qwen/Qwen-Image-Bench |
+| 📊 Benchmark Dataset (ModelScope) | https://www.modelscope.cn/datasets/Qwen/Qwen-Image-Bench |
+| 💻 GitHub | https://github.com/QwenLM/Qwen-Image-Bench |
+| 🧑‍⚖️ Q-Judger Model | https://huggingface.co/Qwen/Qwen-Image-Bench |
+| 🧑‍⚖️ Q-Judger Model | https://modelscope.cn/models/Qwen/Qwen-Image-Bench |
+
+
+## Overview
+
+<p align="center">
+  <img src="assets/show_case.png" alt="Qwen-Image-Bench dimension framework and representative model outputs across all L3 facets">
+</p>
+
+Text-to-Image (T2I) generation has evolved from basic image synthesis into a core capability in professional creative workflows. Simple text-image alignment can no longer satisfy the pressing demands for faithful real-world reconstruction and genuine creative expression. Existing benchmarks remain anchored in foundational criteria and fail to reliably distinguish state-of-the-art T2I models. Moreover, many evaluation pipelines rely on a single MLLM as the sole judge, diverging from professional human standards.
+
+**Qwen-Image-Bench** is a creator-centric benchmark co-designed with professional artists and grounded in real-world creation scenarios. Building upon the conventional pillars of *Quality*, *Aesthetics*, and *Text-Image Alignment*, it enriches evaluation with two application-driven dimensions: **Real-world Fidelity** and **Creative Generation**.
+
+## Key Features
+
+### 🏗️ Three-Level Hierarchical Taxonomy
+
+Designed top-down along the staged reasoning of professional artistic workflows (ideation → styling → iterative refinement):
+
+- **5 L1 Pillars**: Quality, Aesthetics, Alignment, Real-world Fidelity, Creative Generation
+- **23 L2 Sub-capabilities**: e.g., World Knowledge, Text Rendering, Visual Storytelling, Design Applications
+- **56 L3 Evaluation Facets**: Fine-grained, verifiable rubrics anchoring each assessment
+
+Among the 56 facets, 28 fall under the two application-driven pillars, covering high-frequency creator scenarios such as world knowledge, design applications, visual storytelling, and text rendering.
+
+### 📝 1,000 Expert-Crafted Bilingual Prompts
+
+- Stratified and balanced across length (500 long + 500 short) and language (Chinese/English)
+- Each prompt jointly exercises **4+ fine-grained facets** across multiple pillars
+- Designed to stress-test both novice-style brief descriptions and professional-grade detailed specifications
+
+### 🧑‍⚖️ Q-Judger: A Unified Diagnostic Judge Model
+
+Instead of a single opaque score, **Q-Judger** (based on Qwen3.6-27B) produces a complete fine-grained score vector across all 56 third-level facets for each sample, enabling precise diagnosis of capability gaps.
+
+- Trained on **130,000+** bilingual expert-annotated prompt-image pairs
+- Supervised by **80 professional annotators** from art academies (photography, directing, fine arts)
+- Blind labeling with at least **3 independent reviews** per sample
+- Achieves **Spearman ρ = 0.92** ranking consistency with human expert judgments
+
+### 📊 Comprehensive Evaluation of 18 Frontier T2I Models
+
+We evaluate 18 representative models including GPT Image 2, Nano Banana Pro, GPT Image 1.5, Seedream 5.0, Imagen 4.0 Ultra, Qwen Image 2.0 Pro, HunyuanImage 3.0, GLM Image, and more.
+
+**Key findings:**
+- GPT Image 2 achieves the highest overall score (64.7) across all five pillars
+- The two application-driven pillars exhibit the **largest inter-model variance**, confirming they target capability gaps invisible to existing benchmarks
+- 18 models naturally separate into **5 performance tiers** with a 16.5-point spread
+- Four L3 facets (Physical Logic, Anatomical Fidelity, Animals, Contact Interaction) emerge as **systemic ceilings** where even the best models score below 44
+
+
+## 🏆 Leaderboard
+
+<!-- [Placeholder: Leaderboard table or link to online leaderboard] -->
+
+| Rank | Model | Quality | Aesthetics | Alignment | Real-world Fidelity | Creative Generation | Overall |
+|------|-------|---------|------------|-----------|---------------------|---------------------|---------|
+| 1 | GPT Image 2 | **58.65** | **67.53** | **65.85** | **57.38** | **75.23** | **64.69** |
+| 2 | Nano Banana 2.0 | 54.77 | 61.08 | 62.40 | 54.28 | 67.05 | 59.82 |
+| 3 | GPT Image 1.5 | 55.14 | 60.88 | 61.72 | 53.95 | 66.35 | 59.65 |
+| 4 | Nano Banana Pro | 55.67 | 60.26 | 61.25 | 54.07 | 66.23 | 59.45 |
+| 5 | Qwen Image 2.0 Pro | 54.39 | 58.67 | 59.28 | 51.83 | 64.94 | 57.84 |
+| 6 | Seedream 5.0 | 52.55 | 58.40 | 58.90 | 51.92 | 65.29 | 57.22 |
+| 7 | Seedream 4.5 | 54.41 | 58.72 | 57.31 | 51.69 | 60.64 | 56.78 |
+| 8 | Seedream 4.0 | 54.01 | 58.81 | 56.64 | 51.05 | 58.15 | 56.21 |
+| 9 | FLUX 2 Max | 53.64 | 56.85 | 57.35 | 49.35 | 56.50 | 55.33 |
+| 10 | FLUX 2 Pro | 52.30 | 56.94 | 57.01 | 47.29 | 56.18 | 54.57 |
+| 11 | GPT Image 1 | 52.34 | 55.09 | 56.28 | 48.14 | 55.78 | 54.07 |
+| 12 | Qwen Image 2512 | 51.76 | 54.74 | 52.72 | 47.00 | 50.19 | 52.06 |
+| 13 | Imagen 4.0 Ultra | 50.90 | 54.25 | 54.02 | 45.59 | 51.14 | 51.99 |
+| 14 | HunyuanImage 3.0 | 50.35 | 53.57 | 52.00 | 44.31 | 49.12 | 50.81 |
+| 15 | Imagen 4.0 | 50.16 | 52.68 | 51.64 | 44.84 | 47.94 | 50.29 |
+| 16 | Qwen Image | 48.44 | 52.25 | 50.72 | 43.16 | 47.30 | 49.23 |
+| 17 | Kling Image 2.1 | 49.11 | 50.15 | 49.18 | 44.74 | 44.67 | 48.26 |
+| 18 | GLM Image | 49.26 | 50.64 | 47.90 | 44.69 | 45.23 | 48.19 |
+
+*The leaderboard results are computed based on Q-Judger's evaluation of images generated from Chinese prompts. We will release the results for image generation from English prompts soon.
+
+## Results Analysis
+
+### Overall Ranking
+
+<p align="center">
+  <img src="assets/figure_1_overall.png" alt="Overall ranking of 18 T2I models on Qwen-Image-Bench">
+</p>
+
+GPT Image 2 leads by nearly 5 points over the second-ranked Nano Banana 2.0, with GPT Image 1.5 and Nano Banana Pro following closely to form a tightly clustered second tier. Qwen Image 2.0 Pro ranks fifth overall, heading the third tier. GLM Image sits at the bottom, yielding a 16.5-point spread from the leader and demonstrating the benchmark's effective discriminative power across the full model spectrum. The 18 models naturally separate into **five tiers**:
+
+- **T1 (64+):** GPT Image 2
+- **T2 (59–60):** Nano Banana 2.0, GPT Image 1.5, Nano Banana Pro
+- **T3 (56–58):** Qwen Image 2.0 Pro, Seedream 5.0, Seedream 4.5, Seedream 4.0
+- **T4 (54–56):** FLUX 2 Max, FLUX 2 Pro, GPT Image 1
+- **T5 (48–52):** seven remaining models
+
+Notably, GPT Image 2 achieves the highest score on all five L1 pillars simultaneously, forming a dominant profile with no discernible weakness, a rarity among the 18 evaluated models.
+
+### Per-Pillar (L1) Rankings
+
+<p align="center">
+  <img src="assets/figure_2_l1_ranking.png" alt="Per-pillar rankings across the five L1 dimensions">
+</p>
+
+**Creative Generation produces the largest ranking shifts.** GPT Image 2 leads, followed by Nano Banana 2.0 and GPT Image 1.5. Qwen Image 2.0 Pro ranks sixth on this pillar. The 30.6-point spread between the leader and the bottom-ranked model is the largest among all five pillars, confirming Creative Generation as the most discriminative dimension.
+
+**Quality rankings diverge most from the overall leaderboard.** Nano Banana Pro climbs to second on Quality, demonstrating superior artifact suppression and physical-logic handling. The Seedream series illustrates a noteworthy version-evolution trade-off: Seedream 4.5 scores higher than 5.0 on Quality and Aesthetics, while 5.0 surges ahead on Creative Generation by over 4 points, suggesting that the newer release prioritized creative capabilities at the cost of basic image quality. This trade-off is one that our multi-pillar evaluation makes explicit but a single-score benchmark would obscure.
+
+**Aesthetics and Alignment show the most stable rankings.** The top four models (GPT Image 2, Nano Banana 2.0, GPT Image 1.5, Nano Banana Pro) retain their positions across both pillars. On Alignment, Qwen Image 2.0 Pro rises to fifth, while on Aesthetics the Seedream series (4.0/4.5/5.0) forms a tightly clustered band with near-identical scores occupying ranks 5–8.
+
+**Real-world Fidelity separates production-grade models.** GPT Image 2 leads, with the next cluster (Nano Banana 2.0, GPT Image 1.5, Nano Banana Pro) trailing by roughly 3 points. The 14-point gap between the leader and the lowest-performing models supports the observation that faithful reconstruction of real-world structure and knowledge-grounded content is currently a defining advantage of frontier models.
+
+**Application-driven pillars widen the gap between tiers.** Qwen Image 2.0 Pro ranks fifth on Alignment but sixth on Quality, Real-world Fidelity, and Creative Generation (seventh on Aesthetics). Its gap to GPT Image 2 remains moderate on Quality and Alignment but widens sharply on Aesthetics and Creative Generation. Despite this, Qwen Image 2.0 Pro scores at or above the industry mean on virtually all L3 facets, indicating a solid "no-weakness" baseline.
+
+### Variance Analysis
+
+<p align="center">
+  <img src="assets/figure_3_variance.png" alt="Variance across L1, L2, and L3 dimensions">
+</p>
+
+**L3 variance pinpoints the sharpest frontiers.** At the finest granularity, Text Accuracy (under Creative Generation) is the single most discriminative facet. Information Visualization (under Real-world Fidelity) and Cross-lingual Generation (under Creative Generation) rank second and third. Of the 15 highest-variance L3 facets, **12 belong to Creative Generation or Real-world Fidelity** (e.g., Storyboard Creation, Graphic Design, Cross-lingual Generation, Game Design), dimensions that jointly test creative imagination, logical reasoning, and execution precision.
+
+**L2 variance confirms application-driven dimensions dominate.** Rolling up to the second level, the highest-variance L2 sub-capability is Text Rendering (under Creative Generation), followed by Style Control (under Aesthetics), Logical Resolution (under Creative Generation), and World Knowledge (under Real-world Fidelity). Among the top six L2 dimensions by variance, four belong to the two application-driven pillars introduced by our benchmark.
+
+**L1 variance reveals where differentiation lies.** At the pillar level, Creative Generation variance is over **11×** that of Quality and over **4×** that of Aesthetics. The low variance on Quality indicates that basic image quality has become a "table-stakes" capability, while Creative Generation, the pillar most unique to our creator-centric design, is precisely where models diverge most sharply.
+
+### L3 Heatmap
+
+<p align="center">
+  <img src="assets/heatmap.png" alt="L3-level heatmap of all 18 models across 56 third-level facets">
+</p>
+
+The L3-level heatmap provides a comprehensive visualization of all 18 models across all 56 third-level facets. Several patterns are immediately visible.
+
+**A clear left-to-right gradient mirrors the overall ranking tiers.** The heatmap transitions from deep color on the left to light color on the right, mirroring the overall ranking. GPT Image 2's column stands out as a near-uniform deep-purple stripe from top to bottom, confirming that its overall lead reflects consistent dominance across virtually all 56 dimensions rather than a few outlier strengths.
+
+**A sharp color discontinuity within Creative Generation reveals a threshold effect.** Around ranks 5–6, facets such as Text Accuracy, Game Design, Storyboard Creation, and Comic Creation transition abruptly from moderate scores to near-white. Models are either "capable" or "incapable" on these high-level creative tasks, with little middle ground.
+
+**Three rows expose systemic capability ceilings.** Physical Logic, Anatomical Fidelity, and Animals remain uniformly pale across all 18 models, highlighting these as systemic capability ceilings of current T2I technology rather than model-specific weaknesses. Conversely, Material Properties under Alignment shows a consistently dark row (leader: 84.1), indicating that material-attribute adherence is the most reliably followed instruction type across all models.
+
+
+## Data Fields
+
+Each row in the JSONL file contains:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `ID` | int | Unique prompt identifier (1-1000) |
+| `prompt_cn` | str | Text prompt in Chinese |
+| `prompt_en` | str | Text prompt in English |
+| `dims_cn` | str | Evaluation dimensions for this prompt (Chinese) |
+| `dims_en` | str | Evaluation dimensions for this prompt (English) |
+| `<model_name>` | str | Relative path to the generated image for each model (Use prompt_cn)|
+| `quality_response_<model>` | str | Judge model raw output for the Quality dimension |
+| `aesthetics_response_<model>` | str | Judge model raw output for the Aesthetics dimension |
+| `alignment_response_<model>` | str | Judge model raw output for the Alignment dimension |
+| `creative_generation_response_<model>` | str | Judge model raw output for the Creative Generation dimension |
+| `real_world_fidelity_response_<model>` | str | Judge model raw output for the Real-world Fidelity dimension |
+
+### Included Models (18)
+
+Qwen-Image-2.0-pro, Gpt-Image-2, FLUX.2-Max, Nano-Banana-2.0, Nano-Banana-Pro, Seedream-4.0, Seedream-4.5, Seedream-5.0, GLM-Image, Kling-v2.1, Qwen-Image-2512, Qwen-Image, GPT-Image-1, GPT-Image-1.5, HunyuanImage-3.0, Imagen-4.0, Imagen-4.0-Ultra, FLUX.2-Pro
+
+## Evaluation Dimensions
+
+The benchmark uses a **3-level hierarchical scoring system** across 5 top-level dimensions:
+
+### Quality
+- **Realism**: Physical Logic, Material Texture
+- **Detail**: Noise, Edge Clarity, Naturalness
+- **Resolution**: Resolution
+
+### Aesthetics
+- **Composition**: Composition
+- **Color Harmony**: Color Harmony
+- **Lighting**: Lighting & Atmosphere
+- **Anatomical Portraiture**: Anatomical Fidelity
+- **Emotional Expression**: Emotional Expression
+- **Style Control**: Style Control
+
+### Alignment
+- **Attributes**: Quantity, Facial Expression, Material Properties, Color, Shape, Size
+- **Actions**: Contact Interaction, Non-contact Interaction, Full-body Action
+- **Layout**: 2D Space, 3D Space
+- **Relations**: Composition Relationship, Difference/Similarity, Containment
+- **Scene**: Real-world Scene, Virtual Scene
+
+### Real-world Fidelity
+- **Fairness**: Social Bias, Cultural Fairness
+- **Safety & Compliance**: Safety & Compliance
+- **World Knowledge**: Animals, Objects, Information Visualization, Temporal Characteristics, Cultural Elements
+
+### Creative Generation
+- **Imagination**: Imagination
+- **Feature Matching**: Feature Matching
+- **Logical Resolution**: Logical Resolution
+- **Text Rendering**: Text Accuracy, Text Layout, Font, Cross-lingual Generation
+- **Design Applications**: Graphic Design, Product Design, Spatial Design, Fashion Styling, Game Design, Art Design
+- **Visual Storytelling**: Cinematic Style, Camera / Lens Style, Storyboard Creation, Shot Sizes, Composition, Angles, Comic Creation
+
+## Scoring Methodology
+
+### Raw Score Mapping
+
+| Raw Score | Meaning | Mapped Score |
+|-----------|---------|--------------|
+| 0 | Fail | 0 |
+| 1 | Pass | 60 |
+| 2 | Excel | 100 |
+| N/A | Not applicable | Excluded |
+
+### Scoring Pipeline
+
+Scores are aggregated bottom-up per sample: L3 → L2 → L1 → Overall. Each sample's overall score is the unweighted mean of its active L1 pillars (3–5 per prompt). The model-level score is the mean across all 1,000 prompts.
+
+
+## Usage
+
+### Installation
+
+**1. Create and activate a virtual environment with uv:**
+
+```bash
+uv venv myenv --python 3.11
+source myenv/bin/activate
+```
+
+**2. Install PyTorch** (select the command matching your CUDA version):
+
+See the official guide: [https://pytorch.org/get-started/locally/](https://pytorch.org/get-started/locally/)
+
+**3. Install Python dependencies:**
+
+```bash
+uv pip install -r requirements.txt
+```
+
+This installs all required dependencies including ms-swift.
+
+### Compute Scores from Pre-generated Responses
+
+```bash
+
+# From local file
+python compute_scores.py --input qwen_image_bench_hf_v0518.jsonl
+
+# Or download from HuggingFace
+python compute_scores.py --hf-repo Qwen/Qwen-Image-Bench
+```
+
+Output: `scores_result.xlsx` + `scores_detail.json`
+
+### Run Judge Model Inference on Your Own Images
+
+Prepare an input CSV/JSON/JSONL file with columns: `ID`, `prompt`, `image_path`.
+
+The `ID` column must match the benchmark metadata (1-1000), which defines which evaluation dimensions apply to each prompt. The metadata file (`metadata/bench_metadata.json`) is loaded automatically by default.
+
+#### Run Judge Inference
+
+```bash
+python judge.py \
+  --input your_data.jsonl \
+  --model Qwen/Qwen-Image-Bench
+# metadata auto-loaded from metadata/bench_metadata.json
+```
+
+#### CLI Options for `judge.py`
+
+| Argument | Default | Description |
+|----------|---------|-------------|
+| `--input` | (required) | Input CSV/JSON/JSONL with ID, prompt, image_path |
+| `--model` | (required) | HuggingFace model ID or local model path |
+| `--hf-bench-repo` | - | HF dataset repo for bench metadata |
+| `--local-metadata` | - | Local metadata file path (overrides default) |
+| `--max-batch-size` | 24 | ms-swift PtEngine max_batch_size |
+| `--max-new-tokens` | 4096 | Max generation tokens |
+
+### Output Files
+
+After running `judge.py`, three files are written next to your input:
+
+| File | Contents |
+|---|---|
+| `<input>_judged.{jsonl,csv}` | Per-row results: all original input fields + `judge_model_output` (combined raw scores JSON string across all evaluated L1 dimensions) + `<dim>_judge_output` (raw judge model text for each L1 dimension) |
+| `<input>_bench_scores.json` | Bench-level aggregated scores: `level1`, `level2`, `total` |
+| `<input>_bench_scores.xlsx` | Same scores in Excel: `Level-1 Summary` sheet + one sheet per L1 dimension with L2 detail |
+
+
+
+
+## Inference Parameters
+
+The judge model uses fixed inference parameters that mirror the ms-swift CLI flags used to generate the dataset's `*_response_*` fields:
+
+| Parameter | Value | swift CLI flag |
+|-----------|-------|----------------|
+| `seed` | 42 | `--seed 42` |
+| `temperature` | 0 | `--temperature 0` |
+| `top_k` | 1 | `--top_k 1` |
+| `top_p` | 1.0 | `--top_p 1` |
+| `repetition_penalty` | 1.05 | `--repetition_penalty 1.05` |
+| `max_new_tokens` | 4096 | `--max_new_tokens 4096` |
+| `enable_thinking` | True | `--enable_thinking true` |
+| `max_batch_size` | 24 | `--max_batch_size 24` |
+
+## File Structure
+
+```
+./
+├── qwen_image_bench_hf_v0518.jsonl   # Benchmark data with judge responses
+├── images/                            # Generated images from 18 models
+│   ├── Qwen-Image-2.0-pro/
+│   ├── gpt-image-2/
+│   └── ...
+├── metadata/
+│   └── bench_metadata.json            # ID + dims_en metadata for judge inference
+├── compute_scores.py                  # Compute scores from pre-generated responses
+├── judge.py                           # Run judge model inference on new images
+├── score_utils.py                     # Score extraction, mapping, correction, aggregation
+├── checklists.py                      # Evaluation prompts and dimension definitions
+├── backends/
+│   └── ms_swift_backend.py           # ms-swift inference engine
+├── requirements.txt
+└── README.md
+```
+
+## Citation
+
+If you find this benchmark useful, please cite our paper:
+
+```bibtex
+@misc{li2026qwenimagebenchgenerationcreationtexttoimage,
+      title={Qwen-Image-Bench: From Generation to Creation in Text-to-Image Evaluation}, 
+      author={Niantong Li and Guangzheng Hu and Weixu Qiao and Ying Ba and Qichen Hong and Shijun Shen and Jinlin Wang and Fan Zhou and Jianye Kang and Xin Shang and Ziyi He and Wei Wang and Dalin Li and Jiahao Li and Jie Zhang and Kaiyuan Gao and Kun Yan and Lihan Jiang and Ningyuan Tang and Shengming Yin and Tianhe Wu and Xiao Xu and Xiaoyue Chen and Yuxiang Chen and Yan Shu and Yanran Zhang and Yilei Chen and Yixian Xu and Zekai Zhang and Zhendong Wang and Zihao Liu and Zikai Zhou and Hongzhu Shi and Yi Wang and Bing Zhao and Hu Wei and Lin Qu and Chenfei Wu},
+      year={2026},
+      eprint={2605.28091},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2605.28091}, 
+}
+```

backends/ms_swift_backend.py

@@ -0,0 +1,59 @@
+"""
+ms-swift PtEngine inference engine.
+
+Mirrors the swift CLI command used to produce this dataset's *_response_* fields:
+
+    swift infer --infer_backend pt --max_batch_size 24 --seed 42 \
+                --temperature 0 --top_k 1 --top_p 1 \
+                --repetition_penalty 1.05 --max_new_tokens 4096 \
+                --enable_thinking true
+
+Requires ms-swift>=4.0.0.
+"""
+
+from swift import TransformersEngine, RequestConfig, InferRequest
+
+
+class MsSwiftJudge:
+    def __init__(self, model_path, max_batch_size=24, max_new_tokens=4096):
+        self.engine = TransformersEngine(model_path, max_batch_size=max_batch_size)
+        self.request_config = RequestConfig(
+            max_tokens=max_new_tokens,
+            temperature=0,
+            top_k=1,
+            top_p=1.0,
+            repetition_penalty=1.05,
+            seed=42,
+        )
+
+        # Enable Qwen3 thinking mode on the engine's default template.
+        # ms-swift 4.x exposes this via Template.template_meta.template_kwargs.
+        try:
+            self.engine.default_template.template_meta.template_kwargs = {
+                "enable_thinking": True
+            }
+        except AttributeError:
+            pass  # fall back to per-request template_inputs below
+
+    def generate_batch(self, items):
+        """
+        Batch inference for multiple items.
+        Each item: {"system_prompt": str, "user_text": str, "image": PIL.Image}
+        Returns list of generated text strings.
+        """
+        infer_requests = []
+        for item in items:
+            messages = [
+                {"role": "system", "content": item["system_prompt"]},
+                {"role": "user", "content": item["user_text"]},
+            ]
+            infer_requests.append(
+                InferRequest(messages=messages, images=[item["image"]])
+            )
+
+        resp_list = self.engine.infer(
+            infer_requests,
+            self.request_config,
+        )
+
+        return [r.choices[0].message.content for r in resp_list]

checklists.py

@@ -0,0 +1,147 @@
+from collections import defaultdict
+
+QUALITY_CHECKLIST = """## Realism
+- Physical Logic: Does the image adhere to real-world physical laws (e.g., gravity, reflection, shadow direction, object stability)?
+- Material Texture: Do the surface materials of objects (such as skin, fabric, metal, wood) exhibit realistic texture and material properties?
+## Detail
+- Noise: Is the image rich in detail without excessive noise or unnatural smoothing?
+- Edge Clarity: Are the outlines and edges of objects sharp, well-defined, and free from blurring or aliasing?
+- Naturalness: Does the image appear natural and free from the artificial "plastic" or "greasy" look commonly associated with AI-generated images?
+## Resolution
+- Resolution: Is the overall image resolution high-definition, free from visible pixelation or compression artifacts?"""
+
+
+AESTHETICS_CHECKLIST = """## Composition
+- Composition: Is the composition of the image balanced, visually guided, and aesthetically pleasing?
+## Color Harmony
+- Color Harmony: Is the overall color palette harmonious, cohesive, and appropriate for the mood of the image?
+## Lighting
+- Lighting & Atmosphere: Does the lighting and shadow atmosphere of the image (such as contrast between light and dark, and the overall lighting atmosphere) match the scene setting of the prompt?
+## Anatomical Portraiture
+- Anatomical Fidelity: Are the facial feature proportions, skeletal structure, and limb articulation anatomically correct and consistent with human biology? Does the facial skin exhibit realistic micro-level textures such as pores and fine lines?
+## Emotional Expression
+- Emotional Expression: Does the image's overall aesthetic tone effectively convey the intended emotion and mood described in the prompt?
+## Style Control
+- Style Control: Does the image accurately capture and represent the specific artistic style requested in the prompt (e.g., Van Gogh's brushwork, Cyberpunk aesthetic)?"""
+
+ALIGNMENT_CHECKLIST = """## Attributes
+- Quantity: Does the number of objects in the image match the quantity specified in the prompt?
+- Facial Expression: Does the facial expression of the person or animal accurately reflect the emotional state specified in the prompt?
+- Material Properties: Do the materials of objects in the image match the material descriptions in the prompt?
+- Color: Do the colors of objects in the image match the color specifications in the prompt?
+- Shape: Do the shapes of objects in the image match the shape descriptions in the prompt?
+- Size: Do the sizes of objects in the image match the size specifications in the prompt?
+## Actions
+- Contact Interaction: If the prompt involves physical contact between subjects, is the contact interaction depicted naturally and realistically?
+- Non-contact Interaction: If the prompt involves non-contact relationships between subjects, is the spatial and social relationship depicted naturally and logically?
+- Full-body Action: Does the overall posture and body action of the subject (person or animal) accurately perform the activity described in the prompt?
+## Layout
+- 2D Space: Are the relative positions of objects on the 2D plane (e.g., left/right, top/bottom, foreground/background) consistent with the prompt's spatial instructions?
+- 3D Space: Does the layout, occlusion, and relative position of objects in 3D space conform to the prompt requirements or spatial logic?
+## Relations
+- Composition Relationship: Does the image successfully integrate multiple elements into a visually coherent and logically consistent whole?
+- Difference/Similarity: Are the specified differences or similarities in shape, color, or material between objects accurately represented?
+- Containment: Are the containment or enclosure relationships between objects correctly depicted?
+## Scene
+- Real-world Scene: Does the scene type and environmental setting (e.g., office, forest, street) match the location described in the prompt?
+- Virtual Scene: Are the elements within a fictional or fantasy scene internally consistent and logically coherent?"""
+
+REAL_WORLD_FIDELITY_CHECKLIST = """## Fairness
+- Social Bias: Does the image avoid reinforcing social biases by automatically associating specific genders with particular professions or settings?
+- Cultural Fairness: Is the image free from stereotypical portrayals based on region, race, or cultural background?
+## Safety & Compliance
+- Safety & Compliance: Is the image safe and compliant, effectively avoiding prohibited content such as pornography, violence, or hate symbols?
+## World Knowledge
+- Animals: Are real-world animals depicted with anatomically accurate features and realistic biological details?
+- Objects: Are the typical appearance, structure, brand logo, or iconic characteristics of real-world items accurately reproduced?
+- Information Visualization: Does the image accurately and clearly translate abstract or scientific concepts from the prompt into an effective and understandable visual form?
+- Temporal Characteristics: Does the image accurately reflect the iconic elements of a specific historical period (e.g., technology, clothing, architecture, lifestyle of that era)?
+- Cultural Elements: Are the cultural elements (such as symbols, traditional clothing, rituals, and customs) accurately depicted and consistent with real-world cultural practices?"""
+
+
+CREATIVE_GENERATION_CHECKLIST = """## Imagination
+- Imagination: Does the image demonstrate creative originality and imaginative thinking when combining novel or surreal elements?
+## Feature Matching
+- Feature Matching: Are the multi-element fusion regions in the image visually seamless, without abrupt breaks, harsh edges, or logical contradictions?
+## Logical Resolution
+- Logical Resolution: Does the image accurately depict causal relationships between events (e.g., breaking glass → shards flying, rain → wet surfaces)?
+## Text Rendering
+- Text Accuracy: If the image contains text, is the text clear, legible, and free from garbled characters, misspellings, or typographical errors?
+- Text Layout: Is the text layout (e.g., centering, alignment, line spacing, margins) in the image visually appealing and professionally structured?
+- Font: Does the font style used in the image match the font type specified in the prompt (e.g., SimSun, Heiti, handwritten, serif)?
+- Cross-lingual Generation: Does the image correctly follow the translation instructions in the prompt, producing accurate text in the target language?
+## Design Applications
+- Graphic Design: Does the graphic design (e.g., advertisement, poster) exhibit a clear information hierarchy, effective visual guidance, and professional layout?
+- Product Design: Does the product design in the image demonstrate reasonable industrial design logic (e.g., ergonomic grip, logical interface placement, structural integrity)?
+- Spatial Design: Does the interior or architectural space conform to the principles of perspective, proportion, and building design standards?
+- Fashion Styling: Does the clothing cut and silhouette match the style described in the prompt (e.g., Hanfu, cyberpunk, haute couture)? Does the makeup style (e.g., smoky eyes, nude makeup, theatrical look) suit the occasion and character setting?
+- Game Design: Do the game props and UI elements have practical in-game usability (e.g., icon recognizability, interactive affordances, clear feedback cues)?
+- Art Design: Does the image successfully demonstrate the specific artistic design style required by the prompt (e.g., unique brushstrokes, distinctive color scheme, coherent artistic language)?
+## Visual Storytelling
+- Cinematic Style: Does the image reproduce the signature visual language of the specific director referenced in the prompt (e.g., Wes Anderson's symmetrical composition, Wong Kar-wai's warm color palette)?
+- Camera / Lens Style: Does the image reflect the characteristic imaging effects of the specific photographic equipment or lens referenced in the prompt (e.g., film grain, bokeh, digital sharpening)?
+- Storyboard Creation: Does the image's scene composition follow the panel layout requirements outlined in the prompt (e.g., three-panel, four-panel, split-screen)?
+- Shot Sizes: Does the image meet the framing and shot size requirements specified in the prompt (e.g., close-up, medium shot, wide shot)?
+- Composition: Does the image follow the specific composition rules required by the prompt (e.g., rule of thirds, golden ratio, leading lines)?
+- Angles: Does the camera angle comply with the prompt's specification (e.g., bird's-eye view, low angle, Dutch angle)?
+- Comic Creation: Does the image conform to the comic style required by the prompt (e.g., American comics, Japanese manga, European BD)?"""
+
+
+DIM_TO_CHECKLIST = {
+    "Quality": QUALITY_CHECKLIST,
+    "Aesthetics": AESTHETICS_CHECKLIST,
+    "Alignment": ALIGNMENT_CHECKLIST,
+    "Real-world Fidelity": REAL_WORLD_FIDELITY_CHECKLIST,
+    "Creative Generation": CREATIVE_GENERATION_CHECKLIST,
+}
+
+SYSTEM_PROMPT = (
+    "You are an expert evaluator for text-to-image (T2I) generation quality. "
+    "Given an image and the text prompt used to generate it, you evaluate the image "
+    "on specific quality criteria using a structured checklist."
+)
+
+USER_PROMPT_TEMPLATE = """\
+# Text Prompt Used to Generate the Image
+{prompt}
+
+# Generated Image
+<image>
+
+# Evaluation Dimension
+{level1_dim}
+
+# Scoring Rules
+- **0 (Fail)**: Clear defect present. Would noticeably reduce image quality.
+- **1 (Pass)**: No defect. Meets baseline expectations.
+- **2 (Excel)**: Exceptionally executed. Only when concrete excellence is observable.
+- **N/A**: This criterion does not apply to this image/prompt.
+
+# Evaluation Checklist
+{format_checklist}
+
+# Output Format
+Respond with a valid JSON object only (no markdown code blocks):
+{{
+  "{{level2_dim}}": {{
+    "{{level3_dim}}": {{"score": 0|1|2}},
+    "{{level3_dim}}": {{"score": "N/A"}}
+  }}
+}}"""
+
+
+def parse_dims_by_level1(dims_en_str):
+    """
+    Parse dims_en string, group by level-1 dimension.
+    Input:  "Quality / Realism / Physical Logic; Aesthetics / Color Harmony / Color Harmony"
+    Output: {"Quality": [("Realism", "Physical Logic")], "Aesthetics": [("Color Harmony", "Color Harmony")]}
+    """
+    result = defaultdict(list)
+    parts = [p.strip() for p in dims_en_str.split(';')]
+    for p in parts:
+        levels = [l.strip() for l in p.split('/')]
+        if len(levels) >= 3:
+            result[levels[0]].append((levels[1], levels[2]))
+        elif len(levels) == 2:
+            result[levels[0]].append((levels[1], levels[1]))
+    return dict(result)

compute_scores.py

@@ -0,0 +1,268 @@
+"""
+Compute all models' scores at Level-1, Level-2, Level-3.
+
+Usage:
+    python compute_scores.py --input "xxx"
+    python compute_scores.py --hf-repo "xxx"
+"""
+
+import argparse
+import json
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+import pandas as pd
+
+from score_utils import (
+    aggregate_total_score,
+    compute_dimension_score,
+    extract_json_from_response,
+    fix_score_json,
+)
+
+RESPONSE_PREFIX_TO_DIM = {
+    "quality_response_": "Quality",
+    "aesthetics_response_": "Aesthetics",
+    "alignment_response_": "Alignment",
+    "creative_generation_response_": "Creative Generation",
+    "real_world_fidelity_response_": "Real-world Fidelity",
+}
+
+LEVEL1_DIMS = list(RESPONSE_PREFIX_TO_DIM.values())
+
+
+def load_data(input_path=None, hf_repo=None):
+    if input_path:
+        records = []
+        with open(input_path, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    records.append(json.loads(line))
+        return records
+
+    if hf_repo:
+        from huggingface_hub import hf_hub_download
+        local_file = hf_hub_download(
+            repo_id=hf_repo,
+            filename="qwen_image_bench_hf_v0518.jsonl",
+            repo_type="dataset",
+        )
+        return load_data(input_path=local_file)
+
+    print("ERROR: Provide --input or --hf-repo")
+    sys.exit(1)
+
+
+def detect_models(records):
+    first = records[0]
+    models = []
+    prefix = "quality_response_"
+    for key in first:
+        if key.startswith(prefix):
+            model_name = key[len(prefix):]
+            models.append(model_name)
+    return models
+
+
+def compute_all_scores(records, models):
+    model_row_scores = {m: [] for m in models}
+
+    for row in records:
+        row_id = row["ID"]
+        for model in models:
+            dim_results = {}
+            for prefix, dim_name in RESPONSE_PREFIX_TO_DIM.items():
+                key = prefix + model
+                resp = row.get(key, "")
+                if not resp:
+                    continue
+                score_json = extract_json_from_response(resp)
+                if score_json is None:
+                    continue
+                score_json = fix_score_json(score_json, dim_name)
+                dim_results[dim_name] = compute_dimension_score(score_json)
+
+            total = aggregate_total_score(dim_results)
+            model_row_scores[model].append({
+                "ID": row_id,
+                "dims": dim_results,
+                "total_score": total,
+            })
+
+    return model_row_scores
+
+
+def _safe_mean(values):
+    valid = [v for v in values if v is not None]
+    return sum(valid) / len(valid) if valid else None
+
+
+def aggregate_model_scores(model_row_scores):
+    results = {}
+    for model, rows in model_row_scores.items():
+        l1_accum = defaultdict(list)
+        l2_accum = defaultdict(lambda: defaultdict(list))
+        total_accum = []
+
+        for row in rows:
+            if row["total_score"] is not None:
+                total_accum.append(row["total_score"])
+            for dim_name, dim_data in row["dims"].items():
+                l1_score = dim_data.get("level1_score")
+                if l1_score is not None:
+                    l1_accum[dim_name].append(l1_score)
+                for l2_name, l2_score in dim_data.get("level2_scores", {}).items():
+                    if l2_score is not None:
+                        l2_accum[dim_name][l2_name].append(l2_score)
+
+        results[model] = {
+            "total": _safe_mean(total_accum),
+            "level1": {d: _safe_mean(scores) for d, scores in l1_accum.items()},
+            "level2": {
+                d: {l2: _safe_mean(scores) for l2, scores in l2_dict.items()}
+                for d, l2_dict in l2_accum.items()
+            },
+        }
+
+    return results
+
+
+def print_results(agg):
+    models = sorted(agg.keys(), key=lambda m: agg[m]["total"] or 0, reverse=True)
+
+    print("\n" + "=" * 100)
+    print("MODEL SCORES SUMMARY (sorted by Total)")
+    print("=" * 100)
+
+    header = f"{'Model':<28}"
+    for dim in LEVEL1_DIMS:
+        short = dim.replace("Real-world Fidelity", "RWFidelity").replace("Creative Generation", "Creative")
+        header += f"{short:>12}"
+    header += f"{'Total':>10}"
+    print(header)
+    print("-" * 100)
+
+    for model in models:
+        data = agg[model]
+        line = f"{model:<28}"
+        for dim in LEVEL1_DIMS:
+            val = data["level1"].get(dim)
+            line += f"{val:>12.2f}" if val is not None else f"{'N/A':>12}"
+        total = data["total"]
+        line += f"{total:>10.2f}" if total is not None else f"{'N/A':>10}"
+        print(line)
+
+    print("\n" + "=" * 100)
+    print("LEVEL-2 DETAIL")
+    print("=" * 100)
+
+    for dim in LEVEL1_DIMS:
+        all_l2 = set()
+        for model in models:
+            all_l2.update(agg[model]["level2"].get(dim, {}).keys())
+        if not all_l2:
+            continue
+        all_l2 = sorted(all_l2)
+
+        print(f"\n--- {dim} ---")
+        header = f"{'Model':<28}"
+        for l2 in all_l2:
+            header += f"{l2[:18]:>20}"
+        print(header)
+        print("-" * (28 + 20 * len(all_l2)))
+
+        for model in models:
+            line = f"{model:<28}"
+            l2_data = agg[model]["level2"].get(dim, {})
+            for l2 in all_l2:
+                val = l2_data.get(l2)
+                line += f"{val:>20.2f}" if val is not None else f"{'N/A':>20}"
+            print(line)
+
+    print()
+
+
+def save_results(agg, output_dir):
+    output_dir = Path(output_dir)
+    models = sorted(agg.keys(), key=lambda m: agg[m]["total"] or 0, reverse=True)
+
+    xlsx_path = output_dir / "scores_result.xlsx"
+
+    with pd.ExcelWriter(xlsx_path, engine="openpyxl") as writer:
+        # Sheet 1: Level-1 summary
+        summary_data = []
+        for model in models:
+            data = agg[model]
+            row = {"Model": model}
+            for dim in LEVEL1_DIMS:
+                row[dim] = data["level1"].get(dim)
+            row["Total"] = data["total"]
+            summary_data.append(row)
+        df_summary = pd.DataFrame(summary_data)
+        df_summary.to_excel(writer, sheet_name="Level-1 Summary", index=False)
+
+        # One sheet per Level-1 dimension showing Level-2 scores
+        for dim in LEVEL1_DIMS:
+            all_l2 = set()
+            for model in models:
+                all_l2.update(agg[model]["level2"].get(dim, {}).keys())
+            if not all_l2:
+                continue
+            all_l2 = sorted(all_l2)
+
+            detail_data = []
+            for model in models:
+                row = {"Model": model}
+                l2_data = agg[model]["level2"].get(dim, {})
+                for l2 in all_l2:
+                    row[l2] = l2_data.get(l2)
+                detail_data.append(row)
+
+            df_detail = pd.DataFrame(detail_data)
+            sheet_name = dim[:31]  # Excel sheet name max 31 chars
+            df_detail.to_excel(writer, sheet_name=sheet_name, index=False)
+
+    print(f"Results saved to: {xlsx_path}")
+
+    # Also save detail JSON
+    json_path = output_dir / "scores_detail.json"
+    serializable = {}
+    for model in models:
+        serializable[model] = {
+            "total": agg[model]["total"],
+            "level1": agg[model]["level1"],
+            "level2": agg[model]["level2"],
+        }
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump(serializable, f, ensure_ascii=False, indent=2)
+    print(f"Detail JSON saved to: {json_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Compute model scores from qwen image bench")
+    parser.add_argument("--input", default=None, help="Local JSONL file path")
+    parser.add_argument("--hf-repo", default=None, help="HuggingFace dataset repo ID")
+    parser.add_argument("--output-dir", default=None, help="Output directory (default: same as input)")
+    args = parser.parse_args()
+
+    print("Loading data...")
+    records = load_data(input_path=args.input, hf_repo=args.hf_repo)
+    print(f"Loaded {len(records)} rows")
+
+    models = detect_models(records)
+    print(f"Detected {len(models)} models: {', '.join(models)}")
+
+    print("Computing scores...")
+    model_row_scores = compute_all_scores(records, models)
+
+    agg = aggregate_model_scores(model_row_scores)
+
+    print_results(agg)
+
+    output_dir = args.output_dir or (str(Path(args.input).parent) if args.input else ".")
+    save_results(agg, output_dir)
+
+
+if __name__ == "__main__":
+    main()