Auto-sync: 2026-06-27 18:32:13 (part 2)

results/nonexpert_proposal_target_census.md

@@ -0,0 +1,38 @@
+# Non-Expert Proposal Target Census
+
+Dataset: `/scratch/knguy52/dovla/experiments/six_task_h16_collection`
+
+This census uses the per-task `record_index.jsonl` files and defines score as
+`reward_progress + 1(success)`, matching the trainer's reward score convention.
+
+## Candidate Counts
+
+| candidate type | records |
+|---|---:|
+| expert | 2,873 |
+| near_miss | 5,746 |
+| wrong_direction | 2,873 |
+| no_op | 2,873 |
+| wrong_gripper | 2,873 |
+| random_negative | 28,730 |
+
+## Best Candidate Per State
+
+| selection rule | expert | near_miss | wrong_direction | wrong_gripper | random_negative | no_op |
+|---|---:|---:|---:|---:|---:|---:|
+| best any | 1,244 | 988 | 134 | 97 | 258 | 152 |
+| best non-expert | 0 | 1,985 | 186 | 140 | 312 | 250 |
+| best non-expert and successful | 0 | 1,401 | 152 | 117 | 181 | 202 |
+
+## Experiment Implication
+
+The previous near-miss policy target covers the dominant useful non-expert
+proposal family, but the best non-expert action is not a `near_miss` in 888 of
+2,873 states. Job `14842574` trains `nonexpert_policy_bc5` to imitate the best
+non-expert local intervention using:
+
+`POLICY_TARGET_TYPES=near_miss,wrong_direction,wrong_gripper,random_negative,no_op`
+
+with `--loss-weight bc=5.0`. Jobs `14842575`/`14842576` evaluate and summarize
+direct `best_policy.pt` rollout, while `14842577`/`14842578` evaluate and
+summarize Gaussian field selection around `best.pt`.

results/paper_story_memo.md

