scripts/prepare_rgbd_pretrained_v31.py
#!/usr/bin/env python3
"""Freeze EXP-3D-RGBD-PRETRAINED-FEATURES-V31: arm P, the V17 L recipe with frozen DINOv2 features.
P runs the V17 L recipe in its own V17-style root outputs/EXP-3D-RGBD-PRETRAINED-FEATURES-V31/P/
EXP-3D-RGBD-LONG-TRAIN-V17, made by the frozen V17 prepare (as V21 made G1 and V26 made GF). That
prepare locks every src file, so the V31 carrier module is in the root's lock; the V31 training and
EVAL scripts (the V17 scripts with the carrier module swapped) and the backbone weights and code
archive are added to it. The contract records GPU 4, TF32 off and the backbone. GPU training is not
bit-reproducible, so the control file the frozen V17 EVAL code requires says NOT_APPLICABLE_GPU.
The comparison arm is V21's G1 (same recipe on GPU 4, no pretrained features), checked unchanged
here. Then V31's freeze record (freeze.json) holds every hash, before any V31 training.
Run from the repository root under cv_host_run.py (records store zonghan_o paths).
"""
from __future__ import annotations
import datetime
import hashlib
import importlib.util
import json
import shutil
from pathlib import Path
from mcss.mechanism_pilot import rgbd_pretrained_carrier as v31
from mcss.mechanism_pilot.geometry_carrier_experiment import verify_lock
V31 = Path("outputs/EXP-3D-RGBD-PRETRAINED-FEATURES-V31")
PLAN = V31 / "PLAN_BEFORE_V31.md"
PLAN_SHA256 = "82ff870d3a234445ddee9aae178338fd22e87fda98bd5fb2202480b6eb95b85a"
V17 = Path("outputs/EXP-3D-RGBD-LONG-TRAIN-V17")
V17_PREREGISTRATION_SHA256 = "36b8aa6e4e527025d3746aa7af5ffc060fbf7683fc1a26ff50a94e3c744c1d1f"
V21 = Path("outputs/EXP-3D-RGBD-SEGMENT-DIVERSITY-V21")
V17_NAME = "EXP-3D-RGBD-LONG-TRAIN-V17"
ARM = "P"
GPU = "4"
MODULE = Path("src/mcss/mechanism_pilot/rgbd_pretrained_carrier.py")
TRAIN_SCRIPT = Path("scripts/train_rgbd_pretrained_v31.py")
EVAL_SCRIPT = Path("scripts/evaluate_rgbd_pretrained_eval_v31.py")
BACKBONE_FILES = (
v31.MODELS / v31.BACKBONE["weights"],
v31.MODELS / f"dinov2_{v31.BACKBONE['code_commit']}.zip",
)
SCRIPTS = (
Path("scripts/prepare_rgbd_pretrained_v31.py"),
TRAIN_SCRIPT,
EVAL_SCRIPT,
MODULE,
Path("scripts/run_rgbd_pretrained_v31.sh"),
Path("scripts/eval_rgbd_pretrained_v31.sh"),
Path("scripts/analyze_rgbd_pretrained_v31.py"),
Path("scripts/train_rgbd_long_train_carrier.py"),
Path("scripts/evaluate_rgbd_long_train_eval.py"),
Path("scripts/run_rgbd_geometric_baselines.py"),
Path("scripts/run_rgbd_inpaint_baselines.py"),
Path.home() / "cv_tools/fp32_run.py",
Path.home() / "cv_tools/cv_gpu_run.sh",
Path.home() / "cv_tools/cv_host_run.py",
)
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def read(path):
return json.loads(Path(path).read_text())
def write(path, value):
Path(path).parent.mkdir(parents=True, exist_ok=True)
Path(path).write_text(json.dumps(value, indent=2, sort_keys=True) + "\n")
def module(name, path):
spec = importlib.util.spec_from_file_location(name, path)
loaded = importlib.util.module_from_spec(spec)
spec.loader.exec_module(loaded)
return loaded
def control_arm():
"""V21's G1: finished, unchanged since V21's freeze, with all four EVAL cohorts scored."""
freeze = read(V21 / "freeze.json")
root = Path(freeze["arms"]["G1"]["root"])
if sha(root / "preregistration.json") != freeze["arms"]["G1"]["preregistration_sha256"]:
raise PermissionError("V21 G1 lock changed")
if read(V21 / "results.json").get("INTERPRETATION_BRANCH") is None:
raise PermissionError("V21 must be analyzed")
for seed in (20260928, 20260929, 20260930):
summary = read(root / "checkpoints" / f"L_{seed}" / "summary.json")
if summary["status"] != "COMPLETE" or summary["steps"] != 24000:
raise PermissionError(f"V21 G1 seed {seed} incomplete")
for cohort in ("EVAL_V3", "EVAL_V4", "EVAL_FAR", "FRESH_V2"):
if not (root / "raw/eval" / cohort / "prediction_seal.json").is_file():
raise PermissionError(f"V21 G1 lacks the {cohort} seal")
return root
def make_arm(prepare_v17):
root = (V31 / ARM / V17_NAME).resolve()
if root.exists():
raise FileExistsError(root)
root.mkdir(parents=True)
for name in ("PLAN_BEFORE_V17_TRAINING.md", "PROTOCOL.md"):
shutil.copyfile(V17 / name, root / name)
prepare_v17(root)
contract = read(root / "training_contract.json")
contract.update(
device="cuda",
gpu=GPU,
tf32="off (NVIDIA_TF32_OVERRIDE=0 and the fp32 launcher)",
v31_arm=ARM,
pretrained_features={
"backbone": v31.BACKBONE,
"projected_channels": v31.PROJECTED,
"projection_seed_offset": v31.PROJECTION_SEED_OFFSET,
"rule": "per view: frozen DINOv2 patch tokens -> learned 384->24 projection -> "
"bilinear resize to the frame, after the 8 learned channels; the lifted mean and "
"variance of the 24 channels enter the fuse pre-activation through a zero-initialized "
"bias-free 48->64 map (the V17 L draw at initialization)",
"module": str(MODULE),
"training_script": str(TRAIN_SCRIPT),
"evaluation_script": str(EVAL_SCRIPT),
},
execution="three trainings concurrently on GPU 4 through cv_gpu_run.sh; EVAL on CPU, AVX2",
)
write(root / "training_contract.json", contract)
write(
root / "audit/v11_prefix_control.json",
{
"status": "PASS",
"meaning": "NOT_APPLICABLE_GPU",
"note": "V31 GPU arm: GPU training is not bit-reproducible (HIT-REPRO-V1), so the V17 "
"built-in control cannot apply; this file only lets the V17 EVAL code run",
},
)
write(root / "tests.json", read(V31 / "tests.json"))
lock = read(root / "preregistration.json")
key = str((root / "training_contract.json").resolve())
if key not in lock["input_sha256"]:
raise KeyError(key)
if lock["source_sha256"].get(str(MODULE.resolve())) != sha(MODULE):
raise PermissionError("The V17 prepare did not lock the V31 carrier module")
lock["input_sha256"][key] = sha(root / "training_contract.json")
for path in (TRAIN_SCRIPT, EVAL_SCRIPT):
lock["source_sha256"][str(path.resolve())] = sha(path)
for path in BACKBONE_FILES:
lock["input_sha256"][str(path)] = sha(path)
lock["v31"] = {
"arm": ARM,
"plan_sha256": PLAN_SHA256,
"rewritten": ["training_contract.json"],
"added_sources": [str(TRAIN_SCRIPT), str(EVAL_SCRIPT)],
"added_inputs": [str(path) for path in BACKBONE_FILES],
}
write(root / "preregistration.json", lock)
return root
def main():
if sha(PLAN) != PLAN_SHA256:
raise PermissionError("The V31 plan changed")
if sha(V17 / "preregistration.json") != V17_PREREGISTRATION_SHA256:
raise PermissionError("V17 is not the frozen V17")
if read(V31 / "tests.json")["status"] != "PASS":
raise PermissionError("The full suite must PASS before the V31 freeze")
if (V31 / "freeze.json").exists():
raise FileExistsError("V31 is frozen once")
v31.load_backbone("cpu") # every backbone hash is checked here
g1 = control_arm()
v17_prepare = module("v17_prepare", "scripts/prepare_rgbd_long_train_experiment.py")
root = make_arm(v17_prepare.prepare)
manifest, config = verify_lock(root)
print(ARM, "train records", len(config["train_sets"]["TRAIN72"]), "steps", config["steps"])
write(
V31 / "freeze.json",
{
"status": "FROZEN_BEFORE_V31_TRAINING",
"frozen_utc": datetime.datetime.now(datetime.UTC).isoformat(),
"plan_sha256": PLAN_SHA256,
"backbone": v31.BACKBONE,
"projected_channels": v31.PROJECTED,
"arms": {
ARM: {
"root": str(root),
"preregistration_sha256": sha(root / "preregistration.json"),
"training_contract_sha256": sha(root / "training_contract.json"),
},
"G1": {
"root": str(g1),
"preregistration_sha256": sha(g1 / "preregistration.json"),
"source": "V21 (finished)",
},
},
"v17_preregistration_sha256": V17_PREREGISTRATION_SHA256,
"scripts_sha256": {str(p): sha(p) for p in SCRIPTS},
"tests_sha256": sha(V31 / "tests.json"),
},
)
print("V31_FROZEN", str(root))
if __name__ == "__main__":
main()