| """SHADOW Assistant text data: download, route, tokenise (Gemma 4 vocabulary of EmbeddingGemma 2), pack 3 bytes per token,
|
| upload shards as they finish (local disk only holds the shards in flight). Each shard also saves its unigram counts
|
| (.counts.npz), so the frozen table's log-unigram prior is a sum over these files, with no second pass over the data.
|
|
|
| python prep_text.py --source fineweb_edu --workers 30
|
| python prep_text.py --source legal --test # tiny local check: 2 files, 2M tokens per bucket, no upload
|
|
|
| Layout, one folder per source: <area>/<source>/<source>_w<worker>_<shard>.bin (+ .json, .counts.npz)
|
| fineweb_edu HuggingFaceFW/fineweb-edu: .au pages -> knowledge/fineweb_edu_au (all), others -> knowledge/fineweb_edu (75B)
|
| dclm mlfoundations/dclm-baseline-1.0: .au pages -> knowledge/dclm_au (6B, skipping URLs already in FineWeb-Edu .au),
|
| others -> knowledge/dclm (35B)
|
| legal, spaceai, joeyllm whole dataset -> knowledge/<source>
|
| opencoder_fineweb, opencoder_annealing whole dataset -> code/<source>
|
| nemotron_math nvidia/Nemotron-CC-Math-v1 4plus -> math/nemotron_cc_math_4plus, private repo (training only, rebuilt not posted)
|
| wikipedia_au Australian articles of English Wikipedia -> knowledge/wikipedia_au, private repo (CC BY-SA, rebuilt not posted)
|
| anneal_* maths for the anneal (SK 2026-10-23) -> math/anneal/<source>: Dolmino-mix-1124 maths subsets (MathCoder2,
|
| TuluMath, DolminoSynthMath, GSM8K train, CodeSearchNet-owmfilter), MegaMath Q&A, and MegaMath Q&A
|
| Shard file: raw tokens, 3 bytes each little-endian, every document = <bos> text <eos>. The .json lists tokens, documents
|
| and source files.
|
| """
|
| import argparse, hashlib, json, multiprocessing as mp, os, pathlib, re, time
|
| from urllib.parse import urlparse
|
| import numpy as np
|
|
|
| BOS, EOS, VOCAB = 2, 1, 262144
|
| SRC = {
|
| "fineweb_edu": {"repo": "HuggingFaceFW/fineweb-edu", "glob": r"^data/.*\.parquet$", "route": "au_or_global",
|
| "au": "knowledge/fineweb_edu_au", "glb": "knowledge/fineweb_edu", "glb_quota": 75e9, "au_quota": 1e12, "save_au_urls": True},
|
| "dclm": {"repo": "mlfoundations/dclm-baseline-1.0", "glob": r"\.jsonl\.zst$", "route": "au_or_global",
|
| "au": "knowledge/dclm_au", "glb": "knowledge/dclm", "glb_quota": 35e9, "au_quota": 6e9, "skip_au_urls": True},
|
| "dclm_global": {"repo": "mlfoundations/dclm-baseline-1.0", "glob": r"\.jsonl\.zst$", "route": "au_or_global",
|
| "au": "knowledge/dclm_au", "glb": "knowledge/dclm", "glb_quota": 35e9, "au_quota": 0},
|
| "dclm_au": {"repo": "mlfoundations/dclm-baseline-1.0", "glob": r"\.jsonl\.zst$", "route": "au_or_global",
|
| "au": "knowledge/dclm_au", "glb": "knowledge/dclm", "glb_quota": 0, "au_quota": 6e9, "skip_au_urls": True},
|
| "legal": {"repo": "isaacus/open-australian-legal-corpus", "glob": r"\.(parquet|jsonl|jsonl\.gz)$", "route": "all", "all": "knowledge/legal", "quota": 1e12},
|
| "spaceai": {"repo": "MrSpaceCommander/spaceai-australian-corpus", "glob": r"^data/(train|validation)/(?!oalc).*[.]jsonl[.]gz$",
|
| "route": "all", "all": "knowledge/spaceai", "quota": 1e12},
|
| "joeyllm": {"repo": "JoeyLLM/australian-dataset-1b", "glob": r"\.parquet$", "route": "all", "all": "knowledge/joeyllm", "quota": 1e12, "skip_au_urls": True},
|
| "opencoder_fineweb": {"repo": "OpenCoder-LLM/opc-fineweb-code-corpus", "glob": r"^data/.*\.parquet$", "route": "all", "all": "code/opencoder_fineweb", "quota": 1e12},
|
| "opencoder_annealing": {"repo": "OpenCoder-LLM/opc-annealing-corpus", "glob": r"\.jsonl$", "route": "all", "all": "code/opencoder_annealing", "quota": 1e12},
|
| "gutenberg": {"repo": "juniot/qualc-gutenberg-en", "glob": r"^data/.*\.parquet$", "route": "all", "all": "creative/gutenberg", "quota": 1e12},
|
| "poetry_lines": {"repo": "biglam/gutenberg-poetry-corpus", "glob": r"^data/.*\.parquet$", "route": "all", "all": "creative/gutenberg_poetry",
|
| "quota": 1e12, "text": "poetry_lines"},
|
| "poems": {"repo": "DanFosing/public-domain-poetry", "glob": r"^poems\.json$", "route": "all", "all": "creative/public_domain_poetry", "quota": 1e12, "text": "poem"},
|
| "cosmopedia_stories": {"repo": "HuggingFaceTB/cosmopedia", "glob": r"^data/stories/.*\.parquet$", "route": "all", "all": "creative/cosmopedia_stories", "quota": 1e12},
|
| "nemotron_math": {"repo": "nvidia/Nemotron-CC-Math-v1", "glob": r"^4plus/.*\.parquet$", "route": "all", "all": "math/nemotron_cc_math_4plus",
|
| "quota": 1e12, "private": True},
|
| "wikipedia_au": {"repo": "wikimedia/wikipedia", "glob": r"^20231101\.en/.*\.parquet$", "route": "all", "all": "knowledge/wikipedia_au",
|
| "quota": 1e12, "filter": "australia", "private": True},
|
| "anneal_mathcoder2": {"repo": "allenai/dolmino-mix-1124", "glob": r"^data/math/mathcoder2-synthmath/.*\.jsonl(\.gz|\.zst)?$", "route": "all", "all": "math/anneal/mathcoder2", "quota": 1e12},
|
| "anneal_tulu_math": {"repo": "allenai/dolmino-mix-1124", "glob": r"^data/math/tulu_math/.*\.jsonl(\.gz|\.zst)?$", "route": "all", "all": "math/anneal/tulu_math", "quota": 1e12},
|
| "anneal_dolmino_synth": {"repo": "allenai/dolmino-mix-1124", "glob": r"^data/math/dolmino_math_synth/.*\.jsonl(\.gz|\.zst)?$", "route": "all", "all": "math/anneal/dolmino_math_synth", "quota": 1e12},
|
| "anneal_gsm8k": {"repo": "allenai/dolmino-mix-1124", "glob": r"^data/math/gsm8k/main/train/.*\.jsonl(\.gz|\.zst)?$", "route": "all", "all": "math/anneal/gsm8k", "quota": 1e12},
|
| "anneal_codesearchnet": {"repo": "allenai/dolmino-mix-1124", "glob": r"^data/math/codesearchnet-owmfilter/.*\.jsonl(\.gz|\.zst)?$", "route": "all", "all": "math/anneal/codesearchnet_owmfilter", "quota": 1e12},
|
| "anneal_megamath_qa": {"repo": "LLM360/MegaMath", "glob": r"^megamath-qa/.*\.parquet$", "route": "all", "all": "math/anneal/megamath_qa", "quota": 1e12},
|
| }
|
| AU_WORDS = re.compile(r"\b(Australia|Australian|New South Wales|Victoria, Australia|Queensland|Tasmania|Western Australia|South Australia|Northern Territory|Canberra|Sydney|Melbourne|Brisbane|Perth|Adelaide|Hobart|Darwin)\b")
|
|
|
| def is_au(url):
|
| try: return urlparse(url).netloc.lower().split(":")[0].endswith(".au")
|
| except Exception: return False
|
|
|
| def rows_jsonl_zst(repo, f):
|
| """read a .jsonl.zst file line by line, keeping only text and url (DCLM files disagree on the types of other fields)"""
|
| import io, zstandard
|
| from huggingface_hub import HfFileSystem
|
| with HfFileSystem().open(f"datasets/{repo}/{f}", "rb", block_size=16 << 20) as fh:
|
| for line in io.TextIOWrapper(zstandard.ZstdDecompressor().stream_reader(fh), encoding="utf-8", errors="replace"):
|
| try: o = json.loads(line)
|
| except Exception: continue
|
| yield {"text": o.get("text") or "", "url": o.get("url") or ""}
|
|
|
| def poems_from_lines(rows, max_chars=20000):
|
| """the Gutenberg Poetry Corpus has one row per line; join consecutive lines of the same book into documents"""
|
| cur, lines, n = None, [], 0
|
| for r in rows:
|
| if (r["gutenberg_id"] != cur or n > max_chars) and lines: yield {"text": "\n".join(lines)}; lines, n = [], 0
|
| cur = r["gutenberg_id"]; lines.append(r["line"]); n += len(r["line"]) + 1
|
| if lines: yield {"text": "\n".join(lines)}
|
|
|
| def uhash(url): return hashlib.blake2b(url.encode("utf-8", "ignore"), digest_size=8).digest()
|
|
|
| class Shards:
|
| """collects tokens for one bucket and writes 3-byte shards; finished shard names go to the upload queue"""
|
| def __init__(self, out, bucket, wid, shard_tokens, upq):
|
| self.out, self.bucket, self.wid, self.shard_tokens, self.upq = out, bucket, wid, shard_tokens, upq
|
| self.buf, self.n, self.docs, self.k, self.files = [], 0, 0, 0, set()
|
| def add(self, ids_list, src_file):
|
| for ids in ids_list:
|
| self.buf.append(np.asarray([BOS] + ids + [EOS], np.uint32)); self.n += len(ids) + 2; self.docs += 1
|
| self.files.add(src_file)
|
| if self.n >= self.shard_tokens: self.flush()
|
| def flush(self):
|
| if not self.n: return
|
| a = np.concatenate(self.buf); b = np.empty((len(a), 3), np.uint8); b[:, 0] = a & 255; b[:, 1] = (a >> 8) & 255; b[:, 2] = (a >> 16) & 255
|
| name = f"{self.bucket}/{self.bucket.split('/')[-1]}_w{self.wid:02d}_{self.k:05d}"
|
| p = pathlib.Path(self.out) / (name + ".bin"); p.parent.mkdir(parents=True, exist_ok=True); p.write_bytes(b.tobytes())
|
| np.savez_compressed(pathlib.Path(self.out) / (name + ".counts.npz"), counts=np.bincount(a, minlength=VOCAB).astype(np.uint32))
|
| meta = {"tokens": int(len(a)), "documents": self.docs, "bytes_per_token": 3, "bos": BOS, "eos": EOS, "source_files": sorted(self.files)}
|
| pathlib.Path(self.out, name + ".json").write_text(json.dumps(meta))
|
| self.upq.put(name); self.buf, self.n, self.docs, self.files = [], 0, 0, set(); self.k += 1
|
|
|
| def worker(wid, files, args, cfg, counters, upq, ret):
|
| from datasets import load_dataset
|
| from transformers import AutoTokenizer
|
| tk = AutoTokenizer.from_pretrained("google/embeddinggemma-2")
|
| skip = set()
|
| if cfg.get("skip_au_urls") and os.path.exists(args.au_urls):
|
| raw = pathlib.Path(args.au_urls).read_bytes(); skip = {raw[i:i + 8] for i in range(0, len(raw), 8)}
|
| if cfg.get("skip_urls_file"):
|
| raw = pathlib.Path(cfg["skip_urls_file"]).read_bytes(); skip = {raw[i:i + 8] for i in range(0, len(raw), 8)}
|
| au_seen = [] if cfg.get("save_au_urls") else None
|
| sh = {}
|
| def S(b):
|
| if b not in sh: sh[b] = Shards(args.out, b, wid, args.shard_tokens, upq); sh[b].k = args.shard_start
|
| return sh[b]
|
| def room(key, quota):
|
| with counters[key].get_lock(): return counters[key].value < quota
|
| quotas = [("glb", cfg["glb_quota"]), ("au", cfg["au_quota"])] if cfg["route"] == "au_or_global" else [("all", cfg["quota"])]
|
| def put(batch, f):
|
| for (bb, kk, qq), texts in batch.items():
|
| if not texts or not room(kk, qq): continue
|
| ids = tk(texts, add_special_tokens=False)["input_ids"]; S(bb).add(ids, f)
|
| with counters[kk].get_lock(): counters[kk].value += sum(len(i) + 2 for i in ids)
|
| for fi, f in enumerate(files):
|
| if all(not room(k, q) for k, q in quotas): break
|
| ds = rows_jsonl_zst(cfg["repo"], f) if f.endswith(".jsonl.zst") else load_dataset(cfg["repo"], data_files=[f], split="train", streaming=True)
|
| if cfg.get("text") == "poetry_lines": ds = poems_from_lines(ds)
|
| batch = {}
|
| for row in ds:
|
| t = row.get("text") or ""
|
| if cfg.get("text") == "poem": t = f"{row.get('Title') or ''}\nby {row.get('Author') or 'Anonymous'}\n\n{t}".strip()
|
| if len(t) < 50: continue
|
| if cfg.get("filter") == "australia" and not AU_WORDS.search(t[:3000]): continue
|
| if cfg["route"] == "au_or_global":
|
| url = row.get("url") or ""
|
| if is_au(url):
|
| h = uhash(url)
|
| if h in skip: continue
|
| if au_seen is not None: au_seen.append(h)
|
| key = (cfg["au"], "au", cfg["au_quota"])
|
| else: key = (cfg["glb"], "glb", cfg["glb_quota"])
|
| else:
|
| if (cfg.get("skip_au_urls") or cfg.get("skip_urls_file")) and uhash(row.get("url") or "") in skip: continue
|
| key = (cfg["all"], "all", cfg["quota"])
|
| batch.setdefault(key, []).append(t)
|
| if sum(len(v) for v in batch.values()) >= 512:
|
| put(batch, f); batch = {}
|
| if all(not room(k, q) for k, q in quotas): break
|
| put(batch, f)
|
| print(f"w{wid:02d} file {fi + 1}/{len(files)} done {f} | totals " + " ".join(f"{k}={v.value / 1e9:.3f}B" for k, v in counters.items()), flush=True)
|
| for s in sh.values(): s.flush()
|
| if au_seen: ret.put(b"".join(au_seen))
|
|
|
| def upload(names, out, repo):
|
| """one commit per source folder for a batch of finished shards, then delete the local files"""
|
| from huggingface_hub import HfApi, CommitOperationAdd
|
| api = HfApi(); groups = {}
|
| for n in names: groups.setdefault(n.rsplit("/", 1)[0], []).append(n)
|
| for folder, ns in groups.items():
|
| ops = [CommitOperationAdd(path_in_repo=n + ext, path_or_fileobj=str(pathlib.Path(out) / (n + ext))) for n in ns for ext in (".bin", ".json", ".counts.npz")]
|
| for attempt in range(8):
|
| try: api.create_commit(repo, repo_type="dataset", operations=ops, commit_message=f"Add {folder} ({len(ns)} shards)"); break
|
| except Exception as e: print(f"upload retry {attempt + 1} {folder}: {str(e)[:150]}", flush=True); time.sleep(30 * (attempt + 1))
|
| else: print(f"UPLOAD FAILED {folder}: kept on disk", flush=True); continue
|
| for n in ns:
|
| for ext in (".bin", ".json", ".counts.npz"): (pathlib.Path(out) / (n + ext)).unlink(missing_ok=True)
|
|
|
| def main():
|
| ap = argparse.ArgumentParser()
|
| ap.add_argument("--source", required=True, choices=list(SRC)); ap.add_argument("--workers", type=int, default=max(1, os.cpu_count() - 4))
|
| ap.add_argument("--out", default="out"); ap.add_argument("--repo", default="QLNI/shadow-assistant-data")
|
| ap.add_argument("--private-repo", default="QLNI/shadow-assistant-private"); ap.add_argument("--shard-tokens", type=int, default=250_000_000)
|
| ap.add_argument("--batch", type=int, default=8, help="shards per commit"); ap.add_argument("--au-urls", default="fineweb_edu_au_urls.bin")
|
| ap.add_argument("--test", action="store_true"); ap.add_argument("--skip-files", default="", help="file listing source files already done")
|
| ap.add_argument("--glb-quota", type=float, default=0); ap.add_argument("--shard-start", type=int, default=0, help="first shard number (resume)")
|
| args = ap.parse_args(); cfg = dict(SRC[args.source]); repo = args.private_repo if cfg.get("private") else args.repo
|
| if args.glb_quota: cfg["glb_quota"] = args.glb_quota
|
| from huggingface_hub import HfApi
|
| files = sorted(f for f in HfApi().list_repo_files(cfg["repo"], repo_type="dataset") if re.search(cfg["glob"], f))
|
| if args.skip_files:
|
| done = set(open(args.skip_files).read().split()); files = [f for f in files if f not in done]
|
| if args.test:
|
| files = files[:2]; args.workers = min(2, len(files)); args.shard_tokens = 1_000_000; repo = ""
|
| for k in ("glb_quota", "au_quota", "quota"):
|
| if k in cfg: cfg[k] = 2e6
|
| print(f"{args.source}: {len(files)} files, {args.workers} workers, repo {repo or '(none, local only)'}", flush=True)
|
| counters = {k: mp.Value("d", 0.0) for k in (["glb", "au"] if cfg["route"] == "au_or_global" else ["all"])}
|
| upq, ret = mp.Queue(), mp.Queue(); chunks = [files[i::args.workers] for i in range(args.workers)]
|
| t0 = time.time(); ps = [mp.Process(target=worker, args=(i, chunks[i], args, cfg, counters, upq, ret)) for i in range(args.workers)]
|
| for p in ps: p.start()
|
| pending, urls, last = [], [], time.time()
|
| def drain():
|
| while True:
|
| try: pending.append(upq.get_nowait())
|
| except Exception: break
|
| while True:
|
| try: urls.append(ret.get_nowait())
|
| except Exception: break
|
| while any(p.is_alive() for p in ps):
|
| time.sleep(5); drain()
|
| if repo and (len(pending) >= args.batch or (pending and time.time() - last > 900)):
|
| upload(pending, args.out, repo); pending, last = [], time.time()
|
| for p in ps: p.join()
|
| drain()
|
| if repo and pending: upload(pending, args.out, repo)
|
| if cfg.get("save_au_urls") and urls: pathlib.Path(args.au_urls).write_bytes(b"".join(urls))
|
| summary = {"source": args.source, "files": len(files), "hours": round((time.time() - t0) / 3600, 3), **{k: v.value for k, v in counters.items()}}
|
| print("SUMMARY", json.dumps(summary), flush=True)
|
| pathlib.Path(args.out).mkdir(exist_ok=True); pathlib.Path(args.out, f"summary_{args.source}.json").write_text(json.dumps(summary, indent=1))
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