@@ -0,0 +1,103 @@
+# DoVLA-CIL Paper Story Memo
+
+## One-Sentence Thesis
+
+DoVLA-CIL is a counterfactual action-selection framework: same-state intervention
+lattices expose a learnable local utility field, and the field only becomes useful
+when queried on proposal geometry that matches those local counterfactuals.
+
+## What The Current Evidence Supports
+
+| Claim | Evidence | Status |
+|---|---|---|
+| Longer horizon behavior cloning is not enough | h=16 direct policy is 29.74%, essentially h=4 baseline | Supported |
+| The learned field is not a generic off-manifold optimizer | Gaussian field search is 29.10% | Supported |
+| Generic action libraries do not explain the gain | nearest train-state retrieval lattice is 28.93%, no-expert retrieval is 27.13% | Supported |
+| Same-state local counterfactual proposals are the mechanism | near-miss-only lattice is 55.94%; removing expert+near_miss drops to 25.57% | Strongly supported |
+| Conservative same-state result is large | no-expert lattice is 56.99% vs 29.74% policy | Main result |
+| Full lattice gives upper result | full lattice is 69.33%, oracle is 86.78% | Strong but label expert proposal clearly |
+| Deployment-clean proposal is currently a bottleneck | best clean proposal+field sweep is 32.93%, far below 56.99% | Supported |
+| Gradient-based field optimization can solve the clean proposal gap | `field_optim` jobs are pending | Not yet known |
+| A broader non-expert proposal target can reduce the proposal gap | `nonexpert_policy_bc5` jobs are pending; target census shows 888/2873 states have best non-expert action outside `near_miss` | Not yet known |
+| Counterfactual residuals transfer better than absolute retrieved actions | `retrieval_residual` jobs are pending; absolute retrieval was 28.93% | Not yet known |
+
+## Main Table Candidate
+
+Use `scripts/build_paper_table_status.py` to regenerate
+`results/paper_table_status.md` after jobs finish. Until later jobs improve the
+clean proposal result, the intended main rows are:
+
+1. Direct h=16 policy: 29.74%
+2. Gaussian field search: 29.10%
+3. Retrieval lattice, no expert: 27.13%
+4. Near-miss proposal + field, BC x5 field checkpoint: 32.93%
+5. Lattice, near-miss only: 55.94%
+6. Lattice, no expert: 56.99%
+7. Lattice, full: 69.33%
+8. Oracle ceiling: 86.78%
+
+## Novelty Framing
+
+The novelty should not be framed as combining imitation learning, retrieval, and
+test-time search. The cleaner novelty is:
+
+- a data engine that measures many counterfactual interventions from the exact same
+  simulator state;
+- a path-independent field that scores action outcomes rather than imitating one
+  expert action;
+- a mechanism result showing that near-miss local counterfactuals are the minimal
+  proposal family that carries the rollout gain;
+- a proposal-bottleneck story: the learned field is strong, but only on local
+  intervention geometry.
+
+## Reviewer Risks
+
+| Risk | Current answer | Remaining work |
+|---|---|---|
+| Same-state lattice is not deployment-clean | show no-expert lattice and near-miss-only mechanism; show retrieval/Gaussian failures | improve clean proposal route |
+| Full lattice includes expert proposal | label as upper deployment/ceiling, not main conservative result | keep no-expert row as main |
+| Gains are from candidate leakage, not learning | selection never reads candidate rewards; no-expert and near-miss-only isolate mechanism | add field_optim/proposal model evidence |
+| Method is just a bundle of tricks | use mechanism ablations to show one central idea: local counterfactual field | avoid presenting unrelated variants as core |
+| Not SOTA enough | current clean deploy result is modest | need external baselines and stronger proposal generator before claiming SOTA |
+
+## Active Jobs
+
+Last checked: `2026-06-27 21:12 UTC`.
+
+- `14842523`: GPU smoke for `selection_mode=field_optim`.
+- `14842557`: low-resource CPU unit smoke for the pure action-optimization helper.
+- `14842528`: 4-config x 3-seed `field_optim` sweep, dependent on `14842523`.
+- `14842529`: sweep summary, dependent on `14842528`.
+- `14842551`: after-any fallback summary for partial sweep results.
+- `14842574`: train `nonexpert_policy_bc5` on best non-expert local interventions.
+- `14842575`: direct rollout eval for `nonexpert_policy_bc5`.
+- `14842616`: direct rollout summary.
+- `14842577`: field-selection sweep for `nonexpert_policy_bc5`.
+- `14842617`: field-selection summary.
+- `14842596`: smoke-test `retrieval_residual`, which translates nearest
+  train-state counterfactual residuals around the policy mean.
+- `14842597`: full `retrieval_residual` rollout after smoke.
+- `14842618`: `retrieval_residual` summary.
+- `14842609`: smoke-test `retrieval_residual` with `RETRIEVAL_NEIGHBORS=4`.
+- `14842610`: full KNN4 `retrieval_residual` rollout after smoke.
+- `14842619`: KNN4 `retrieval_residual` summary.
+- `14842646`: CPU unit smoke for the KNN residual helper.
+
+Current scheduler state: `14842523` is waiting on priority, and `14842557` is
+waiting for CPU nodes that are not down, drained, or reserved. The
+`nonexpert_policy_bc5` train array `14842574` is waiting on unavailable GPU
+nodes, and downstream jobs are waiting on dependencies.
+`14842596` is also waiting on currently unavailable GPU nodes; `14842597` and
+`14842618` are dependency-held.
+`14842609` is waiting on the same unavailable GPU nodes; `14842610` and
+`14842619` are dependency-held.
+`14842646` is waiting on unavailable CPU nodes.
+
+## Decision Rule For Field Optim Jobs
+
+- If `field_optim` beats 32.93% but remains below 40%, keep it as a better
+  deployment-clean positive control, not the main result.
+- If `field_optim` reaches 40-50%, promote it to the main clean-deployment bridge
+  and frame same-state lattice as mechanistic supervision/upper bound.
+- If `field_optim` fails or stays near 30%, keep it as a negative ablation and
+  prioritize training a proposal model on successful non-expert lattice candidates.

