beyarkay's picture
Handoff note
fb4bb78 verified
|
Raw History Blame Contribute Delete
6.12 kB

Handoff: human-factory training data (functional windows)

For the session picking this up on the M1 Mac. Everything persistent is in two places:

  • Code: branch blueprint-corpus, PR #501, head 0596291. All tests pass.
  • Data: HF dataset beyarkay/factorio-blueprints. It's public; the write token is the user's.

Nothing from the old cloud container is needed.

What exists

Where What
corpus/convert.py edit turns a save region's 30×30 interior into a working 32×32 factory: sources and sinks where flows leave it, of the item the save saw on the belt. paste rebuilds a window from its edits. functional is the SFT stream (random turn and mirror).
corpus/windows.py The precompute: one windows/<save>.parquet per input file. It resumes, skipping files already written, and keeps only windows that deliver anything. Columns: crafted, delivered.
sft.py --windows-frac F mixes F of functional windows into every batch. val/human/thput@N is the generation eval on the windows of the 5% of saves held out (convert.held_out(save, 20)).
ci/ /ci sft takes --windows-frac, --corpus-frac and --lr.
HF designs/ Every design (unchanged). Windows join to it on layout_hash.
HF windows/ Precomputed windows of 164 of ~1,425 lane-labelled save files.
HF raw_lanes/ One *.jsonl.gz per save: scraped-style records with each region's string, unbuildable and lanes ([x, y, line, "item,…"], line 1 = left lane). 1,425 files.
HF scripts/saves/ relabel.py (the re-export: download → check → extract with belt contents → delete, one save at a time), plus fetch_saves.py and save_meta.py. relabel_state/ holds the candidate lists (relabel_part_00..02, 2,083 saves in total) and the done lists (relabel_done_0..2.jsonl, 1,447 done).
HF scripts/flow_debug/ Scratch scripts for renders and A/B checks. render_ported.py renders 12 random windows; ab.py compares two builder versions on the same views; dump.py dumps one window with its surroundings. They use the prototype functional.py only for its sample().

Jobs to resume

1. Window precompute over all of raw_lanes/. About 30 ms per window, ~18 windows per region. Use every core:

uv sync && uv run maturin develop --release --manifest-path factorion_rs/Cargo.toml
huggingface-cli download beyarkay/factorio-blueprints --repo-type dataset --include "raw_lanes/*" "windows/*" --local-dir hf
uv run python -m corpus.windows hf/raw_lanes/*.jsonl.gz --out hf --procs $(sysctl -n hw.ncpu)
# then upload hf/windows to the dataset's windows/ (corpus.windows --repo, or HfApi.upload_folder)

Expect roughly 240k windows with machine output, from ~1,400 saves.

2. Lane re-export of the remaining ~640 saves (optional; the ~1,400 done are enough for the sweep).

  • It needs Factorio, and the free headless server is Linux x64 only. On the Mac, either:

    • point corpus/extract_saves.py's FACTORIO / FACTORIO_EXPERIMENTAL at the macOS app binary (full game with Space Age; untested), or
    • run the Linux headless server in Docker (--platform linux/amd64).
  • Run three pipelines on ports 27300/27310/27320, each reading one candidate part on stdin:

    python relabel.py <dl_dir> <out_dir> relabel_done_i.jsonl <port> < relabel_part_0i
    

    Each save's records are written atomically to their own file, and the done list makes it resumable.

Results so far

Two 1M-sample SFT runs, one seed each, at the same commit:

Run val/thput@8 val/trial_thput@8 Human eval
25% windows i2t3fu8g 0.223 0.010 0.86
Baseline 41ciydxe 0.373 0.079 1.41 (scored offline)
  • The windows run is worse even at equal synthetic samples.
  • The human eval doesn't measure what we want. Only 17% of held-out windows have machine output; the rest are belt routing. And 16% of each window's sinks get nothing in the human build, so a model that feeds them beats the human score.

Decided

Next experiment: a human share × LR sweep at 5M samples, human data mixed into every batch (not phased).

  • Proposed grid: share {0, 0.25, 0.5} × LR {5e-4, 1e-3, 1.5e-3 (default), 3e-3}, 12 runs, ~55 GPU-hours on an A4000.
  • Don't launch until the user approves the details.

Before the sweep:

  1. Finish the precompute (job 1). Today's 26.6k machine windows would be seen ~47–94 times each at 25–50% human.
  2. Train only on windows with machine output (crafted > 0).
  3. Fix the human eval: hold out only machine windows, and keep only the sinks of items those machines make, so feeding raw items to sinks earns nothing.

Known issues

  • Loops: any cycle in the flow graph makes the engine score the whole factory 0 (throughput.rs::calc_throughput). That loses belt balancers and platform loops, about 4% of windows; they're filtered out today. There's a separate task, "Make the throughput engine handle belt loops".
  • Labels: a source carries one item, so a lane the save saw empty (e.g. starved steel) leaves its machines unfed. Example: low-density-structure rows.
  • Space platforms with no poles come out unpowered. Unverified whether platforms need poles in the game.
  • Marker clutter: some windows have 50–150 markers (inserter grids into masked entities).
  • CPU smoke tests: sft.py refuses CPU unless CI=1. A script that starts DataLoader workers needs an if __name__ == "__main__": guard.

The user's standing preferences for this work

  • After each builder change, render 12 randomly sampled windows (not filtered on success) for spot-checks. They have a low bar for checking against the real game.
  • No GPU runs without approval; keep runs short while bugs remain.
  • Per CLAUDE.md: small commits, minimal diffs, end-to-end tests, and the full checklist before pushing.