eval: per-cube records for the replay page

code/eval_value_search.py

@@ -44,6 +44,12 @@ def main():
     p.add_argument("--max-depth", type=int, default=26)
     p.add_argument("--limit-per-depth", type=int, default=25)
     p.add_argument("--depths", default="")
+    p.add_argument("--records", default="",
+                   help="Also write one JSON line per cube (depth, index, beam, "
+                        "moves, solved, seconds, states scored) to this path, and "
+                        "print each as a RECORD line. The totals alone cannot be "
+                        "uploaded: they do not say which cube failed or with what "
+                        "moves, and the first value-iteration sweep kept only them.")
     args = p.parse_args()
 
     import torch
@@ -72,6 +78,8 @@ def main():
                 seen[s["depth"]] += 1
         states = kept
 
+    rec_fh = open(args.records, "a") if args.records else None
+
     grid = [(b, l) for b in [int(x) for x in str(args.beam).split(",")]
                    for l in [float(x) for x in str(args.lam).split(",")]]
     for beam, lam in grid:
@@ -81,9 +89,23 @@ def main():
               flush=True)
         for s_ in states:
             t0 = time.time()
+            stats = {}
             moves = solve_value_beam(model, s_["facelets"], device, beam=beam,
-                                     max_depth=args.max_depth, lam=lam)
+                                     max_depth=args.max_depth, lam=lam, stats=stats)
             ok = bool(moves) and apply_sequence(s_["facelets"], moves) == SOLVED
+            if rec_fh:
+                rec = {"depth": s_["depth"], "index": s_["index"],
+                       "facelets": s_["facelets"], "beam": beam, "lam": lam,
+                       "max_depth": args.max_depth, "moves": moves, "solved": ok,
+                       "seconds": round(time.time() - t0, 3),
+                       "scored": stats.get("scored"), "steps": stats.get("steps"),
+                       "device": torch.cuda.get_device_name(0) if device == "cuda" else "cpu",
+                       # Fixed per cube, so the upload derives the same row id
+                       # from the same record however many times it is re-run.
+                       "finished_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())}
+                rec_fh.write(json.dumps(rec) + "\n")
+                rec_fh.flush()
+                print("RECORD " + json.dumps(rec), flush=True)
             b = by_depth[s_["depth"]]
             b[0] += ok
             b[1] += 1

code/search.py

@@ -89,13 +89,19 @@ def heuristic(model, states, device, batch_size=1024):
 
 
 def solve_value_beam(model, state, device, beam=64, max_depth=26, lam=0.0,
-                     batch_size=1024):
+                     batch_size=1024, stats=None):
     """Beam search over states, ranked by `h + lam * g`.
 
     Returns the move list that solves, or [] if the beam is exhausted. Visited
     states are tracked globally: revisiting one cannot help, and on a group this
     symmetric the frontier collapses onto duplicates quickly without it.
+
+    `stats`, when given a dict, receives `scored` (states the network evaluated)
+    and `steps` (levels expanded) -- the cost of the solve, which a replay page
+    can show beside the time.
     """
+    if stats is not None:
+        stats["scored"], stats["steps"] = 0, 0
     if state == SOLVED:
         return []
     frontier = [(state, [])]