scripts/build_paper_table_status.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+
+RESULTS_DIR = Path("results")
+BASELINE_H16_POLICY = 0.29739130434782607
+
+
+@dataclass(frozen=True)
+class ResultSpec:
+    key: str
+    label: str
+    path: str
+    clean_deployment: str
+    same_state_proposals: str
+    expert_proposal: str
+    story_role: str
+    fallback_success: float | None = None
+    pending_job: str = ""
+
+
+SPECS = [
+    ResultSpec(
+        key="h16_policy",
+        label="Direct h=16 policy",
+        path="h16_policy_ckpt_summary.json",
+        clean_deployment="yes",
+        same_state_proposals="no",
+        expert_proposal="no",
+        story_role="behavior-cloning baseline",
+        fallback_success=0.29739130434782607,
+    ),
+    ResultSpec(
+        key="gaussian_field",
+        label="Gaussian field search",
+        path="h16_field_sweep_summary.json",
+        clean_deployment="yes",
+        same_state_proposals="no",
+        expert_proposal="no",
+        story_role="negative off-manifold field ablation",
+        fallback_success=0.2910,
+    ),
+    ResultSpec(
+        key="retrieval_lattice_no_expert",
+        label="Nearest train-state lattice, no expert",
+        path="h16_retrieval_lattice_no_expert_summary.json",
+        clean_deployment="yes",
+        same_state_proposals="no",
+        expert_proposal="no",
+        story_role="negative generic action-library ablation",
+        fallback_success=0.2713,
+    ),
+    ResultSpec(
+        key="near_miss_policy_bc5_field",
+        label="Near-miss proposal policy + field",
+        path="h16_policy_ckpt_near_miss_policy_bc5_bestpt_field_sweep_summary.json",
+        clean_deployment="yes",
+        same_state_proposals="no",
+        expert_proposal="no",
+        story_role="current best clean deployment bridge",
+        fallback_success=0.3293,
+    ),
+    ResultSpec(
+        key="field_optim",
+        label="Trust-region field optimization",
+        path="h16_field_optim_near_miss_policy_bc5_bestpt_s4_trust05_summary.json",
+        clean_deployment="yes",
+        same_state_proposals="no",
+        expert_proposal="no",
+        story_role="pending differentiable field-ascent bridge",
+        pending_job="14842528/14842551",
+    ),
+    ResultSpec(
+        key="nonexpert_policy_bc5",
+        label="Best non-expert proposal policy",
+        path="h16_policy_ckpt_nonexpert_policy_bc5_summary.json",
+        clean_deployment="yes",
+        same_state_proposals="no",
+        expert_proposal="no",
+        story_role="pending broader non-expert proposal model",
+        pending_job="14842574/14842575/14842616",
+    ),
+    ResultSpec(
+        key="nonexpert_policy_bc5_field",
+        label="Best non-expert proposal policy + field",
+        path="h16_policy_ckpt_nonexpert_policy_bc5_bestpt_field_sweep_summary.json",
+        clean_deployment="yes",
+        same_state_proposals="no",
+        expert_proposal="no",
+        story_role="pending broader proposal-field bridge",
+        pending_job="14842574/14842577/14842617",
+    ),
+    ResultSpec(
+        key="retrieval_residual",
+        label="Train-state counterfactual residual retrieval",
+        path="h16_policy_ckpt_near_miss_policy_bc5_bestpt_retrieval_residual_summary.json",
+        clean_deployment="yes",
+        same_state_proposals="no",
+        expert_proposal="no",
+        story_role="pending transferable local tangent proposal",
+        pending_job="14842596/14842597/14842618",
+    ),
+    ResultSpec(
+        key="retrieval_residual_knn4",
+        label="KNN counterfactual residual retrieval",
+        path="h16_policy_ckpt_near_miss_policy_bc5_bestpt_retrieval_residual_knn4_summary.json",
+        clean_deployment="yes",
+        same_state_proposals="no",
+        expert_proposal="no",
+        story_role="pending KNN tangent proposal",
+        pending_job="14842609/14842610/14842619",
+    ),
+    ResultSpec(
+        key="near_miss_only_lattice",
+        label="Same-state lattice, near-miss only",
+        path="h16_lattice_near_miss_only_v2_summary.json",
+        clean_deployment="no",
+        same_state_proposals="yes",
+        expert_proposal="no",
+        story_role="minimal mechanism result",
+        fallback_success=0.5594,
+    ),
+    ResultSpec(
+        key="no_expert_lattice",
+        label="Same-state lattice, no expert",
+        path="h16_lattice_no_expert_summary.json",
+        clean_deployment="no",
+        same_state_proposals="yes",
+        expert_proposal="no",
+        story_role="main conservative mechanism result",
+        fallback_success=0.5699,
+    ),
+    ResultSpec(
+        key="no_near_miss_no_expert_lattice",
+        label="Same-state lattice, no expert/no near-miss",
+        path="h16_lattice_no_near_miss_no_expert_v2_summary.json",
+        clean_deployment="no",
+        same_state_proposals="yes",
+        expert_proposal="no",
+        story_role="mechanism knockout",
+        fallback_success=0.2557,
+    ),
+    ResultSpec(
+        key="full_lattice",
+        label="Same-state lattice, full",
+        path="h16_lattice_summary.json",
+        clean_deployment="no",
+        same_state_proposals="yes",
+        expert_proposal="yes",
+        story_role="upper result with expert proposal",
+        fallback_success=0.6933,
+    ),
+]
+
+
+def main() -> int:
+    RESULTS_DIR.mkdir(exist_ok=True)
+    rows = [_row_for_spec(spec) for spec in SPECS]
+    payload = {
+        "baseline_h16_policy_success": BASELINE_H16_POLICY,
+        "rows": rows,
+        "best_clean": _best_row(rows, clean="yes"),
+        "best_mechanism_no_expert": _best_mechanism_row(rows),
+        "decision_notes": _decision_notes(rows),
+    }
+    json_path = RESULTS_DIR / "paper_table_status.json"
+    md_path = RESULTS_DIR / "paper_table_status.md"
+    json_path.write_text(json.dumps(payload, indent=2) + "\n")
+    md_path.write_text(_render_markdown(payload) + "\n")
+    print(f"Wrote {json_path}")
+    print(f"Wrote {md_path}")
+    return 0
+
+
+def _row_for_spec(spec: ResultSpec) -> dict[str, Any]:
+    path = RESULTS_DIR / spec.path
+    extracted = _extract_result(path) if path.exists() else {}
+    success = extracted.get("success", spec.fallback_success)
+    status = "complete" if path.exists() else ("fallback" if success is not None else "pending")
+    return {
+        **asdict(spec),
+        "path_exists": path.exists(),
+        "status": status,
+        "success": success,
+        "std_success": extracted.get("std_success"),
+        "completed_seeds": extracted.get("completed_seeds"),
+        "num_completed": extracted.get("num_completed"),
+        "best_config": extracted.get("best_config"),
+        "gain_vs_h16_policy": (success - BASELINE_H16_POLICY) if success is not None else None,
+    }
+
+
+def _extract_result(path: Path) -> dict[str, Any]:
+    data = json.loads(path.read_text())
+    output: dict[str, Any] = {}
+    if "mean_success" in data:
+        output["success"] = _float_or_none(data.get("mean_success"))
+        output["std_success"] = _float_or_none(data.get("std_success"))
+        output["num_completed"] = data.get("num_completed")
+    elif isinstance(data.get("best"), dict):
+        best = data["best"]
+        output["success"] = _float_or_none(best.get("mean_success"))
+        output["std_success"] = _float_or_none(best.get("std_success"))
+        output["completed_seeds"] = best.get("completed_seeds")
+        output["num_completed"] = best.get("num_completed")
+        output["best_config"] = best.get("config")
+    elif "policy_rollout_success_rate" in data:
+        output["success"] = _float_or_none(data.get("policy_rollout_success_rate"))
+        output["num_completed"] = data.get("num_groups")
+    return output
+
+
+def _float_or_none(value: Any) -> float | None:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _best_row(rows: list[dict[str, Any]], *, clean: str) -> dict[str, Any] | None:
+    completed = [
+        row
+        for row in rows
+        if row["clean_deployment"] == clean and row["success"] is not None
+    ]
+    return max(completed, key=lambda row: row["success"]) if completed else None
+
+
+def _best_mechanism_row(rows: list[dict[str, Any]]) -> dict[str, Any] | None:
+    candidates = [
+        row
+        for row in rows
+        if row["same_state_proposals"] == "yes"
+        and row["expert_proposal"] == "no"
+        and row["success"] is not None
+    ]
+    return max(candidates, key=lambda row: row["success"]) if candidates else None
+
+
+def _decision_notes(rows: list[dict[str, Any]]) -> list[str]:
+    by_key = {row["key"]: row for row in rows}
+    notes = [
+        "Use no-expert same-state lattice as the conservative mechanism result, not as deployment-clean inference.",
+        "Use full lattice only as an upper result because it includes expert proposals.",
+        "Do not claim external SOTA from this table alone; add current external baselines separately.",
+    ]
+    clean_best = _best_row(rows, clean="yes")
+    if clean_best is not None:
+        notes.append(
+            "Current best clean deployment row is "
+            f"{clean_best['label']} at {_fmt_percent(clean_best['success'])}."
+        )
+    for key in ("field_optim", "retrieval_residual", "retrieval_residual_knn4"):
+        row = by_key[key]
+        if row["success"] is None:
+            notes.append(f"{row['label']} is pending ({row['pending_job']}).")
+        elif row["success"] >= 0.40:
+            notes.append(f"{row['label']} is strong enough to promote as a clean bridge.")
+        elif row["success"] > 0.3293:
+            notes.append(f"{row['label']} improves the clean bridge but is not yet the main result.")
+        else:
+            notes.append(f"{row['label']} should be framed as a negative/diagnostic ablation.")
+    return notes
+
+
+def _render_markdown(payload: dict[str, Any]) -> str:
+    lines = [
+        "# Paper Table Status",
+        "",
+        f"Baseline h=16 policy: {_fmt_percent(payload['baseline_h16_policy_success'])}",
+        "",
+        "| key | method | status | success | gain vs h16 | clean | same-state props | expert prop | role |",
+        "|---|---|---|---:|---:|---|---|---|---|",
+    ]
+    for row in payload["rows"]:
+        lines.append(
+            "| {key} | {label} | {status} | {success} | {gain} | {clean} | {same} | {expert} | {role} |".format(
+                key=row["key"],
+                label=row["label"],
+                status=_status_text(row),
+                success=_fmt_percent(row["success"]),
+                gain=_fmt_signed_percent(row["gain_vs_h16_policy"]),
+                clean=row["clean_deployment"],
+                same=row["same_state_proposals"],
+                expert=row["expert_proposal"],
+                role=row["story_role"],
+            )
+        )
+    lines.extend(["", "## Decision Notes", ""])
+    for note in payload["decision_notes"]:
+        lines.append(f"- {note}")
+    return "\n".join(lines)
+
+
+def _status_text(row: dict[str, Any]) -> str:
+    if row["status"] == "pending":
+        return f"pending {row['pending_job']}".strip()
+    if row["status"] == "fallback":
+        return "fallback canonical"
+    if row.get("best_config"):
+        return f"complete {row['best_config']}"
+    return "complete"
+
+
+def _fmt_percent(value: float | None) -> str:
+    return "pending" if value is None else f"{100.0 * value:.2f}%"
+
+
+def _fmt_signed_percent(value: float | None) -> str:
+    return "pending" if value is None else f"{100.0 * value:+.2f} pp"
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/slurm/build_paper_table_status.sbatch

