Upload run_evaluation_vlm.py

run_evaluation_vlm.py

@@ -0,0 +1,362 @@
+"""
+GIS_Bench 통합 VLM 평가 파이프라인 v4 (최종)
+========================================
+모든 출력물(HTML / PNG / JPG)을 동일한 VLM Judge로 평가
+
+v4 변경사항 :
+  1. 평가 모델 추가: claude_zeroshot, gpt_5.4_mini (총 5개 모델)
+  2. 결과 저장 폴더명 변경: evaluation_results_vlm → evaluation_results_final
+  3. 스크린샷 폴더명 변경: screenshots → screenshots_final
+
+평가 흐름:
+  HTML  →  Playwright 렌더링(3초 대기)  →  스크린샷  →  Claude VLM × 3회
+  PNG / JPG  →  직접  →  Claude VLM × 3회
+
+실행 방법:
+    set ANTHROPIC_API_KEY=your_key_here
+    python run_evaluation_vlm_v4_final.py
+"""
+
+import os, json, base64, time, re
+from pathlib import Path
+from playwright.sync_api import sync_playwright
+import anthropic
+import openpyxl
+import pandas as pd
+
+# ══════════════════════════════════════════════════════
+#  설정
+# ══════════════════════════════════════════════════════
+BASE_DIR    = r"C:\Users\A\Desktop\대학원 졸업논문"
+EXCEL_PATH  = os.path.join(BASE_DIR, "GIS_Bench_문항.xlsx")
+MODELS      = ["claude_mcp", "claude_baseline", "claude_zeroshot", "gpt_5.2", "gpt_5.4_mini"]
+RESULT_DIR  = os.path.join(BASE_DIR, "evaluation_results_final")
+SHOT_DIR    = os.path.join(RESULT_DIR, "screenshots_final")
+os.makedirs(RESULT_DIR, exist_ok=True)
+os.makedirs(SHOT_DIR, exist_ok=True)
+
+N_REPEAT    = 3       # VLM 반복 횟수
+PASS_SCORE  = 60      # Pass 기준 (100점 정규화 기준)
+RENDER_WAIT = 5000    # HTML 렌더링 대기 시간 (ms)
+VIEWPORT    = {"width": 1280, "height": 800}
+
+client = anthropic.Anthropic()
+
+# ══════════════════════════════════════════════════════
+#  태스크 로드
+# ══════════════════════════════════════════════════════
+def load_tasks(excel_path: str) -> dict:
+    wb = openpyxl.load_workbook(excel_path)
+    ws = wb.active
+    tasks = {}
+    for row in ws.iter_rows(min_row=2, values_only=True):
+        no, prompt, level = row[0], row[1], row[2]
+        if no and prompt:
+            lv = int(str(level).replace("Level", "").strip()[0])
+            tasks[int(no)] = {"prompt": prompt, "level": lv}
+    return tasks
+
+# ══════════════════════════════════════════════════════
+#  파일 탐색
+# ══════════════════════════════════════════════════════
+def find_output_file(model: str, task_no: int) -> Path | None:
+    folder = Path(BASE_DIR) / model
+    if not folder.exists():
+        return None
+    for ext in [".html", ".htm", ".png", ".jpg", ".jpeg"]:
+        exact = folder / f"{task_no}{ext}"
+        if exact.exists():
+            return exact
+        matches = sorted(folder.glob(f"{task_no}_*{ext}"))
+        if matches:
+            return matches[0]
+    return None
+
+# ══════════════════════════════════════════════════════
+#  HTML → 스크린샷 변환
+# ══════════════════════════════════════════════════════
+def html_to_screenshot(html_path: str, out_path: str, page) -> bool:
+    try:
+        file_uri = Path(html_path).as_uri()
+        page.goto(file_uri, timeout=30000)
+        page.wait_for_timeout(RENDER_WAIT)
+        try:
+            page.wait_for_selector(".leaflet-container", timeout=3000)
+            page.wait_for_timeout(1000)
+        except Exception:
+            pass
+        page.screenshot(path=out_path, full_page=False)
+        return True
+    except Exception as e:
+        print(f"      ⚠️  스크린샷 실패: {e}")
+        return False
+
+# ══════════════════════════════════════════════════════
+#  이미지 → base64 인코딩
+# ══════════════════════════════════════════════════════
+def encode_image(image_path: str) -> tuple[str, str]:
+    ext = Path(image_path).suffix.lower()
+    media_type = "image/jpeg" if ext in [".jpg", ".jpeg"] else "image/png"
+    with open(image_path, "rb") as f:
+        return base64.standard_b64encode(f.read()).decode("utf-8"), media_type
+
+# ══════════════════════════════════════════════════════
+#  JSON 파싱 (마크다운·불완전 응답 방어)
+# ══════════════════════════════════════════════════════
+def safe_parse_json(text: str) -> dict | None:
+    text = text.replace("```json", "").replace("```", "").strip()
+    match = re.search(r'\{.*\}', text, re.DOTALL)
+    if not match:
+        return None
+    try:
+        return json.loads(match.group())
+    except json.JSONDecodeError:
+        return None
+
+# ══════════════════════════════════════════════════════
+#  VLM Judge 프롬프트
+# ══════════════════════════════════════════════════════
+JUDGE_PROMPT_TEMPLATE = """GIS 결과물 평가 전문가로서 아래 태스크의 출력 이미지를 채점하세요.
+
+[태스크 Level {level}]
+{prompt}
+
+[채점 기준 — 130점 만점]
+기본(100점):
+  exists(0/20): 의미있는 시각화 존재 여부
+  accuracy(0-30): 요청 지역·데이터셋 정확성
+  requirement(0-30): 색상·필터·버퍼 등 조건 충족
+  completeness(0-20): 범례·제목·라벨 완성도
+
+공간정확성(30점, 스크린샷 시각 판단):
+  spatial_location(0/8/15): 데이터가 올바른 지역에 표시되는지
+    15=정상, 8=경미한 이상, 0=좌표오류·엉뚱한위치
+  geometry_validity(0/2/5): 폴리곤·버퍼 형태 이상 여부
+    5=정상, 2=경미한이상, 0=명백한왜곡
+  numeric_match(0/5/10): 수치·조건이 결과에 반영되었는지
+    10=일치, 5=부분반영, 0=미반영
+
+total_raw = 7개 항목 합계
+total_normalized = round(total_raw / 130 * 100)
+
+[응답] JSON만 출력, 다른 텍스트 금지:
+{{"exists":정수,"accuracy":정수,"requirement":정수,"completeness":정수,"spatial_location":정수,"geometry_validity":정수,"numeric_match":정수,"total_raw":정수,"total_normalized":정수,"pass":불리언,"reason":"한줄이유"}}"""
+
+
+# ══════════════════════════════════════════════════════
+#  VLM Judge 실행
+# ══════════════════════════════════════════════════════
+def vlm_judge(image_path: str, task_no: int, prompt: str, level: int,
+              source_type: str) -> dict:
+    img_b64, media_type = encode_image(image_path)
+    judge_prompt = JUDGE_PROMPT_TEMPLATE.format(level=level, prompt=prompt)
+
+    raw_scores     = []
+    raw_scores_130 = []
+    parsed_results = []
+
+    for attempt in range(N_REPEAT):
+        try:
+            resp = client.messages.create(
+                model="claude-sonnet-4-6",
+                max_tokens=1024,
+                messages=[{
+                    "role": "user",
+                    "content": [
+                        {"type": "image",
+                         "source": {"type": "base64",
+                                    "media_type": media_type,
+                                    "data": img_b64}},
+                        {"type": "text", "text": judge_prompt}
+                    ]
+                }]
+            )
+            text = resp.content[0].text.strip()
+            r = safe_parse_json(text)
+
+            if r is None:
+                raise ValueError(f"JSON 파싱 실패: {text[:80]}")
+
+            if "total_normalized" not in r:
+                basic   = int(r.get("exists",0)) + int(r.get("accuracy",0)) + \
+                          int(r.get("requirement",0)) + int(r.get("completeness",0))
+                spatial = int(r.get("spatial_location",0)) + \
+                          int(r.get("geometry_validity",0)) + \
+                          int(r.get("numeric_match",0))
+                r["total_raw"]        = basic + spatial
+                r["total_normalized"] = round((basic + spatial) / 130 * 100)
+
+            raw_scores.append(int(r["total_normalized"]))
+            raw_scores_130.append(int(r.get("total_raw", 0)))
+            parsed_results.append(r)
+
+        except Exception as e:
+            print(f"        ⚠️  VLM 호출 오류 (시도 {attempt+1}): {e}")
+            raw_scores.append(0)
+            raw_scores_130.append(0)
+            parsed_results.append({})
+
+        time.sleep(1.5)
+
+    avg_normalized = round(sum(raw_scores)     / max(len(raw_scores), 1), 1)
+    avg_raw        = round(sum(raw_scores_130) / max(len(raw_scores_130), 1), 1)
+
+    def avg_field(field):
+        vals = [r.get(field, 0) for r in parsed_results if r]
+        return round(sum(vals) / max(len(vals), 1), 1)
+
+    reason_parts   = [r.get("reason", "") for r in parsed_results if r.get("reason")]
+    reason_summary = reason_parts[0] if reason_parts else "vlm_no_reason"
+
+    return {
+        "file_type":         "html_screenshot" if source_type == "screenshot" else Path(image_path).suffix.lstrip("."),
+        "scores_3x":         raw_scores,
+        "scores_3x_raw":     raw_scores_130,
+        "score":             avg_normalized,
+        "score_raw":         avg_raw,
+        "spatial_location":  avg_field("spatial_location"),
+        "geometry_validity": avg_field("geometry_validity"),
+        "numeric_match":     avg_field("numeric_match"),
+        "pass":              avg_normalized >= PASS_SCORE,
+        "reason":            f"vlm_avg({','.join(map(str, raw_scores))}) | {reason_summary}"
+    }
+
+# ══════════════════════════════════════════════════════
+#  빈 결과 행 생성 헬퍼
+# ══════════════════════════════════════════════════════
+def empty_row(task_no, level_str, model, file_type, reason):
+    return {
+        "task_no": task_no, "level": level_str,
+        "model": model,     "file_type": file_type,
+        "score": 0,         "score_raw": 0,
+        "spatial_location": 0, "geometry_validity": 0, "numeric_match": 0,
+        "pass": False,      "reason": reason,
+        "scores_3x": "",    "scores_3x_raw": ""
+    }
+
+# ══════════════════════════════════════════════════════
+#  메인 실행
+# ══════════════════════════════════════════════════════
+def main():
+    print("📂 태스크 로드 중...")
+    tasks = load_tasks(EXCEL_PATH)
+    print(f"   총 {len(tasks)}개 태스크 로드 완료")
+    print(f"   평가 모델: {MODELS}\n")
+
+    results = []
+
+    with sync_playwright() as pw:
+        browser = pw.chromium.launch(headless=True)
+        page    = browser.new_page(viewport=VIEWPORT)
+
+        for task_no in range(1, 51):
+            task_info = tasks.get(task_no, {})
+            prompt    = task_info.get("prompt", "")
+            level     = task_info.get("level", 1)
+            level_str = f"Level{level}"
+
+            for model in MODELS:
+                filepath = find_output_file(model, task_no)
+                tag = f"[{model:20s}] Task {task_no:02d} (L{level})"
+
+                # ── 파일 없음 ──────────────────────────────────
+                if filepath is None:
+                    results.append(empty_row(task_no, level_str, model, "없음", "출력파일없음"))
+                    print(f"  {tag}: ❌  파일 없음")
+                    continue
+
+                ext = filepath.suffix.lower()
+
+                # ── HTML: 스크린샷 변환 후 VLM ─────────────────
+                if ext in [".html", ".htm"]:
+                    shot_name = f"{model}_{task_no:02d}.png"
+                    shot_path = os.path.join(SHOT_DIR, shot_name)
+                    print(f"  {tag}: 🖥️  렌더링 중... ({filepath.name})")
+                    ok = html_to_screenshot(str(filepath), shot_path, page)
+                    if not ok:
+                        results.append(empty_row(task_no, level_str, model, "html_render_fail", "HTML 렌더링 실패"))
+                        continue
+                    res = vlm_judge(shot_path, task_no, prompt, level, "screenshot")
+
+                # ── PNG / JPG: 직접 VLM ────────────────────────
+                elif ext in [".png", ".jpg", ".jpeg"]:
+                    print(f"  {tag}: 🖼️  이미지 VLM 평가 중... ({filepath.name})")
+                    res = vlm_judge(str(filepath), task_no, prompt, level, "original")
+
+                # ── 지원하지 않는 형식 ─────────────────────────
+                else:
+                    results.append(empty_row(task_no, level_str, model, ext, f"미지원형식:{ext}"))
+                    print(f"  {tag}: ⏭️  미지원 형식 ({ext})")
+                    continue
+
+                icon = "✅" if res["pass"] else "❌"
+                print(f"  {tag}: {icon}  {res['score']:5.1f}점  "
+                      f"[{res['file_type']}]  scores={res['scores_3x']}")
+
+                results.append({
+                    "task_no":           task_no,
+                    "level":             level_str,
+                    "model":             model,
+                    "file_type":         res["file_type"],
+                    "score":             res["score"],
+                    "score_raw":         res["score_raw"],
+                    "spatial_location":  res["spatial_location"],
+                    "geometry_validity": res["geometry_validity"],
+                    "numeric_match":     res["numeric_match"],
+                    "pass":              res["pass"],
+                    "reason":            res["reason"],
+                    "scores_3x":         str(res["scores_3x"]),
+                    "scores_3x_raw":     str(res["scores_3x_raw"])
+                })
+
+        browser.close()
+
+    # ── 결과 저장 ──────────────────────────────────────
+    df = pd.DataFrame(results)
+    all_path     = os.path.join(RESULT_DIR, "all_scores_final.csv")
+    summary_path = os.path.join(RESULT_DIR, "paper_table_final.csv")
+    df.to_csv(all_path, index=False, encoding="utf-8-sig")
+
+    # ── 요약 출력 ──────────────────────────────────────
+    print("\n" + "═" * 70)
+    print("📊  모델 × 레벨별 성공률 (SR%) — 100점 정규화")
+    print("═" * 70)
+    sr = (df.groupby(["model", "level"])["pass"]
+            .mean().mul(100).round(1).unstack())
+    sr["전체"] = df.groupby("model")["pass"].mean().mul(100).round(1)
+    # 모델 순서 고정
+    model_order = [m for m in MODELS if m in sr.index]
+    print(sr.reindex(model_order).to_string())
+
+    print("\n📊  모델별 평균 점수 (100점 정규화)")
+    avg_score = df.groupby("model")["score"].mean().round(1)
+    print(avg_score.reindex(model_order).to_string())
+
+    print("\n📊  레벨별 평균 점수 (100점 정규화)")
+    print(df.groupby("level")["score"].mean().round(1).to_string())
+
+    print("\n📊  모델별 공간 정확성 항목 평균 (원점수)")
+    spatial_cols = ["spatial_location", "geometry_validity", "numeric_match"]
+    spatial_avg = df.groupby("model")[spatial_cols].mean().round(1)
+    print(spatial_avg.reindex(model_order).to_string())
+    print("   만점: spatial_location=15 / geometry_validity=5 / numeric_match=10")
+
+    # ── 논문용 요약 테이블 ─────────────────────────────
+    summary = df.groupby(["model", "level"]).agg(
+        SR            = ("pass",              lambda x: f"{x.mean() * 100:.1f}%"),
+        Score         = ("score",             lambda x: f"{x.mean():.1f}"),
+        Score_raw     = ("score_raw",         lambda x: f"{x.mean():.1f}"),
+        Spatial_loc   = ("spatial_location",  lambda x: f"{x.mean():.1f}"),
+        Geom_validity = ("geometry_validity", lambda x: f"{x.mean():.1f}"),
+        Numeric_match = ("numeric_match",     lambda x: f"{x.mean():.1f}"),
+    ).reset_index()
+    summary.to_csv(summary_path, index=False, encoding="utf-8-sig")
+
+    print(f"\n✅  결과 저장 완료")
+    print(f"   전체 점수    : {all_path}")
+    print(f"   논문 테이블  : {summary_path}")
+    print(f"   스크린샷 폴더: {SHOT_DIR}")
+
+
+if __name__ == "__main__":
+    main()