@@ -116,6 +122,9 @@ def solve_value_beam(model, state, device, beam=64, max_depth=26, lam=0.0,
         if not children:
             return []
         h = heuristic(model, children, device, batch_size)
+        if stats is not None:
+            stats["scored"] += len(children)
+            stats["steps"] += 1
         scored = sorted(zip(h, children, paths), key=lambda x: x[0] + lam * len(x[2]))
         frontier = [(c, p) for _, c, p in scored[:beam]]
     return []

code/vast_bootstrap.sh

@@ -92,7 +92,14 @@ if [ -n "${EVAL_VALUE_ONLY:-}" ]; then
   /opt/venv/bin/python eval_value_search.py --value "$EVAL_VALUE_ONLY" \
     --value-file "${VALUE_FILE:-value.pt}" \
     --beam "${SEARCH_BEAM:-64}" --limit-per-depth "${SEARCH_N:-25}" \
-    ${SEARCH_DEPTHS:+--depths "$SEARCH_DEPTHS"} ${SEARCH_LAM:+--lam "$SEARCH_LAM"}
+    ${SEARCH_DEPTHS:+--depths "$SEARCH_DEPTHS"} ${SEARCH_LAM:+--lam "$SEARCH_LAM"} \
+    ${SEARCH_RECORDS:+--records "$SEARCH_RECORDS"}
+  # The per-cube records are the product of the run, so they leave the box before
+  # it can be destroyed. The RECORD lines in the log are the fallback copy.
+  if [ -n "${SEARCH_RECORDS:-}" ] && [ -n "${RECORDS_REPO:-}" ]; then
+    echo "=== pushing records to ${RECORDS_REPO} ==="
+    RR="$RECORDS_REPO" RF="$SEARCH_RECORDS" /opt/venv/bin/python -c 'import os; from huggingface_hub import HfApi; HfApi(token=os.environ["HF_TOKEN"]).upload_file(path_or_fileobj=os.environ["RF"], path_in_repo="eval/" + os.path.basename(os.environ["RF"]), repo_id=os.environ["RR"])'
+  fi
   echo "=== done ==="
   exit 0
 fi

code/vast_onstart.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+# What a rented box runs first. Give it to vast.ai as the instance's `onstart`
+# script, with `runtype: "ssh"` and a vastai/base-image, then let it fetch the
+# code and hand over to vast_bootstrap.sh.
+#
+# Two things this file exists to stop repeating.
+#
+# **`runtype: "args"` with an onstart script does not work.** vast hands the
+# script text to the container as its command, runc tries to exec it, and the
+# instance dies with "unable to start container process: exec:
+# #!/bin/bash\nexec > ...". A plain nvidia/cuda image has no vast entrypoint to
+# run an onstart script at all. Use a vastai/base-image and runtype "ssh"; the
+# box then runs this file for you.
+#
+# **Never let the shell trace expand HF_TOKEN.** `set -x` prints every expanded
+# word, so a bare `[ -z "$HF_TOKEN" ]` writes the token into the instance log in
+# clear text -- which is then readable through vast's log API and copied into
+# every archive made from it. That happened on 2026-09-16 and cost a token
+# rotation. Tracing goes off around anything that touches a secret.
+exec > >(tee -a /workspace/onstart.log) 2>&1
+set -x
+# vast writes API-supplied env vars here; onstart does not always inherit them.
+source /etc/environment 2>/dev/null || true
+
+set +x          # <-- nothing between here and `set -x` may reach the log
+if [ -z "${HF_TOKEN:-}" ]; then
+  echo "ABORT: HF_TOKEN not in environment"
+  exit 1
+fi
+set -x
+
+export DEBIAN_FRONTEND=noninteractive
+apt-get update -qq
+apt-get install -y -qq python3-pip python3-venv python3-dev build-essential curl git
+pip3 install --break-system-packages -q huggingface_hub
+
+# The repo is private, so a rented box cannot clone it. Code ships through the
+# model's own Hub repo instead, reusing the token the checkpoints already need.
+python3 - <<'PY'
+import os
+from huggingface_hub import snapshot_download
+print(snapshot_download(os.environ.get("CODE_REPO", "briscoooe/tiny-cube-value-iter"),
+                        allow_patterns=["code/*"], token=os.environ["HF_TOKEN"],
+                        local_dir="/workspace/hub"))
+PY
+
+# snapshot_download does not raise when the box cannot reach Hugging Face -- it
+# returns an empty local dir, so the run would exit 0 having done nothing. Check
+# for a file from the download, loudly.
+if [ ! -f /workspace/hub/code/vast_bootstrap.sh ]; then
+  echo "ABORT: vast_bootstrap.sh missing after download; this box cannot reach Hugging Face"
+  exit 1
+fi
+
+cp -r /workspace/hub/code /workspace/code
+cd /workspace/code
+echo "=== starting bootstrap ==="
+bash vast_bootstrap.sh
+echo "=== BOOTSTRAP EXITED $? ==="