@@ -0,0 +1,18 @@
+#!/bin/bash
+#SBATCH --job-name=build_paper_table
+#SBATCH --account=def-yalda
+#SBATCH --time=00:05:00
+#SBATCH --cpus-per-task=1
+#SBATCH --mem=1G
+#SBATCH --output=outputs/hpc/logs/%x_%j.out
+#SBATCH --error=outputs/hpc/logs/%x_%j.err
+
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-$SLURM_SUBMIT_DIR}"
+PYTHON="${PYTHON:-python3}"
+
+cd "$PROJECT_DIR"
+mkdir -p outputs/hpc/logs results
+
+"$PYTHON" scripts/build_paper_table_status.py

scripts/slurm/eval_maniskill_policy_rollout_cpu_smoke.sbatch

@@ -0,0 +1,99 @@
+#!/bin/bash
+#SBATCH --job-name=dovla_ms_cpu_smoke
+#SBATCH --account=def-yalda
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=4
+#SBATCH --mem=16G
+#SBATCH --time=00:30:00
+#SBATCH --array=0-0
+#SBATCH --output=outputs/hpc/logs/%x_%A_%a.out
+#SBATCH --error=outputs/hpc/logs/%x_%A_%a.err
+
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-$SLURM_SUBMIT_DIR}"
+DATASET="${DATASET:?Set DATASET to a ManiSkill CIL dataset or collection}"
+SEED="${SLURM_ARRAY_TASK_ID:-0}"
+RUN_ROOT="${RUN_ROOT:-}"
+OBJECTIVE="${OBJECTIVE:-lattice_field}"
+CHECKPOINT_NAME="${CHECKPOINT_NAME:-best.pt}"
+OUT_NAME="${OUT_NAME:-policy_rollout_cpu_smoke.json}"
+if [[ -n "$RUN_ROOT" ]]; then
+  CHECKPOINT="${CHECKPOINT:-$RUN_ROOT/$OBJECTIVE/seed_$SEED/$CHECKPOINT_NAME}"
+  OUT="${OUT:-$RUN_ROOT/$OBJECTIVE/seed_$SEED/$OUT_NAME}"
+else
+  CHECKPOINT="${CHECKPOINT:?Set CHECKPOINT, or RUN_ROOT for seed-indexed array runs}"
+  OUT="${OUT:?Set OUT, or RUN_ROOT for seed-indexed array runs}"
+fi
+
+SCRATCH_ROOT="/scratch/$USER/dovla"
+SIF="${SIF:-$SCRATCH_ROOT/containers/pytorch_2.7.1_cuda12.8.sif}"
+PYTHON="${PYTHON:-$SCRATCH_ROOT/envs/maniskill/bin/python}"
+NATIVE_LIBS="$SCRATCH_ROOT/native_libs/lib"
+CPU_RENDER_LIBS="$SCRATCH_ROOT/cpu_render_libs"
+CA_BUNDLE="$SCRATCH_ROOT/ca-bundle.crt"
+VULKAN_ICD="$CPU_RENDER_LIBS/share/vulkan/icd.d/lvp_icd.x86_64.json"
+MAX_GROUPS="${MAX_GROUPS:-8}"
+GROUP_BATCH_SIZE="${GROUP_BATCH_SIZE:-2}"
+SIM_BACKEND="${SIM_BACKEND:-physx_cpu}"
+RENDER_BACKEND="${RENDER_BACKEND:-cpu}"
+ALL_GROUPS="${ALL_GROUPS:-0}"
+DEVICE="${DEVICE:-cpu}"
+SELECTION_MODE="${SELECTION_MODE:-field_optim}"
+NUM_CANDIDATES="${NUM_CANDIDATES:-4}"
+CANDIDATE_SIGMA="${CANDIDATE_SIGMA:-0.2}"
+SELECTION_SEED="${SELECTION_SEED:-0}"
+FIELD_OPTIM_STEPS="${FIELD_OPTIM_STEPS:-2}"
+FIELD_OPTIM_STEP_SIZE="${FIELD_OPTIM_STEP_SIZE:-0.05}"
+FIELD_OPTIM_TRUST_RADIUS="${FIELD_OPTIM_TRUST_RADIUS:-0.5}"
+FIELD_OPTIM_L2_PENALTY="${FIELD_OPTIM_L2_PENALTY:-0.02}"
+LATTICE_EXCLUDE_TYPES="${LATTICE_EXCLUDE_TYPES:-}"
+if [[ -n "${LATTICE_EXCLUDE_TYPES_COLON:-}" ]]; then
+  LATTICE_EXCLUDE_TYPES="${LATTICE_EXCLUDE_TYPES_COLON//:/,}"
+fi
+
+module load StdEnv/2023 apptainer/1.4.5
+cd "$PROJECT_DIR"
+mkdir -p outputs/hpc/logs "$(dirname "$OUT")"
+
+RUNTIME_DIR="/tmp/$USER/dovla-policy-rollout-cpu-$SLURM_JOB_ID-${SLURM_ARRAY_TASK_ID:-0}"
+CACHE_DIR="/tmp/$USER/dovla-policy-rollout-cpu-mesa-$SLURM_JOB_ID-${SLURM_ARRAY_TASK_ID:-0}"
+mkdir -p "$RUNTIME_DIR" "$CACHE_DIR"
+chmod 700 "$RUNTIME_DIR"
+
+export OMP_NUM_THREADS=1
+export OPENBLAS_NUM_THREADS=1
+export MKL_NUM_THREADS=1
+export DOVLA_TORCH_THREADS=1
+
+EXTRA_ARGS=()
+if [[ "$ALL_GROUPS" == "1" ]]; then
+  EXTRA_ARGS+=(--all-groups)
+fi
+if [[ "$MAX_GROUPS" != "all" ]]; then
+  EXTRA_ARGS+=(--max-groups "$MAX_GROUPS")
+fi
+
+apptainer exec \
+  --env "LD_LIBRARY_PATH=$CPU_RENDER_LIBS/lib:$NATIVE_LIBS,VK_ICD_FILENAMES=$VULKAN_ICD,VK_DRIVER_FILES=$VULKAN_ICD,XDG_RUNTIME_DIR=$RUNTIME_DIR,MESA_SHADER_CACHE_DIR=$CACHE_DIR,LIBGL_ALWAYS_SOFTWARE=1,LP_NUM_THREADS=1,SSL_CERT_FILE=$CA_BUNDLE,REQUESTS_CA_BUNDLE=$CA_BUNDLE,OMP_NUM_THREADS=1,OPENBLAS_NUM_THREADS=1,MKL_NUM_THREADS=1,DOVLA_TORCH_THREADS=1,MPLBACKEND=Agg,PYTHONDONTWRITEBYTECODE=1" \
+  -B "$PROJECT_DIR:$PROJECT_DIR" \
+  -B "/scratch/$USER:/scratch/$USER" \
+  "$SIF" "$PYTHON" scripts/eval_maniskill_policy_rollout.py \
+    --checkpoint "$CHECKPOINT" \
+    --dataset "$DATASET" \
+    --out "$OUT" \
+    --device "$DEVICE" \
+    --group-batch-size "$GROUP_BATCH_SIZE" \
+    --sim-backend "$SIM_BACKEND" \
+    --render-backend "$RENDER_BACKEND" \
+    --selection-mode "$SELECTION_MODE" \
+    --num-candidates "$NUM_CANDIDATES" \
+    --candidate-sigma "$CANDIDATE_SIGMA" \
+    --selection-seed "$SELECTION_SEED" \
+    --field-optim-steps "$FIELD_OPTIM_STEPS" \
+    --field-optim-step-size "$FIELD_OPTIM_STEP_SIZE" \
+    --field-optim-trust-radius "$FIELD_OPTIM_TRUST_RADIUS" \
+    --field-optim-l2-penalty "$FIELD_OPTIM_L2_PENALTY" \
+    --lattice-exclude-types "$LATTICE_EXCLUDE_TYPES" \
+    "${EXTRA_ARGS[@]}"

