| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| from collections import Counter |
| from pathlib import Path |
| from typing import Any |
|
|
| from .arena import ARENA_VERSION, Action |
| from .arena_generation import GENERATOR_VERSION, generate_mechanics_state, generate_state |
| from .arena_oracle import deterministic_policy, local_policy_action, solve_joint_action |
| from .arena_protocol import ARENA_PROMPT_VERSION, parse_action, parse_broadcast |
| from .arena_sft import DATASET_VERSION, split_for_seed |
| from .arena_splits import FROZEN_EVAL_SEEDS |
|
|
|
|
| def _action(value: dict[str, Any]) -> Action: |
| return Action(value["type"], value.get("target"), value.get("amount")) |
|
|
|
|
| def audit_dataset(path: Path, require_split_action_coverage: bool = False) -> dict[str, Any]: |
| manifest = json.loads((path / "manifest.json").read_text(encoding="utf-8")) |
| rows = [] |
| for split in ("train", "validation", "test"): |
| for line in (path / f"{split}.jsonl").read_text(encoding="utf-8").splitlines(): |
| if line.strip(): |
| row = json.loads(line) |
| row["_file_split"] = split |
| rows.append(row) |
|
|
| failures: list[str] = [] |
| ids: set[str] = set() |
| phases: Counter[str] = Counter() |
| action_kinds: Counter[str] = Counter() |
| action_kinds_by_split: dict[str, Counter[str]] = { |
| split: Counter() for split in ("train", "validation", "test") |
| } |
| action_positions: Counter[int] = Counter() |
| broadcast_facts: Counter[int] = Counter() |
| seeds_by_split: dict[int, set[str]] = {} |
| solver_cache = {} |
| for row_number, row in enumerate(rows, 1): |
| metadata = row.get("metadata", {}) |
| messages = row.get("messages", []) |
| row_id = row.get("id") |
| prefix = f"row {row_number} ({row_id})" |
| if row_id in ids: |
| failures.append(f"{prefix}: duplicate_id") |
| ids.add(row_id) |
| if [item.get("role") for item in messages] != ["system", "user", "assistant"]: |
| failures.append(f"{prefix}: chat_schema") |
| continue |
| if metadata.get("dataset_version") != DATASET_VERSION: |
| failures.append(f"{prefix}: dataset_version") |
| if metadata.get("arena_version") != ARENA_VERSION: |
| failures.append(f"{prefix}: arena_version") |
| if metadata.get("generator_version") != GENERATOR_VERSION: |
| failures.append(f"{prefix}: generator_version") |
| if metadata.get("prompt_version") != ARENA_PROMPT_VERSION: |
| failures.append(f"{prefix}: prompt_version") |
| seed = metadata.get("seed") |
| if not isinstance(seed, int): |
| failures.append(f"{prefix}: seed") |
| continue |
| if seed in FROZEN_EVAL_SEEDS: |
| failures.append(f"{prefix}: frozen_eval_leakage") |
| expected_split = split_for_seed(seed) |
| if metadata.get("split") != expected_split or row["_file_split"] != expected_split: |
| failures.append(f"{prefix}: wrong_split") |
| seeds_by_split.setdefault(seed, set()).add(expected_split) |
| user_text = messages[1].get("content", "") |
| if any(term in user_text for term in ("required_joint", "oracle_message", "solver_reward", "answer_key")): |
| failures.append(f"{prefix}: answer_leakage") |
| try: |
| user = json.loads(user_text) |
| except json.JSONDecodeError: |
| failures.append(f"{prefix}: invalid_user_json") |
| continue |
| if metadata.get("generator_mode") == "targeted_mechanics": |
| state = generate_mechanics_state(seed, metadata.get("targeted_skill")) |
| else: |
| state = generate_state(seed) |
| agent_id = metadata.get("agent_id") |
| phase = metadata.get("phase") |
| phases[phase] += 1 |
| assistant = messages[2].get("content", "") |
| if phase == "BROADCAST": |
| parsed = parse_broadcast(assistant, state, agent_id) |
| if not parsed.valid: |
| failures.append(f"{prefix}: invalid_broadcast:{','.join(parsed.errors)}") |
| else: |
| broadcast_facts[len(parsed.value.facts)] += 1 |
| elif phase == "ACT": |
| raw_actions = user.get("legal_actions") |
| if not isinstance(raw_actions, list): |
| failures.append(f"{prefix}: missing_legal_actions") |
| continue |
| displayed = tuple(_action(item) for item in raw_actions) |
| if [item.get("id") for item in raw_actions] != [f"A{index}" for index in range(len(raw_actions))]: |
| failures.append(f"{prefix}: action_ids") |
| parsed = parse_action(assistant, displayed) |
| if not parsed.valid: |
| failures.append(f"{prefix}: invalid_action:{','.join(parsed.errors)}") |
| continue |
| selected = parsed.value |
| action_kinds[selected.kind] += 1 |
| action_kinds_by_split[expected_split][selected.kind] += 1 |
| action_positions[displayed.index(selected)] += 1 |
| if seed not in solver_cache: |
| solver_cache[seed] = solve_joint_action( |
| state, "BLUE", deterministic_policy(state, "RED") |
| ) |
| solution = solver_cache[seed] |
| if selected not in solution.acceptable_for(agent_id): |
| failures.append(f"{prefix}: not_solver_optimal") |
| if selected != local_policy_action(state, agent_id): |
| failures.append(f"{prefix}: not_prompt_identifiable") |
| for inbox_item in user.get("inbox", []): |
| intent = inbox_item.get("broadcast", {}).get("intent") |
| if intent is not None and _action(intent) == selected: |
| failures.append(f"{prefix}: conflicting_declared_intent") |
| else: |
| failures.append(f"{prefix}: unknown_phase") |
|
|
| if any(len(splits) != 1 for splits in seeds_by_split.values()): |
| failures.append("seed_crosses_splits") |
| content_hash = hashlib.sha256("".join(sorted(row["id"] for row in rows)).encode()).hexdigest() |
| if content_hash != manifest.get("content_sha256"): |
| failures.append("manifest_content_hash") |
| if len(rows) != manifest.get("num_examples"): |
| failures.append("manifest_example_count") |
| expected_versions = { |
| "dataset_version": DATASET_VERSION, |
| "arena_version": ARENA_VERSION, |
| "generator_version": GENERATOR_VERSION, |
| "prompt_version": ARENA_PROMPT_VERSION, |
| } |
| for key, expected in expected_versions.items(): |
| if manifest.get(key) != expected: |
| failures.append(f"manifest_{key}") |
| actual_splits = Counter(row["metadata"]["split"] for row in rows) |
| if dict(sorted(actual_splits.items())) != manifest.get("examples_by_split"): |
| failures.append("manifest_split_counts") |
| if dict(sorted(phases.items())) != manifest.get("examples_by_phase"): |
| failures.append("manifest_phase_counts") |
| required_actions = {"WAIT", "SCAN", "PROBE", "CAPTURE", "FORTIFY", "RECOVER", "TRANSFER"} |
| missing_actions = sorted(required_actions - set(action_kinds)) |
| if missing_actions: |
| failures.append("missing_action_coverage:" + ",".join(missing_actions)) |
| if require_split_action_coverage: |
| for split, counts in action_kinds_by_split.items(): |
| missing = sorted(required_actions - set(counts)) |
| if missing: |
| failures.append(f"missing_{split}_action_coverage:" + ",".join(missing)) |
| if broadcast_facts[0] == 0: |
| failures.append("missing_silence_coverage") |
| return { |
| "valid": not failures, |
| "failures": failures, |
| "num_examples": len(rows), |
| "num_unique_seeds": len(seeds_by_split), |
| "phases": dict(sorted(phases.items())), |
| "action_kinds": dict(sorted(action_kinds.items())), |
| "action_kinds_by_split": { |
| split: dict(sorted(counts.items())) |
| for split, counts in action_kinds_by_split.items() |
| }, |
| "action_positions": {str(key): value for key, value in sorted(action_positions.items())}, |
| "broadcast_fact_counts": {str(key): value for key, value in sorted(broadcast_facts.items())}, |
| "verified_solver_seeds": len(solver_cache), |
| "required_split_action_coverage": require_split_action_coverage, |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description="Independently audit an arena SFT dataset.") |
| parser.add_argument("path", type=Path) |
| parser.add_argument("--output", type=Path) |
| parser.add_argument("--require-split-action-coverage", action="store_true") |
| args = parser.parse_args() |
| report = audit_dataset(args.path, args.require_split_action_coverage) |
| output = args.output or args.path / "audit.json" |
| output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8") |
| print(json.dumps(report, indent=2, sort_keys=True)) |
| if not report["valid"]: |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
