| """Independently verify a built Sudoku_DLM_Reasoning release.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| from collections import Counter |
| from pathlib import Path |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
|
|
| EXPECTED_BUCKETS = { |
| "train": {"original": 65_536, "r0": 65_536, "r1_4": 65_536}, |
| "validation": {"original": 2_048, "r0": 2_048, "r1_4": 2_048}, |
| "test": {"original": 1_000, "r0": 1_000, "r1_4": 1_000, "r5_19": 1_000}, |
| "test_ood_confirm": {"r5_19": 4_000}, |
| } |
|
|
| EXPECTED_SUBBUCKETS = { |
| "test": { |
| "original": 1_000, |
| "r0": 1_000, |
| "r1_2": 250, |
| "r2_3": 250, |
| "r3_4": 250, |
| "r4_5": 250, |
| "r5_7": 250, |
| "r8_11": 250, |
| "r12_15": 250, |
| "r16_19": 250, |
| }, |
| "test_ood_confirm": { |
| "r5_7": 1_000, |
| "r8_11": 1_000, |
| "r12_15": 1_000, |
| "r16_19": 1_000, |
| }, |
| } |
|
|
| EXPECTED_SCHEMA = pa.schema( |
| [ |
| pa.field("example_id", pa.string(), nullable=False), |
| pa.field("puzzle_id", pa.string(), nullable=False), |
| pa.field("digit_normalized_id", pa.string(), nullable=False), |
| pa.field("puzzle", pa.string(), nullable=False), |
| pa.field("solution", pa.string(), nullable=False), |
| pa.field("difficulty_bucket", pa.string(), nullable=False), |
| pa.field("difficulty_subbucket", pa.string(), nullable=False), |
| pa.field("source_family", pa.string(), nullable=False), |
| pa.field("source_collection", pa.string(), nullable=False), |
| pa.field("official_rating", pa.float64(), nullable=True), |
| pa.field("rating_type", pa.string(), nullable=False), |
| pa.field("clues", pa.int16(), nullable=False), |
| pa.field("upstream_split", pa.string(), nullable=False), |
| pa.field("release_split", pa.string(), nullable=False), |
| pa.field("evaluation_role", pa.string(), nullable=False), |
| pa.field("is_ood", pa.bool_(), nullable=False), |
| pa.field("source_file", pa.string(), nullable=False), |
| pa.field("source_row_index", pa.int64(), nullable=False), |
| pa.field("stratum", pa.string(), nullable=False), |
| ] |
| ) |
|
|
| VERIFY_COLUMNS = [ |
| "example_id", |
| "puzzle_id", |
| "digit_normalized_id", |
| "puzzle", |
| "solution", |
| "difficulty_bucket", |
| "difficulty_subbucket", |
| "clues", |
| "upstream_split", |
| "release_split", |
| "evaluation_role", |
| "is_ood", |
| "source_row_index", |
| ] |
|
|
|
|
| def sha256_text(value: str) -> str: |
| return hashlib.sha256(value.encode("utf-8")).hexdigest() |
|
|
|
|
| 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 digit_normalized_id(puzzle: str, solution: str) -> str: |
| mapping: dict[str, str] = {} |
| for digit in solution: |
| mapping.setdefault(digit, str(len(mapping) + 1)) |
| if len(mapping) != 9: |
| raise AssertionError("solution does not contain all digits") |
| normalized_puzzle = "".join("0" if digit == "0" else mapping[digit] for digit in puzzle) |
| normalized_solution = "".join(mapping[digit] for digit in solution) |
| return sha256_text(f"{normalized_puzzle}|{normalized_solution}") |
|
|
|
|
| def validate_sudoku(puzzle: str, solution: str) -> None: |
| assert len(puzzle) == 81 and set(puzzle) <= set("0123456789") |
| assert len(solution) == 81 and set(solution) <= set("123456789") |
| assert all(clue == "0" or clue == solution[index] for index, clue in enumerate(puzzle)) |
| expected = set("123456789") |
| units = [solution[index : index + 9] for index in range(0, 81, 9)] |
| units.extend(solution[index::9] for index in range(9)) |
| for box_row in range(3): |
| for box_col in range(3): |
| units.append( |
| "".join( |
| solution[row * 9 + box_col * 3 : row * 9 + box_col * 3 + 3] |
| for row in range(box_row * 3, box_row * 3 + 3) |
| ) |
| ) |
| assert all(set(unit) == expected for unit in units) |
|
|
|
|
| def expected_role(split: str, bucket: str) -> tuple[str, bool]: |
| if split == "train": |
| return "train_id", False |
| if split == "validation": |
| return "validation_id", False |
| if split == "test": |
| return ("test_ood", True) if bucket == "r5_19" else ("test_id", False) |
| return "confirm_ood", True |
|
|
|
|
| def verify_split(path: Path, split: str) -> tuple[dict[str, set[str]], dict[str, object]]: |
| file_schema = pq.read_schema(path) |
| if not file_schema.equals(EXPECTED_SCHEMA, check_metadata=False): |
| raise AssertionError(f"{split}: schema mismatch\n{file_schema}\n!=\n{EXPECTED_SCHEMA}") |
| table = pq.read_table(path, columns=VERIFY_COLUMNS) |
| expected_rows = sum(EXPECTED_BUCKETS[split].values()) |
| assert table.num_rows == expected_rows, (split, table.num_rows, expected_rows) |
| columns = table.to_pydict() |
| ids = {name: set() for name in ("example_id", "puzzle_id", "digit_normalized_id")} |
| buckets: Counter[str] = Counter() |
| subbuckets: Counter[str] = Counter() |
| expected_upstream = "train" if split in {"train", "validation"} else "test" |
|
|
| for index in range(table.num_rows): |
| puzzle = columns["puzzle"][index] |
| solution = columns["solution"][index] |
| bucket = columns["difficulty_bucket"][index] |
| validate_sudoku(puzzle, solution) |
| assert columns["example_id"][index] == sha256_text(f"{puzzle}|{solution}") |
| assert columns["puzzle_id"][index] == sha256_text(puzzle) |
| assert columns["digit_normalized_id"][index] == digit_normalized_id(puzzle, solution) |
| assert columns["clues"][index] == sum(value != "0" for value in puzzle) |
| assert columns["upstream_split"][index] == expected_upstream |
| assert columns["release_split"][index] == split |
| role, is_ood = expected_role(split, bucket) |
| assert columns["evaluation_role"][index] == role |
| assert columns["is_ood"][index] is is_ood |
| assert columns["source_row_index"][index] >= 0 |
| buckets[bucket] += 1 |
| subbuckets[columns["difficulty_subbucket"][index]] += 1 |
| for name in ids: |
| value = columns[name][index] |
| if value in ids[name]: |
| raise AssertionError(f"{split}: duplicate {name} {value}") |
| ids[name].add(value) |
|
|
| assert dict(buckets) == EXPECTED_BUCKETS[split], (split, buckets) |
| if split in EXPECTED_SUBBUCKETS: |
| assert dict(subbuckets) == EXPECTED_SUBBUCKETS[split], (split, subbuckets) |
| return ids, { |
| "rows": table.num_rows, |
| "difficulty_buckets": dict(sorted(buckets.items())), |
| "difficulty_subbuckets": dict(sorted(subbuckets.items())), |
| "sha256": sha256_file(path), |
| } |
|
|
|
|
| def count_csv_rows(path: Path) -> int: |
| with path.open("r", encoding="utf-8", newline="") as handle: |
| reader = csv.reader(handle) |
| next(reader) |
| return sum(1 for _ in reader) |
|
|
|
|
| def verify_raw_snapshot(root: Path, manifest: dict[str, object]) -> dict[str, object] | None: |
| raw_manifest_name = manifest.get("raw_snapshot_file") |
| if raw_manifest_name is None: |
| return None |
| raw_manifest = json.loads((root / str(raw_manifest_name)).read_text(encoding="utf-8")) |
| assert raw_manifest["label"] == "raw" |
| rows = 0 |
| for relative_path, declared in raw_manifest["files"].items(): |
| path = root / relative_path |
| assert relative_path.startswith("raw/"), relative_path |
| assert path.is_file(), relative_path |
| assert path.stat().st_size == declared["bytes"], relative_path |
| assert sha256_file(path) == declared["sha256"], relative_path |
| observed_rows = count_csv_rows(path) |
| assert observed_rows == declared["rows"], relative_path |
| release_declared = manifest["files"][relative_path] |
| assert release_declared["sha256"] == declared["sha256"], relative_path |
| assert release_declared["rows"] == observed_rows, relative_path |
| rows += observed_rows |
| assert rows == raw_manifest["candidate_rows"] |
| return {"label": "raw", "files": len(raw_manifest["files"]), "rows": rows} |
|
|
|
|
| def verify_release( |
| root: Path, |
| expected_version: str | None = None, |
| expected_seed: str | None = None, |
| ) -> dict[str, object]: |
| manifest = json.loads((root / "metadata/manifest.json").read_text(encoding="utf-8")) |
| audit = json.loads((root / "metadata/audit.json").read_text(encoding="utf-8")) |
| split_spec = json.loads( |
| (root / "metadata/split_spec.json").read_text(encoding="utf-8") |
| ) |
| assert manifest["dataset_id"] == "stwistzz/Sudoku_DLM_Reasoning" |
| dataset_version = str(manifest["dataset_version"]) |
| if expected_version is not None: |
| assert dataset_version == expected_version, (dataset_version, expected_version) |
| selection_seed = str(manifest["seed"]) |
| if expected_seed is not None: |
| assert selection_seed == expected_seed, (selection_seed, expected_seed) |
| assert audit["dataset_version"] == dataset_version |
| assert split_spec["dataset_version"] == dataset_version |
| assert str(audit["seed"]) == selection_seed |
| assert str(split_spec["seed"]) == selection_seed |
|
|
| split_ids: dict[str, dict[str, set[str]]] = {} |
| summaries: dict[str, object] = {} |
| for split in EXPECTED_BUCKETS: |
| relative_path = f"data/{split}.parquet" |
| ids, summary = verify_split(root / relative_path, split) |
| split_ids[split] = ids |
| summaries[split] = summary |
| declared = manifest["files"][relative_path] |
| assert declared["rows"] == summary["rows"] |
| assert declared["sha256"] == summary["sha256"] |
|
|
| split_names = list(EXPECTED_BUCKETS) |
| overlaps: dict[str, dict[str, int]] = {} |
| for left_index, left in enumerate(split_names): |
| for right in split_names[left_index + 1 :]: |
| key = f"{left}__vs__{right}" |
| overlaps[key] = { |
| name: len(split_ids[left][name] & split_ids[right][name]) |
| for name in split_ids[left] |
| } |
| assert not any(value for result in overlaps.values() for value in result.values()) |
| assert audit["pairwise_overlap"] == overlaps |
| assert audit["strict_selected_rows_verified"] == sum( |
| sum(counts.values()) for counts in EXPECTED_BUCKETS.values() |
| ) |
|
|
| for relative_path, declared in manifest["files"].items(): |
| path = root / relative_path |
| assert path.is_file(), relative_path |
| assert path.stat().st_size == declared["bytes"], relative_path |
| assert sha256_file(path) == declared["sha256"], relative_path |
|
|
| raw_summary = verify_raw_snapshot(root, manifest) |
| return { |
| "dataset_version": dataset_version, |
| "selection_seed": selection_seed, |
| "splits": summaries, |
| "pairwise_overlap": overlaps, |
| "raw_snapshot": raw_summary, |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("release_dir", type=Path) |
| parser.add_argument("--expected-version") |
| parser.add_argument("--expected-seed") |
| args = parser.parse_args() |
| result = verify_release( |
| args.release_dir.resolve(), args.expected_version, args.expected_seed |
| ) |
| print(json.dumps(result, indent=2, sort_keys=True)) |
| print("VERIFICATION_OK") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