scripts/slurm/smoke_field_optim_unit.sbatch

@@ -0,0 +1,104 @@
+#!/bin/bash
+#SBATCH --job-name=smoke_field_optim
+#SBATCH --account=def-yalda
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH --mem=1G
+#SBATCH --time=00:05:00
+#SBATCH --output=outputs/hpc/logs/%x_%j.out
+#SBATCH --error=outputs/hpc/logs/%x_%j.err
+
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-$SLURM_SUBMIT_DIR}"
+SCRATCH_ROOT="/scratch/$USER/dovla"
+SIF="${SIF:-$SCRATCH_ROOT/containers/pytorch_2.7.1_cuda12.8.sif}"
+PYTHON="${PYTHON:-$SCRATCH_ROOT/envs/maniskill/bin/python}"
+
+module load StdEnv/2023 apptainer/1.4.5
+cd "$PROJECT_DIR"
+mkdir -p outputs/hpc/logs
+
+export OMP_NUM_THREADS=1
+export OPENBLAS_NUM_THREADS=1
+export MKL_NUM_THREADS=1
+export DOVLA_TORCH_THREADS=1
+
+apptainer exec \
+  --env "OMP_NUM_THREADS=1,OPENBLAS_NUM_THREADS=1,MKL_NUM_THREADS=1,DOVLA_TORCH_THREADS=1,PYTHONDONTWRITEBYTECODE=1" \
+  -B "$PROJECT_DIR:$PROJECT_DIR" \
+  -B "/scratch/$USER:/scratch/$USER" \
+  "$SIF" "$PYTHON" - <<'PY'
+import torch
+
+from dovla_cil.eval.maniskill_policy_rollout import _select_action_chunk
+
+
+class StubModel:
+    def __init__(self, mean, target):
+        self.mean = mean
+        self.target = target
+
+    def forward_policy(self, observation, instruction):
+        del observation, instruction
+        return self.mean
+
+    def forward_field(self, observation, instruction, action):
+        del observation, instruction
+        distance = ((action - self.target) ** 2).reshape(action.shape[0], -1).sum(dim=1)
+        return {"potential": -distance}
+
+
+mean = torch.zeros(1, 1, 3)
+target = torch.full_like(mean, 0.4)
+model = StubModel(mean, target)
+actions, index = _select_action_chunk(
+    model,
+    observations=torch.zeros(1, 3),
+    instructions=["smoke"],
+    torch=torch,
+    selection_mode="field_optim",
+    num_candidates=4,
+    candidate_sigma=0.2,
+    selection_seed=7,
+    field_optim_steps=6,
+    field_optim_step_size=0.1,
+    field_optim_trust_radius=0.5,
+    field_optim_l2_penalty=0.0,
+)
+before = float(((mean - target) ** 2).sum())
+after = float(((actions - target) ** 2).sum())
+assert after < before, (before, after, actions)
+assert index.shape == (1,)
+
+bounded_actions, _ = _select_action_chunk(
+    model,
+    observations=torch.zeros(1, 3),
+    instructions=["smoke"],
+    torch=torch,
+    selection_mode="field_optim",
+    num_candidates=4,
+    candidate_sigma=1.0,
+    selection_seed=11,
+    field_optim_steps=6,
+    field_optim_step_size=0.2,
+    field_optim_trust_radius=0.25,
+    field_optim_l2_penalty=0.0,
+    action_low=torch.full_like(mean, -0.5),
+    action_high=torch.full_like(mean, 0.5),
+)
+assert float(bounded_actions.max()) <= 0.250001, bounded_actions
+assert float(bounded_actions.min()) >= -0.250001, bounded_actions
+
+print(
+    {
+        "status": "ok",
+        "before": before,
+        "after": after,
+        "selected_index": index.tolist(),
+        "bounded_max": float(bounded_actions.max()),
+        "bounded_min": float(bounded_actions.min()),
+    }
+)
+PY

