| """Small compute-only multi-shard equivalence and global leak regressions.""" |
| from itertools import islice |
| import json |
| import os |
| from pathlib import Path |
| import time |
| import unittest |
|
|
| from barbet_bgd.io import iter_jsonl_gz, sha256_file, write_json_atomic, write_jsonl_gz_atomic |
| from barbet_bgd.export_sft_v3 import export_sft |
| from barbet_bgd.quality_v2 import validate_record_quality_v2 |
| from barbet_bgd.release_v3 import native_streaming_verify |
| from barbet_bgd.serializers_v3 import canonical_json_v3 |
| from parallel_release import parallel_export_sft, parallel_native_streaming_verify |
|
|
|
|
| ROOT = Path("/groups/voidful/barbet-sft") / ("parallel-bench-" + os.environ.get("SLURM_JOB_ID", "NO_JOB")) |
|
|
|
|
| def _minimal(index, split, group=None, record_id=None): |
| record = { |
| "record_id": record_id or f"row:{index}", "source_group": group or f"group:{index}", |
| "split": split, "primitive": "COPY", "task_family": "FAITHFUL_OCR", "locale": "zh-TW", |
| "task_spec": {"query": "請保留來源文字。", "requested_schema": {}}, |
| "inputs": [{"id": "src", "units": [{"id": "src:u01", "text": "臺灣資料。"}]}], |
| "target": {"decision": "COPIED", "evidence": ["src:u01"], "output_text": "臺灣資料。"}, |
| "presentation": {"serializer": "JSON"}, |
| } |
| import hashlib |
| verdict = {"record_id": record["record_id"], "record_sha256": hashlib.sha256(canonical_json_v3(record).encode()).hexdigest(), |
| "disposition": "KEEP", "training_ready": True, "hard_failures": [], "pipeline_checks": {"test": True}} |
| return record, verdict |
|
|
|
|
| class ParallelReleaseTests(unittest.TestCase): |
| @classmethod |
| def setUpClass(cls): |
| if not os.environ.get("SLURM_JOB_ID"): |
| raise RuntimeError("Slurm compute allocation required") |
| ROOT.mkdir(exist_ok=False) |
|
|
| def test_real_three_split_equivalence_and_native_streaming(self): |
| import pyarrow.parquet as pq |
| source = ROOT / "real-source" |
| original = Path("/groups/voidful/barbet-sft/release_v3") |
| for dest_index, source_index in enumerate((0, 98, 99)): |
| canonical = list(islice(iter_jsonl_gz(original / "canonical" / f"part-{source_index:05d}.jsonl.gz"), 20)) |
| quality = list(islice(iter_jsonl_gz(original / "quality/verdicts" / f"part-{source_index:05d}.quality.jsonl.gz"), 20)) |
| write_jsonl_gz_atomic(source / "canonical" / f"part-{dest_index:05d}.jsonl.gz", canonical) |
| write_jsonl_gz_atomic(source / "quality/verdicts" / f"part-{dest_index:05d}.quality.jsonl.gz", quality) |
| sizes = {"train": 20, "validation": 20, "test": 20} |
| start = time.perf_counter() |
| serial = export_sft(source, ROOT / "serial", expected_records=60, expected_split_counts=sizes, |
| record_validator=validate_record_quality_v2) |
| serial_seconds = time.perf_counter() - start |
| start = time.perf_counter() |
| parallel = parallel_export_sft(source, ROOT / "parallel", expected_records=60, |
| expected_split_counts=sizes, record_validator=validate_record_quality_v2, |
| workers=3, shard_size=20, progress=print) |
| parallel_seconds = time.perf_counter() - start |
| for name in ("records", "readback_records", "unique_record_ids", "source_groups", "split_counts", "serializer_counts", "task_family_counts", "schema"): |
| self.assertEqual(serial[name], parallel[name], name) |
| self.assertTrue(all(parallel["checks"].values())) |
| for first, second in zip(serial["shards"], parallel["shards"], strict=True): |
| for name in ("path", "canonical_sha256", "quality_sha256", "rows_sha256", "records", "split", "first_record_id", "last_record_id"): |
| self.assertEqual(first[name], second[name], name) |
| self.assertEqual(pq.read_table(ROOT / "serial" / first["path"]).to_pylist(), |
| pq.read_table(ROOT / "parallel" / second["path"]).to_pylist()) |
| self.assertEqual(json.loads((ROOT / "serial/reports/taiwan-usage.json").read_text()), |
| json.loads((ROOT / "parallel/reports/taiwan-usage.json").read_text())) |
| serial_native = native_streaming_verify(ROOT / "serial", serial) |
| native = parallel_native_streaming_verify(ROOT / "parallel", parallel, workers=3) |
| self.assertTrue(native["verified"]) |
| for name in ("records", "split_counts", "shards", "datasets_version"): |
| self.assertEqual(serial_native[name], native[name], name) |
| self.assertEqual(len(native["parallel_provenance"]["worker_report_pins"]), 3) |
| write_json_atomic(ROOT / "equivalence.json", {"verified": True, "records": 60, |
| "serial_seconds": serial_seconds, "parallel_seconds": parallel_seconds, |
| "native_verified": native["verified"]}) |
| with self.assertRaises(FileExistsError): |
| parallel_export_sft(source, ROOT / "parallel", expected_records=60, expected_split_counts=sizes, |
| workers=3, shard_size=20) |
|
|
| def test_global_duplicate_record_ids_across_workers_fail(self): |
| source = ROOT / "duplicate-source" |
| for index in range(2): |
| record, quality = _minimal(index, "train", record_id="same-id") |
| write_jsonl_gz_atomic(source / "canonical" / f"part-{index:05d}.jsonl.gz", [record]) |
| write_jsonl_gz_atomic(source / "quality/verdicts" / f"part-{index:05d}.quality.jsonl.gz", [quality]) |
| with self.assertRaisesRegex(ValueError, "duplicate global record_id"): |
| parallel_export_sft(source, ROOT / "duplicate-output", expected_records=2, |
| expected_split_counts={"train": 2}, workers=2, shard_size=1) |
| self.assertFalse((ROOT / "duplicate-output/reports/sft-export-verification.json").exists()) |
|
|
| def test_global_source_group_leak_across_workers_fails(self): |
| source = ROOT / "group-source" |
| for index, split in enumerate(("train", "test")): |
| record, quality = _minimal(index, split, group="same-group") |
| write_jsonl_gz_atomic(source / "canonical" / f"part-{index:05d}.jsonl.gz", [record]) |
| write_jsonl_gz_atomic(source / "quality/verdicts" / f"part-{index:05d}.quality.jsonl.gz", [quality]) |
| with self.assertRaisesRegex(ValueError, "global source_group crosses splits"): |
| parallel_export_sft(source, ROOT / "group-output", expected_records=2, |
| expected_split_counts={"train": 1, "test": 1}, workers=2, shard_size=1) |
| self.assertFalse((ROOT / "group-output/reports/sft-export-verification.json").exists()) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main(verbosity=2) |
|
|
