Release VisSlideBench (data, images, evaluation code)

README.md

@@ -0,0 +1,127 @@
+---
+pretty_name: VisSlideBench
+license: cc-by-nc-4.0
+language:
+- en
+task_categories:
+- text-to-image
+- image-to-image
+tags:
+- slides
+- presentation
+- text-rendering
+- image-editing
+- benchmark
+size_categories:
+- 1K<n<10K
+configs:
+- config_name: t2i
+  data_files:
+  - split: test
+    path: data/t2i.jsonl
+- config_name: template
+  data_files:
+  - split: test
+    path: data/template.jsonl
+- config_name: multi_image
+  data_files:
+  - split: test
+    path: data/multi_image.jsonl
+- config_name: edit
+  data_files:
+  - split: test
+    path: data/edit.jsonl
+---
+
+# VisSlideBench
+
+VisSlideBench evaluates single-slide image generation and editing. It has 1,527
+manually screened cases in four tracks that share one text-and-image interface.
+
+| Track | Config | Visual input | Real | Synthetic | Total |
+|---|---|---|---:|---:|---:|
+| Text-to-slide | `t2i` | none | 167 | 150 | 317 |
+| Template-conditioned | `template` | one reference slide | 147 | 150 | 297 |
+| Multi-image grounded | `multi_image` | one to four assets | 179 | 150 | 329 |
+| Slide editing | `edit` | source slide | – | – | 584 |
+
+Real cases come from presentation decks. Synthetic cases were built with
+Nano-Banana-2. Every generation track mixes three prompt forms: short requests,
+detailed descriptions, and structured `style_json` specifications.
+
+| Prompt form | t2i | template | multi_image |
+|---|---:|---:|---:|
+| short | 115 | 111 | 103 |
+| long | 109 | 114 | 110 |
+| style_json | 93 | 72 | 116 |
+
+The edit track covers nine operations: text modification (50), block addition
+(74), block removal (49), background update (52), color change (49), font change
+(49), typography change (73), image replacement (103), and theme switching (85).
+
+## Files
+
+```
+data/t2i.jsonl  data/template.jsonl  data/multi_image.jsonl  data/edit.jsonl
+images/<track>/<id>_input_<k>.<ext>   # visual inputs (template, multi_image)
+images/<track>/<id>_target.<ext>      # reference target slide, when available
+images/edit/<id>_source.png           # slide to edit
+images/edit/<id>_target.png           # reference edited slide
+eval/                                 # scoring code and judge prompts
+```
+
+All image paths in the jsonl files are relative to the dataset root.
+
+Generation record:
+
+```json
+{"index": 0, "id": "46f1aa2e-...", "task": "t2i", "source": "real", "prompt_type": "short",
+ "instruction": "The slide is titled ...", "input_images": [],
+ "target_image": "images/t2i/46f1aa2e-..._target.jpg", "width": 2589, "height": 1455}
+```
+
+`width` and `height` are the size of the reference slide. Our runs generate
+t2i cases at 1280x720 and template and multi-image cases at `width` x
+`height`. `target_image` is a reference only and is `null` for some synthetic
+template and multi-image cases; no metric compares against it.
+
+Edit record:
+
+```json
+{"index": 0, "id": "add_block__add_000299", "task": "edit", "operation": "add_block",
+ "instruction": "Insert the subtitle ...", "source_image": "images/edit/..._source.png",
+ "target_image": "images/edit/..._target.png", "width": 1280, "height": 720}
+```
+
+## Evaluation
+
+Save one PNG per case as `<pred_dir>/<track>/<id>.png`, then run the scripts in
+`eval/` (see `eval/README.md`).
+
+| Track | Metrics |
+|---|---|
+| t2i, template | Content Faithfulness (CF), Instruction Following (IF), Aesthetic Quality (AQ) |
+| multi_image | CF (text and input-image preservation, averaged), IF, AQ |
+| edit | Semantic Consistency (SC = min of edit success and edit consistency), Presentation Quality (PQ) |
+
+CF text fidelity uses OCR and a normalized edit distance against the text the
+instruction requires. IF, AQ, image preservation, SC, and PQ use GPT-4.1 as the
+judge; IF and AQ are the unweighted means of their sub-dimension scores. The
+overall score averages the eleven metrics.
+
+## License
+
+VisSlideBench is released under CC BY-NC 4.0 for non-commercial research use.
+Real cases come from publicly shared presentation decks, whose content remains
+the property of its authors; synthetic cases were generated with Nano-Banana-2.
+If you own content in this dataset and want it removed, please open a
+discussion on this repository.
+
+## Citation
+
+```bibtex
+@misc{visslidebench,
+  title  = {InfoVis: Unified Slide Image Generation and Editing},
+  year   = {2026}
+}
+```

eval/README.md

@@ -0,0 +1,52 @@
+# VisSlideBench evaluation
+
+## Setup
+
+```bash
+pip install -r eval/requirements.txt          # judge + text matching
+pip install paddlepaddle-gpu paddleocr==3.3.2  # OCR, only for run_ocr.py
+export OPENAI_API_KEY=...                     # any OpenAI-compatible endpoint
+export OPENAI_BASE_URL=...                    # optional
+export VISSLIDEBENCH_JUDGE=gpt-4.1            # optional, default gpt-4.1
+```
+
+## Predictions
+
+Generate one image per case and save it as `<pred_dir>/<track>/<id>.png`,
+where `<track>` is `t2i`, `template`, `multi_image`, or `edit` and `<id>` is the
+`id` field. Our runs generate t2i cases at 1280x720 and template, multi_image
+and edit cases at the record's `width` and `height`, with seed `2233 + index`
+for case `index`.
+
+## Scoring
+
+```bash
+cd VisSlideBench
+for t in t2i template multi_image; do
+  python eval/run_ocr.py          --task $t --pred_dir $PRED --device gpu:0
+  python eval/score_generation.py --task $t --pred_dir $PRED --workers 16
+done
+python eval/score_edit.py --pred_dir $PRED --workers 16
+python eval/aggregate.py  --pred_dir $PRED                  # Table 1 layout
+python eval/aggregate.py  --pred_dir $PRED --by source      # real vs synthetic
+python eval/aggregate.py  --pred_dir $PRED --by prompt_type # short / long / style_json
+```
+
+Per-case scores go to `<pred_dir>/scores/<track>.jsonl`. A case that fails a
+metric (missing image, no OCR text, no required text in the instruction, or a
+judge error after three retries) has no value for that metric and is left out
+of that metric's average.
+
+## Judge settings
+
+| Call | Prompt | Temperature | Max tokens |
+|---|---|---:|---:|
+| Required-text extraction (CF) | in `score_generation.py` | 0.2 | 800 |
+| Input-image preservation (multi_image CF) | `prompts/content_faithfulness.txt` | 0.2 | 1200 |
+| Instruction Following | `prompts/style_instruction_following_{text,json}.txt` | 0.2 | 2000 |
+| Aesthetic Quality | `prompts/aesthetic_quality.txt` | 0.2 | 2000 |
+| Edit success + consistency | `prompts/edit_evaluation_source_control.txt` | 0.7 | 512 |
+| Edit presentation quality | `prompts/edit_evaluation_quality.txt` | 0.7 | 512 |
+
+Images sent to the judge are JPEG-encoded with the long side capped at 1,600
+pixels and `detail: high`.

eval/aggregate.py

