Datasets:

nur-dev
/

pns-world

Tasks:

Question Answering

Tags:

persistent-memory

event-stream

Synthetic

License:

Dataset card Files Files and versions

xet

Community

pns-world / benchmark /generate.py

nur-dev

PNS-World: benchmark source, manifests, preregistrations, audit

e213b85 verified 2 months ago

Raw History Blame Contribute Delete

5.82 kB

#!/usr/bin/env python3
"""Generate the PNS corpus: train the tokenizer (train text only), then pack
all splits as npz shards with a hashed manifest.
Seed namespaces are disjoint by construction and cross-checked by content hash:
  train        0        .. n_train-1          L=256
  val          1_000_000 ..                    L=256
  val_1k       1_100_000 ..                    L=1024
  val_4k       1_200_000 ..                    L=4096
  test         2_000_000 ..                    L=256   (touched once, at the end)
  test_1k      2_100_000 ..                    L=1024
  test_4k      2_200_000 ..                    L=4096
"""
import argparse
import sys
import time
from concurrent.futures import ProcessPoolExecutor
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))

from pns.common import PNS_ROOT, SCHEMA_VERSION, atomic_write_json, sha256_file, shards_root, tokenizer_path  # noqa: E402
from pns.data.pack import pack_lifetimes  # noqa: E402
from pns.data.tokenize import load_tokenizer, train_tokenizer  # noqa: E402
from pns.world.sim import generate_lifetime  # noqa: E402

SPLITS = {
    "train":   (0,          None, 256),
    "val":     (1_000_000,  2000, 256),
    "val_1k":  (1_100_000,  400, 1024),
    "val_4k":  (1_200_000,  120, 4096),
    "test":    (2_000_000,  2000, 256),
    "test_1k": (2_100_000,  400, 1024),
    "test_4k": (2_200_000,  120, 4096),
    # ---- E3 (fresh namespace; exp-1 test data motivated the E3 design, so it
    # is burned for confirmatory use). Confirmation split is single-use.
    "e3_train":   (3_000_000, None, 256),
    "e3_dev":     (3_500_000, 2000, 256),
    "e3_dev_1k":  (3_600_000,  400, 1024),
    "e3_conf":    (3_900_000, 2000, 256),
    "e3_conf_1k": (3_950_000,  400, 1024),
    # forensic relabel of the ORIGINAL val seeds: identical event streams,
    # corrected SEM golds (generate with PNS_GOLD=sem)
    "val_relabel": (1_000_000, 2000, 256),
    # forensic relabel of the ORIGINAL train seeds, same construction. Needed
    # so the Sigma-decode probe can be *trained* on corrected labels too; the
    # probe only ever reads the first ~1.5k train lifetimes (AUDIT.md 9).
    "train_relabel": (0, 2000, 256),
}
LT_PER_SHARD = {256: 1000, 1024: 250, 4096: 60}


