"""Build OPUS-5.5-DATABASE from the raw upstream files. Usage: OPUSDB_RAW=raw OPUSDB_OUT=out python scripts/build.py [--stages sft,preference,synth_eval,pretrain] Outputs (Hugging Face `datasets`-compatible Parquet): out/data/sft/{train,test}-*.parquet out/data/preference/{train,test}-*.parquet out/data/synth_eval/test-*.parquet out/data/tools/{train,test}-*.parquet out/data/pretrain/train-*.parquet out/stats/*.json (filter funnels, token counts; used by scripts/charts.py) """ import argparse import gzip import json import multiprocessing as mp import os import random import sys import time from collections import Counter, defaultdict sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) import pyarrow as pa # noqa: E402 import pyarrow.parquet as pq # noqa: E402 from opusdb import synth, synth_tools # noqa: E402 from opusdb import tool_formats as tf # noqa: E402 from opusdb.decontam import Decontaminator # noqa: E402 from opusdb.dedup import ExactDeduper, MinHashLSH # noqa: E402 from opusdb.sources import SOURCES # noqa: E402 from opusdb.text import gopher_quality, guess_language, key, scrub_pii, stable_id # noqa: E402 RAW = os.environ.get("OPUSDB_RAW", "raw") OUT = os.environ.get("OPUSDB_OUT", "out") TOKENIZER = "HuggingFaceTB/SmolLM2-135M" # Apache-2.0, 49k vocab; used only for counting tokens SEED = 55 SRC = {s.name: s for s in SOURCES} def raw(source_name, idx=0): s = SRC[source_name] return os.path.join(RAW, s.repo.replace("/", "__"), s.files[idx]) def log(*a): print(time.strftime("%H:%M:%S"), *a, flush=True) # --------------------------------------------------------------------------- tokenizer _TOK = None def tok(): global _TOK if _TOK is None: from tokenizers import Tokenizer _TOK = Tokenizer.from_pretrained(TOKENIZER) return _TOK def count_tokens(texts): return [len(e.ids) for e in tok().encode_batch(texts, add_special_tokens=False)] # --------------------------------------------------------------------------- writer MSG = pa.list_(pa.struct([("role", pa.string()), ("content", pa.string())])) SCHEMAS = { "sft": pa.schema([("id", pa.string()), ("messages", MSG), ("source", pa.string()), ("domain", pa.string()), ("language", pa.string()), ("license", pa.string()), ("num_turns", pa.int32()), ("num_tokens", pa.int32())]), "preference": pa.schema([("id", pa.string()), ("prompt", pa.string()), ("chosen", MSG), ("rejected", MSG), ("source", pa.string()), ("domain", pa.string()), ("language", pa.string()), ("license", pa.string()), ("score_chosen", pa.float32()), ("score_rejected", pa.float32()), ("num_tokens", pa.int32())]), "pretrain": pa.schema([("id", pa.string()), ("text", pa.string()), ("source", pa.string()), ("domain", pa.string()), ("language", pa.string()), ("license", pa.string()), ("url", pa.string()), ("num_tokens", pa.int32())]), "tools": pa.schema([("id", pa.string()), ("messages", pa.list_(pa.struct([("role", pa.string()), ("content", pa.string()), ("tool_calls", pa.string()), ("tool_call_id", pa.string()), ("name", pa.string())]))), ("tools", pa.string()), ("source", pa.string()), ("domain", pa.string()), ("language", pa.string()), ("license", pa.string()), ("num_tool_calls", pa.int32()), ("num_tokens", pa.int32())]), "synth_eval": pa.schema([("id", pa.string()), ("family", pa.string()), ("language", pa.string()), ("difficulty", pa.int32()), ("prompt", pa.string()), ("answer", pa.string()), ("reference_response", pa.string())]), } def write_split(config, split, rows, rows_per_shard): d = os.path.join(OUT, "data", config) os.makedirs(d, exist_ok=True) n = max(1, -(-len(rows) // rows_per_shard)) for i in range(n): part = rows[i * rows_per_shard:(i + 1) * rows_per_shard] table = pa.Table.from_pylist(part, schema=SCHEMAS[config]) pq.write_table(table, os.path.join(d, f"{split}-{i:05d}-of-{n:05d}.parquet"), compression="zstd", row_group_size=10_000) log(f"wrote {config}/{split}: {len(rows):,} rows in {n} shard(s)") def save_stats(name, obj): os.makedirs(os.path.join(OUT, "stats"), exist_ok=True) with open(os.path.join(OUT, "stats", name + ".json"), "w") as f: json.dump(obj, f, indent=2, ensure_ascii=False) # --------------------------------------------------------------------------- benchmarks def build_decontaminator(): d = Decontaminator() for row in pq.read_table(raw("gsm8k-test")).to_pylist(): d.add(row["question"]) with open(raw("math500")) as f: for line in f: d.add(json.loads(line)["problem"]) for row in pq.read_table(raw("humaneval")).to_pylist(): d.add(row["prompt"]) for row in pq.read_table(raw("mmlu"), columns=["question"]).to_pylist(): d.add(row["question"]) d.finalize() log(f"decontamination index: {len(d):,} benchmark n-grams") return d # --------------------------------------------------------------------------- SFT readers def m(role, content): return {"role": role, "content": content} def read_smoltalk(name): s = SRC[name] for f in s.files: cols = pq.ParquetFile(os.path.join(RAW, s.repo.replace("/", "__"), f)).schema_arrow.names t = pq.read_table(os.path.join(RAW, s.repo.replace("/", "__"), f)) for row in t.to_pylist(): if "quality" in cols and row.get("quality") not in ("good", "excellent"): yield None, "low_quality_label" continue yield [m(x["role"], x["content"]) for x in row["messages"]], None def read_oasst2(): with gzip.open(raw("oasst2"), "rt") as f: for line in f: tree = json.loads(line) node, path = tree["prompt"], [] while node is not None: path.append(m("user" if node["role"] == "prompter" else "assistant", node["text"])) replies = [r for r in node.get("replies", []) if not r.get("deleted")] if not replies: break node = min(replies, key=lambda r: (r.get("rank") is None, r.get("rank") or 0)) if path and path[-1]["role"] == "user": path = path[:-1] if len(path) < 2: yield None, "incomplete_tree" continue yield path, tree["prompt"].get("lang") def read_metamath(): with open(raw("metamathqa")) as f: data = json.load(f) for row in data: yield [m("user", row["query"]), m("assistant", row["response"])], None def read_omi2(): for row in pq.read_table(raw("openmathinstruct2"), columns=["problem", "generated_solution"]).to_pylist(): yield [m("user", row["problem"]), m("assistant", row["generated_solution"])], None def read_gsm8k(): for row in pq.read_table(raw("gsm8k")).to_pylist(): reasoning, ans = row["answer"].split("####") import re reasoning = re.sub(r"<<[^>]*>>", "", reasoning).strip() yield [m("user", row["question"]), m("assistant", f"{reasoning}\n\n**Answer:** {ans.strip()}")], None def read_magicoder(): with open(raw("magicoder-oss")) as f: for line in f: row = json.loads(line) yield [m("user", row["problem"]), m("assistant", row["solution"])], None def read_codealpaca(): with open(raw("codealpaca")) as f: for row in json.load(f): q = row["instruction"] + (f"\n\n{row['input']}" if row["input"].strip() else "") yield [m("user", q), m("assistant", row["output"])], None SFT_READERS = { "smol-magpie-ultra": lambda: read_smoltalk("smol-magpie-ultra"), "smol-constraints": lambda: read_smoltalk("smol-constraints"), "smol-rewrite": lambda: read_smoltalk("smol-rewrite"), "smol-summarize": lambda: read_smoltalk("smol-summarize"), "oasst2": read_oasst2, "metamathqa": read_metamath, "openmathinstruct2": read_omi2, "gsm8k": read_gsm8k, "magicoder-oss": read_magicoder, "codealpaca": read_codealpaca, } def valid_conversation(msgs): roles = [x["role"] for x in msgs] body = [r for r in roles if r != "system"] if not body or body[0] != "user" or body[-1] != "assistant": return "bad_roles" if any(a == b for a, b in zip(body, body[1:])): return "bad_roles" if any(not x["content"] or not x["content"].strip() for x in msgs): return "empty_turn" last = msgs[-1]["content"] if len(last) < 2: return "empty_turn" low = last.lower() if any(p in low for p in ("as an ai language model", "i'm sorry, but i cannot", "openai", "chatgpt")): return "boilerplate_or_identity" return None def build_sft(decon, synth_train): rng = random.Random(SEED) exact, near = ExactDeduper(), MinHashLSH() funnel, rows = {}, [] for name, reader in SFT_READERS.items(): s = SRC[name] c = Counter() kept = [] for msgs, info in reader(): c["read"] += 1 if msgs is None: c[info] += 1 continue reason = valid_conversation(msgs) if reason: c[reason] += 1 continue first_user = next(x["content"] for x in msgs if x["role"] == "user") if decon.contaminated(first_user): c["benchmark_contaminated"] += 1 continue kept.append((msgs, info, first_user)) rng.shuffle(kept) # random subsample when a cap applies for msgs, info, first_user in kept: if s.max_rows and c["kept"] >= s.max_rows: c["over_cap"] += 1 continue if exact.is_dup(first_user): c["exact_duplicate"] += 1 continue if near.is_dup(first_user): c["near_duplicate"] += 1 continue msgs = [m(x["role"], scrub_pii(x["content"])) for x in msgs] lang = info if name == "oasst2" and info else guess_language(first_user) rows.append({"id": f"{name}-" + stable_id(name, json.dumps(msgs, ensure_ascii=False)), "messages": msgs, "source": name, "domain": s.domain, "language": lang, "license": s.license, "num_turns": sum(x["role"] == "user" for x in msgs)}) c["kept"] += 1 funnel[name] = dict(c) log(f"sft {name}: {dict(c)}") # OPUS-synth (original, verified) c = Counter() for ex in synth_train: c["read"] += 1 if exact.is_dup(ex["prompt"]): c["exact_duplicate"] += 1 continue msgs = [m("user", ex["prompt"]), m("assistant", ex["response"])] rows.append({"id": ex["id"], "messages": msgs, "source": "opus-synth", "domain": "synthetic-" + ex["family"].split("/")[0], "language": ex["language"], "license": "apache-2.0", "num_turns": 1}) c["kept"] += 1 funnel["opus-synth"] = dict(c) log(f"sft opus-synth: {dict(c)}") # token counts (full conversation, content only) B = 2000 for i in range(0, len(rows), B): batch = rows[i:i + B] counts = count_tokens(["\n".join(x["content"] for x in r["messages"]) for r in batch]) for r, n in zip(batch, counts): r["num_tokens"] = n before = len(rows) rows = [r for r in rows if r["num_tokens"] <= 8192] funnel["_too_long_removed"] = before - len(rows) rng.shuffle(rows) test, train = rows[:2000], rows[2000:] write_split("sft", "train", train, 100_000) write_split("sft", "test", test, 100_000) save_stats("sft_funnel", funnel) by = defaultdict(lambda: Counter()) for r in train: b = by[r["source"]] b["rows"] += 1 b["tokens"] += r["num_tokens"] b["lang_" + r["language"]] += 1 save_stats("sft_sources", {k: dict(v) for k, v in by.items()}) save_stats("sft_lengths", {"num_tokens": [r["num_tokens"] for r in train], "source": [r["source"] for r in train]}) return len(train) # --------------------------------------------------------------------------- preference def build_preference(decon, synth_pairs): rng = random.Random(SEED + 1) exact = ExactDeduper() rows, funnel = [], {} c = Counter() for row in pq.read_table(raw("ultrafeedback")).to_pylist(): c["read"] += 1 if row["score_chosen"] <= row["score_rejected"]: c["no_margin"] += 1 continue if row["chosen"][-1]["content"].strip() == row["rejected"][-1]["content"].strip(): c["identical"] += 1 continue if decon.contaminated(row["prompt"]): c["benchmark_contaminated"] += 1 continue if exact.is_dup(row["prompt"]): c["exact_duplicate"] += 1 continue rows.append({"id": "ultrafeedback-" + row["prompt_id"][:24], "prompt": row["prompt"], "chosen": [m(x["role"], x["content"]) for x in row["chosen"]], "rejected": [m(x["role"], x["content"]) for x in row["rejected"]], "source": "ultrafeedback", "domain": "general", "language": guess_language(row["prompt"]), "license": "mit", "score_chosen": row["score_chosen"], "score_rejected": row["score_rejected"]}) c["kept"] += 1 funnel["ultrafeedback"] = dict(c) c = Counter() for row in pq.read_table(raw("orca-dpo")).to_pylist(): c["read"] += 1 if row["status"] == "tie" or (row["chosen_score"] or 0) < 8 or row["in_gsm8k_train"]: c["argilla_recipe_filter"] += 1 continue if decon.contaminated(row["input"]): c["benchmark_contaminated"] += 1 continue if exact.is_dup(row["input"]): c["exact_duplicate"] += 1 continue sys_msg = [m("system", row["system"])] if row["system"] and row["system"].strip() else [] user = [m("user", row["input"])] rows.append({"id": "orca-dpo-" + stable_id(row["input"]), "prompt": row["input"], "chosen": sys_msg + user + [m("assistant", row["chosen"])], "rejected": sys_msg + user + [m("assistant", row["rejected"])], "source": "orca-dpo", "domain": "general", "language": "en", "license": "apache-2.0", "score_chosen": float(row["chosen_score"]), "score_rejected": None}) c["kept"] += 1 funnel["orca-dpo"] = dict(c) c = Counter() for ex, bad in synth_pairs: c["read"] += 1 rows.append({"id": ex["id"] + "-pref", "prompt": ex["prompt"], "chosen": [m("user", ex["prompt"]), m("assistant", ex["response"])], "rejected": [m("user", ex["prompt"]), m("assistant", bad)], "source": "opus-synth-pref", "domain": "synthetic-" + ex["family"].split("/")[0], "language": ex["language"], "license": "apache-2.0", "score_chosen": 1.0, "score_rejected": 0.0}) c["kept"] += 1 funnel["opus-synth-pref"] = dict(c) log("preference funnel", funnel) B = 2000 for i in range(0, len(rows), B): batch = rows[i:i + B] counts = count_tokens([r["prompt"] + "\n" + r["chosen"][-1]["content"] + "\n" + r["rejected"][-1]["content"] for r in batch]) for r, n in zip(batch, counts): r["num_tokens"] = n rng.shuffle(rows) test, train = rows[:1000], rows[1000:] write_split("preference", "train", train, 50_000) write_split("preference", "test", test, 50_000) by = defaultdict(Counter) for r in train: by[r["source"]]["rows"] += 1 by[r["source"]]["tokens"] += r["num_tokens"] save_stats("preference_funnel", funnel) save_stats("preference_sources", {k: dict(v) for k, v in by.items()}) return len(train) # --------------------------------------------------------------------------- tool use def build_tools(decon, n_synth=30_000, n_test=1_000): rng = random.Random(SEED + 2) exact, near = ExactDeduper(), MinHashLSH() funnel, train, test = {}, [], [] def row(src, msgs, tools, lang, license_, domain): enc = tf.encode_messages(msgs) return {"id": f"{src}-" + stable_id(src, json.dumps(enc, ensure_ascii=False)), "messages": enc, "tools": json.dumps(tools, ensure_ascii=False), "source": src, "domain": domain, "language": lang, "license": license_, "num_tool_calls": sum(len(m.get("tool_calls") or []) for m in msgs)} # verified synthetic: held-out test first (own seed), then train with disjoint prompts c = Counter() test_prompts = set() for ex in synth_tools.generate(n_test, seed=9002): test_prompts.add(ex["messages"][0]["content"]) r = row("opus-synth-tools", ex["messages"], ex["tools"], ex["language"], "apache-2.0", "tools-" + ex["family"]) r["id"] = ex["id"] test.append(r) for ex in synth_tools.generate(n_synth + 3000, seed=3): c["read"] += 1 p = ex["messages"][0]["content"] if p in test_prompts or exact.is_dup(p): c["exact_duplicate"] += 1 continue if c["kept"] >= n_synth: c["over_cap"] += 1 continue r = row("opus-synth-tools", ex["messages"], ex["tools"], ex["language"], "apache-2.0", "tools-" + ex["family"]) r["id"] = ex["id"] train.append(r) c["kept"] += 1 funnel["opus-synth-tools"] = dict(c) readers = {"hermes-fc": tf.read_hermes, "toolace": tf.read_toolace, "glaive-fc-v2": tf.read_glaive} for name, fn in readers.items(): s = SRC[name] c = Counter() items = [] for f in s.files: with open(os.path.join(RAW, s.repo.replace("/", "__"), f)) as fh: items.extend(json.load(fh)) rng.shuffle(items) for item in items: c["read"] += 1 try: out = fn(item) except Exception: # malformed upstream rows out = None if not out or not tf.valid(*out): c["parse_or_format_error"] += 1 continue msgs, tools = out first = msgs[0]["content"] if decon.contaminated(first): c["benchmark_contaminated"] += 1 continue if s.max_rows and c["kept"] >= s.max_rows: c["over_cap"] += 1 continue if exact.is_dup(first): c["exact_duplicate"] += 1 continue if near.is_dup(first + " " + " ".join(t["function"]["name"] for t in tools)): c["near_duplicate"] += 1 continue msgs = [dict(m, content=scrub_pii(m.get("content") or "")) for m in msgs] train.append(row(name, msgs, tools, guess_language(first), s.license, "function-calling")) c["kept"] += 1 funnel[name] = dict(c) log(f"tools {name}: {dict(c)}") for rows in (train, test): for i in range(0, len(rows), 2000): batch = rows[i:i + 2000] texts = [r["tools"] + "\n" + "\n".join(m["content"] + m["tool_calls"] for m in r["messages"]) for r in batch] for r, n in zip(batch, count_tokens(texts)): r["num_tokens"] = n train = [r for r in train if r["num_tokens"] <= 8192] rng.shuffle(train) write_split("tools", "train", train, 50_000) write_split("tools", "test", test, 50_000) by = defaultdict(Counter) for r in train: by[r["source"]]["rows"] += 1 by[r["source"]]["tokens"] += r["num_tokens"] by[r["source"]]["tool_calls"] += r["num_tool_calls"] save_stats("tools_funnel", funnel) save_stats("tools_sources", {k: dict(v) for k, v in by.items()}) save_stats("tools_families", dict(Counter(r["domain"] for r in train if r["source"] == "opus-synth-tools"))) # --------------------------------------------------------------------------- pretraining (parallel) _DECON = None def _init_worker(decon): global _DECON _DECON = decon def _process_pretrain_batch(args): name, texts, urls, lang_default = args out, c = [], Counter() keep_texts = [] for text, url in zip(texts, urls): c["read"] += 1 fails = gopher_quality(text) if fails: c["quality:" + fails[0]] += 1 continue if _DECON.contaminated(text, check_short=False): c["benchmark_contaminated"] += 1 continue text = scrub_pii(text) keep_texts.append((text, url)) counts = count_tokens([t for t, _ in keep_texts]) if keep_texts else [] for (text, url), n in zip(keep_texts, counts): out.append((key(text), text, url, n)) return name, out, c def iter_pretrain_batches(name, batch_rows=2000): s = SRC[name] lang = "tr" if name == "fineweb2-tr" else "en" seen = 0 for f in s.files: pf = pq.ParquetFile(os.path.join(RAW, s.repo.replace("/", "__"), f)) cols = ["text", "url"] + (["language_score"] if name == "fineweb2-tr" else []) for batch in pf.iter_batches(batch_size=batch_rows, columns=cols): d = batch.to_pydict() texts, urls = d["text"], d["url"] if name == "fineweb2-tr": keep = [i for i, sc in enumerate(d["language_score"]) if sc >= 0.9] texts, urls = [texts[i] for i in keep], [urls[i] for i in keep] if s.max_rows and seen >= s.max_rows * 1.15: # read a bit past the cap to absorb filtering return seen += len(texts) yield name, texts, urls, lang def build_pretrain(decon): exact = ExactDeduper() funnel = defaultdict(Counter) tokens = Counter() d = os.path.join(OUT, "data", "pretrain") os.makedirs(d, exist_ok=True) shard_rows, shard_idx, buf = 60_000, 0, [] lengths = defaultdict(list) def flush(final=False): nonlocal shard_idx, buf while len(buf) >= shard_rows or (final and buf): part, buf = buf[:shard_rows], buf[shard_rows:] pq.write_table(pa.Table.from_pylist(part, schema=SCHEMAS["pretrain"]), os.path.join(d, f"train-{shard_idx:05d}.parquet"), compression="zstd", row_group_size=5_000) shard_idx += 1 def jobs(): for name in ("fineweb-edu", "fineweb2-tr", "open-web-math"): yield from iter_pretrain_batches(name) ctx = mp.get_context("fork") with ctx.Pool(4, initializer=_init_worker, initargs=(decon,)) as pool: for name, out, c in pool.imap(_process_pretrain_batch, jobs(), chunksize=1): s = SRC[name] funnel[name].update(c) for k, text, url, n in out: if s.max_rows and funnel[name]["kept"] >= s.max_rows: funnel[name]["over_cap"] += 1 continue if k in exact.seen: funnel[name]["exact_duplicate"] += 1 continue exact.seen.add(k) funnel[name]["kept"] += 1 tokens[name] += n if len(lengths[name]) < 50_000: lengths[name].append(n) buf.append({"id": f"{name}-{k[:20]}", "text": text, "source": name, "domain": s.domain, "language": "tr" if name == "fineweb2-tr" else "en", "license": s.license, "url": url, "num_tokens": n}) flush() if sum(f["read"] for f in funnel.values()) % 100_000 < 2000: log("pretrain progress", {k: v["kept"] for k, v in funnel.items()}, dict(tokens)) flush(final=True) # rename shards with -of-N suffix so the HF loader shows the count files = sorted(x for x in os.listdir(d) if x.startswith("train-")) for i, f in enumerate(files): os.rename(os.path.join(d, f), os.path.join(d, f"train-{i:05d}-of-{len(files):05d}.parquet")) save_stats("pretrain_funnel", {k: dict(v) for k, v in funnel.items()}) save_stats("pretrain_tokens", dict(tokens)) save_stats("pretrain_lengths", dict(lengths)) log("pretrain done", dict(tokens)) # --------------------------------------------------------------------------- main def main(): ap = argparse.ArgumentParser() ap.add_argument("--stages", default="sft,preference,synth_eval,tools,pretrain") ap.add_argument("--synth-train", type=int, default=60_000) ap.add_argument("--synth-pref", type=int, default=10_000) ap.add_argument("--synth-eval", type=int, default=2_000) a = ap.parse_args() stages = a.stages.split(",") decon = build_decontaminator() # Disjoint synthetic sets: eval prompts are generated first with their own seed and # excluded from train/preference generation. eval_set = list(synth.generate(a.synth_eval, seed=9001)) eval_prompts = {e["prompt"] for e in eval_set} train_set = [e for e in synth.generate(a.synth_train + 2000, seed=1) if e["prompt"] not in eval_prompts][:a.synth_train] used = eval_prompts | {e["prompt"] for e in train_set} rng = random.Random(7) pairs = [] for e in synth.generate(a.synth_pref * 3, seed=2): if e["prompt"] in used or e["answer"] in ("UNANSWERABLE", "CODE_VERIFIED_BY_TESTS"): continue bad = synth.corrupt(e, rng) if bad: pairs.append((e, bad)) if len(pairs) >= a.synth_pref: break if "synth_eval" in stages: write_split("synth_eval", "test", [{"id": e["id"], "family": e["family"], "language": e["language"], "difficulty": e["difficulty"], "prompt": e["prompt"], "answer": e.get("tests") or e["answer"], "reference_response": e["response"]} for e in eval_set], 10_000) save_stats("synth_eval_families", dict(Counter(e["family"].split("/")[0] for e in eval_set))) if "sft" in stages: build_sft(decon, train_set) if "preference" in stages: build_preference(decon, pairs) if "tools" in stages: build_tools(decon) if "pretrain" in stages: build_pretrain(decon) log("ALL DONE") if __name__ == "__main__": main()