Upload bench_eval_code/eval_intelligent.py with huggingface_hub

bench_eval_code/eval_intelligent.py

@@ -0,0 +1,482 @@
+"""
+CPI-Bench: Intelligent benchmark evaluation script (open-source version).
+
+Evaluates image-editing expert-domain reasoning results (with reference image(s))
+using a 3-dimension weighted score:
+
+    1. Knowledge Reasoning (fuses `rationale` as reference material) — 45%
+    2. Visual Quality                                                — 30%
+    3. Input Consistency                                             — 25%
+   (degrades to Knowledge 60% + Visual 40% if the sample has no reference image)
+
+   Knowledge score <= 2 -> final weighted score is multiplied by 0.6
+   (penalty for factual/knowledge errors).
+
+Dataset format (CPI_intelligent_benchmark-*.parquet):
+    - id                       : str
+    - expert_domain            : str   (format: "<domain>-<subtask>")
+    - a_to_b_instructions      : str   (Chinese instruction)
+    - a_to_b_instructions_eng  : str   (English instruction)
+    - rationale                : str   (may be empty)
+    - target_resolution        : str
+    - source                   : List[PIL.Image]  (one or more reference images)
+
+Result JSONL format:
+    {"sample_index": 0, "result": "/path/to/result_0.png"}
+
+Output:
+    <output_dir>/cases.jsonl
+    <output_dir>/summary.json
+        - overall_avg_score / by_task_type / by_dimension : sample-weighted (micro) averages
+        - hierarchy                                       : re-aggregated by (domain, subtask)
+                                                             using each sample's own fields
+
+Usage:
+    python eval_intelligent.py \
+        --dataset_path "/path/to/CPI_intelligent_benchmark-*.parquet" \
+        --result_jsonl /path/to/my_results.jsonl \
+        --prompts_json prompts/intelligent_prompts.json \
+        --output_dir eval_output/my_model_intelligent \
+        --api_key YOUR_KEY \
+        --lang eng \
+        --workers 8
+"""
+
+import argparse
+import json
+import os
+import re
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import numpy as np
+from datasets import load_dataset
+from tqdm import tqdm
+
+from bench_utils import ApiKeyPool, call_vlm_with_retries, load_local_image, pil_to_base64
+
+DEFAULT_MODEL = "gemini-3-flash-preview"
+DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
+
+NO_RATIONALE_PLACEHOLDER = "(No reference rationale provided for this sample.)"
+
+INSTRUCTION_FIELD = "a_to_b_instructions"
+INSTRUCTION_FIELD_ENG = "a_to_b_instructions_eng"
+
+
+# ---------------------------------------------------------------------------
+# Prompts
+# ---------------------------------------------------------------------------
+
+def load_prompts(path: str) -> dict:
+    with open(path, "r", encoding="utf-8") as f:
+        cfg = json.load(f)
+    for key in ("dimensions", "task_focus"):
+        if key not in cfg:
+            raise KeyError(f"prompts.json missing key: '{key}'")
+    for dim in ("knowledge_reasoning", "visual_quality", "input_consistency"):
+        if dim not in cfg["dimensions"]:
+            raise KeyError(f"prompts.json 'dimensions' missing: '{dim}'")
+    return cfg
+
+
+def get_task_focus(cfg: dict, task: str) -> str:
+    return cfg["task_focus"].get(
+        task,
+        cfg.get("generic_focus", "Evaluate based on general domain knowledge accuracy."),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Result JSONL
+# ---------------------------------------------------------------------------
+
+def load_result_jsonl(path: str) -> "dict[int, str]":
+    index_to_path = {}
+    with open(path, "r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                entry = json.loads(line)
+            except json.JSONDecodeError as e:
+                print(f"Warning: malformed line {line_no}: {e}")
+                continue
+            idx = entry.get("sample_index")
+            result_path = entry.get("result")
+            if idx is None or result_path is None:
+                continue
+            index_to_path[int(idx)] = str(result_path)
+    return index_to_path
+
+
+# ---------------------------------------------------------------------------
+# Field access helpers
+# ---------------------------------------------------------------------------
+
+def get_expert_domain(sample: dict) -> str:
+    """Prefer the new `expert_domain` field; fall back to the legacy `task` field."""
+    return sample.get("expert_domain") or sample.get("task", "unknown-unknown")
+
+
+def split_domain_subtask(expert_domain: str) -> "tuple[str, str]":
+    if "-" in expert_domain:
+        domain, subtask = expert_domain.split("-", 1)
+    else:
+        domain, subtask = expert_domain, "unknown"
+    return domain, subtask
+
+
+def get_instruction(sample: dict, lang: str) -> str:
+    base = sample.get(INSTRUCTION_FIELD, "") or ""
+    if lang == "eng":
+        eng = sample.get(INSTRUCTION_FIELD_ENG, "") or ""
+        return eng or base
+    return base
+
+
+# ---------------------------------------------------------------------------
+# Score extraction
+# ---------------------------------------------------------------------------
+
+def extract_score(answer: str) -> "int | None":
+    if not answer:
+        return None
+    m = re.search(r"<score>\s*(\d+)\s*</score>", answer, re.IGNORECASE)
+    if m:
+        return int(m.group(1))
+    for pattern in (r"\*?\*?Final\s*Score\*?\*?\s*:?\s*\*?\*?\s*(\d+)",):
+        m = re.search(pattern, answer, re.IGNORECASE)
+        if m:
+            return int(m.group(1))
+    return None
+
+
+def is_valid_score(v) -> bool:
+    return v is not None and not (isinstance(v, float) and np.isnan(v))
+
+
+def weighted_score(knowledge, visual, consistency) -> "float | None":
+    """
+    Weighted composite score (1-5):
+        - With consistency:    Knowledge 45% + Visual 30% + Consistency 25%
+        - Without consistency: Knowledge 60% + Visual 40%  (safety fallback,
+          should rarely trigger for the i2i subset since it always has `source`)
+        - Knowledge <= 2 -> multiply final score by 0.6 (knowledge-error penalty)
+    """
+    if not is_valid_score(knowledge) or not is_valid_score(visual):
+        return None
+    if is_valid_score(consistency):
+        score = 0.45 * knowledge + 0.30 * visual + 0.25 * consistency
+    else:
+        score = 0.60 * knowledge + 0.40 * visual
+    if knowledge <= 2:
+        score *= 0.6
+    return round(score, 4)
+
+
+# ---------------------------------------------------------------------------
+# Single sample scoring
+# ---------------------------------------------------------------------------
+
+def score_one_sample(sample_index, dataset, result_path, prompts_cfg, lang, key_pool, base_url, model):
+    try:
+        sample = dataset[sample_index]
+    except (IndexError, KeyError) as e:
+        return {"sample_index": sample_index, "error": f"Dataset access failed: {e}"}
+
+    expert_domain = get_expert_domain(sample)
+    domain, subtask = split_domain_subtask(expert_domain)
+    sample_id = sample.get("id")
+    instruct = get_instruction(sample, lang)
+    rationale = (sample.get("rationale") or "").strip()
+    rationale_ref = rationale if rationale else NO_RATIONALE_PLACEHOLDER
+    source_images = sample.get("source") or []
+
+    if not os.path.exists(result_path):
+        return {"sample_index": sample_index, "task": expert_domain, "id": sample_id,
+                 "error": f"Result image not found: {result_path}"}
+
+    try:
+        result_img = load_local_image(result_path)
+    except Exception as e:
+        return {"sample_index": sample_index, "task": expert_domain, "id": sample_id,
+                 "error": f"Failed to load result image: {e}"}
+
+    result_b64 = pil_to_base64(result_img)
+    ref_b64_list = [pil_to_base64(img) for img in source_images]
+    domain_focus = get_task_focus(prompts_cfg, expert_domain)
+
+    def build_content(prompt_text, include_refs, include_result=True):
+        parts = [{"type": "text", "text": prompt_text}]
+        if include_refs:
+            for b64 in ref_b64_list:
+                parts.append({"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}})
+        if include_result:
+            parts.append({"type": "image_url", "image_url": {"url": f"data:image/png;base64,{result_b64}"}})
+        return parts
+
+    extra_body = {"enableThinking": False, "thinkingBudget": 1024}
+
+    # --- Dim 1: Knowledge Reasoning (fuses rationale) ---
+    ref_note = "5. One or more **reference input images** provided by the user." if ref_b64_list else ""
+    prompt_knowledge = prompts_cfg["dimensions"]["knowledge_reasoning"].format(
+        instruct=instruct, domain=domain, subtask=subtask,
+        domain_focus=domain_focus, ref_image_note=ref_note, rationale=rationale_ref,
+    )
+    judge_knowledge = call_vlm_with_retries(
+        build_content(prompt_knowledge, include_refs=True), key_pool, base_url, model,
+        extra_body=extra_body, tag=f"{expert_domain}-{sample_id}-knowledge",
+    )
+
+    # --- Dim 2: Visual Quality ---
+    prompt_visual = prompts_cfg["dimensions"]["visual_quality"].format(
+        instruct=instruct, domain=domain, subtask=subtask,
+    )
+    judge_visual = call_vlm_with_retries(
+        build_content(prompt_visual, include_refs=False), key_pool, base_url, model,
+        extra_body=extra_body, tag=f"{expert_domain}-{sample_id}-visual",
+    )
+
+    # --- Dim 3: Input Consistency (only when reference images exist) ---
+    judge_consistency = None
+    if ref_b64_list:
+        prompt_consistency = prompts_cfg["dimensions"]["input_consistency"].format(
+            instruct=instruct, domain=domain, subtask=subtask,
+        )
+        judge_consistency = call_vlm_with_retries(
+            build_content(prompt_consistency, include_refs=True), key_pool, base_url, model,
+            extra_body=extra_body, tag=f"{expert_domain}-{sample_id}-consistency",
+        )
+
+    score_knowledge = extract_score(judge_knowledge)
+    score_visual = extract_score(judge_visual)
+    score_consistency = extract_score(judge_consistency) if judge_consistency else None
+    avg = weighted_score(score_knowledge, score_visual, score_consistency)
+
+    return {
+        "sample_index": sample_index,
+        "id": sample_id,
+        "task": expert_domain,
+        "domain": domain,
+        "subtask": subtask,
+        "instruction": instruct,
+        "result_image": result_path,
+        "dimension_scores": {
+            "KnowledgeReasoning": score_knowledge,
+            "VisualQuality": score_visual,
+            "InputConsistency": score_consistency,
+        },
+        "avg_score": avg,
+        "judge_knowledge": judge_knowledge,
+        "judge_visual": judge_visual,
+        "judge_consistency": judge_consistency,
+        "error": None if avg is not None else "Failed to compute weighted score",
+    }
+
+
+# ---------------------------------------------------------------------------
+# Aggregation
+# ---------------------------------------------------------------------------
+
+def _agg(scores: list) -> dict:
+    """Return {avg_score, num_samples} for a list of per-sample scores."""
+    if not scores:
+        return {"avg_score": None, "num_samples": 0}
+    return {"avg_score": round(float(np.mean(scores)), 4), "num_samples": len(scores)}
+
+
+def build_hierarchy_summary(valid_cases: list) -> dict:
+    """Re-aggregate valid cases by (domain, subtask) taxonomy.
+
+    Uses sample-weighted (micro) averaging. Each sample's `domain` and
+    `subtask` fields (derived from `expert_domain`) are used directly — no
+    external map required.
+    """
+    domain_scores = defaultdict(list)
+    subtask_scores = defaultdict(list)   # key: (domain, subtask)
+    nested_scores = defaultdict(lambda: defaultdict(list))
+
+    for c in valid_cases:
+        domain = c.get("domain") or "unknown"
+        subtask = c.get("subtask") or "unknown"
+        score = c["avg_score"]
+        domain_scores[domain].append(score)
+        subtask_scores[(domain, subtask)].append(score)
+        nested_scores[domain][subtask].append(score)
+
+    by_domain = {domain: _agg(scores) for domain, scores in domain_scores.items()}
+    by_subtask = {
+        f"{domain} || {subtask}": _agg(scores)
+        for (domain, subtask), scores in subtask_scores.items()
+    }
+
+    nested = {}
+    for domain, subtask_dict in nested_scores.items():
+        all_scores = []
+        subtask_out = {}
+        for subtask, scores in subtask_dict.items():
+            subtask_out[subtask] = _agg(scores)
+            all_scores.extend(scores)
+        node = _agg(all_scores)
+        node["subtask"] = subtask_out
+        nested[domain] = node
+
+    return {
+        "by_domain": by_domain,
+        "by_subtask": by_subtask,
+        "nested": nested,
+    }
+
+
+def build_summary(cases: list) -> dict:
+    """Aggregate results using **micro (sample-weighted) averages**.
+
+    - `overall_avg_score`: mean weighted score over all valid samples.
+    - `by_task_type`: mean per `expert_domain`.
+    - `by_dimension`: global per-dimension micro averages.
+    - `hierarchy`: re-aggregation by (domain, subtask), using each sample's
+                    own `domain` / `subtask` fields (no external map needed).
+    """
+    valid = [c for c in cases if c.get("avg_score") is not None]
+    task_scores = defaultdict(list)
+    for c in valid:
+        task_scores[c["task"]].append(c["avg_score"])
+
+    by_task = {t: round(float(np.mean(s)), 2) for t, s in task_scores.items()}
+    overall = round(float(np.mean([c["avg_score"] for c in valid])), 2) if valid else 0.0
+
+    def dim_mean(dim):
+        vals = [c["dimension_scores"][dim] for c in valid if is_valid_score(c["dimension_scores"].get(dim))]
+        return round(float(np.mean(vals)), 2) if vals else None
+
+    summary = {
+        "overall_avg_score": overall,
+        "by_task_type": dict(sorted(by_task.items())),
+        "by_dimension": {
+            "KnowledgeReasoning": dim_mean("KnowledgeReasoning"),
+            "VisualQuality": dim_mean("VisualQuality"),
+            "InputConsistency": dim_mean("InputConsistency"),
+        },
+        "total_samples": len(cases),
+        "scored_samples": len(valid),
+        "error_samples": len(cases) - len(valid),
+        "hierarchy": build_hierarchy_summary(valid),
+    }
+    return summary
+
+
+# ---------------------------------------------------------------------------
+# Main pipeline
+# ---------------------------------------------------------------------------
+
+def run_evaluation(dataset, index_to_result, prompts_cfg, args, key_pool):
+    cases_path = os.path.join(args.output_dir, "cases.jsonl")
+
+    done_indices = set()
+    if os.path.exists(cases_path) and args.resume:
+        with open(cases_path, "r", encoding="utf-8") as f:
+            for line in f:
+                try:
+                    entry = json.loads(line)
+                    if entry.get("avg_score") is not None:
+                        done_indices.add(entry["sample_index"])
+                except json.JSONDecodeError:
+                    pass
+
+    pending = [i for i in sorted(index_to_result) if i not in done_indices]
+    print(f"Total: {len(index_to_result)}, already scored: {len(done_indices)}, pending: {len(pending)}")
+
+    mode = "a" if (args.resume and os.path.exists(cases_path)) else "w"
+    if pending:
+        with open(cases_path, mode, encoding="utf-8") as out_f:
+            with ThreadPoolExecutor(max_workers=args.workers) as executor:
+                futures = {
+                    executor.submit(
+                        score_one_sample, idx, dataset, index_to_result[idx],
+                        prompts_cfg, args.lang, key_pool, args.base_url, args.model,
+                    ): idx
+                    for idx in pending
+                }
+                for future in tqdm(as_completed(futures), total=len(futures), desc="Scoring"):
+                    result = future.result()
+                    out_f.write(json.dumps(result, ensure_ascii=False) + "\n")
+                    out_f.flush()
+
+    all_cases = []
+    with open(cases_path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                all_cases.append(json.loads(line))
+
+    summary = build_summary(all_cases)
+    summary_path = os.path.join(args.output_dir, "summary.json")
+    with open(summary_path, "w", encoding="utf-8") as f:
+        json.dump(summary, f, ensure_ascii=False, indent=2)
+
+    # ---- Terminal report ----
+    print("\n" + "=" * 60)
+    print(f"[intelligent] Overall (weighted 1-5, micro): {summary['overall_avg_score']:.2f}")
+    print(f"By dimension: {json.dumps(summary['by_dimension'], ensure_ascii=False)}")
+    print(f"Scored {summary['scored_samples']}/{summary['total_samples']} "
+          f"(errors: {summary['error_samples']})")
+
+    hierarchy = summary.get("hierarchy", {})
+    if hierarchy.get("by_domain"):
+        print("\nBy domain (micro avg):")
+        print(json.dumps(hierarchy["by_domain"], indent=2, ensure_ascii=False))
+    if hierarchy.get("by_subtask"):
+        print("\nBy subtask (micro avg):")
+        print(json.dumps(hierarchy["by_subtask"], indent=2, ensure_ascii=False))
+
+    print(f"\nCases:   {cases_path}")
+    print(f"Summary: {summary_path}")
+    print("=" * 60)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="CPI-Bench: intelligent benchmark evaluation")
+    parser.add_argument("--dataset_path", required=True)
+    parser.add_argument("--result_jsonl", required=True)
+    parser.add_argument("--prompts_json", required=True)
+    parser.add_argument("--output_dir", default="eval_output")
+    parser.add_argument("--api_key", required=True)
+    parser.add_argument("--base_url", default=DEFAULT_BASE_URL)
+    parser.add_argument("--model", default=DEFAULT_MODEL)
+    parser.add_argument("--lang", choices=["cn", "eng"], default="eng")
+    parser.add_argument("--workers", type=int, default=8)
+    parser.add_argument("--resume", action="store_true", default=True)
+    parser.add_argument("--no_resume", dest="resume", action="store_false")
+    parser.add_argument("--num_samples", type=int, default=None)
+    args = parser.parse_args()
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    key_pool = ApiKeyPool([k.strip() for k in args.api_key.split(",") if k.strip()])
+
+    print(f"Loading dataset: {args.dataset_path}")
+    dataset = load_dataset("parquet", data_files=args.dataset_path, split="train")
+    print(f"Dataset loaded: {len(dataset)} samples")
+
+    prompts_cfg = load_prompts(args.prompts_json)
+
+    index_to_result = load_result_jsonl(args.result_jsonl)
+    max_idx = len(dataset) - 1
+    for i in [i for i in index_to_result if i < 0 or i > max_idx]:
+        print(f"Warning: sample_index {i} out of range, skipped.")
+        del index_to_result[i]
+
+    if args.num_samples is not None:
+        keep = sorted(index_to_result)[:args.num_samples]
+        index_to_result = {i: index_to_result[i] for i in keep}
+
+    if not index_to_result:
+        print("No valid entries to evaluate. Exiting.")
+        return
+
+    run_evaluation(dataset, index_to_result, prompts_cfg, args, key_pool)
+
+
+if __name__ == "__main__":
+    main()