@@ -0,0 +1,57 @@
+"""Combine per-task score files into the VisSlideBench summary (Table 1 layout).
+
+    python eval/aggregate.py --pred_dir outputs/my_model
+
+Each metric is averaged over the cases with a valid score for that metric.
+Overall is the mean of the eleven metrics (CF/IF/AQ for three generation
+tasks, SC/PQ for editing) and is reported only when all four tasks exist.
+"""
+
+import argparse
+import json
+import os
+
+from common import load_jsonl, mean
+
+GEN_TASKS = ("t2i", "template", "multi_image")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pred_dir", required=True)
+    ap.add_argument("--by", choices=["none", "source", "prompt_type"], default="none",
+                    help="Optionally split generation scores by real/synthetic source or prompt type.")
+    args = ap.parse_args()
+    score_dir = os.path.join(args.pred_dir, "scores")
+
+    table, metrics = {}, []
+    for task in GEN_TASKS:
+        path = os.path.join(score_dir, f"{task}.jsonl")
+        if not os.path.exists(path):
+            continue
+        rows = load_jsonl(path)
+        groups = {"all": rows} if args.by == "none" else {}
+        if args.by != "none":
+            for r in rows:
+                groups.setdefault(r.get(args.by), []).append(r)
+        for g, rs in groups.items():
+            entry = {m: mean(r[m] for r in rs if r.get(m) is not None) for m in ("cf", "if", "aq")}
+            entry["n"] = len(rs)
+            table[task if g == "all" else f"{task}/{g}"] = entry
+        if args.by == "none":
+            metrics += [table[task][m] for m in ("cf", "if", "aq")]
+
+    edit_path = os.path.join(score_dir, "edit.jsonl")
+    if os.path.exists(edit_path):
+        ok = [r for r in load_jsonl(edit_path) if "sc" in r]
+        sc, pq = mean(r["sc"] for r in ok), mean(r["pq"] for r in ok)
+        table["edit"] = {"sc": sc, "pq": pq, "n": len(ok)}
+        metrics += [sc, pq]
+
+    if args.by == "none" and len(metrics) == 11 and None not in metrics:
+        table["overall"] = mean(metrics)
+    print(json.dumps(table, indent=1))
+
+
+if __name__ == "__main__":
+    main()

eval/common.py

