bloxy-data-v1 / code /scripts /build_dataset.py
Radinkazemian's picture
Update Bloxy training code
2d155ca verified
Raw History Blame Contribute Delete
10.5 kB
"""Builds the Bloxy v1 training set (~30k chat examples) from 19 Hugging Face datasets.
Usage:
pip install -r requirements-data.txt
python scripts/build_dataset.py # full build -> out/
python scripts/build_dataset.py --scale 0.05 # quick smoke test (~1.5k examples)
python scripts/build_dataset.py --only procedural_builds,minecraft_builds
Outputs (in out/):
train.jsonl.gz training examples: {"messages": [...], "tools": [...]?, "source", "category"}
val.jsonl small held-out slice for eval loss
robloxqa_test.jsonl multiple-choice exam (never trained on)
stats.json counts, token estimates, cost estimate
samples.md a few examples from every source to eyeball
"""
from __future__ import annotations
import argparse
import json
import random
import sys
import time
from collections import Counter, defaultdict
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from bloxy_data import sources as S # noqa: E402
from bloxy_data.common import answer_key, est_tokens, example_key, luau_compiles, write_jsonl # noqa: E402
# Builds whose Luau we generate ourselves get compiled to prove they're valid.
LUAU_CHECKED = {"minecraft_builds", "minecraftbuildings", "procedural_builds", "hack337_schematics", "brick_builds"}
# name -> (category, target, function). Targets add up to ~30k.
RECIPE = [
# Building (~60%)
("minecraft_builds", "building", 6500, lambda n, r, l: S.minecraft_builds(n, r, l)),
("minecraftbuildings", "building", 1000, lambda n, r, l: S.minecraftbuildings(n, r, l)),
("hack337_schematics", "building", 1500, lambda n, r, l: S.hack337_schematics(n, r, l)),
("blender_3dcode", "building", 1500, lambda n, r, l: S.blender_3dcode(n, r, l)),
("cadquery_code", "building", 2500, lambda n, r, l: S.cadquery_code(n, r, l)),
("cadquery_plans", "building", 1000, lambda n, r, l: S.cadquery_plans(n, r, l)),
("omar_cadquery", "building", 1000, lambda n, r, l: S.omar_cadquery(n, r, l)),
("brick_builds", "building", 3500, lambda n, r, l: S.brick_builds(n, r, l)),
("procedural_builds", "building", 2000, lambda n, r, l: S.procedural_builds(n, r, l)),
# Studio tool use (~25%)
("robloxagent_v2", "agent", 3750, lambda n, r, l: S.roblox_agent("Pinkstack/RobloxAgent-v2", n, r, l)),
("robloxagent_v1", "agent", 3750, lambda n, r, l: S.roblox_agent("Pinkstack/RobloxAgent-toolreason-v1-2500", n, r, l)),
# Luau scripting (~12%)
("luau_coder", "luau", 1000, lambda n, r, l: S.luau_coder(n, r, l)),
("luaudev", "luau", 700, lambda n, r, l: S.luaudev(n, r, l)),
("luau_reasoning", "luau", 600, lambda n, r, l: S.luau_reasoning(n, r, l)),
("luau_coding_l1", "luau", 500, lambda n, r, l: S.instruction_rows("8BitStudio/Roblox-luau-coding_L1", n, r, l)),
("luau_corpus", "luau", 400, lambda n, r, l: S.luau_corpus(n, r, l)),
("danik_roblox", "luau", 300, lambda n, r, l: S.instruction_rows("danik7x/roblox-ai-training-data", n, r, l)),
# Roblox knowledge (~3%)
("roblox_docs", "knowledge", 400, lambda n, r, l: S.docs_rows("khtsly/roblox_docs_corpus_text", n, r, l, config="en-us")),
("roblox_info_dump", "knowledge", 300, lambda n, r, l: S.docs_rows("TorpedoSoftware/roblox-info-dump", n, r, l, title_col="url")),
("devforum", "knowledge", 300, lambda n, r, l: S.devforum(n, r, l)),
# Radin-dev1/BloxyAItraining: Roblox building / Luau skill guides
("bloxy_skill_guides", "knowledge", 120, lambda n, r, l: S.bloxy_skill_guides(n, r, l)),
]
# Kermitkiller666/Minecraftbuilding2 and /Minecraft-Building1 are image-input
# datasets (cross-section PNGs -> /setblock), so they are left out of this
# text-only v1. Their share went to minecraft_builds.
ANSWER_REUSE_OK = {"bloxy_skill_guides"}
# Shortfalls (a source with fewer usable rows than its target) are refilled
# from these, so the final mix keeps its shape.
FILLERS = {"building": "procedural_builds", "agent": "luau_coder", "luau": "luau_coder", "knowledge": None}
# Keep synthetic builds to a sane share so Bloxy doesn't only learn 13 templates.
FILLER_CAP = {"procedural_builds": 4000} # at --scale 1
SECOND_FILLER = {"building": "cadquery_code"}
def main() -> None:
ap = argparse.ArgumentParser()
ap.add_argument("--out", default=str(ROOT / "out"))
ap.add_argument("--scale", type=float, default=1.0, help="multiply every target (0.05 = smoke test)")
ap.add_argument("--only", default="", help="comma list of source names")
ap.add_argument("--seed", type=int, default=42)
ap.add_argument("--val", type=int, default=300)
ap.add_argument("--luau", default="", help="path to luau-compile; drops generated builds that don't compile")
args = ap.parse_args()
out = Path(args.out)
out.mkdir(parents=True, exist_ok=True)
only = {s for s in args.only.split(",") if s}
rng = random.Random(args.seed)
log_lines: list[str] = []
def log(msg: str) -> None:
print(msg, flush=True)
log_lines.append(msg)
by_source: dict[str, list[dict]] = defaultdict(list)
seen_ex, seen_ans = set(), set()
dupes = Counter()
bad_luau = Counter()
errors = {}
def take(name: str, cat: str, n: int, fn) -> int:
got = 0
t0 = time.time()
try:
# ask for extra so duplicates/filters don't leave us short
for item in fn(int(n * 1.3) + 10, random.Random(rng.random()), log):
rec = item if isinstance(item, dict) else {"messages": item}
if args.luau and name in LUAU_CHECKED and not luau_compiles(rec["messages"], args.luau):
bad_luau[name] += 1
continue
k1, k2 = example_key(rec["messages"]), answer_key(rec["messages"])
# agent runs and the skill guides legitimately reuse answers under new questions
if k1 in seen_ex or (name not in ANSWER_REUSE_OK and cat != "agent" and k2 in seen_ans):
dupes[name] += 1
continue
seen_ex.add(k1)
seen_ans.add(k2)
rec["source"], rec["category"] = name, cat
by_source[name].append(rec)
got += 1
if got >= n:
break
except Exception as e: # keep going: one broken dataset must not kill the build
import traceback
errors[name] = repr(e)
log(f" !! {name} failed: {e!r}")
traceback.print_exc()
log(f" -> {name}: {got}/{n} in {time.time() - t0:.0f}s")
return got
short: Counter = Counter()
for name, cat, target, fn in RECIPE:
if only and name not in only:
continue
n = max(1, int(target * args.scale))
log(f"[{cat}] {name} (target {n})")
got = take(name, cat, n, fn)
if got < n:
short[cat] += n - got
for cat, missing in short.items():
filler = FILLERS.get(cat)
if not filler or missing <= 0 or (only and filler not in only):
continue
fn = next(f for nm, c, t, f in RECIPE if nm == filler)
cap = int(FILLER_CAP[filler] * args.scale) if filler in FILLER_CAP else None
n = missing if cap is None else max(0, min(missing, cap - len(by_source.get(filler, []))))
if n:
log(f"[{cat}] refilling {n} from {filler}")
missing -= take(filler, cat, n, fn)
second = SECOND_FILLER.get(cat)
if missing > 0 and second and not (only and second not in only):
fn2 = next(f for nm, c, t, f in RECIPE if nm == second)
log(f"[{cat}] refilling {missing} from {second}")
take(second, cat, missing, fn2)
rows = [r for rs in by_source.values() for r in rs]
rng.shuffle(rows)
val = rows[: args.val]
train = rows[args.val:]
write_jsonl(out / "train.jsonl.gz", train)
write_jsonl(out / "val.jsonl", val)
if not only:
try:
n_eval = write_jsonl(out / "robloxqa_test.jsonl", S.robloxqa_eval(random.Random(7)))
log(f"eval: {n_eval} RobloxQA questions")
except Exception as e:
errors["robloxqa_eval"] = repr(e)
log(f" !! robloxqa eval failed: {e!r}")
toks = Counter()
cnt = Counter()
for r in train:
t = est_tokens(r["messages"]) + (len(json.dumps(r.get("tools", []))) // 4 if r.get("tools") else 0)
toks[r["category"]] += t
cnt[r["category"]] += 1
total_tokens = sum(toks.values())
# A6000 + Unsloth QLoRA on a 12B model: ~1,500-2,500 tokens/s.
hours = (total_tokens / 2000) / 3600
stats = {
"examples": len(train), "val": len(val),
"by_category": dict(cnt), "by_source": {k: len(v) for k, v in by_source.items()},
"est_tokens": total_tokens, "est_tokens_by_category": dict(toks),
"est_train_hours_12b_a6000_1epoch": round(hours, 1),
"est_cost_usd_a6000": round(hours * 0.59, 2),
"duplicates_dropped": dict(dupes), "luau_compile_failures": dict(bad_luau),
"luau_checked": bool(args.luau), "errors": errors,
}
(out / "stats.json").write_text(json.dumps(stats, indent=2))
with open(out / "samples.md", "w", encoding="utf-8") as f:
for name, rs in by_source.items():
f.write(f"\n\n# {name} ({len(rs)})\n")
for r in rs[:2]:
for m in r["messages"]:
body = m.get("content") or ""
if m.get("tool_calls"):
body += "\n" + json.dumps([c["function"] for c in m["tool_calls"]])[:600]
f.write(f"\n**{m['role']}**: {body[:1500]}\n")
f.write("\n---\n")
ex_dir = out / "example_builds"
ex_dir.mkdir(exist_ok=True)
import re as _re
for name in sorted(LUAU_CHECKED):
for i, r in enumerate(by_source.get(name, [])[:4]):
code = _re.findall(r"```lua\n(.*?)```", r["messages"][-1]["content"], _re.DOTALL)
if code:
(ex_dir / f"{name}_{i}.luau").write_text(f"-- {r['messages'][1]['content'][:200]}\n{code[0]}")
(out / "build_log.txt").write_text("\n".join(log_lines))
print(json.dumps(stats, indent=2))
if __name__ == "__main__":
main()