Datasets:
File size: 10,443 Bytes
0bf2389 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 | from __future__ import annotations
from copy import deepcopy
from importlib.util import find_spec
from pathlib import Path
import hashlib
import tempfile
import unittest
from barbet_bgd.io import write_jsonl_gz_atomic
from barbet_bgd.serializers_v2 import SERIALIZERS_V2, SerializationV2Error, parse_target_v2
from barbet_bgd.serializers_v3 import (
build_messages_v3, canonical_json_v3, parse_request_message_v3, validate_messages_v3,
)
from barbet_bgd.export_sft_v3 import export_sft
def _record(index: int = 0, split: str = "train") -> dict:
return {
"record_id": f"row:{index}", "source_group": 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": SERIALIZERS_V2[index % 4]},
"provenance": {"internal_audit_marker": "not-model-visible-747f"},
}
def _quality(record: dict) -> dict:
return {"record_id": record["record_id"], "disposition": "KEEP", "training_ready": True,
"record_sha256": hashlib.sha256(canonical_json_v3(record).encode("utf-8")).hexdigest(),
"hard_failures": [], "pipeline_checks": {"test": True}}
def _write_shard(root: Path, index: int, records: list[dict], verdicts: list[dict] | None = None):
write_jsonl_gz_atomic(root / "canonical" / f"part-{index:05d}.jsonl.gz", records)
write_jsonl_gz_atomic(root / "quality" / "verdicts" / f"part-{index:05d}.quality.jsonl.gz",
verdicts if verdicts is not None else [_quality(row) for row in records])
class ReleaseSerializerTests(unittest.TestCase):
def test_all_output_syntaxes_are_explicit_and_lossless(self):
for index, serializer in enumerate(SERIALIZERS_V2):
with self.subTest(serializer=serializer):
record = _record(index)
record["target"]["edge_text"] = '<臺灣>\\n"'
record["target"]["typed_numbers"] = [1, 1.0, None, False]
messages = build_messages_v3(record)
validate_messages_v3(record, messages)
request = parse_request_message_v3(messages[1]["content"])
self.assertEqual(request["response_format"]["serializer"], serializer)
self.assertEqual(parse_target_v2(request["response_format"]["empty_target_example"], serializer), {})
self.assertEqual(canonical_json_v3(parse_target_v2(messages[2]["content"], serializer)),
canonical_json_v3(record["target"]))
self.assertNotIn("not-model-visible-747f", messages[1]["content"])
self.assertNotIn("record_id", request)
self.assertNotIn(record["record_id"], messages[1]["content"])
def test_changing_serializer_changes_model_visible_request(self):
record = _record()
first = build_messages_v3(record)
record["presentation"]["serializer"] = "KEY_VALUE"
second = build_messages_v3(record)
self.assertNotEqual(first[1]["content"], second[1]["content"])
def test_changed_format_and_target_are_rejected(self):
record = _record()
messages = build_messages_v3(record)
broken = deepcopy(messages)
broken[1]["content"] = broken[1]["content"].replace('"serializer":"JSON"', '"serializer":"KEY_VALUE"')
with self.assertRaises(SerializationV2Error):
validate_messages_v3(record, broken)
broken = deepcopy(messages)
broken[2]["content"] = broken[2]["content"].replace("COPIED", "FAIL")
with self.assertRaises(SerializationV2Error):
validate_messages_v3(record, broken)
@unittest.skipUnless(find_spec("pyarrow"), "pyarrow is required for Parquet export")
class ReleaseExportTests(unittest.TestCase):
@unittest.skipUnless(find_spec("datasets"), "datasets is required for native streaming check")
def test_native_datasets_streams_messages_as_list_of_turns(self):
from datasets import load_dataset
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
records = [_record(index) for index in range(4)]
_write_shard(root, 0, records)
export_sft(root, root, expected_records=4, expected_split_counts={"train": 4})
streamed = load_dataset("parquet", data_files={"train": str(root / "data" / "train-00000.parquet")},
split="train", streaming=True, cache_dir=str(root / "hf-cache"))
actual = list(streamed)
self.assertEqual(len(actual), 4)
for row, record in zip(actual, records, strict=True):
self.assertEqual(row["messages"], build_messages_v3(record))
def test_fixed_schema_export_and_full_readback_across_splits(self):
import pyarrow.parquet as pq
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
train = [_record(index) for index in range(4)]
validation = [_record(4, "validation")]
_write_shard(root, 0, train)
_write_shard(root, 1, validation)
observed = []
def validator(row):
observed.append(row["record_id"])
return _quality(row)
report = export_sft(root, root, expected_records=5,
expected_split_counts={"train": 4, "validation": 1},
batch_rows=1, batch_bytes=1024, record_validator=validator)
self.assertTrue(report["verified"])
self.assertTrue(all(report["checks"].values()))
self.assertEqual(report["readback_records"], 5)
self.assertEqual(len(observed), 10)
data = pq.read_table(root / "data" / "train-00000.parquet").to_pylist()
self.assertEqual(len(data), 4)
self.assertIsInstance(data[0]["messages"], list)
self.assertEqual(data[0]["messages"], build_messages_v3(train[0]))
self.assertTrue((root / "reports" / "sft-export-verification.json").is_file())
self.assertTrue((root / "reports" / "taiwan-usage.json").is_file())
self.assertTrue(report["checks"]["taiwan_usage_readback_identical"])
with self.assertRaises(FileExistsError):
export_sft(root, root, expected_records=5, expected_split_counts={"train": 4, "validation": 1})
def test_duplicate_ids_and_source_group_split_leak_are_rejected(self):
for duplicate_id in (True, False):
with self.subTest(duplicate_id=duplicate_id), tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
first, second = _record(0), _record(1, "test")
if duplicate_id:
second["record_id"] = first["record_id"]
else:
second["source_group"] = first["source_group"]
_write_shard(root, 0, [first])
_write_shard(root, 1, [second])
with self.assertRaisesRegex(ValueError, "duplicate record_id|source_group crosses splits"):
export_sft(root, root, expected_records=2, expected_split_counts={"train": 1, "test": 1})
self.assertFalse((root / "reports" / "sft-export-verification.json").exists())
def test_verdict_rejection_and_unaligned_counts_fail_closed(self):
for mode in ("reject", "missing", "wrong_id", "extra"):
with self.subTest(mode=mode), tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
row = _record()
quality = _quality(row)
if mode == "reject":
quality["disposition"] = "REJECT"
if mode == "wrong_id":
quality["record_id"] = "wrong"
verdicts = [] if mode == "missing" else [quality]
if mode == "extra":
verdicts.append(quality)
_write_shard(root, 0, [row], verdicts)
with self.assertRaises(ValueError):
export_sft(root, root, expected_records=1, expected_split_counts={"train": 1})
self.assertFalse((root / "reports" / "sft-export-verification.json").exists())
def test_lost_records_and_independent_validator_rejection_fail_closed(self):
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
_write_shard(root, 0, [_record()])
with self.assertRaisesRegex(ValueError, "total/split count mismatch"):
export_sft(root, root, expected_records=2, expected_split_counts={"train": 2})
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
_write_shard(root, 0, [_record()])
with self.assertRaisesRegex(ValueError, "independent record validator rejected"):
export_sft(root, root, expected_records=1, expected_split_counts={"train": 1},
record_validator=lambda row: {"disposition": "REJECT"})
def test_stale_quality_hash_and_locale_review_do_not_pass(self):
for mode in ("stale_hash", "locale_block", "locale_review"):
with self.subTest(mode=mode), tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
row = _record()
if mode == "locale_block":
row["task_spec"]["query"] = "請檢查這個軟件。"
if mode == "locale_review":
row["task_spec"]["query"] = "請使用 opaque ID 識別候選項目。"
quality = _quality(row)
if mode == "stale_hash":
row["target"]["output_text"] = "內容已經改動。"
_write_shard(root, 0, [row], [quality])
with self.assertRaisesRegex(ValueError, "canonical record hash|Taiwan usage review/rejection"):
export_sft(root, root, expected_records=1, expected_split_counts={"train": 1})
self.assertFalse((root / "reports" / "sft-export-verification.json").exists())
if __name__ == "__main__":
unittest.main()
|