File size: 4,976 Bytes
34defc2 | 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 | import argparse
import random
import re
import sys
from pathlib import Path
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
import kit
SOURCES = {
"xstest": ("walledai/XSTest", None, "test"),
"orbench_hard": ("bench-llm/or-bench", "or-bench-hard-1k", "train"),
"harmbench": ("walledai/HarmBench", "standard", "train"),
"advbench": ("walledai/AdvBench", None, "train"),
"alpaca": ("tatsu-lab/alpaca", None, "train"),
}
def norm(text: str) -> str:
return re.sub(r"\s+", " ", text.strip().lower())
def load(name: str):
from datasets import load_dataset
from huggingface_hub import HfApi
repo, config, split = SOURCES[name]
ds = load_dataset(repo, config, split=split)
try:
sha = HfApi().dataset_info(repo).sha
except Exception:
sha = None
return [dict(r) for r in ds], {"repo": repo, "config": config, "split": split, "revision": sha, "rows": len(ds)}
def prompt_of(row: dict) -> str:
for key in ("prompt", "instruction", "Prompt", "goal"):
if isinstance(row.get(key), str) and row[key].strip():
return row[key].strip()
raise KeyError(f"no prompt column in {sorted(row)}")
def dedupe(prompts: list[str]) -> list[str]:
seen, out = set(), []
for p in prompts:
k = norm(p)
if k not in seen:
seen.add(k)
out.append(p)
return out
def xstest_split(rows: list[dict]) -> tuple[list[str], list[str]]:
safe, unsafe = [], []
for r in rows:
label = str(r.get("label", "")).lower()
if not label:
label = "unsafe" if str(r.get("type", "")).startswith("contrast") else "safe"
(unsafe if label.startswith("unsafe") else safe).append(prompt_of(r))
return dedupe(safe), dedupe(unsafe)
def rows(suite: str, prompts: list[str], split: str) -> list[dict]:
return [{"id": f"{suite}-{i:04d}", "suite": suite, "split": split, "prompt": p} for i, p in enumerate(prompts)]
def main() -> None:
ap = argparse.ArgumentParser()
ap.add_argument("--out", default=str(HERE / "data"))
ap.add_argument("--seed", type=int, default=0)
ap.add_argument("--direction", type=int, default=128)
ap.add_argument("--dev", type=int, default=100)
ap.add_argument("--orbench-test", type=int, default=500)
args = ap.parse_args()
rng = random.Random(args.seed)
out = Path(args.out)
meta = {}
xs, meta["xstest"] = load("xstest")
xs_safe, xs_unsafe = xstest_split(xs)
orb, meta["orbench_hard"] = load("orbench_hard")
orb = dedupe([prompt_of(r) for r in orb])
rng.shuffle(orb)
direction_pos = orb[: args.direction]
dev_safe = orb[args.direction : args.direction + args.dev]
orb_test = orb[args.direction + args.dev : args.direction + args.dev + args.orbench_test]
hb, meta["harmbench"] = load("harmbench")
hb = dedupe([prompt_of(r) for r in hb])
adv, meta["advbench"] = load("advbench")
test_keys = {norm(p) for p in hb + xs_unsafe}
adv = [p for p in dedupe([prompt_of(r) for r in adv]) if norm(p) not in test_keys]
rng.shuffle(adv)
dev_harmful = adv[: args.dev]
alp, meta["alpaca"] = load("alpaca")
alp = dedupe([r["instruction"] for r in alp if not (r.get("input") or "").strip()])
rng.shuffle(alp)
direction_neg = alp[: args.direction]
test = (
rows("xstest_safe", xs_safe, "test")
+ rows("orbench_hard", orb_test, "test")
+ rows("harmbench", hb, "test")
+ rows("xstest_unsafe", xs_unsafe, "test")
)
used = {norm(p) for p in direction_pos + direction_neg + dev_safe + dev_harmful}
leaks = [r["id"] for r in test if norm(r["prompt"]) in used]
if leaks:
sys.exit(f"leak between fit or dev prompts and test prompts: {leaks[:10]}")
kit.write_jsonl(out / "direction_pos.jsonl", rows("orbench_dir", direction_pos, "fit"))
kit.write_jsonl(out / "direction_neg.jsonl", rows("alpaca_dir", direction_neg, "fit"))
kit.write_jsonl(out / "dev_safe.jsonl", rows("orbench_dev", dev_safe, "dev"))
kit.write_jsonl(out / "dev_harmful.jsonl", rows("advbench_dev", dev_harmful, "dev"))
kit.write_jsonl(out / "test.jsonl", test)
counts = {}
for r in test:
counts[r["suite"]] = counts.get(r["suite"], 0) + 1
kit.write_json(
out / "data_manifest.json",
{
"seed": args.seed,
"sources": meta,
"fit": {"direction_pos": len(direction_pos), "direction_neg": len(direction_neg)},
"dev": {"dev_safe": len(dev_safe), "dev_harmful": len(dev_harmful)},
"test": counts,
"leak_check": "no normalized prompt appears in both fit or dev and test",
"test_merkle": kit.jsonl_merkle(out / "test.jsonl")[0],
},
)
print(f"test suites {counts}")
print(f"fit {len(direction_pos)}+{len(direction_neg)}, dev {len(dev_safe)}+{len(dev_harmful)}, leaks 0")
if __name__ == "__main__":
main()
|