| |
| """Stage 3: build the final Medium (25,000) and Large (65,000) files. |
| * per stream: the first N VALID rows by plan rank -> Large; the first M of those -> Medium (so Medium is nested in Large) |
| * Small's 15,000 rows come straight from its raw file (unchanged) and sit in every tier; Small's own validation rows stay validation |
| * new rows are validation with probability 8% by id hash (same share as Small); everything else is train |
| * rows are sharded by id hash, then each shard is shuffled so every shard mixes all sources |
| Outputs (plain JSONL, {"messages": [...]} per line, like Small): out/<tier>/train-0000i-of-0000N.jsonl, valid.jsonl, row_index.csv, stats.json""" |
| import csv, gzip, hashlib, json, os, random, re, shutil, sys, time, collections |
| import huggingface_hub as hf |
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| from common import * |
|
|
| t0 = time.time() |
| plan = json.load(open(os.path.join(SCRATCH, "plan.json"))) |
| small = json.load(open(os.path.join(HERE, "..", "scan", "small_ids.json"))) |
| small_valid = set(small["valid_ids"]) |
| head = re.compile(r'^\{"rk": (\d+), "id": "((?:[^"\\]|\\.)*)"') |
| STAGE = os.path.join(SCRATCH, "stage"); shutil.rmtree(STAGE, ignore_errors=True); os.makedirs(STAGE) |
| shutil.rmtree(OUTDIR, ignore_errors=True) |
|
|
| |
| sel = {} |
| for stream, s in plan["streams"].items(): |
| fn = os.path.join(SCRATCH, "rows_" + stream.replace("/", "_").replace(":", "_") + ".jsonl.gz") |
| ranks = [] |
| with gzip.open(fn, "rt", encoding="utf-8") as f: |
| for line in f: |
| m = head.match(line[:300]); ranks.append((int(m.group(1)), json.loads('"' + m.group(2) + '"'))) |
| ranks.sort() |
| assert len(ranks) >= s["new_large"], (stream, len(ranks), s["new_large"]) |
| for i, (_, rid) in enumerate(ranks[: s["new_large"]]): |
| assert rid not in sel |
| sel[rid] = (stream, i < s["new_medium"]) |
| print(f"selected {len(sel)} new rows (medium-new {sum(1 for v in sel.values() if v[1])}) {time.time()-t0:.0f}s", flush=True) |
|
|
| |
| W, INDEX = {}, {"medium": [], "large": []} |
| def w(tier, name): |
| k = (tier, name) |
| if k not in W: |
| os.makedirs(os.path.join(STAGE, tier), exist_ok=True) |
| W[k] = gzip.open(os.path.join(STAGE, tier, name + ".jsonl.gz"), "wt", encoding="utf-8", compresslevel=3) |
| return W[k] |
| def emit(rid, source_key, msgs, valid, in_small, in_medium): |
| line = json.dumps({"messages": msgs}, ensure_ascii=False) + "\n" |
| for tier in (("medium", "large") if in_medium else ("large",)): |
| name = "valid" if valid else f"train_{shard_of(rid, N_TRAIN_SHARDS[tier])}" |
| w(tier, name).write(line) |
| INDEX[tier].append((rid, source_key, "valid" if valid else "train", int(in_small))) |
|
|
| |
| rp = hf.hf_hub_download("VertexAGI/cyberdata-1", "raw_examples.jsonl", repo_type="dataset") |
| n_small = 0 |
| for line in open(rp, encoding="utf-8"): |
| r = json.loads(line) |
| emit(r["id"], SRC_KEY[r["source"]], r["messages"], r["id"] in small_valid, True, True) |
| n_small += 1 |
| for p in {rp, os.path.realpath(rp)}: |
| try: os.remove(p) |
| except OSError: pass |
| assert n_small == 15000 |
| print(f"small rows written {n_small} {time.time()-t0:.0f}s", flush=True) |
|
|
| |
| seen = collections.Counter() |
| for stream in plan["streams"]: |
| fn = os.path.join(SCRATCH, "rows_" + stream.replace("/", "_").replace(":", "_") + ".jsonl.gz") |
| with gzip.open(fn, "rt", encoding="utf-8") as f: |
| for line in f: |
| m = head.match(line[:300]); rid = json.loads('"' + m.group(2) + '"') |
| if rid not in sel or seen[rid]: continue |
| seen[rid] = 1 |
| r = json.loads(line) |
| emit(rid, SRC_KEY[r["source"]], r["messages"], is_valid_new(rid), False, sel[rid][1]) |
| assert len(seen) == len(sel), (len(seen), len(sel)) |
| for h in W.values(): h.close() |
| print(f"new rows written {len(seen)} {time.time()-t0:.0f}s", flush=True) |
|
|
| |
| stats = {} |
| for tier in ("medium", "large"): |
| od = os.path.join(OUTDIR, tier); os.makedirs(od) |
| nshard = N_TRAIN_SHARDS[tier]; total = {"train": 0, "valid": 0}; bytes_ = 0 |
| for k in list(range(nshard)) + ["valid"]: |
| name = "valid" if k == "valid" else f"train_{k}" |
| with gzip.open(os.path.join(STAGE, tier, name + ".jsonl.gz"), "rt", encoding="utf-8") as f: |
| lines = f.readlines() |
| random.Random(f"{SALT}{tier}:{name}").shuffle(lines) |
| out = os.path.join(od, "valid.jsonl" if k == "valid" else f"train-{k:05d}-of-{nshard:05d}.jsonl") |
| with open(out, "w", encoding="utf-8") as g: g.writelines(lines) |
| total["valid" if k == "valid" else "train"] += len(lines); bytes_ += os.path.getsize(out) |
| os.remove(os.path.join(STAGE, tier, name + ".jsonl.gz")) |
| with open(os.path.join(od, "row_index.csv"), "w", newline="") as f: |
| cw = csv.writer(f); cw.writerow(["id", "source", "split", "in_small"]); cw.writerows(sorted(INDEX[tier])) |
| by_src = collections.Counter(r[1] for r in INDEX[tier]); by_split = collections.Counter((r[1], r[2]) for r in INDEX[tier]) |
| stats[tier] = {"rows": len(INDEX[tier]), "train": total["train"], "valid": total["valid"], "bytes": bytes_, "by_source": dict(by_src), |
| "by_source_split": {f"{a}/{b}": v for (a, b), v in by_split.items()}, "unique_ids": len({r[0] for r in INDEX[tier]})} |
| print(tier, {k: v for k, v in stats[tier].items() if k not in ("by_source_split",)}, flush=True) |
| json.dump(stats[tier], open(os.path.join(od, "stats.json"), "w"), indent=1) |
| shutil.rmtree(STAGE, ignore_errors=True) |
| print("ASSEMBLE_DONE", f"{time.time()-t0:.0f}s") |
|
|
