"""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()