Datasets:
File size: 7,724 Bytes
6f8b699 | 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 | #!/usr/bin/env python3
"""Validate structure, labels, cross-format parity, hashes and holdout exclusion."""
from __future__ import annotations
import hashlib
import json
import re
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
PATTERNS = {
"email": re.compile(r"[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}"),
"phone_cn": re.compile(r"(?<!\d)1[3-9]\d{9}(?!\d)"),
"id_cn": re.compile(r"(?<!\d)\d{17}[0-9Xx](?!\d)"),
"url": re.compile(r"https?://\S+"),
}
IGNORED_STRING_KEYS = {"case_id", "family_id", "unit_id", "source_sha", "question_sha", "source_run"}
PAIRS = [
("data/pol2-specialist/laya/train-m0.jsonl", "data/pol2-specialist/kev/train-m0.jsonl"),
("data/pol2-specialist/laya/validation.jsonl", "data/pol2-specialist/kev/validation.jsonl"),
("data/pol2-specialist/laya/calibration.jsonl", "data/pol2-specialist/kev/calibration.jsonl"),
("data/pol2-specialist/laya/score-dev.jsonl", "data/pol2-specialist/kev/score-dev.jsonl"),
("data/pol2-specialist/score-v2-new-units/laya.jsonl", "data/pol2-specialist/score-v2-new-units/kev.jsonl"),
("data/general-replay/laya/train-m10.jsonl", "data/general-replay/kev/train-m10.jsonl"),
("data/general-replay/laya/train-m25.jsonl", "data/general-replay/kev/train-m25.jsonl"),
("data/general-replay/laya/train-m40.jsonl", "data/general-replay/kev/train-m40.jsonl"),
("data/general-replay/laya/validation.jsonl", "data/general-replay/kev/validation.jsonl"),
("data/general-replay/laya/guard.jsonl", "data/general-replay/kev/guard.jsonl"),
("data/mixed-training/laya-m10.jsonl", "data/mixed-training/kev-m10.jsonl"),
]
def sha(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(path: Path) -> list[dict]:
rows = []
with path.open(encoding="utf-8") as handle:
for number, line in enumerate(handle, 1):
if not line.strip():
continue
try:
rows.append(json.loads(line))
except Exception as exc:
raise AssertionError(f"{path}:{number}: invalid JSON: {exc}") from exc
return rows
def strings(value, path=()):
if isinstance(value, dict):
for key, child in value.items():
if key not in IGNORED_STRING_KEYS:
yield from strings(child, path + (key,))
elif isinstance(value, list):
for child in value:
yield from strings(child, path)
elif isinstance(value, str):
yield ".".join(path), value
def decoded(row: dict) -> tuple[dict, dict, dict]:
state = json.loads(row["state"]) if isinstance(row["state"], str) else row["state"]
questions = json.loads(row["questions"]) if isinstance(row["questions"], str) else row["questions"]
gold = json.loads(row["gold"]) if isinstance(row.get("gold"), str) else row.get("gold")
return state, questions, gold
def one_hot(values: dict) -> bool:
return bool(values) and all(float(v) in (0.0, 1.0) for v in values.values()) and sum(float(v) for v in values.values()) == 1.0
def normalize_label(qtype: str, label):
if qtype == "score":
return str(int(label))
if qtype == "noul":
if isinstance(label, str):
return label.lower() == "true"
return bool(label)
return str(label)
def check_answers(row: dict, path: str) -> None:
_, questions, gold = decoded(row)
assert isinstance(questions, dict) and questions, f"{path}: no questions"
for qid, q in questions.items():
assert q.get("type") in {"choice", "score", "noul"}, f"{path}:{qid}: bad type"
assert q.get("instructions"), f"{path}:{qid}: missing instructions"
if q["type"] in {"choice", "score"}:
assert isinstance(q.get("criteria"), (dict, list)), f"{path}:{qid}: missing criteria"
if gold is not None:
assert qid in gold, f"{path}:{qid}: missing gold"
label = gold[qid].get("label")
probabilities = gold[qid].get("probabilities")
assert probabilities is not None and one_hot(probabilities), f"{path}:{qid}: non-one-hot gold"
winner = sorted(probabilities, key=lambda key: float(probabilities[key]), reverse=True)[0]
assert str(winner) == str(label) or (q["type"] == "noul" and str(label).lower() == str(winner).lower()), f"{path}:{qid}: label mismatch"
else:
assert "label" in q and "target" in q, f"{path}:{qid}: missing Kev label/target"
assert one_hot(q["target"]), f"{path}:{qid}: non-one-hot Kev target"
winner = sorted(q["target"], key=lambda key: float(q["target"][key]), reverse=True)[0]
assert str(winner) == str(q["label"]) or (q["type"] == "noul" and str(q["label"]).lower() == str(winner).lower()), f"{path}:{qid}: Kev label mismatch"
def question_view(row: dict) -> tuple[dict, dict, dict]:
state, questions, gold = decoded(row)
labels = {}
normalized = {}
for qid, q in questions.items():
normalized[qid] = {
"type": q.get("type"),
"instructions": q.get("instructions"),
"criteria": q.get("criteria"),
}
if gold is not None:
labels[qid] = normalize_label(q["type"], gold[qid]["label"])
else:
labels[qid] = normalize_label(q["type"], q["label"])
return state, normalized, labels
def main() -> None:
manifest = json.loads((ROOT / "manifest.json").read_text(encoding="utf-8"))
listed = set(manifest["files"])
listed_jsonl = {relative for relative in listed if relative.endswith(".jsonl")}
actual_jsonl = {str(path.relative_to(ROOT)) for path in ROOT.rglob("*.jsonl") if path.is_file()}
assert listed_jsonl == actual_jsonl, f"manifest/file mismatch: missing={actual_jsonl-listed_jsonl}, extra={listed_jsonl-actual_jsonl}"
assert not any("blind" in path.lower() or "sealed" in path.lower() for path in listed)
total_rows = 0
warnings = []
for relative, expected in manifest["files"].items():
path = ROOT / relative
assert path.stat().st_size == expected["bytes"], relative
assert sha(path) == expected["sha256"], relative
if path.suffix != ".jsonl":
continue
rows = load(path)
assert len(rows) == expected["rows"], relative
total_rows += len(rows)
for number, row in enumerate(rows, 1):
if "/lineage/" not in relative:
check_answers(row, f"{relative}:{number}")
for field, text in strings(row):
for kind, pattern in PATTERNS.items():
for match in pattern.findall(text):
warnings.append((relative, number, field, kind, match))
assert not warnings, f"privacy-pattern candidates: {warnings[:10]}"
for left, right in PAIRS:
a = load(ROOT / left)
b = load(ROOT / right)
assert len(a) == len(b), (left, right)
for index, (x, y) in enumerate(zip(a, b), 1):
sx, qx, lx = question_view(x)
sy, qy, ly = question_view(y)
assert sx == sy, f"{left}:{index} state mismatch"
assert qx == qy, f"{left}:{index} question mismatch"
assert lx == ly, f"{left}:{index} label mismatch"
print(json.dumps({
"status": "PASS",
"files": len(listed),
"jsonl_rows": total_rows,
"format_pairs": len(PAIRS),
"blind_files_included": False,
"privacy_pattern_candidates": 0,
}, ensure_ascii=False, indent=2))
if __name__ == "__main__":
main()
|