scripts/slurm/smoke_retrieval_residual_unit.sbatch

@@ -0,0 +1,128 @@
+#!/bin/bash
+#SBATCH --job-name=smoke_retrieval_residual
+#SBATCH --account=def-yalda
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=1
+#SBATCH --mem=1G
+#SBATCH --time=00:05:00
+#SBATCH --output=outputs/hpc/logs/%x_%j.out
+#SBATCH --error=outputs/hpc/logs/%x_%j.err
+
+set -euo pipefail
+
+PROJECT_DIR="${PROJECT_DIR:-$SLURM_SUBMIT_DIR}"
+SCRATCH_ROOT="/scratch/$USER/dovla"
+SIF="${SIF:-$SCRATCH_ROOT/containers/pytorch_2.7.1_cuda12.8.sif}"
+PYTHON="${PYTHON:-$SCRATCH_ROOT/envs/maniskill/bin/python}"
+
+module load StdEnv/2023 apptainer/1.4.5
+cd "$PROJECT_DIR"
+mkdir -p outputs/hpc/logs
+
+export OMP_NUM_THREADS=1
+export OPENBLAS_NUM_THREADS=1
+export MKL_NUM_THREADS=1
+export DOVLA_TORCH_THREADS=1
+
+apptainer exec \
+  --env "OMP_NUM_THREADS=1,OPENBLAS_NUM_THREADS=1,MKL_NUM_THREADS=1,DOVLA_TORCH_THREADS=1,PYTHONDONTWRITEBYTECODE=1" \
+  -B "$PROJECT_DIR:$PROJECT_DIR" \
+  -B "/scratch/$USER:/scratch/$USER" \
+  "$SIF" "$PYTHON" - <<'PY'
+from pathlib import Path
+from types import SimpleNamespace
+
+import numpy as np
+
+from dovla_cil.data.schema import ActionChunk
+from dovla_cil.eval.maniskill_policy_rollout import (
+    _RolloutCase,
+    _attach_retrieved_residual_candidates,
+    _selected_candidate_type,
+)
+
+
+def record(group_id: str, candidate_type: str, action_value: float, feature: float):
+    return SimpleNamespace(
+        group_id=group_id,
+        task_id="PickCube-v1",
+        candidate_type=candidate_type,
+        record_id=f"{group_id}-{candidate_type}-{action_value}",
+        observation_inline={"features": [feature, 0.0]},
+        action_chunk=ActionChunk(
+            representation="continuous",
+            horizon=1,
+            values=[[action_value, 0.0]],
+        ),
+    )
+
+
+dataset = SimpleNamespace(
+    group_ids=["train_a", "train_b", "heldout"],
+    get_group=lambda group_id: {
+        "train_a": [
+            record("train_a", "expert", 1.0, 0.0),
+            record("train_a", "near_miss", 1.2, 0.0),
+        ],
+        "train_b": [
+            record("train_b", "expert", -1.0, 0.4),
+            record("train_b", "wrong_direction", -1.3, 0.4),
+        ],
+        "heldout": [
+            record("heldout", "expert", 9.0, 0.1),
+            record("heldout", "near_miss", 9.9, 0.1),
+        ],
+    }[group_id],
+)
+case = _RolloutCase(
+    group_id="heldout",
+    task_id="PickCube-v1",
+    source_dataset=Path("."),
+    state={},
+    observation={"features": [0.1, 0.0]},
+    instruction="pick",
+    oracle_score=1.0,
+    oracle_success=True,
+    expert_score=1.0,
+    expert_success=True,
+    best_action_values=[[9.9, 0.0]],
+    candidate_action_values=[],
+    candidate_types=[],
+)
+
+[attached] = _attach_retrieved_residual_candidates(
+    dataset,
+    [case],
+    heldout_group_ids=["heldout"],
+    obs_dim=2,
+    observation_mode="state",
+    retrieval_neighbors=2,
+)
+
+expected_values = np.asarray(
+    [[[0.0, 0.0]], [[0.2, 0.0]], [[0.0, 0.0]], [[-0.3, 0.0]]],
+    dtype=np.float32,
+)
+actual_values = np.asarray(attached.candidate_action_values, dtype=np.float32)
+assert attached.candidate_source_group_id == "train_a;train_b"
+assert attached.candidate_types == [
+    "policy_residual",
+    "residual_near_miss",
+    "policy_residual",
+    "residual_wrong_direction",
+]
+assert np.allclose(actual_values, expected_values), actual_values
+assert (
+    _selected_candidate_type(attached, selected_index=3, selection_mode="retrieval_residual")
+    == "retrieval_residual_residual_wrong_direction"
+)
+print(
+    {
+        "status": "ok",
+        "candidate_source_group_id": attached.candidate_source_group_id,
+        "candidate_types": attached.candidate_types,
+        "candidate_values": actual_values.tolist(),
+    }
+)
+PY