KeremTT's picture
Update code
fb6c876 verified
Raw History Blame Contribute Delete
27.1 kB
"""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()