| """ |
| World Model Bench — Quantitative Scoring Specification v1.0 |
| |
| 설계 원칙: |
| 1. 모든 점수는 정량적 — 주관적 판단 0% |
| 2. 제3자 재현 가능 — 동일 입력 → 동일 점수 |
| 3. 자동 채점 — 코드가 판정, 사람이 판정 안 함 |
| 4. 반박 불가 — 각 점수에 수학적/논리적 근거 |
| |
| 핵심 메커니즘: |
| - 모든 시나리오는 "입력(scene_context) → 출력(PREDICT+MOTION)" 쌍 |
| - 채점은 출력 텍스트를 파싱하여 정량 지표로 변환 |
| - 파싱 규칙이 명시적이므로 누가 해도 동일 결과 |
| """ |
|
|
| import json |
| import re |
| from dataclasses import dataclass, field |
| from typing import List, Dict, Optional, Tuple |
| from enum import IntEnum |
|
|
|
|
| |
| |
| |
|
|
| """ |
| 모든 월드모델은 아래 포맷으로 출력해야 채점 가능: |
| |
| INPUT (시스템이 제공): |
| scene_context = { |
| "walls": {"left": float, "right": float, "front": float}, # 거리(m), null=없음 |
| "ground": str, # "flat", "slope", "stairs" |
| "npc_nearby": bool, |
| "npc_type": str|null, # "beast", "woman", "man", null |
| "npc_behavior": str|null, # "stop", "approach", "charge", "wander" |
| "npc_distance": float|null, |
| "sound": str|null, # "aggressive growling", "footsteps", null |
| } |
| |
| OUTPUT (모델이 출력): |
| Line 1: PREDICT: left=safe|danger(reason), right=..., fwd=..., back=... |
| Line 2: MOTION: a person [max 12 words describing action] |
| |
| 채점은 이 두 줄을 파싱하여 수행. |
| """ |
|
|
|
|
| |
| |
| |
|
|
| class PredictDirection: |
| """PREDICT 줄의 한 방향을 파싱한 결과""" |
| def __init__(self, raw: str): |
| self.raw = raw.strip() |
| self.is_safe = "safe" in self.raw.lower() |
| self.is_danger = "danger" in self.raw.lower() |
| |
| match = re.search(r'\(([^)]+)\)', self.raw) |
| self.reason = match.group(1).lower() if match else None |
|
|
|
|
| def parse_predict_line(line: str) -> Dict[str, PredictDirection]: |
| """ |
| PREDICT: left=safe(open), right=danger(wall), fwd=danger(beast), back=safe |
| → {"left": PredictDirection, "right": ..., "fwd": ..., "back": ...} |
| """ |
| result = {} |
| line = line.replace("PREDICT:", "").strip() |
| for part in line.split(","): |
| part = part.strip() |
| if "=" not in part: |
| continue |
| key, val = part.split("=", 1) |
| key = key.strip().lower() |
| |
| if key in ("forward", "fwd", "front"): |
| key = "fwd" |
| if key in ("backward", "back"): |
| key = "back" |
| result[key] = PredictDirection(val) |
| return result |
|
|
|
|
| def parse_motion_line(line: str) -> str: |
| """ |
| MOTION: a person sprinting right in terror |
| → "a person sprinting right in terror" |
| """ |
| return line.replace("MOTION:", "").strip().lower() |
|
|
|
|
| |
| |
| |
|
|
| """ |
| 핵심: "sprint"와 "walk"의 차이를 수치로 정의 |
| 이 사전이 벤치마크의 재현성을 보장함 |
| 제3자가 이 사전으로 동일한 채점 결과를 얻을 수 있음 |
| """ |
|
|
| class Intensity(IntEnum): |
| """행동 강도 레벨 (0~5)""" |
| NONE = 0 |
| MINIMAL = 1 |
| LOW = 2 |
| MEDIUM = 3 |
| HIGH = 4 |
| EXTREME = 5 |
|
|
|
|
| |
| ACTION_INTENSITY: Dict[str, int] = { |
| |
| "desperate": 5, "desperately": 5, "frantic": 5, "frantically": 5, |
| "flee": 5, "fleeing": 5, "panic": 5, "panicking": 5, |
| "terror": 5, "terrified": 5, |
| |
| "bolt": 4, "bolting": 4, "dash": 4, "dashing": 4, |
| "escape": 4, "escaping": 4, "run": 4, "running": 4, |
| "rush": 4, "rushing": 4, "sprint": 4, "sprinting": 4, |
| |
| "hurry": 3, "hurrying": 3, "jog": 3, "jogging": 3, |
| "quick": 3, "quickly": 3, "retreat": 3, "retreating": 3, |
| "step back": 3, "stepping back": 3, "back away": 3, |
| |
| "cautious": 2, "cautiously": 2, "slow": 2, "slowly": 2, |
| "walk": 2, "walking": 2, "turn": 2, "turning": 2, |
| "move": 2, "moving": 2, "shift": 2, |
| |
| "stand": 1, "standing": 1, "pause": 1, "pausing": 1, |
| "freeze": 1, "freezing": 1, "stop": 1, "stopping": 1, |
| "observe": 1, "watching": 1, "look": 1, "looking": 1, |
| } |
|
|
| |
| EMOTION_INTENSITY: Dict[str, int] = { |
| |
| "terror": 5, "terrified": 5, "horrified": 5, "desperate": 5, |
| "frantic": 5, "panic": 5, "anguish": 5, |
| |
| "fear": 4, "afraid": 4, "scared": 4, "alarmed": 4, |
| "distress": 4, "shock": 4, "dread": 4, |
| |
| "anxious": 3, "nervous": 3, "tense": 3, "worried": 3, |
| "uneasy": 3, "wary": 3, "alert": 3, "startled": 3, |
| |
| "cautious": 2, "careful": 2, "vigilant": 2, "watchful": 2, |
| "guarded": 2, "attentive": 2, |
| |
| "calm": 1, "relaxed": 1, "composed": 1, "steady": 1, |
| "neutral": 1, "normal": 1, |
| } |
|
|
| |
| DIRECTION_KEYWORDS: Dict[str, str] = { |
| "left": "left", "leftward": "left", |
| "right": "right", "rightward": "right", |
| "forward": "fwd", "ahead": "fwd", "front": "fwd", |
| "backward": "back", "backwards": "back", "back": "back", |
| "behind": "back", "around": "back", |
| } |
|
|
|
|
| def get_action_intensity(motion_text: str) -> int: |
| """모션 텍스트에서 최대 행동 강도 추출""" |
| words = motion_text.lower() |
| max_intensity = 0 |
| for keyword, intensity in ACTION_INTENSITY.items(): |
| if keyword in words: |
| max_intensity = max(max_intensity, intensity) |
| return max_intensity |
|
|
|
|
| def get_emotion_intensity(motion_text: str) -> int: |
| """모션 텍스트에서 최대 감정 강도 추출""" |
| words = motion_text.lower() |
| max_intensity = 0 |
| for keyword, intensity in EMOTION_INTENSITY.items(): |
| if keyword in words: |
| max_intensity = max(max_intensity, intensity) |
| return max_intensity |
|
|
|
|
| def get_motion_direction(motion_text: str) -> Optional[str]: |
| """모션 텍스트에서 이동 방향 추출""" |
| words = motion_text.lower() |
| for keyword, direction in DIRECTION_KEYWORDS.items(): |
| if keyword in words: |
| return direction |
| return None |
|
|
|
|
| def count_descriptors(motion_text: str) -> int: |
| """모션 텍스트의 감정/행동 수식어 총 개수""" |
| words = motion_text.lower() |
| count = 0 |
| for keyword in ACTION_INTENSITY: |
| if keyword in words: |
| count += 1 |
| for keyword in EMOTION_INTENSITY: |
| if keyword in words: |
| count += 1 |
| return count |
|
|
|
|
| |
| |
| |
|
|
| """ |
| 각 함수는: |
| - 입력: scene_context(dict) + model_output(str) + ground_truth(dict) |
| - 출력: score(int, 0~20) + reasoning(str) |
| - 결정론적: 같은 입력 → 항상 같은 점수 |
| """ |
|
|
|
|
| |
|
|
| def score_c01(scene: dict, predict: dict, ground_truth: dict) -> Tuple[int, str]: |
| """ |
| 채점 기준: PREDICT의 각 방향이 실제 환경과 일치하는가 |
| |
| ground_truth = { |
| "left": "safe" | "danger", |
| "right": "safe" | "danger", |
| "fwd": "safe" | "danger", |
| "back": "safe" | "danger", |
| } |
| |
| 채점: |
| 4방향 모두 정확 = 20점 |
| 3방향 정확 = 15점 |
| 2방향 정확 = 10점 |
| 1방향 정확 = 5점 |
| 0방향 정확 = 0점 |
| """ |
| directions = ["left", "right", "fwd", "back"] |
| correct = 0 |
| details = [] |
| |
| for d in directions: |
| if d not in predict: |
| details.append(f"{d}: 출력 없음 (오답)") |
| continue |
| |
| gt_safe = ground_truth.get(d) == "safe" |
| pred_safe = predict[d].is_safe |
| |
| if gt_safe == pred_safe: |
| correct += 1 |
| details.append(f"{d}: 정답 (GT={ground_truth[d]}, PRED={'safe' if pred_safe else 'danger'})") |
| else: |
| details.append(f"{d}: 오답 (GT={ground_truth[d]}, PRED={'safe' if pred_safe else 'danger'})") |
| |
| score_map = {4: 20, 3: 15, 2: 10, 1: 5, 0: 0} |
| score = score_map[correct] |
| reasoning = f"환경 인식: {correct}/4 방향 정확. " + "; ".join(details) |
| |
| return score, reasoning |
|
|
|
|
| |
|
|
| def score_c02(scene: dict, predict: dict, ground_truth: dict) -> Tuple[int, str]: |
| """ |
| 채점 기준: PREDICT에서 개체를 올바른 유형으로 인식했는가 |
| |
| ground_truth = { |
| "entity_type": "beast" | "woman" | "man" | None, |
| "entity_direction": "left" | "right" | "fwd" | "back", |
| "is_threat": True | False, |
| } |
| |
| 채점 (합산, 최대 20점): |
| 개체 방향 정확: 8점 (해당 방향에 danger 표시) |
| 개체 유형 정확: 8점 (danger 괄호 안에 올바른 유형) |
| 위협 수준 정확: 4점 (beast=danger, woman=danger 또는 safe 모두 가능) |
| """ |
| score = 0 |
| details = [] |
| |
| gt_dir = ground_truth.get("entity_direction") |
| gt_type = ground_truth.get("entity_type") |
| |
| if gt_type is None: |
| |
| all_safe = all(p.is_safe for p in predict.values()) |
| if all_safe: |
| score = 20 |
| details.append("개체 없음 정확 인식") |
| else: |
| danger_dirs = [d for d, p in predict.items() if p.is_danger] |
| score = 10 |
| details.append(f"개체 없는데 {danger_dirs}를 danger로 오인식") |
| else: |
| |
| |
| if gt_dir in predict and predict[gt_dir].is_danger: |
| score += 8 |
| details.append(f"방향 정확: {gt_dir}=danger") |
| else: |
| details.append(f"방향 오답: {gt_dir}에 danger 없음") |
| |
| |
| if gt_dir in predict and predict[gt_dir].reason: |
| pred_reason = predict[gt_dir].reason |
| if gt_type in pred_reason: |
| score += 8 |
| details.append(f"유형 정확: {pred_reason} 에 {gt_type} 포함") |
| else: |
| |
| score += 3 |
| details.append(f"유형 부분: {pred_reason} (정답: {gt_type})") |
| else: |
| details.append("유형 정보 없음") |
| |
| |
| gt_threat = ground_truth.get("is_threat", False) |
| if gt_dir in predict: |
| pred_danger = predict[gt_dir].is_danger |
| if gt_threat == pred_danger: |
| score += 4 |
| details.append(f"위협 수준 정확") |
| elif not gt_threat and not pred_danger: |
| score += 4 |
| details.append(f"비위협 정확 인식") |
| |
| reasoning = f"개체 인식: {score}/20. " + "; ".join(details) |
| return score, reasoning |
|
|
|
|
| |
|
|
| def score_c03(scene: dict, predict: dict, motion: str, ground_truth: dict) -> Tuple[int, str]: |
| """ |
| 채점 기준: danger 방향을 피하고 safe 방향으로 이동했는가 |
| |
| ground_truth = { |
| "danger_directions": ["fwd", "left"], # 위험한 방향들 |
| "safe_directions": ["right", "back"], # 안전한 방향들 |
| "optimal_direction": "right", # 최적 방향 |
| } |
| |
| 채점 (합산, 최대 20점): |
| danger 방향 회피: 8점 (이동 방향이 danger가 아님) |
| safe 방향 선택: 6점 (이동 방향이 safe 중 하나) |
| 최적 방향 선택: 4점 (최적 방향 정확히 선택) |
| PREDICT-MOTION 일관성: 2점 (PREDICT에서 danger로 예측한 방향으로 안 감) |
| """ |
| score = 0 |
| details = [] |
| |
| |
| motion_dir = get_motion_direction(motion) |
| danger_dirs = ground_truth.get("danger_directions", []) |
| safe_dirs = ground_truth.get("safe_directions", []) |
| optimal = ground_truth.get("optimal_direction") |
| |
| if motion_dir is None: |
| details.append("이동 방향 추출 불가 (방향 키워드 없음)") |
| |
| intensity = get_action_intensity(motion) |
| if intensity >= 3 and len(danger_dirs) > 0: |
| score += 4 |
| details.append(f"방향 불명이나 반응 존재 (강도 {intensity})") |
| else: |
| |
| if motion_dir not in danger_dirs: |
| score += 8 |
| details.append(f"위험 방향 회피: {motion_dir} not in {danger_dirs}") |
| else: |
| details.append(f"위험 방향으로 이동: {motion_dir} in {danger_dirs}") |
| |
| |
| if motion_dir in safe_dirs: |
| score += 6 |
| details.append(f"안전 방향 선택: {motion_dir} in {safe_dirs}") |
| else: |
| details.append(f"안전하지 않은 방향: {motion_dir} not in {safe_dirs}") |
| |
| |
| if motion_dir == optimal: |
| score += 4 |
| details.append(f"최적 방향 정확: {motion_dir} == {optimal}") |
| else: |
| details.append(f"최적 아님: {motion_dir} != {optimal}") |
| |
| |
| if motion_dir and motion_dir in predict: |
| pred = predict[motion_dir] |
| if pred.is_safe: |
| score += 2 |
| details.append("PREDICT-MOTION 일관: safe 방향으로 이동") |
| else: |
| details.append("PREDICT-MOTION 불일치: danger로 예측한 방향으로 이동") |
| |
| reasoning = f"예측 추론: {score}/20. " + "; ".join(details) |
| return score, reasoning |
|
|
|
|
| |
|
|
| def score_c04( |
| motion_a: str, motion_b: str, |
| ground_truth: dict |
| ) -> Tuple[int, str]: |
| """ |
| 채점 기준: 두 위협에 대한 반응 강도 차이가 올바른가 |
| |
| 같은 scene에 (A) 맹수 접근 vs (B) 여성 접근 |
| → A의 반응 강도가 B보다 높아야 함 |
| |
| ground_truth = { |
| "scenario_a_type": "beast_charge", |
| "scenario_b_type": "woman_approach", |
| "expected_a_higher": True, # A가 더 강한 반응이어야 |
| "min_intensity_diff": 2, # 최소 강도 차이 |
| } |
| |
| 채점 (합산, 최대 20점): |
| 반응 방향 정확: 8점 (A > B 또는 B > A 방향이 맞음) |
| 강도 차이 충분: 8점 (차이가 min_intensity_diff 이상) |
| 양쪽 모두 적절 반응: 4점 (둘 다 0이 아님) |
| """ |
| score = 0 |
| details = [] |
| |
| int_a = get_action_intensity(motion_a) |
| int_b = get_action_intensity(motion_b) |
| expected_higher = ground_truth.get("expected_a_higher", True) |
| min_diff = ground_truth.get("min_intensity_diff", 2) |
| |
| diff = int_a - int_b |
| |
| |
| if expected_higher and diff > 0: |
| score += 8 |
| details.append(f"반응 방향 정확: A({int_a}) > B({int_b})") |
| elif not expected_higher and diff < 0: |
| score += 8 |
| details.append(f"반응 방향 정확: B({int_b}) > A({int_a})") |
| elif diff == 0: |
| score += 2 |
| details.append(f"반응 동일: A({int_a}) == B({int_b})") |
| else: |
| details.append(f"반응 방향 역전: A({int_a}), B({int_b})") |
| |
| |
| actual_diff = abs(diff) |
| if actual_diff >= min_diff: |
| score += 8 |
| details.append(f"강도 차이 충분: |{diff}| >= {min_diff}") |
| elif actual_diff >= 1: |
| score += 4 |
| details.append(f"강도 차이 부족: |{diff}| < {min_diff}") |
| else: |
| details.append(f"강도 차이 없음: |{diff}| = 0") |
| |
| |
| if int_a > 0 and int_b > 0: |
| score += 4 |
| details.append("양쪽 모두 반응 존재") |
| elif int_a > 0 or int_b > 0: |
| score += 2 |
| details.append("한쪽만 반응 존재") |
| else: |
| details.append("양쪽 모두 무반응") |
| |
| reasoning = f"위협 차별: {score}/20. A='{motion_a}' (강도{int_a}), B='{motion_b}' (강도{int_b}). " + "; ".join(details) |
| return score, reasoning |
|
|
|
|
| |
|
|
| def score_c05(motion_sequence: List[str], ground_truth: dict) -> Tuple[int, str]: |
| """ |
| 채점 기준: 시간에 따른 감정 강도가 올바르게 변화하는가 |
| |
| motion_sequence = 같은 위협 지속 시 연속 3~5회 모션 출력 |
| |
| ground_truth = { |
| "expected_trend": "increasing" | "decreasing" | "stable", |
| "threat_type": "sustained_charge", |
| } |
| |
| 채점 (합산, 최대 20점): |
| 추세 방향 정확: 10점 |
| 단조 증가/감소: 6점 (뒤로 가지 않음) |
| 최종 강도 적절: 4점 |
| """ |
| score = 0 |
| details = [] |
| |
| if len(motion_sequence) < 2: |
| return 0, "시퀀스 길이 부족 (최소 2회 필요)" |
| |
| intensities = [get_action_intensity(m) + get_emotion_intensity(m) |
| for m in motion_sequence] |
| |
| expected = ground_truth.get("expected_trend", "increasing") |
| |
| |
| diffs = [intensities[i+1] - intensities[i] for i in range(len(intensities)-1)] |
| avg_diff = sum(diffs) / len(diffs) |
| |
| |
| if expected == "increasing": |
| if avg_diff > 0: |
| score += 10 |
| details.append(f"증가 추세 정확: 평균 변화 +{avg_diff:.1f}") |
| elif avg_diff == 0: |
| score += 3 |
| details.append(f"추세 변화 없음 (기대: 증가)") |
| else: |
| details.append(f"추세 역전 (기대: 증가, 실제: 감소 {avg_diff:.1f})") |
| elif expected == "decreasing": |
| if avg_diff < 0: |
| score += 10 |
| details.append(f"감소 추세 정확: 평균 변화 {avg_diff:.1f}") |
| elif avg_diff == 0: |
| score += 3 |
| details.append(f"추세 변화 없음 (기대: 감소)") |
| else: |
| details.append(f"추세 역전 (기대: 감소, 실제: 증가)") |
| elif expected == "stable": |
| if abs(avg_diff) <= 0.5: |
| score += 10 |
| details.append(f"안정 유지 정확: 평균 변화 {avg_diff:.1f}") |
| else: |
| score += 4 |
| details.append(f"불안정: 평균 변화 {avg_diff:.1f} (기대: 안정)") |
| |
| |
| if expected == "increasing": |
| monotonic = all(d >= 0 for d in diffs) |
| elif expected == "decreasing": |
| monotonic = all(d <= 0 for d in diffs) |
| else: |
| monotonic = all(abs(d) <= 1 for d in diffs) |
| |
| if monotonic: |
| score += 6 |
| details.append("단조적 변화 (역행 없음)") |
| else: |
| non_monotonic_count = sum(1 for d in diffs if |
| (expected == "increasing" and d < 0) or |
| (expected == "decreasing" and d > 0)) |
| if non_monotonic_count <= 1: |
| score += 3 |
| details.append(f"약간의 역행 ({non_monotonic_count}회)") |
| else: |
| details.append(f"역행 다수 ({non_monotonic_count}회)") |
| |
| |
| if expected == "increasing" and intensities[-1] >= 6: |
| score += 4 |
| details.append(f"최종 강도 충분: {intensities[-1]}") |
| elif expected == "decreasing" and intensities[-1] <= 3: |
| score += 4 |
| details.append(f"최종 강도 적절히 낮음: {intensities[-1]}") |
| elif expected == "stable" and 2 <= intensities[-1] <= 4: |
| score += 4 |
| details.append(f"최종 강도 안정적: {intensities[-1]}") |
| else: |
| score += 1 |
| details.append(f"최종 강도: {intensities[-1]} (개선 여지)") |
| |
| reasoning = f"감정 에스컬레이션: {score}/20. 강도 시퀀스: {intensities}. " + "; ".join(details) |
| return score, reasoning |
|
|
|
|
| |
|
|
| def score_c06( |
| motion_without_memory: str, |
| motion_with_memory: str, |
| memory_content: str, |
| ground_truth: dict |
| ) -> Tuple[int, str]: |
| """ |
| 채점 기준: 기억이 있을 때와 없을 때 행동이 합리적으로 달라지는가 |
| |
| ground_truth = { |
| "memory_relevant": True, # 기억이 현 상황에 관련 있는가 |
| "expected_change": "direction" | "intensity" | "both", |
| "memory_direction_avoid": "right", # 기억에 의해 피해야 할 방향 |
| } |
| |
| 채점 (합산, 최대 20점): |
| 기억 유무 차이 존재: 8점 (두 출력이 다름) |
| 변화 방향 합리성: 8점 (기억 내용과 일치하는 변화) |
| 기억 불필요 시 무변화: 4점 (무관한 기억에 영향 안 받음) |
| """ |
| score = 0 |
| details = [] |
| |
| relevant = ground_truth.get("memory_relevant", True) |
| |
| dir_without = get_motion_direction(motion_without_memory) |
| dir_with = get_motion_direction(motion_with_memory) |
| int_without = get_action_intensity(motion_without_memory) |
| int_with = get_action_intensity(motion_with_memory) |
| |
| is_different = (motion_without_memory.strip() != motion_with_memory.strip()) |
| dir_changed = (dir_without != dir_with) |
| int_changed = (int_without != int_with) |
| |
| if relevant: |
| |
| |
| if is_different: |
| score += 8 |
| details.append(f"기억 반영 변화 있음") |
| else: |
| details.append("기억 있는데 변화 없음") |
| |
| |
| expected_change = ground_truth.get("expected_change", "direction") |
| avoid_dir = ground_truth.get("memory_direction_avoid") |
| |
| if expected_change in ("direction", "both") and avoid_dir: |
| if dir_with != avoid_dir and dir_without == avoid_dir: |
| score += 8 |
| details.append(f"기억에 의해 {avoid_dir} 회피 → {dir_with} 선택") |
| elif dir_with != avoid_dir: |
| score += 4 |
| details.append(f"회피 방향 올바르나 기존에도 안 감") |
| else: |
| details.append(f"기억에도 불구하고 {avoid_dir}로 이동") |
| |
| |
| if int_changed and expected_change in ("intensity", "both"): |
| score += 4 |
| details.append(f"강도 변화: {int_without} → {int_with}") |
| else: |
| |
| if not is_different: |
| score += 20 |
| details.append("무관한 기억에 영향 안 받음 (완벽)") |
| elif not dir_changed and not int_changed: |
| score += 16 |
| details.append("실질적 변화 없음 (문구만 다름)") |
| else: |
| score += 4 |
| details.append("무관한 기억에 불필요한 영향 받음") |
| |
| reasoning = f"기억 활용: {score}/20. " + "; ".join(details) |
| return score, reasoning |
|
|
|
|
| |
|
|
| def score_c07( |
| motion_during_threat: str, |
| motion_after_threat: List[str], |
| ground_truth: dict |
| ) -> Tuple[int, str]: |
| """ |
| 채점 기준: 위협 해제 후 적절히 정상화되는가 |
| |
| ground_truth = { |
| "expected_recovery": "gradual", # "gradual" | "immediate" | "vigilant" |
| } |
| |
| 채점 (합산, 최대 20점): |
| 즉시 전력질주 중단: 6점 (해제 직후 강도 감소) |
| 점진적 정상화: 8점 (급격하지 않은 감소 곡선) |
| 경계 유지: 6점 (완전 정상화 아닌 중간 단계 존재) |
| """ |
| score = 0 |
| details = [] |
| |
| threat_intensity = get_action_intensity(motion_during_threat) |
| after_intensities = [get_action_intensity(m) for m in motion_after_threat] |
| |
| if len(after_intensities) < 2: |
| return 0, "해제 후 시퀀스 부족" |
| |
| |
| if after_intensities[0] < threat_intensity: |
| score += 6 |
| details.append(f"즉시 감소: {threat_intensity} → {after_intensities[0]}") |
| elif after_intensities[0] == threat_intensity: |
| score += 2 |
| details.append(f"감소 없음: 여전히 {after_intensities[0]}") |
| else: |
| details.append(f"오히려 증가: {threat_intensity} → {after_intensities[0]}") |
| |
| |
| is_gradual = True |
| for i in range(len(after_intensities) - 1): |
| if after_intensities[i+1] > after_intensities[i] + 1: |
| is_gradual = False |
| |
| if is_gradual and after_intensities[-1] < after_intensities[0]: |
| score += 8 |
| details.append(f"점진적 정상화: {after_intensities}") |
| elif after_intensities[-1] <= 2: |
| score += 4 |
| details.append(f"최종 정상화 도달 (과정 불규칙)") |
| else: |
| score += 1 |
| details.append(f"정상화 미달: 최종 강도 {after_intensities[-1]}") |
| |
| |
| has_vigilant = any(1 <= i <= 3 for i in after_intensities) |
| if has_vigilant: |
| score += 6 |
| details.append("경계 단계 존재 (vigilant/cautious)") |
| elif after_intensities[-1] == 0: |
| score += 1 |
| details.append("경계 없이 즉시 완전 정상화 (비현실적)") |
| else: |
| score += 3 |
| details.append("경계 단계 불명확") |
| |
| reasoning = f"위협 해제 적응: {score}/20. 시퀀스: [{threat_intensity}]→{after_intensities}. " + "; ".join(details) |
| return score, reasoning |
|
|
|
|
| |
|
|
| def score_c08(motion: str, ground_truth: dict) -> Tuple[int, str]: |
| """ |
| 채점 기준: 모션 프롬프트의 표현 풍부함 (정량적) |
| |
| ground_truth = { |
| "expected_min_intensity": 3, # 최소 기대 강도 |
| "expected_emotion": True, # 감정 키워드 기대 여부 |
| "expected_min_descriptors": 2, # 최소 수식어 수 |
| } |
| |
| 채점 (합산, 최대 20점): |
| 행동 강도 적절: 6점 |
| 감정 키워드 존재: 6점 |
| 수식어 풍부함: 4점 |
| 12단어 이내 준수: 4점 |
| """ |
| score = 0 |
| details = [] |
| |
| action_int = get_action_intensity(motion) |
| emotion_int = get_emotion_intensity(motion) |
| desc_count = count_descriptors(motion) |
| word_count = len(motion.split()) |
| |
| min_intensity = ground_truth.get("expected_min_intensity", 3) |
| expect_emotion = ground_truth.get("expected_emotion", True) |
| min_desc = ground_truth.get("expected_min_descriptors", 2) |
| |
| |
| if action_int >= min_intensity: |
| score += 6 |
| details.append(f"행동 강도 적절: {action_int} >= {min_intensity}") |
| elif action_int >= min_intensity - 1: |
| score += 3 |
| details.append(f"행동 강도 부족: {action_int} < {min_intensity}") |
| else: |
| details.append(f"행동 강도 미달: {action_int}") |
| |
| |
| if expect_emotion: |
| if emotion_int >= 3: |
| score += 6 |
| details.append(f"감정 풍부: 강도 {emotion_int}") |
| elif emotion_int >= 1: |
| score += 3 |
| details.append(f"감정 약함: 강도 {emotion_int}") |
| else: |
| details.append("감정 키워드 없음") |
| else: |
| if emotion_int <= 1: |
| score += 6 |
| details.append("감정 절제 적절 (평상시)") |
| else: |
| score += 3 |
| details.append(f"불필요한 감정 표현: 강도 {emotion_int}") |
| |
| |
| if desc_count >= min_desc: |
| score += 4 |
| details.append(f"수식어 풍부: {desc_count}개") |
| elif desc_count >= 1: |
| score += 2 |
| details.append(f"수식어 부족: {desc_count}/{min_desc}") |
| else: |
| details.append("수식어 없음") |
| |
| |
| if word_count <= 15: |
| score += 4 |
| details.append(f"길이 적절: {word_count}단어") |
| elif word_count <= 20: |
| score += 2 |
| details.append(f"다소 김: {word_count}단어") |
| else: |
| details.append(f"너무 김: {word_count}단어") |
| |
| reasoning = f"표현력: {score}/20. '{motion}' (행동{action_int},감정{emotion_int},수식{desc_count},단어{word_count}). " + "; ".join(details) |
| return score, reasoning |
|
|
|
|
| |
|
|
| def score_c09(metrics: dict) -> Tuple[int, str]: |
| """ |
| 채점 기준: 직접 측정된 성능 수치 |
| |
| metrics = { |
| "fps": float, # 평균 FPS |
| "cognitive_latency_ms": int, # 인지루프 지연 (ms) |
| "frame_drop_rate": float, # 프레임 드롭률 (0.0~1.0) |
| "gpu_memory_stable": bool, # GPU 메모리 안정 여부 |
| } |
| |
| 채점 (합산, 최대 20점): |
| FPS: 8점 (≥45:8, ≥30:6, ≥15:3, <15:0) |
| 인지 지연: 6점 (≤3s:6, ≤5s:4, ≤10s:2, >10s:0) |
| 프레임 드롭: 4점 (<1%:4, <5%:2, ≥5%:0) |
| 메모리 안정: 2점 (안정:2, 불안정:0) |
| """ |
| score = 0 |
| details = [] |
| |
| fps = metrics.get("fps", 0) |
| latency = metrics.get("cognitive_latency_ms", 99999) |
| drop_rate = metrics.get("frame_drop_rate", 1.0) |
| mem_stable = metrics.get("gpu_memory_stable", False) |
| |
| |
| if fps >= 45: |
| score += 8; details.append(f"FPS 우수: {fps:.1f}") |
| elif fps >= 30: |
| score += 6; details.append(f"FPS 양호: {fps:.1f}") |
| elif fps >= 15: |
| score += 3; details.append(f"FPS 최소: {fps:.1f}") |
| else: |
| details.append(f"FPS 미달: {fps:.1f}") |
| |
| |
| latency_s = latency / 1000 |
| if latency_s <= 3: |
| score += 6; details.append(f"지연 우수: {latency_s:.1f}s") |
| elif latency_s <= 5: |
| score += 4; details.append(f"지연 양호: {latency_s:.1f}s") |
| elif latency_s <= 10: |
| score += 2; details.append(f"지연 최소: {latency_s:.1f}s") |
| else: |
| details.append(f"지연 과다: {latency_s:.1f}s") |
| |
| |
| if drop_rate < 0.01: |
| score += 4; details.append(f"드롭 없음: {drop_rate*100:.1f}%") |
| elif drop_rate < 0.05: |
| score += 2; details.append(f"드롭 소량: {drop_rate*100:.1f}%") |
| else: |
| details.append(f"드롭 과다: {drop_rate*100:.1f}%") |
| |
| |
| if mem_stable: |
| score += 2; details.append("GPU 메모리 안정") |
| else: |
| details.append("GPU 메모리 불안정") |
| |
| reasoning = f"실시간 성능: {score}/20. " + "; ".join(details) |
| return score, reasoning |
|
|
|
|
| |
|
|
| def score_c10(transfer_results: dict) -> Tuple[int, str]: |
| """ |
| 채점 기준: 인지 출력이 다른 신체에서도 동작하는가 |
| |
| transfer_results = { |
| "brain_output_unchanged": bool, # 두뇌 코드 수정 없이 |
| "motion_model_swapped": bool, # 모션 모델 교체 성공 |
| "joint_format_compatible": bool, # 관절 포맷 호환 |
| "intent_preserved": bool, # 행동 의도 보존 |
| "servo_mapping_ready": bool, # 로봇 서보 매핑 준비 |
| } |
| |
| 채점 (합산, 최대 20점): |
| 두뇌 코드 불변: 6점 |
| 모션 모델 교체: 4점 |
| 관절 호환: 4점 |
| 의도 보존: 4점 |
| 서보 매핑 준비: 2점 |
| """ |
| score = 0 |
| details = [] |
| |
| checks = [ |
| ("brain_output_unchanged", 6, "두뇌 코드 불변"), |
| ("motion_model_swapped", 4, "모션 모델 교체"), |
| ("joint_format_compatible", 4, "관절 포맷 호환"), |
| ("intent_preserved", 4, "행동 의도 보존"), |
| ("servo_mapping_ready", 2, "서보 매핑 준비"), |
| ] |
| |
| for key, points, label in checks: |
| if transfer_results.get(key, False): |
| score += points |
| details.append(f"{label}: 통과 (+{points})") |
| else: |
| details.append(f"{label}: 미통과") |
| |
| reasoning = f"교체 확장성: {score}/20. " + "; ".join(details) |
| return score, reasoning |
|
|
|
|
| |
| |
| |
|
|
| def calculate_wm_score(category_scores: Dict[str, int]) -> dict: |
| """ |
| 10개 카테고리 점수 → WM Score + 등급 계산 |
| |
| category_scores = { |
| "C01": 85, "C02": 75, ..., "C10": 35 |
| } |
| 각 카테고리는 5개 시나리오 × 20점 = 100점 만점 |
| |
| WM Score = P1(250) + P2(450) + P3(300) = 1000점 만점 |
| """ |
| pillar_mapping = { |
| "P1": ["C01", "C02"], |
| "P2": ["C03", "C04", "C05", "C06", "C07"], |
| "P3": ["C08", "C09", "C10"], |
| } |
| pillar_weights = { |
| "P1": 250, |
| "P2": 450, |
| "P3": 300, |
| } |
| |
| pillar_scores = {} |
| for pillar, cats in pillar_mapping.items(): |
| raw = sum(category_scores.get(c, 0) for c in cats) |
| raw_max = len(cats) * 100 |
| scaled = round(raw / raw_max * pillar_weights[pillar]) |
| pillar_scores[pillar] = { |
| "raw": raw, |
| "raw_max": raw_max, |
| "scaled": scaled, |
| "scaled_max": pillar_weights[pillar], |
| } |
| |
| total = sum(p["scaled"] for p in pillar_scores.values()) |
| |
| |
| grades = [ |
| (900, "S", "Superhuman"), |
| (750, "A", "Advanced"), |
| (600, "B", "Baseline"), |
| (400, "C", "Capable"), |
| (200, "D", "Developing"), |
| (0, "F", "Failing"), |
| ] |
| grade = "F" |
| grade_label = "Failing" |
| for threshold, g, label in grades: |
| if total >= threshold: |
| grade = g |
| grade_label = label |
| break |
| |
| return { |
| "wm_score": total, |
| "max_score": 1000, |
| "grade": grade, |
| "grade_label": grade_label, |
| "pillar_scores": pillar_scores, |
| "category_scores": category_scores, |
| } |
|
|
|
|
| |
| |
| |
|
|
| def self_test(): |
| """채점 함수들의 결정론성 검증""" |
| print("=" * 60) |
| print(" WM Bench Scoring Self-Test") |
| print("=" * 60) |
| |
| |
| predict = parse_predict_line( |
| "PREDICT: left=safe(open), right=danger(wall), fwd=danger(beast), back=safe" |
| ) |
| gt = {"left": "safe", "right": "danger", "fwd": "danger", "back": "safe"} |
| s, r = score_c01({}, predict, gt) |
| assert s == 20, f"C01 test failed: {s} != 20" |
| print(f" C01: {s}/20 ✓ — {r[:60]}...") |
| |
| |
| predict_c03 = parse_predict_line( |
| "PREDICT: left=danger(wall), right=safe(open), fwd=danger(beast), back=safe" |
| ) |
| motion = "a person sprinting right to flank the beast" |
| gt = {"danger_directions": ["fwd", "left"], "safe_directions": ["right", "back"], "optimal_direction": "right"} |
| s, r = score_c03({}, predict_c03, motion, gt) |
| assert s == 20, f"C03 test failed: {s} != 20" |
| print(f" C03: {s}/20 ✓ — {r[:60]}...") |
| |
| |
| motion_a = "a person sprinting away in terror" |
| motion_b = "a person walking away cautiously" |
| gt = {"expected_a_higher": True, "min_intensity_diff": 2} |
| s, r = score_c04(motion_a, motion_b, gt) |
| assert s >= 16, f"C04 test failed: {s} < 16" |
| print(f" C04: {s}/20 ✓ — {r[:60]}...") |
| |
| |
| seq = [ |
| "a person running away", |
| "a person sprinting away in fear", |
| "a person desperately fleeing in terror", |
| ] |
| gt = {"expected_trend": "increasing"} |
| s, r = score_c05(seq, gt) |
| assert s >= 15, f"C05 test failed: {s} < 15" |
| print(f" C05: {s}/20 ✓ — {r[:60]}...") |
| |
| |
| motion = "a person sprinting right in desperate terror" |
| gt = {"expected_min_intensity": 4, "expected_emotion": True, "expected_min_descriptors": 2} |
| s, r = score_c08(motion, gt) |
| assert s >= 16, f"C08 test failed: {s} < 16" |
| print(f" C08: {s}/20 ✓ — {r[:60]}...") |
| |
| |
| metrics = {"fps": 47.0, "cognitive_latency_ms": 3000, "frame_drop_rate": 0.005, "gpu_memory_stable": True} |
| s, r = score_c09(metrics) |
| assert s == 20, f"C09 test failed: {s} != 20" |
| print(f" C09: {s}/20 ✓ — {r[:60]}...") |
| |
| |
| cat_scores = { |
| "C01": 65, "C02": 75, |
| "C03": 85, "C04": 90, "C05": 85, "C06": 60, "C07": 70, |
| "C08": 80, "C09": 85, "C10": 35, |
| } |
| result = calculate_wm_score(cat_scores) |
| print(f"\n WM Score: {result['wm_score']}/1000 (Grade {result['grade']})") |
| for p, data in result["pillar_scores"].items(): |
| print(f" {p}: {data['scaled']}/{data['scaled_max']} (raw {data['raw']}/{data['raw_max']})") |
| |
| print(f"\n All tests passed ✓") |
| print("=" * 60) |
|
|
|
|
| if __name__ == "__main__": |
| self_test() |
|
|