@@ -0,0 +1,120 @@
+"""Shared helpers for VisSlideBench evaluation.
+
+The judge is any OpenAI-compatible chat endpoint. Configure it with
+environment variables; nothing is hard-coded:
+
+    export OPENAI_API_KEY=...
+    export OPENAI_BASE_URL=...      # optional, defaults to the official endpoint
+    export VISSLIDEBENCH_JUDGE=gpt-4.1   # optional
+"""
+
+import base64
+import json
+import os
+import re
+import time
+from io import BytesIO
+from pathlib import Path
+
+from PIL import Image
+
+BENCH_ROOT = Path(__file__).resolve().parents[1]
+PROMPT_DIR = Path(__file__).resolve().parent / "prompts"
+JUDGE_MODEL = os.environ.get("VISSLIDEBENCH_JUDGE", "gpt-4.1")
+MAX_RETRIES = 3
+
+
+def load_jsonl(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return [json.loads(line) for line in f if line.strip()]
+
+
+def write_jsonl(path, rows):
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def load_prompt(name):
+    return (PROMPT_DIR / name).read_text(encoding="utf-8")
+
+
+def bench_path(rel):
+    return str(BENCH_ROOT / rel)
+
+
+def get_client():
+    from openai import OpenAI
+
+    return OpenAI()  # credentials and endpoint come from OPENAI_API_KEY / OPENAI_BASE_URL
+
+
+def image_to_data_uri(path, max_size=1600):
+    """JPEG-encode an image with its long side capped at `max_size` pixels."""
+    img = Image.open(path).convert("RGB")
+    w, h = img.size
+    if max(w, h) > max_size:
+        r = max_size / max(w, h)
+        img = img.resize((int(w * r), int(h * r)), Image.LANCZOS)
+    buf = BytesIO()
+    img.save(buf, format="JPEG", quality=85)
+    return "data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode("utf-8")
+
+
+def image_part(path):
+    return {"type": "image_url", "image_url": {"url": image_to_data_uri(path), "detail": "high"}}
+
+
+def text_part(text):
+    return {"type": "text", "text": text}
+
+
+def parse_json_block(text):
+    """Return the first JSON object or array found in a model reply."""
+    text = text.strip()
+    m = re.search(r"```(?:json)?\s*\n(.*?)```", text, re.DOTALL)
+    if m:
+        text = m.group(1).strip()
+    else:
+        starts = [i for i in (text.find("{"), text.find("[")) if i >= 0]
+        if starts:
+            s = min(starts)
+            e = max(text.rfind("}"), text.rfind("]"))
+            if e > s:
+                text = text[s : e + 1]
+    return json.loads(text)
+
+
+def chat(client, system, user_content, temperature, max_tokens):
+    """Call the judge with retries; returns the parsed JSON reply."""
+    err = None
+    for attempt in range(1, MAX_RETRIES + 1):
+        try:
+            resp = client.chat.completions.create(
+                model=JUDGE_MODEL,
+                messages=([{"role": "system", "content": system}] if system else [])
+                + [{"role": "user", "content": user_content}],
+                temperature=temperature,
+                max_tokens=max_tokens,
+            )
+            return parse_json_block(resp.choices[0].message.content)
+        except Exception as e:  # network errors, rate limits, unparsable replies
+            err = e
+            if attempt < MAX_RETRIES:
+                time.sleep(2 ** attempt)
+    raise RuntimeError(f"judge call failed after {MAX_RETRIES} attempts: {err}")
+
+
+def mean(xs):
+    xs = list(xs)
+    return sum(xs) / len(xs) if xs else None
+
+
+def subdimension_mean(result):
+    """Unweighted mean of the per-dimension `score` fields of a judge reply.
+
+    The judge also returns an `overall_score`; it is not used.
+    """
+    scores = [v["score"] for v in result.values() if isinstance(v, dict) and "score" in v]
+    return mean(float(s) for s in scores)

eval/prompts/aesthetic_quality.txt

@@ -0,0 +1,198 @@
+You are an expert evaluator for AI-generated presentation slides. Your task is to assess the Aesthetic Quality of a generated slide image.
+
+Your default stance is skeptical and conservative. Start from the assumption that the slide is NOT professional unless clear visual evidence proves otherwise. Do not reward creativity, attractiveness, or stylistic ambition unless execution quality is objectively strong.
+
+## Evaluation Dimension: Aesthetic Quality
+
+This dimension evaluates whether the generated slide looks like a professional, readable, structurally coherent, and realistically usable PPT page. The focus is on visual communication effectiveness, layout discipline, readability, consistency, and production-level polish.
+
+Aesthetic appeal alone MUST NOT increase the score.
+
+## Inputs
+
+1. **Generated Slide Image**: The AI-generated slide image to be evaluated.
+
+## Mandatory Evaluation Procedure
+
+Follow this exact order:
+
+1. Inspect the entire slide globally before scoring.
+2. Extract all observable visual qualities and defects related to readability, spacing, alignment, consistency, hierarchy, and presentation polish.
+3. For each sub-dimension, explicitly identify:
+   - strengths
+   - weaknesses
+   - visible defects
+4. Count all visible issues. Any noticeable issue counts as a mismatch.
+5. Apply hard score caps before assigning scores.
+6. Compute the overall score as the mean of the sub-dimension scores.
+
+Never score first and justify later.
+
+If a feature is ambiguous, partially visible, blurry, cropped, distorted, or difficult to verify, treat it as a defect rather than assuming correctness.
+
+## Evaluation Criteria
+
+Evaluate the following sub-dimensions carefully:
+
+### 1. Clarity
+Evaluate readability and information communication quality.
+
+Check:
+- Are all text elements clearly legible?
+- Is font size sufficient for presentation viewing?
+- Is contrast between text and background adequate?
+- Is the hierarchy between title, subtitle, body text, captions, and highlights visually obvious?
+- Is reading order natural and effortless?
+- Are charts, icons, diagrams, and images recognizable and not blurry?
+- Is information density appropriate?
+
+Penalize:
+- Small or crowded text
+- Low contrast
+- Visual noise
+- Overlapping elements
+- Ambiguous hierarchy
+- Cluttered composition
+- Illegible charts/tables
+- Excessive decoration that harms readability
+
+### 2. Layout
+Evaluate structural organization and spatial discipline.
+
+Check:
+- Are elements aligned consistently?
+- Is spacing between blocks visually even and intentional?
+- Is whitespace used effectively?
+- Is the composition balanced?
+- Are margins clean and professional?
+- Is the slide visually stable rather than chaotic?
+- Are elements properly grouped?
+
+Penalize:
+- Misalignment
+- Uneven spacing
+- Cramped layout
+- Excessive empty space
+- Floating or disconnected elements
+- Poor balance
+- Edge crowding
+- Inconsistent sizing
+- Random placement
+
+### 3. Style Coherence
+Evaluate visual consistency and design system coherence.
+
+Check:
+- Are colors used consistently?
+- Are typography choices coherent?
+- Do containers/cards/shapes follow a unified style?
+- Are illustration styles consistent?
+- Are icon styles visually compatible?
+- Is decoration applied consistently across blocks?
+- Does the slide feel like one unified design system?
+
+Penalize:
+- Mixed visual styles
+- Inconsistent fonts
+- Random accent colors
+- Incompatible iconography
+- Uneven border/shadow usage
+- Inconsistent image treatment
+- Decorative elements that conflict stylistically
+- Abrupt style changes between blocks
+
+### 4. Presentation Professionalism
+Evaluate whether the slide resembles a realistic, production-quality professional PPT.
+
+Check:
+- Does the slide look polished and presentation-ready?
+- Would the slide be acceptable in a business, academic, investor, consulting, or conference setting?
+- Is the visual quality comparable to professionally designed slides?
+- Does the slide avoid common AI-generation artifacts?
+- Does the slide appear intentional rather than auto-generated?
+
+Penalize:
+- Obvious AI artifacts
+- Distorted text or shapes
+- Unrealistic layout behavior
+- Amateur styling
+- Excessive gimmicks
+- Poor typography discipline
+- Inconsistent rendering quality
+- Visually cheap or template-like appearance
+- Lack of refinement
+
+## Strict Scoring Rules
+
+You MUST apply these hard constraints strictly.
+
+### General Rules
+- Every visible issue counts as a mismatch.
+- Small defects still require deduction.
+- Do NOT assume missing details are correct.
+- If uncertain between two scores, choose the lower one.
+- Aesthetic attractiveness MUST NOT compensate for structural or readability flaws.
+
+### Sub-dimension Caps
+- Score 9-10 ONLY if there are essentially no noticeable flaws.
+- Score 8 is allowed only for very minor defects.
+- Any clearly noticeable defect caps the sub-dimension at 7.
+- Two or more noticeable defects cap the sub-dimension at 6.
+- Any major readability/layout/professionalism issue caps the sub-dimension at 5.
+- Multiple major issues cap the sub-dimension at 4 or below.
+- Severe readability failure MUST score 3 or below.
+
+### Automatic Major Defects
+The following are considered major defects:
+- Illegible or blurry text
+- Overlapping content
+- Broken hierarchy
+- Chaotic layout
+- Severe alignment inconsistency
+- Strong visual clutter
+- Distorted charts/icons
+- Mixed incompatible styles
+- Obvious AI rendering artifacts
+- Unprofessional appearance
+
+## Scoring Rubric
+
+- **9-10 (Excellent)**: Extremely polished, highly readable, visually disciplined, and indistinguishable from a professionally designed presentation slide. No meaningful flaws.
+- **7-8 (Good)**: Strong overall quality, but includes noticeable issues in spacing, hierarchy, consistency, or polish.
+- **5-6 (Fair)**: Moderately effective but contains multiple visible weaknesses that reduce professionalism or readability.
+- **3-4 (Poor)**: Significant design and communication problems. Slide appears unrefined or structurally weak.
+- **1-2 (Very Poor)**: Severely unreadable, chaotic, inconsistent, or obviously broken. Does not resemble a usable professional PPT slide.
+
+## Scoring Bias Control
+
+- Do not use 8 as a default “safe” score.
+- Prefer 5-7 unless evidence strongly supports higher quality.
+- Do not reward effort, complexity, or decoration.
+- Professional simplicity should score higher than decorative clutter.
+- Conservative scoring is preferred.
+
+## Output Format
+
+You MUST respond in the following JSON format ONLY. Do not include any other text:
+
+```json
+{
+  "clarity": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation with concrete evidence>"
+  },
+  "layout": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation with concrete evidence>"
+  },
+  "style_coherence": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation with concrete evidence>"
+  },
+  "presentation_professionalism": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation with concrete evidence>"
+  },
+  "overall_score": <1-10 mean of the sub-dimension scores>,
+  "overall_reasoning": "<2-3 sentence summary grounded in visible strengths and defects>"
+}

eval/prompts/content_faithfulness.txt

@@ -0,0 +1,202 @@
+You are an expert evaluator for AI-generated presentation slides.
+
+Your task is to assess **Content Faithfulness** by rigorously verifying whether all required sub-images in a provided sub-image list are correctly represented in the generated PPT.
+
+Your default stance is skeptical and conservative. Do NOT assume a sub-image is correctly matched unless there is strong visual evidence. Partial similarity is NOT sufficient for full credit.
+
+The focus is strict faithfulness to required content, NOT aesthetic quality.
+
+## Evaluation Target
+
+Evaluate whether every required sub-image (content block) from the sub-image list appears in the generated PPT with:
+
+- correct semantic content
+- correct visual identity
+- correct structural composition
+- reasonable positional/layout consistency
+
+Each sub-image may represent:
+- charts
+- tables
+- figures
+- diagrams
+- screenshots
+- icon groups
+- text blocks
+- mixed visual compositions
+
+You MUST verify each required sub-image individually before assigning scores.
+
+## Inputs
+
+1. **Generated PPT**: The AI-generated presentation file to be evaluated.
+2. **Sub-Image List**: A list of required sub-images that must appear in the generated PPT.
+
+## Mandatory Evaluation Procedure
+
+Follow this exact order:
+
+1. Enumerate all required sub-images from the sub-image list.
+2. For EACH required sub-image:
+   - search for the best matching region/page in the generated PPT
+   - determine whether it is:
+     - EXACT_MATCH
+     - PARTIAL_MATCH
+     - FAIL
+     - NOT_FOUND
+3. Explicitly verify:
+   - semantic content
+   - major text
+   - chart/table meaning
+   - visual composition
+   - structural arrangement
+4. Count mismatches:
+   - PARTIAL_MATCH counts as a mismatch
+   - FAIL counts as a mismatch
+   - NOT_FOUND counts as a major mismatch
+5. Apply hard score caps before assigning the final score.
+6. Compute final score conservatively.
+
+Never score first and justify later.
+
+If content is blurry, ambiguous, cropped, occluded, distorted, or difficult to verify, treat it as NOT fully matched.
+
+## Evaluation Criteria
+
+### 1. Coverage Completeness
+Check whether ALL required sub-images are present.
+
+Requirements:
+- Every required sub-image must appear somewhere in the PPT.
+- Presence alone is NOT enough; the matched region must clearly correspond to the intended content block.
+- Missing required sub-images are major failures.
+
+Penalize:
+- Missing blocks
+- Replaced blocks
+- Hallucinated substitute content
+- Severe cropping
+- Wrong slide/page placement if it breaks intended correspondence
+
+### 2. Content Correctness
+Check whether matched sub-images preserve the intended semantic content.
+
+Verify:
+- Main text content
+- Key labels
+- Chart type and meaning
+- Table structure and values (when visible)
+- Diagram semantics
+- Important icons/symbols
+- Core visual identity
+
+Penalize:
+- Wrong chart type
+- Incorrect labels
+- Missing important elements
+- Hallucinated text
+- Semantic mismatch
+- Incorrect data relationships
+- Wrong figure identity
+- Fake or placeholder content
+
+Superficial resemblance is NOT sufficient.
+
+### 3. Visual / Structural Consistency
+Check whether the matched content block is structurally consistent with the required sub-image.
+
+Verify:
+- Overall composition
+- Relative arrangement of elements
+- Element grouping
+- Layout pattern
+- Visual hierarchy
+- Spatial organization
+
+Minor stylistic differences are acceptable ONLY if the semantic and structural identity remain clearly faithful.
+
+Penalize:
+- Major layout restructuring
+- Missing key visual regions
+- Incorrect element arrangement
+- Collapsed or merged structures
+- Broken hierarchy
+- Distorted composition
+
+## Strict Scoring Rules
+
+You MUST apply these hard constraints strictly.
+
+### General Principles
+- Any missing required sub-image is a major error.
+- Any ambiguous match should be downgraded.
+- Similar-looking but semantically incorrect content is a FAIL.
+- Do NOT infer correctness from approximate appearance alone.
+- If uncertain between two scores, choose the lower score.
+
+### Match-Level Interpretation
+- EXACT_MATCH:
+  - Correct semantic content
+  - Correct structural composition
+  - No meaningful missing elements
+- PARTIAL_MATCH:
+  - Some recognizable correspondence exists
+  - But important content/structure differs or is missing
+- FAIL:
+  - Wrong semantic content
+  - Wrong structure
+  - Hallucinated replacement
+  - Severe distortion
+- NOT_FOUND:
+  - Required sub-image cannot be reliably identified anywhere in the PPT
+
+### Hard Score Caps
+- Any NOT_FOUND item caps overall_score at 6.
+- Two or more NOT_FOUND items cap overall_score at 4.
+- Any major semantic mismatch caps overall_score at 5.
+- Multiple FAIL items cap overall_score at 4.
+- If more than 30% of sub-images are PARTIAL_MATCH or worse, overall_score MUST NOT exceed 6.
+- If more than 50% are PARTIAL_MATCH or worse, overall_score MUST NOT exceed 4.
+- Perfect scores (9-10) are ONLY allowed when ALL required sub-images are present with near-perfect semantic and structural fidelity.
+
+### Severity Guidelines
+Major errors include:
+- Missing required block
+- Wrong chart/table/diagram identity
+- Incorrect semantic meaning
+- Hallucinated replacement content
+- Major structural mismatch
+- Severe cropping or truncation
+
+Minor errors include:
+- Small local visual deviations
+- Slight spacing/layout changes
+- Minor style differences
+- Small non-critical omissions
+
+## Scoring Rubric (1-10)
+
+- **9-10 (Excellent)**: All required sub-images are present with highly accurate semantic and structural fidelity. No meaningful mismatches.
+- **7-8 (Good)**: Most required sub-images are correct, but some minor omissions or structural inconsistencies exist.
+- **5-6 (Fair)**: Noticeable missing, partial, or incorrect sub-images reduce overall faithfulness.
+- **3-4 (Poor)**: Many required sub-images are missing, structurally wrong, or semantically incorrect.
+- **1-2 (Very Poor)**: Most required content is absent, hallucinated, or fundamentally mismatched.
+
+## Scoring Bias Control
+
+- Do NOT use score 8 as a default safe score.
+- Prefer conservative scoring.
+- Similar appearance alone MUST NOT receive high scores.
+- Semantic correctness is more important than visual attractiveness.
+- Presence alone is insufficient without content fidelity.
+- If evidence is weak or unclear, lower the score.
+
+## Output Format
+
+You MUST respond in the following JSON format ONLY. Do not include any other text:
+
+```json
+{
+  "overall_score": <1-10>,
+  "overall_reasoning": "<2-4 sentence summary explicitly discussing missing sub-images, semantic mismatches, structural inconsistencies, and overall faithfulness quality>"
+}

eval/prompts/edit_evaluation_quality.txt

@@ -0,0 +1,24 @@
+You are an expert evaluator for instruction-guided slide image editing.
+All images are AI-generated slide pages. Focus on the editing result itself.
+
+IMPORTANT: Return exactly one JSON object in this format:
+{
+  "reasoning": "...",
+  "score": [...]
+}
+Keep the reasoning concise.
+
+RULES:
+
+One edited slide image will be provided.
+Evaluate the presentation quality of the edited slide page itself using a 0 to 10 scale for each dimension:
+1. Clarity: text/chart readability, hierarchy, and reading order.
+2. Layout: alignment, spacing, composition balance, and use of whitespace.
+3. Style Coherence: consistency of colors, fonts, decoration, and image style.
+4. Presentation Professionalism: whether the page looks polished and like a real professional slide.
+
+Return:
+{
+  "reasoning": "...",
+  "score": [clarity, layout, style_coherence, presentation_professionalism]
+}

eval/prompts/edit_evaluation_source_control.txt

@@ -0,0 +1,26 @@
+You are an expert evaluator for instruction-guided slide image editing.
+All images are AI-generated slide pages. Focus on the editing result itself.
+
+IMPORTANT: Return exactly one JSON object in this format:
+{
+  "reasoning": "...",
+  "score": [...]
+}
+Keep the reasoning concise.
+
+RULES:
+
+Two images will be provided: the first is the source slide and the second is the edited slide.
+Evaluate whether the edit instruction is correctly applied while preserving all content that should remain unchanged.
+
+Use a 0 to 10 scale for both scores:
+1. Editing Success: 0 means the instruction is not followed at all, 10 means the requested slide edit is executed perfectly.
+2. Overediting: 0 means the slide is unnecessarily changed or damaged, 10 means only the intended parts are changed and the rest is preserved well.
+
+Return:
+{
+  "reasoning": "...",
+  "score": [editing_success, overediting]
+}
+
+Instruction: <instruction>

eval/prompts/style_instruction_following_json.txt

@@ -0,0 +1,138 @@
+You are an expert evaluator for AI-generated presentation slides. Your task is to assess how well a generated slide image follows the style instructions defined in a structured Style JSON specification.
+
+Your default stance is skeptical and conservative. Start from strict compliance assumptions and deduct for every mismatch. Do not reward visual attractiveness.
+
+## Evaluation Dimension: Style Instruction Following
+
+This dimension evaluates whether the generated slide image faithfully follows the given style specification. The focus is NOT on whether the result looks beautiful, but on whether it was made according to the requirements. The evaluation MUST be based on strict comparison with the Style JSON. Visual appeal or subjective quality MUST NOT influence the score. Even small deviations from the specification should be penalized.
+
+## Inputs
+
+1. **Style JSON**: A structured JSON specification that defines the visual style requirements for the slide, including:
+   - `global_style`: Theme name, background (color, gradient, texture, pattern), font palette, color palette, and special instructions
+   - `visual_hierarchy`: Mood/tone and composition style
+   - `styled_slides[].blocks`: Individual content blocks with their style attributes (color, font, position, container, text effects, etc.)
+
+2. **Generated Slide Image**: The AI-generated slide image that should conform to the Style JSON specification.
+
+3. **Reference Slide Image(s) [optional]**: One slide from the same presentation, generated earlier in the same deck. Use these only to infer the visual style of the presentation, such as palette, typography, background treatment, decorative motifs, and overall aesthetic language. Do NOT use them to infer or judge the target slide's layout, block positions, or content placement unless those details are explicitly present in the Style JSON.
+
+You MUST explicitly check each requirement in the Style JSON and verify whether it is present in the generated slide. Do NOT assume correctness without visual evidence.
+
+You MUST perform requirement-by-requirement verification before scoring. If an item cannot be clearly verified from the image, treat it as not satisfied.
+
+## Mandatory Evaluation Procedure
+
+Follow this exact order:
+
+1. Extract all checkable requirements from Style JSON (global + hierarchy + block-level).
+2. For each requirement, assign one status: PASS / PARTIAL / FAIL / NOT_VERIFIABLE.
+3. Count mismatches. Any PARTIAL, FAIL, or NOT_VERIFIABLE counts as a mismatch.
+4. Apply hard score caps first (see Strict Scoring Rules), then assign sub-dimension scores.
+5. Compute the overall score as the mean of the sub-dimension scores.
+
+Never skip steps. Never score first and justify later.
+
+## Evaluation Criteria
+
+Evaluate the following sub-dimensions carefully:
+
+### 1. Background Compliance
+- Does the background color match the specified hex code?
+- If a gradient is specified, does the background show the correct gradient direction and colors?
+- Are specified textures (paper, noise, grid, dots) or patterns present?
+
+### 2. Color Palette Adherence
+- Does the slide use the specified primary, secondary, text, and accent colors?
+- Are the color relationships (primary vs secondary vs accent) maintained?
+- Do text elements use the specified text color?
+
+### 3. Typography Compliance
+- Does the font style match the specified font families (serif vs sans-serif, bold vs regular)?
+- Is the font weight (bold/normal/light) correctly applied?
+- Are text effects (shadow, outline, glow) applied as specified?
+
+### 4. Layout & Position Accuracy
+- Are elements positioned as specified (e.g., "top-left", "center", "bottom-right")?
+- Does the composition style match (e.g., centered, two-column, asymmetric, grid-based)?
+- Is the visual hierarchy maintained (dominant elements are larger/more prominent)?
+
+### 5. Mood & Atmosphere Match
+- Does the overall mood match the specified mood_tone (e.g., Professional, Technical, Playful)?
+- Are special instructions in the global_style followed?
+- Do decorative elements and visual embellishments match the description?
+
+### 6. Block-Level Style Fidelity
+- For each block, are the specified style attributes (container, opacity, special_instructions) followed?
+- Are illustration blocks rendered according to their natural language descriptions?
+- Do image containers have the specified effects (border, shadow, frame)?
+
+## Strict Scoring Rules
+
+- Any clear mismatch with the Style JSON (e.g., wrong color, incorrect layout, missing effect) MUST result in a score of 6 or below for that sub-dimension.
+- Multiple mismatches in one dimension MUST result in a score of 4 or below.
+- If a key requirement (e.g., background type, layout structure, primary color) is missing or incorrect, the score for that dimension MUST NOT exceed 5.
+- Perfect or near-perfect scores (9-10) are ONLY allowed when there are NO noticeable deviations.
+- If uncertain, always choose the lower score.
+
+Additional hard constraints (must enforce):
+
+- A sub-dimension can be 9-10 only if ALL its checkable requirements are PASS and zero mismatches exist.
+- A sub-dimension can be at most 8 if there is any PARTIAL.
+- A sub-dimension can be at most 6 if there is any FAIL.
+- A sub-dimension can be at most 5 if any key requirement in that dimension is FAIL or NOT_VERIFIABLE.
+- A sub-dimension can be at most 4 if mismatch count in that dimension is 2 or more.
+- A sub-dimension can be at most 3 if mismatch count in that dimension is 3 or more.
+- Do not give score 7-10 when evidence is weak, ambiguous, occluded, or not visible.
+
+## Scoring Rubric
+
+- **9-10 (Excellent)**: Nearly perfect match. NO visible mismatches in color, layout, typography, or mood.
+- **7-8 (Good)**: Mostly correct, but includes noticeable deviations that affect fidelity.
+- **5-6 (Fair)**: Multiple deviations or one major mismatch in key style elements.
+- **3-4 (Poor)**: Significant mismatches in several dimensions; style is only partially recognizable.
+- **1-2 (Very Poor)**: Style instructions are largely ignored or contradicted.
+
+Scoring bias control:
+
+- Do not use score 8 as a default "safe" score.
+- Prefer 5-7 unless there is strong evidence for higher.
+- Aesthetic quality, creativity, readability, and beauty must not raise the score if fidelity is weak.
+- If two score options seem plausible, choose the lower one.
+
+## Output Format
+
+You MUST respond in the following JSON format ONLY. Do not include any other text:
+
+```json
+{
+  "background_compliance": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "color_palette_adherence": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "typography_compliance": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "layout_position_accuracy": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "mood_atmosphere_match": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "block_level_style_fidelity": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "overall_score": <1-10 mean of the sub-dimension scores>,
+  "overall_reasoning": "<2-3 sentence summary of the overall style instruction following quality>"
+}
+```
+
+Reasoning must be evidence-grounded and mention concrete mismatches (for example: wrong hex family, missing texture, incorrect block position, missing effect, wrong hierarchy emphasis).

eval/prompts/style_instruction_following_text.txt

@@ -0,0 +1,138 @@
+You are an expert evaluator for AI-generated presentation slides. Your task is to assess how well a generated slide image follows the style instructions defined in a descriptive style specification text.
+
+Your default stance is skeptical and conservative. Start from strict compliance assumptions and deduct for every mismatch. Do not reward visual attractiveness.
+
+## Evaluation Dimension: Style Instruction Following
+
+This dimension evaluates whether the generated slide image faithfully follows the given style specification. The focus is NOT on whether the result looks beautiful, but on whether it was made according to the requirements. The evaluation MUST be based on strict comparison with the style description text. Visual appeal or subjective quality MUST NOT influence the score. Even small deviations from the specification should be penalized.
+
+## Inputs
+
+1. **Style Description Text**: A descriptive text specification that defines the visual style requirements for the slide, potentially including:
+  - Theme name, background style (color, gradient, texture, pattern), font palette, color palette, and special instructions
+  - Mood/tone and composition style
+  - Block-level style requirements (color, font, position, container, text effects, etc.)
+
+2. **Generated Slide Image**: The AI-generated slide image that should conform to the style description text.
+
+3. **Reference Slide Image(s) [optional]**: One slide from the same presentation, generated earlier in the same deck. Use these only to infer the visual style of the presentation, such as palette, typography, background treatment, decorative motifs, and overall aesthetic language. Do NOT use them to infer or judge the target slide's layout, block positions, or content placement unless those details are explicitly present in the style description text.
+
+You MUST explicitly check each requirement in the style description text and verify whether it is present in the generated slide. Do NOT assume correctness without visual evidence.
+
+You MUST perform requirement-by-requirement verification before scoring. If an item cannot be clearly verified from the image, treat it as not satisfied.
+
+## Mandatory Evaluation Procedure
+
+Follow this exact order:
+
+1. Extract all checkable requirements from the style description text (global + hierarchy + block-level).
+2. For each requirement, assign one status: PASS / PARTIAL / FAIL / NOT_VERIFIABLE.
+3. Count mismatches. Any PARTIAL, FAIL, or NOT_VERIFIABLE counts as a mismatch.
+4. Apply hard score caps first (see Strict Scoring Rules), then assign sub-dimension scores.
+5. Compute the overall score as the mean of the sub-dimension scores.
+
+Never skip steps. Never score first and justify later.
+
+## Evaluation Criteria
+
+Evaluate the following sub-dimensions carefully:
+
+### 1. Background Compliance
+- Does the background color match the specified hex code?
+- If a gradient is specified, does the background show the correct gradient direction and colors?
+- Are specified textures (paper, noise, grid, dots) or patterns present?
+
+### 2. Color Palette Adherence
+- Does the slide use the specified primary, secondary, text, and accent colors?
+- Are the color relationships (primary vs secondary vs accent) maintained?
+- Do text elements use the specified text color?
+
+### 3. Typography Compliance
+- Does the font style match the specified font families (serif vs sans-serif, bold vs regular)?
+- Is the font weight (bold/normal/light) correctly applied?
+- Are text effects (shadow, outline, glow) applied as specified?
+
+### 4. Layout & Position Accuracy
+- Are elements positioned as specified (e.g., "top-left", "center", "bottom-right")?
+- Does the composition style match (e.g., centered, two-column, asymmetric, grid-based)?
+- Is the visual hierarchy maintained (dominant elements are larger/more prominent)?
+
+### 5. Mood & Atmosphere Match
+- Does the overall mood match the specified mood_tone (e.g., Professional, Technical, Playful)?
+- Are global style instructions in the style description text followed?
+- Do decorative elements and visual embellishments match the description?
+
+### 6. Block-Level Style Fidelity
+- For each block, are the specified style attributes (container, opacity, and any block-level special instructions) followed?
+- Are illustration blocks rendered according to their natural language descriptions?
+- Do image containers have the specified effects (border, shadow, frame)?
+
+## Strict Scoring Rules
+
+- Any clear mismatch with the style description text (e.g., wrong color, incorrect layout, missing effect) MUST result in a score of 6 or below for that sub-dimension.
+- Multiple mismatches in one dimension MUST result in a score of 4 or below.
+- If a key requirement (e.g., background type, layout structure, primary color) is missing or incorrect, the score for that dimension MUST NOT exceed 5.
+- Perfect or near-perfect scores (9-10) are ONLY allowed when there are NO noticeable deviations.
+- If uncertain, always choose the lower score.
+
+Additional hard constraints (must enforce):
+
+- A sub-dimension can be 9-10 only if ALL its checkable requirements are PASS and zero mismatches exist.
+- A sub-dimension can be at most 8 if there is any PARTIAL.
+- A sub-dimension can be at most 6 if there is any FAIL.
+- A sub-dimension can be at most 5 if any key requirement in that dimension is FAIL or NOT_VERIFIABLE.
+- A sub-dimension can be at most 4 if mismatch count in that dimension is 2 or more.
+- A sub-dimension can be at most 3 if mismatch count in that dimension is 3 or more.
+- Do not give score 7-10 when evidence is weak, ambiguous, occluded, or not visible.
+
+## Scoring Rubric
+
+- **9-10 (Excellent)**: Nearly perfect match. NO visible mismatches in color, layout, typography, or mood.
+- **7-8 (Good)**: Mostly correct, but includes noticeable deviations that affect fidelity.
+- **5-6 (Fair)**: Multiple deviations or one major mismatch in key style elements.
+- **3-4 (Poor)**: Significant mismatches in several dimensions; style is only partially recognizable.
+- **1-2 (Very Poor)**: Style instructions are largely ignored or contradicted.
+
+Scoring bias control:
+
+- Do not use score 8 as a default "safe" score.
+- Prefer 5-7 unless there is strong evidence for higher.
+- Aesthetic quality, creativity, readability, and beauty must not raise the score if fidelity is weak.
+- If two score options seem plausible, choose the lower one.
+
+## Output Format
+
+You MUST respond in the following JSON format ONLY. Do not include any other text:
+
+```json
+{
+  "background_compliance": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "color_palette_adherence": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "typography_compliance": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "layout_position_accuracy": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "mood_atmosphere_match": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "block_level_style_fidelity": {
+    "score": <1-10>,
+    "reasoning": "<brief explanation>"
+  },
+  "overall_score": <1-10 mean of the sub-dimension scores>,
+  "overall_reasoning": "<2-3 sentence summary of the overall style instruction following quality>"
+}
+```
+
+Reasoning must be evidence-grounded and mention concrete mismatches (for example: wrong hex family, missing texture, incorrect block position, missing effect, wrong hierarchy emphasis).

eval/requirements.txt

@@ -0,0 +1,4 @@
+openai>=1.40
+rapidfuzz>=3.0
+pillow>=10.0
+numpy

eval/run_ocr.py

@@ -0,0 +1,95 @@
+"""Step 1 of Content Faithfulness: OCR every generated slide.
+
+Uses PaddleOCR 3.x (paddleocr==3.3.2 in our runs) and merges detected boxes
+into text lines. Output: one text file per case, one recognized line per row.
+
+    python eval/run_ocr.py --task t2i --pred_dir outputs/my_model --device gpu:0
+"""
+
+import argparse
+import os
+from pathlib import Path
+
+import numpy as np
+
+from common import bench_path, load_jsonl
+
+
+def merge_ocr_lines(texts, polys, y_thresh_ratio=0.5, x_gap_ratio=1.2):
+    """Group OCR boxes into lines (top to bottom), then join neighbours left to right.
+
+    A box joins the first line whose running vertical center is within
+    0.5 x the mean box height of that line. Inside a line, two neighbours are
+    joined when the horizontal gap is at most 1.2 x their mean height; a space
+    is inserted only between two ASCII characters.
+    """
+    items = []
+    for text, poly in zip(texts, polys):
+        text = text.strip()
+        if not text:
+            continue
+        poly = np.asarray(poly)
+        left, right = poly[:, 0].min(), poly[:, 0].max()
+        top, bottom = poly[:, 1].min(), poly[:, 1].max()
+        items.append({"text": text, "left": left, "right": right, "height": bottom - top, "cy": (top + bottom) / 2})
+    items.sort(key=lambda x: x["cy"])
+
+    lines = []
+    for it in items:
+        for line in lines:
+            if abs(line["cy"] - it["cy"]) <= np.mean([i["height"] for i in line["items"]]) * y_thresh_ratio:
+                line["items"].append(it)
+                line["cy"] = np.mean([i["cy"] for i in line["items"]])
+                break
+        else:
+            lines.append({"cy": it["cy"], "items": [it]})
+
+    merged = []
+    for line in lines:
+        row = sorted(line["items"], key=lambda x: x["left"])
+        cur, prev = row[0]["text"], row[0]
+        for it in row[1:]:
+            if it["left"] - prev["right"] <= (prev["height"] + it["height"]) / 2 * x_gap_ratio:
+                cur += (" " if cur[-1].isascii() and it["text"][0].isascii() else "") + it["text"]
+            else:
+                merged.append(cur)
+                cur = it["text"]
+            prev = it
+        merged.append(cur)
+    return merged
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--task", required=True, choices=["t2i", "template", "multi_image"])
+    ap.add_argument("--pred_dir", required=True, help="Folder with <task>/<id>.png predictions.")
+    ap.add_argument("--out_dir", default=None, help="Defaults to <pred_dir>/ocr.")
+    ap.add_argument("--device", default="gpu:0", help="PaddleOCR device, e.g. gpu:0 or cpu.")
+    args = ap.parse_args()
+
+    from paddleocr import PaddleOCR
+
+    ocr = PaddleOCR(
+        device=args.device,
+        use_doc_orientation_classify=True,
+        use_doc_unwarping=False,
+        use_textline_orientation=True,
+    )
+    out_dir = Path(args.out_dir or os.path.join(args.pred_dir, "ocr")) / args.task
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    cases = load_jsonl(bench_path(f"data/{args.task}.jsonl"))
+    for case in cases:
+        img = Path(args.pred_dir) / args.task / f"{case['id']}.png"
+        dst = out_dir / f"{case['id']}.txt"
+        if not img.exists() or dst.exists():
+            continue
+        lines = []
+        for res in ocr.predict(input=str(img)):
+            lines += merge_ocr_lines(res.get("rec_texts") or [], res.get("rec_polys") or [])
+        dst.write_text("\n".join(l for l in lines if l) + "\n", encoding="utf-8")
+    print(f"OCR written to {out_dir}")
+
+
+if __name__ == "__main__":
+    main()

eval/score_edit.py

@@ -0,0 +1,74 @@
+"""Score the edit track: Semantic Consistency (SC) and Presentation Quality (PQ).
+
+Predictions are read from <pred_dir>/edit/<id>.png.
+
+    python eval/score_edit.py --pred_dir outputs/my_model --workers 16
+
+SC = min(editing_success, overediting), judged from (source, edited) slides.
+PQ = unweighted mean of clarity, layout, style coherence, professionalism,
+     judged from the edited slide alone.
+Edit score = sqrt(SC * PQ). One call per prompt, temperature 0.7, 512 tokens.
+"""
+
+import argparse
+import json
+import math
+import os
+import re
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from common import bench_path, chat, get_client, image_part, load_jsonl, load_prompt, mean, write_jsonl
+
+
+def _numbers(values, n):
+    nums = []
+    for v in values if isinstance(values, list) else []:
+        if isinstance(v, (int, float)):
+            nums.append(float(v))
+        elif isinstance(v, str) and re.search(r"-?\d+(?:\.\d+)?", v):
+            nums.append(float(re.search(r"-?\d+(?:\.\d+)?", v).group()))
+    return (nums + [5.0] * n)[:n]  # missing values fall back to the scale midpoint
+
+
+def score_case(client, case, img):
+    sc_prompt = load_prompt("edit_evaluation_source_control.txt").replace("<instruction>", case["instruction"])
+    sc_res = chat(client, "", [image_part(bench_path(case["source_image"])), image_part(img), {"type": "text", "text": sc_prompt}], 0.7, 512)
+    pq_res = chat(client, "", [image_part(img), {"type": "text", "text": load_prompt("edit_evaluation_quality.txt")}], 0.7, 512)
+    success, preserve = _numbers(sc_res.get("score"), 2)
+    pq = mean(_numbers(pq_res.get("score"), 4))
+    sc = min(success, preserve)
+    return {"id": case["id"], "operation": case["operation"], "editing_success": success, "edit_consistency": preserve,
+            "sc": sc, "pq": pq, "edit_score": math.sqrt(max(sc, 0) * max(pq, 0))}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pred_dir", required=True)
+    ap.add_argument("--out", default=None, help="Defaults to <pred_dir>/scores/edit.jsonl.")
+    ap.add_argument("--workers", type=int, default=8)
+    args = ap.parse_args()
+
+    client = get_client()
+    cases = load_jsonl(bench_path("data/edit.jsonl"))
+
+    def run(case):
+        img = Path(args.pred_dir) / "edit" / f"{case['id']}.png"
+        if not img.exists():
+            return {"id": case["id"], "error": "missing prediction"}
+        try:
+            return score_case(client, case, str(img))
+        except Exception as e:
+            return {"id": case["id"], "error": repr(e)}
+
+    with ThreadPoolExecutor(args.workers) as ex:
+        rows = list(ex.map(run, cases))
+    out = args.out or os.path.join(args.pred_dir, "scores", "edit.jsonl")
+    write_jsonl(out, rows)
+    ok = [r for r in rows if "sc" in r]
+    sc, pq = mean(r["sc"] for r in ok), mean(r["pq"] for r in ok)
+    print(json.dumps({"task": "edit", "sc": sc, "pq": pq, "edit": math.sqrt(sc * pq) if ok else None, "n_scored": len(ok)}, indent=1))
+
+
+if __name__ == "__main__":
+    main()

eval/score_generation.py

@@ -0,0 +1,207 @@
+"""Score one generation task: Content Faithfulness (CF), Instruction Following (IF), Aesthetic Quality (AQ).
+
+Run `run_ocr.py` first. Predictions are read from <pred_dir>/<task>/<id>.png.
+
+    python eval/score_generation.py --task multi_image --pred_dir outputs/my_model --workers 16
+
+CF   text: GPT-4.1 extracts the slide text the instruction requires; OCR lines
+           are re-joined against those strings; each required string is matched
+           to its closest OCR line by Levenshtein distance;
+           S_text = max(10 - 9 * sum(dist) / sum(len), 1).
+     multi_image adds an input-image preservation score (judge `overall_score`)
+           and CF = (S_text + S_image) / 2.
+IF   unweighted mean of six sub-dimensions (text or style_json prompt;
+     template cases also show the reference slide).
+AQ   unweighted mean of four sub-dimensions, judged from the output image only.
+"""
+
+import argparse
+import json
+import os
+import re
+from concurrent.futures import ThreadPoolExecutor
+from itertools import combinations
+from pathlib import Path
+
+from rapidfuzz import fuzz
+
+from common import (bench_path, chat, get_client, image_part, load_jsonl, load_prompt, mean,
+                    subdimension_mean, text_part, write_jsonl)
+
+EXTRACT_PROMPT = (
+    "From the following PPT instruction, extract ALL text strings that are explicitly written out and are required "
+    "to appear on the PPT page. This includes any quoted text, statements, captions, labels, or any other text that "
+    "is directly specified in the instruction as content to be displayed on the slide. DO NOT infer or generate new "
+    "text. Only extract what is explicitly present in the instruction and is required to be shown on the PPT. "
+    "Return ONLY a JSON array (Python list) of strings, each string is a text to be displayed. Do not output "
+    "anything except the JSON array."
+)
+
+
+# ----------------------------------------------------------------- CF (text)
+def levenshtein(a, b):
+    if a == b:
+        return 0
+    if not a or not b:
+        return len(a) or len(b)
+    prev = list(range(len(b) + 1))
+    for i, ca in enumerate(a, 1):
+        cur = [i]
+        for j, cb in enumerate(b, 1):
+            cur.append(min(cur[j - 1] + 1, prev[j] + 1, prev[j - 1] + (ca != cb)))
+        prev = cur
+    return prev[-1]
+
+
+def _norm(s):
+    return "".join(s.lower().split())
+
+
+def rejoin_lines(lines, targets, max_extra=3):
+    """Join OCR lines that together spell a required string (RapidFuzz ratio > 90)."""
+    target_norms = [_norm(t) for t in targets]
+    out, used = [], set()
+    for i, line in enumerate(lines):
+        if i in used:
+            continue
+        cur = _norm(line)
+        if cur in target_norms:
+            out.append(line)
+            used.add(i)
+            continue
+        joined = None
+        for tn in target_norms:
+            if fuzz.ratio(cur, tn[: len(cur)]) <= 90:
+                continue
+            for r in range(1, max_extra + 1):
+                for combo in combinations(range(i + 1, len(lines)), r):
+                    cand = " ".join(lines[k] for k in (i,) + combo)
+                    if fuzz.ratio(_norm(cand), tn) > 90:
+                        joined = (cand, (i,) + combo)
+                        break
+                if joined:
+                    break
+            if joined:
+                break
+        if joined:
+            out.append(joined[0])
+            used.update(joined[1])
+        else:
+            out.append(line)
+            used.add(i)
+    return out
+
+
+def text_score(targets, ocr_lines):
+    dist = sum(min(levenshtein(t, g) for g in ocr_lines) for t in targets)
+    total = sum(len(t) for t in targets)
+    return round(max(10 - 9 * dist / total, 1), 2)
+
+
+def extract_style_json(instruction):
+    """Return the JSON block of a style_json instruction (text after '### SLIDE JSON:')."""
+    idx = instruction.find("### SLIDE JSON:")
+    if idx < 0:
+        idx = instruction.find("```json")
+    if idx < 0:
+        return instruction
+    rest = instruction[idx:]
+    m = re.search(r"```json\s*\n(.*?)```", rest, re.DOTALL)
+    if m:
+        return m.group(1).strip()
+    s, e = rest.find("{"), rest.rfind("}")
+    return rest[s : e + 1] if 0 <= s < e else rest
+
+
+# ------------------------------------------------------------------- scoring
+def score_cf(client, task, case, img, ocr_file):
+    targets = chat(client, EXTRACT_PROMPT, case["instruction"], temperature=0.2, max_tokens=800)
+    targets = [str(t).strip() for t in targets if str(t).strip()] if isinstance(targets, list) else []
+    lines = [l.strip() for l in open(ocr_file, encoding="utf-8")] if os.path.exists(ocr_file) else []
+    lines = [l for l in lines if l]
+    if not targets or not lines:
+        return {"cf_error": "no required text extracted" if not targets else "no OCR text"}
+    out = {"cf_text": text_score(targets, rejoin_lines(lines, targets))}
+    out["cf"] = out["cf_text"]
+    if task == "multi_image":
+        content = [text_part("Generated PPT:"), image_part(img), text_part("Sub-Image List (required sub-images):")]
+        for k, p in enumerate(case["input_images"], 1):
+            content += [text_part(f"Sub-Image {k}:"), image_part(bench_path(p))]
+        res = chat(client, load_prompt("content_faithfulness.txt"), content, temperature=0.2, max_tokens=1200)
+        out["cf_image"] = float(res["overall_score"])
+        out["cf"] = round((out["cf_text"] + out["cf_image"]) / 2, 2)
+    return out
+
+
+def score_if(client, task, case, img):
+    is_json = "JSON" in case["instruction"]
+    if is_json:
+        content = [text_part(f"## Style JSON Specification\n\n```json\n{extract_style_json(case['instruction'])}\n```\n\n")]
+    else:
+        content = [text_part(f"## Style Description\n\n{case['instruction']}\n\n")]
+    if task == "template":
+        content += [
+            text_part(
+                "## Reference Slide Image (for style only)\n\nThe following image is a reference slide from the same "
+                "presentation. Use it only to infer the visual style (palette, typography, background, decorative "
+                "motifs, etc.), not for layout or content placement.\n"
+            ),
+            image_part(bench_path(case["input_images"][0])),
+        ]
+    content += [
+        text_part("## Generated Slide Image\n\nThe image below is the AI-generated slide. Evaluate how well it follows the style instructions above."),
+        image_part(img),
+    ]
+    prompt = "style_instruction_following_json.txt" if is_json else "style_instruction_following_text.txt"
+    return {"if": subdimension_mean(chat(client, load_prompt(prompt), content, temperature=0.2, max_tokens=2000))}
+
+
+def score_aq(client, img):
+    content = [text_part("## Generated Slide Image\n\nThe image below is the AI-generated slide. Evaluate its aesthetic quality."), image_part(img)]
+    return {"aq": subdimension_mean(chat(client, load_prompt("aesthetic_quality.txt"), content, temperature=0.2, max_tokens=2000))}
+
+
+def score_case(client, task, case, img, ocr_file):
+    """Each metric is scored independently; a failure leaves only that metric empty."""
+    out = {"id": case["id"], "source": case["source"], "prompt_type": case["prompt_type"]}
+    for name, fn in (("cf", lambda: score_cf(client, task, case, img, ocr_file)),
+                     ("if", lambda: score_if(client, task, case, img)),
+                     ("aq", lambda: score_aq(client, img))):
+        try:
+            out.update(fn())
+        except Exception as e:
+            out[f"{name}_error"] = repr(e)
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--task", required=True, choices=["t2i", "template", "multi_image"])
+    ap.add_argument("--pred_dir", required=True)
+    ap.add_argument("--ocr_dir", default=None, help="Defaults to <pred_dir>/ocr.")
+    ap.add_argument("--out", default=None, help="Defaults to <pred_dir>/scores/<task>.jsonl.")
+    ap.add_argument("--workers", type=int, default=8)
+    args = ap.parse_args()
+
+    client = get_client()
+    ocr_dir = Path(args.ocr_dir or os.path.join(args.pred_dir, "ocr")) / args.task
+    cases = load_jsonl(bench_path(f"data/{args.task}.jsonl"))
+
+    def run(case):
+        img = Path(args.pred_dir) / args.task / f"{case['id']}.png"
+        if not img.exists():
+            return {"id": case["id"], "error": "missing prediction"}
+        return score_case(client, args.task, case, str(img), str(ocr_dir / f"{case['id']}.txt"))
+
+    with ThreadPoolExecutor(args.workers) as ex:
+        rows = list(ex.map(run, cases))
+
+    out = args.out or os.path.join(args.pred_dir, "scores", f"{args.task}.jsonl")
+    write_jsonl(out, rows)
+    summary = {m: mean(r[m] for r in rows if r.get(m) is not None) for m in ("cf", "if", "aq")}
+    summary["n_scored"] = {m: sum(r.get(m) is not None for r in rows) for m in ("cf", "if", "aq")}
+    print(json.dumps({"task": args.task, **summary}, indent=1))
+
+
+if __name__ == "__main__":
+    main()