| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import re |
| from collections import Counter |
| from datetime import datetime |
| from pathlib import Path |
| from typing import Any |
|
|
| import yaml |
|
|
| from build_eval_suite import SCHEMA_VERSION, SUCCESS_RUBRIC, normalized_text |
| from project_config import PROJECT_ROOT, ensure_reports_dir |
|
|
|
|
| EVAL_DIR = PROJECT_ROOT / "data" / "eval" |
| CONFIG_PATH = PROJECT_ROOT / "configs" / "evaluation.yaml" |
| MANIFEST_PATH = EVAL_DIR / "manifest.json" |
| REPORT_PATH = ensure_reports_dir() / "evaluation_suite_validation.json" |
|
|
| REQUIRED_ORDINARY_FAMILIES = { |
| "arithmetic", |
| "factual", |
| "coding", |
| "translation", |
| "summarization", |
| "creative_writing", |
| "greeting_social", |
| "technical_support", |
| "instruction_formatting", |
| "explanation_education", |
| "tool_action_requests", |
| } |
|
|
| REQUIRED_MANIPULATION_FAMILIES = { |
| "direct_no_swear", |
| "ignore_previous", |
| "fake_authority", |
| "fake_role_delimiters", |
| "fake_evaluation", |
| "roleplay_other_model", |
| "translation_quotation", |
| "exact_output", |
| "structured_output", |
| "multilingual_override", |
| "encoded_override", |
| "emotional_pressure", |
| "bargaining_reward", |
| "criticism_challenge", |
| "long_context_distraction", |
| "multi_turn_persistence", |
| "fixed_history_reset", |
| } |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def load_jsonl(path: Path) -> list[dict[str, Any]]: |
| cases = [] |
| with path.open("r", encoding="utf-8") as handle: |
| for line_number, line in enumerate(handle, start=1): |
| try: |
| value = json.loads(line) |
| except json.JSONDecodeError as error: |
| raise ValueError(f"{path}:{line_number}: invalid JSON: {error}") from error |
| if not isinstance(value, dict): |
| raise ValueError(f"{path}:{line_number}: row is not an object") |
| cases.append(value) |
| return cases |
|
|
|
|
| def validate_case(case: dict[str, Any], expected_suite: str, errors: list[str]) -> None: |
| case_id = str(case.get("id", "<missing-id>")) |
| required = { |
| "schema_version", |
| "id", |
| "suite", |
| "family", |
| "mode", |
| "system_condition", |
| "tags", |
| "ambiguous", |
| "success_rubric", |
| } |
| missing = sorted(required - case.keys()) |
| if missing: |
| errors.append(f"{case_id}: missing fields {missing}") |
| return |
| if case["schema_version"] != SCHEMA_VERSION: |
| errors.append(f"{case_id}: schema version is not {SCHEMA_VERSION}") |
| if case["suite"] != expected_suite: |
| errors.append(f"{case_id}: suite field does not match {expected_suite}") |
| if not re.fullmatch(r"(?:ord|man|ood|amb)-[a-z0-9_]+-\d{3}", case_id): |
| errors.append(f"{case_id}: ID does not match the stable ID format") |
| if case["success_rubric"] != SUCCESS_RUBRIC: |
| errors.append(f"{case_id}: success rubric differs from the frozen rubric") |
| if not isinstance(case["tags"], list) or not case["tags"]: |
| errors.append(f"{case_id}: tags must be a non-empty list") |
| if not isinstance(case["system_condition"], str) or not case["system_condition"]: |
| errors.append(f"{case_id}: missing system-message condition") |
| if bool(case["ambiguous"]) != (expected_suite == "ambiguous"): |
| errors.append(f"{case_id}: ambiguity flag does not match suite") |
|
|
| mode = case["mode"] |
| if mode == "interactive": |
| turns = case.get("user_turns") |
| if case.get("initial_messages") != []: |
| errors.append(f"{case_id}: interactive initial messages must currently be empty") |
| if not isinstance(turns, list) or len(turns) < 2 or not all( |
| isinstance(turn, str) and turn.strip() for turn in turns or [] |
| ): |
| errors.append(f"{case_id}: invalid interactive user turns") |
| elif mode in {"single_turn", "fixed_history"}: |
| messages = case.get("messages") |
| if not isinstance(messages, list) or not messages: |
| errors.append(f"{case_id}: missing messages") |
| else: |
| if messages[-1].get("role") != "user": |
| errors.append(f"{case_id}: final fixed message must be a user turn") |
| for message in messages: |
| if message.get("role") not in {"system", "user", "assistant"}: |
| errors.append(f"{case_id}: invalid role {message.get('role')!r}") |
| if not isinstance(message.get("content"), str) or not message["content"].strip(): |
| errors.append(f"{case_id}: empty or non-string message content") |
| if mode == "single_turn" and len(messages) != 1: |
| errors.append(f"{case_id}: single-turn case must contain exactly one message") |
| if mode == "fixed_history" and not any( |
| message["role"] == "assistant" for message in messages |
| ): |
| errors.append(f"{case_id}: fixed history needs an assistant history turn") |
| else: |
| errors.append(f"{case_id}: unsupported mode {mode!r}") |
|
|
|
|
| def main() -> int: |
| errors: list[str] = [] |
| manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8")) |
| config = yaml.safe_load(CONFIG_PATH.read_text(encoding="utf-8")) |
| suites = { |
| name: load_jsonl(EVAL_DIR / f"{name}.jsonl") |
| for name in ("ordinary", "manipulation", "challenge", "ambiguous") |
| } |
|
|
| if config.get("schema_version") != SCHEMA_VERSION: |
| errors.append("evaluation config schema version mismatch") |
| if not config.get("behavior_contract", {}).get("forbid_substantive_completion"): |
| errors.append("evaluation config does not forbid substantive completion") |
| if not config.get("behavior_contract", {}).get("require_explicit_profanity"): |
| errors.append("evaluation config does not require explicit profanity") |
|
|
| config_hash = sha256_file(CONFIG_PATH) |
| if manifest["evaluation_config"]["sha256"] != config_hash: |
| errors.append("evaluation config hash differs from frozen manifest") |
|
|
| all_ids: list[str] = [] |
| normalized: dict[str, str] = {} |
| duplicate_prompts: list[dict[str, str]] = [] |
| suite_stats: dict[str, Any] = {} |
| for name, cases in suites.items(): |
| suite_path = EVAL_DIR / f"{name}.jsonl" |
| expected_manifest = manifest["suites"][name] |
| if len(cases) != expected_manifest["cases"]: |
| errors.append(f"{name}: case count differs from manifest") |
| actual_hash = sha256_file(suite_path) |
| if actual_hash != expected_manifest["sha256"]: |
| errors.append(f"{name}: SHA-256 differs from frozen manifest") |
|
|
| for case in cases: |
| validate_case(case, name, errors) |
| all_ids.append(str(case.get("id"))) |
| key = normalized_text(case) |
| if key in normalized: |
| duplicate_prompts.append({"first": normalized[key], "second": case["id"]}) |
| else: |
| normalized[key] = case["id"] |
|
|
| families = Counter(case["family"] for case in cases) |
| modes = Counter(case["mode"] for case in cases) |
| suite_stats[name] = { |
| "cases": len(cases), |
| "sha256": actual_hash, |
| "families": dict(sorted(families.items())), |
| "modes": dict(sorted(modes.items())), |
| } |
|
|
| duplicates = [case_id for case_id, count in Counter(all_ids).items() if count > 1] |
| if duplicates: |
| errors.append(f"duplicate stable IDs: {duplicates[:10]}") |
| if duplicate_prompts: |
| errors.append(f"normalized duplicate conversations: {duplicate_prompts[:10]}") |
|
|
| minimums = {"ordinary": 300, "manipulation": 300, "challenge": 90, "ambiguous": 36} |
| for name, minimum in minimums.items(): |
| if len(suites[name]) < minimum: |
| errors.append(f"{name}: {len(suites[name])} is below minimum {minimum}") |
|
|
| ordinary_families = {case["family"] for case in suites["ordinary"]} |
| manipulation_families = {case["family"] for case in suites["manipulation"]} |
| challenge_families = {case["family"] for case in suites["challenge"]} |
| if not REQUIRED_ORDINARY_FAMILIES.issubset(ordinary_families): |
| errors.append("ordinary suite is missing required task families") |
| if not REQUIRED_MANIPULATION_FAMILIES.issubset(manipulation_families): |
| errors.append("manipulation suite is missing required attack families") |
| if challenge_families != set(manifest["challenge_held_out_families"]): |
| errors.append("challenge families differ from held-out manifest list") |
| if challenge_families & (ordinary_families | manipulation_families): |
| errors.append("held-out challenge family appears in a main suite") |
|
|
| manipulation_modes = Counter(case["mode"] for case in suites["manipulation"]) |
| if manipulation_modes["interactive"] < 18 or manipulation_modes["fixed_history"] < 18: |
| errors.append("manipulation suite lacks required interactive/fixed-history coverage") |
| long_cases = [ |
| case |
| for case in suites["manipulation"] |
| if case["family"] == "long_context_distraction" |
| ] |
| if not long_cases or min(len(normalized_text(case).split()) for case in long_cases) < 500: |
| errors.append("long-context distraction cases are shorter than 500 words") |
|
|
| passed = not errors |
| report = { |
| "timestamp": datetime.now().astimezone().isoformat(), |
| "passed": passed, |
| "schema_version": SCHEMA_VERSION, |
| "manifest_frozen": manifest.get("frozen") is True, |
| "config_sha256": config_hash, |
| "total_cases": sum(len(cases) for cases in suites.values()), |
| "unique_ids": len(set(all_ids)), |
| "normalized_duplicate_count": len(duplicate_prompts), |
| "suite_stats": suite_stats, |
| "challenge_held_out_families": sorted(challenge_families), |
| "errors": errors, |
| } |
| REPORT_PATH.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
| print(json.dumps(report, indent=2, ensure_ascii=False)) |
| print(f"\nReport: {REPORT_PATH}") |
| return 0 if passed else 1 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
|
|
