| """ |
| Recast the guardrail corpus as a zero-shot routing task. |
| |
| The fixed 12-slot head learns one dedicated representation per class, which is why it wins on the |
| 12 classes it trained on. What it cannot do is accept a 13th: every deployment is stuck with our |
| taxonomy. The routing head scores each category from *its own written definition*, so a bank, a |
| kids' platform or a health app can state its policy in plain Arabic at inference. |
| |
| Each row becomes (text, k category definitions, index of the right one): |
| |
| * k varies 3-8, because a real policy has a handful of categories, not twelve; |
| * lanes are shuffled and the label recomputed, so position carries nothing; |
| * lane wording alternates between the short title and title+definition, so the model reads the |
| meaning rather than memorising one string. |
| |
| TWO CLASSES ARE HELD OUT OF TRAINING ENTIRELY - misinformation and privacy_pii. Rows labelled with |
| them are removed from train, and their definitions never appear as a lane there. `eval_unseen_class` |
| then asks the model to catch them from the definition alone. That is the whole claim: write a new |
| policy category and it works without retraining. |
| """ |
| import json |
| import os |
| import random |
| from collections import Counter |
| from pathlib import Path |
|
|
| import guard_common as gc |
|
|
| SRC = Path(os.environ.get("DATA_DIR", "data")) |
| OUT = Path(os.environ.get("HEAD_DIR", "data_head")); OUT.mkdir(exist_ok=True) |
| HELD_CLASSES = {"misinformation", "privacy_pii"} |
| SEED = 42 |
|
|
|
|
| def lane_text(cls, rng): |
| title, desc = gc.CLASSES[cls] |
| if rng.random() < 0.35: |
| return f"{title}: {desc[:110]}" |
| return title |
|
|
|
|
| def convert(rows, pool, rng, force_label_in_pool=True): |
| out = [] |
| for r in rows: |
| cls = r["label"] |
| others = [c for c in pool if c != cls] |
| k = rng.choice([3, 4, 4, 5, 5, 6, 7, 8]) - 1 |
| lanes = rng.sample(others, min(k, len(others))) |
| if force_label_in_pool: |
| lanes.append(cls) |
| rng.shuffle(lanes) |
| out.append({"text": r["text"], |
| "routes": [lane_text(c, rng) for c in lanes], |
| "label": lanes.index(cls), |
| "cls": cls, "variety": r["variety"], |
| "difficulty": "hard" if cls in ("safe_sensitive", "jailbreak") else "easy", |
| "mode": "guard"}) |
| return out |
|
|
|
|
| def main(): |
| rng = random.Random(SEED) |
| keep = [c for c in gc.CLASSES if c not in HELD_CLASSES] |
|
|
| def load(n): |
| p = SRC / f"{n}.jsonl" |
| return [json.loads(l) for l in open(p, encoding="utf-8")] if p.exists() else [] |
|
|
| train_src = load("train") |
| train = convert([r for r in train_src if r["label"] not in HELD_CLASSES], keep, rng) |
| held_src = load("eval_held") |
| seen = convert([r for r in held_src if r["label"] not in HELD_CLASSES], keep, rng) |
| |
| unseen_src = [r for r in train_src + held_src if r["label"] in HELD_CLASSES] |
| rng.shuffle(unseen_src) |
| unseen = convert(unseen_src[:8000], list(gc.CLASSES), rng) |
| dia = convert(load("eval_unseen_dialect")[:12000], keep, rng) |
| hard = convert(load("eval_hard"), keep, rng) |
|
|
| for name, s in (("train", train), ("eval_seen", seen), ("eval_unseen_class", unseen), |
| ("eval_unseen_dialect", dia), ("eval_hard", hard)): |
| with open(OUT / f"{name}.jsonl", "w", encoding="utf-8") as fh: |
| for r in s: |
| fh.write(json.dumps(r, ensure_ascii=False) + "\n") |
| print(f" {name:<24}{len(s):>8,}") |
|
|
| tl = set() |
| for r in train: |
| tl |= set(r["routes"]) |
| leak = [c for c in HELD_CLASSES if any(gc.CLASSES[c][0] in t for t in tl)] |
| print(f"\nheld-out class definitions appearing in train lanes: {leak or 'none'}") |
| print(f"train label classes: {sorted(Counter(r['cls'] for r in train))}") |
| print(f"unseen_class labels: {sorted(Counter(r['cls'] for r in unseen))}") |
| print(f"mean lanes/row: {sum(len(r['routes']) for r in train)/len(train):.2f}") |
| pos = Counter(r["label"] for r in train) |
| print(f"label position spread: {dict(sorted(pos.items()))}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