def build_shard(args):
    split, base_seed, count, length, shard_idx, out = args
    lts = [generate_lifetime(base_seed + i, length) for i in range(count)]
    tok = load_tokenizer()
    info = pack_lifetimes(lts, tok, Path(out))
    info.update(split=split, shard=shard_idx, seed_lo=base_seed, seed_hi=base_seed + count - 1,
                length=length, path=str(out),
                dropped={k: v for lt in lts for k, v in lt["dropped"].items()},
                digests=[lt["digest"] for lt in lts])
    return info


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--n-train", type=int, default=120_000)
    ap.add_argument("--e3-train", type=int, default=120_000)
    ap.add_argument("--workers", type=int, default=64)
    ap.add_argument("--tokenizer-sample", type=int, default=1500)
    args = ap.parse_args()
    root = shards_root()
    root.mkdir(parents=True, exist_ok=True)

    if not tokenizer_path().exists():
        print("training tokenizer on train-split sample ...", flush=True)
        texts = []
        for s in range(args.tokenizer_sample):
            lt = generate_lifetime(s, 256)
            texts.extend(f"+{e.dt}m {e.text}" for e in lt["events"])
        t = train_tokenizer(texts)
        print("tokenizer:", t.get_vocab_size(), "->", tokenizer_path(), flush=True)

    jobs = []
    for split, (base, n, length) in SPLITS.items():
        n = (args.e3_train if split == "e3_train" else args.n_train) if n is None else n
        per = LT_PER_SHARD[length]
        for i in range(0, n, per):
            cnt = min(per, n - i)
            out = root / split / f"shard_{i // per:05d}.npz"
            if not out.exists():
                jobs.append((split, base + i, cnt, length, i // per, str(out)))
    print(f"{len(jobs)} shards to build", flush=True)
    t0 = time.time()
    infos = []
    with ProcessPoolExecutor(max_workers=args.workers) as ex:
        for k, info in enumerate(ex.map(build_shard, jobs)):
            infos.append(info)
            if k % 20 == 0:
                print(f"  {k + 1}/{len(jobs)} shards, {time.time() - t0:.0f}s", flush=True)

    # cross-split content-hash disjointness
    seen: dict[str, str] = {}
    dup = 0
    for info in infos:
        for d in info["digests"]:
            if d in seen and seen[d] != info["split"]:
                dup += 1
            seen[d] = info["split"]
    # merge with any existing manifest: rebuilding it from newly-built shards
    # alone once erased the original corpus's provenance (audit/AUDIT.md 5)
    prev = []
    mpath = root / "MANIFEST.json"
    if mpath.exists():
        import json as _json
        prev = _json.loads(mpath.read_text()).get("shards", [])
    have = {i["path"] for i in infos}
    infos = [p for p in prev if p.get("path") not in have] + infos
    manifest = dict(schema=SCHEMA_VERSION, n_train=args.n_train,
                    generator_sha=sha256_file(PNS_ROOT / "pns" / "world" / "sim.py"),
                    reducer_sha=sha256_file(PNS_ROOT / "pns" / "world" / "reducer.py"),
                    verbalizer_sha=sha256_file(PNS_ROOT / "pns" / "world" / "verbalize.py"),
                    tokenizer_sha=sha256_file(tokenizer_path()),
                    cross_split_digest_collisions=dup,
                    shards=[{k: v for k, v in i.items() if k != "digests"} for i in infos])
    atomic_write_json(root / "MANIFEST.json", manifest)
    print("cross-split digest collisions:", dup)
    print("manifest written:", root / "MANIFEST.json")


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Generate the PNS corpus: train the tokenizer (train text only), then pack
	all splits as npz shards with a hashed manifest.

	Seed namespaces are disjoint by construction and cross-checked by content hash:
	train 0 .. n_train-1 L=256
	val 1_000_000 .. L=256
	val_1k 1_100_000 .. L=1024
	val_4k 1_200_000 .. L=4096
	test 2_000_000 .. L=256 (touched once, at the end)
	test_1k 2_100_000 .. L=1024
	test_4k 2_200_000 .. L=4096
	"""
	import argparse
	import sys
	import time
	from concurrent.futures import ProcessPoolExecutor
	from pathlib import Path

	sys.path.insert(0, str(Path(__file__).resolve().parent))

	from pns.common import PNS_ROOT, SCHEMA_VERSION, atomic_write_json, sha256_file, shards_root, tokenizer_path # noqa: E402
	from pns.data.pack import pack_lifetimes # noqa: E402
	from pns.data.tokenize import load_tokenizer, train_tokenizer # noqa: E402
	from pns.world.sim import generate_lifetime # noqa: E402

	SPLITS = {
	"train": (0, None, 256),
	"val": (1_000_000, 2000, 256),
	"val_1k": (1_100_000, 400, 1024),
	"val_4k": (1_200_000, 120, 4096),
	"test": (2_000_000, 2000, 256),
	"test_1k": (2_100_000, 400, 1024),
	"test_4k": (2_200_000, 120, 4096),
	# ---- E3 (fresh namespace; exp-1 test data motivated the E3 design, so it
	# is burned for confirmatory use). Confirmation split is single-use.
	"e3_train": (3_000_000, None, 256),
	"e3_dev": (3_500_000, 2000, 256),
	"e3_dev_1k": (3_600_000, 400, 1024),
	"e3_conf": (3_900_000, 2000, 256),
	"e3_conf_1k": (3_950_000, 400, 1024),
	# forensic relabel of the ORIGINAL val seeds: identical event streams,
	# corrected SEM golds (generate with PNS_GOLD=sem)
	"val_relabel": (1_000_000, 2000, 256),
	# forensic relabel of the ORIGINAL train seeds, same construction. Needed
	# so the Sigma-decode probe can be trained on corrected labels too; the
	# probe only ever reads the first ~1.5k train lifetimes (AUDIT.md 9).
	"train_relabel": (0, 2000, 256),
	}
	LT_PER_SHARD = {256: 1000, 1024: 250, 4096: 60}


	def build_shard(args):
	split, base_seed, count, length, shard_idx, out = args
	lts = [generate_lifetime(base_seed + i, length) for i in range(count)]
	tok = load_tokenizer()
	info = pack_lifetimes(lts, tok, Path(out))
	info.update(split=split, shard=shard_idx, seed_lo=base_seed, seed_hi=base_seed + count - 1,
	length=length, path=str(out),
	dropped={k: v for lt in lts for k, v in lt["dropped"].items()},
	digests=[lt["digest"] for lt in lts])
	return info


	def main():
	ap = argparse.ArgumentParser()
	ap.add_argument("--n-train", type=int, default=120_000)
	ap.add_argument("--e3-train", type=int, default=120_000)
	ap.add_argument("--workers", type=int, default=64)
	ap.add_argument("--tokenizer-sample", type=int, default=1500)
	args = ap.parse_args()
	root = shards_root()
	root.mkdir(parents=True, exist_ok=True)

	if not tokenizer_path().exists():
	print("training tokenizer on train-split sample ...", flush=True)
	texts = []
	for s in range(args.tokenizer_sample):
	lt = generate_lifetime(s, 256)
	texts.extend(f"+{e.dt}m {e.text}" for e in lt["events"])
	t = train_tokenizer(texts)
	print("tokenizer:", t.get_vocab_size(), "->", tokenizer_path(), flush=True)

	jobs = []
	for split, (base, n, length) in SPLITS.items():
	n = (args.e3_train if split == "e3_train" else args.n_train) if n is None else n
	per = LT_PER_SHARD[length]
	for i in range(0, n, per):
	cnt = min(per, n - i)
	out = root / split / f"shard_{i // per:05d}.npz"
	if not out.exists():
	jobs.append((split, base + i, cnt, length, i // per, str(out)))
	print(f"{len(jobs)} shards to build", flush=True)
	t0 = time.time()
	infos = []
	with ProcessPoolExecutor(max_workers=args.workers) as ex:
	for k, info in enumerate(ex.map(build_shard, jobs)):
	infos.append(info)
	if k % 20 == 0:
	print(f" {k + 1}/{len(jobs)} shards, {time.time() - t0:.0f}s", flush=True)

	# cross-split content-hash disjointness
	seen: dict[str, str] = {}
	dup = 0
	for info in infos:
	for d in info["digests"]:
	if d in seen and seen[d] != info["split"]:
	dup += 1
	seen[d] = info["split"]
	# merge with any existing manifest: rebuilding it from newly-built shards
	# alone once erased the original corpus's provenance (audit/AUDIT.md 5)
	prev = []
	mpath = root / "MANIFEST.json"
	if mpath.exists():
	import json as _json
	prev = _json.loads(mpath.read_text()).get("shards", [])
	have = {i["path"] for i in infos}
	infos = [p for p in prev if p.get("path") not in have] + infos
	manifest = dict(schema=SCHEMA_VERSION, n_train=args.n_train,
	generator_sha=sha256_file(PNS_ROOT / "pns" / "world" / "sim.py"),
	reducer_sha=sha256_file(PNS_ROOT / "pns" / "world" / "reducer.py"),
	verbalizer_sha=sha256_file(PNS_ROOT / "pns" / "world" / "verbalize.py"),
	tokenizer_sha=sha256_file(tokenizer_path()),
	cross_split_digest_collisions=dup,
	shards=[{k: v for k, v in i.items() if k != "digests"} for i in infos])
	atomic_write_json(root / "MANIFEST.json", manifest)
	print("cross-split digest collisions:", dup)
	print("manifest written:", root / "MANIFEST.json")


	if __name__ == "__main__":
	main()