Files
SkillFactory/tests/test_contact_cycle_sim_replay.py
chenlin 9fe9d27865 feat: checkpoint contact-cycle evaluation and RootXY PPO progress
Consolidate next-stage docs, archive superseded narratives, and preserve frozen document inputs. Retain invalid P2 pairs, partial RootXY training, failed attempts and nonselectable checkpoints as explicit limitations.

Include supervised evaluation/training, desktop GPU admission, bounded evidence and atomic-publication monitor repairs with CPU regressions. Ignore local dotenv configuration.

Validation: 1403 passed, 6 skipped for contact-cycle and related contracts/CLI tests. Full-suite legacy ABI and registration tests require Python 3.12/Torch 2.10/pxr; no runtime checks relaxed. No new physical run or accepted skill.
2026-10-15 14:18:17 +08:00

439 lines
22 KiB
Python

"""CPU-only frozen replay interfaces and failure artifacts; no Kit or optimizer."""
import copy
import importlib.util
import json
import sys
from pathlib import Path
from types import SimpleNamespace
import pytest
import torch
from SkillFactory.legs.contact_cycle_sim import replay
from SkillFactory.legs.contact_cycle_sim.model import SimResidualActorCritic
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "scripts"))
import replay_cycle_sim_residual as cli
@pytest.fixture(autouse=True)
def cpu_only(monkeypatch):
old = torch.get_num_threads()
torch.set_num_threads(1)
def forbidden(*args, **kwargs):
raise AssertionError("Optimizer construction is forbidden in frozen replay")
monkeypatch.setattr(torch.optim.Adam, "__init__", forbidden)
yield
torch.set_num_threads(old)
def write_json(path, data):
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(json.dumps(data))
@pytest.fixture
def bundle(tmp_path, monkeypatch):
"""Synthetic trusted root; production CLI never exposes hash override flags."""
root, prepared = tmp_path / "repo", tmp_path / "frozen"
root.mkdir()
prepared.mkdir()
config_path = "configs/contact_cycle/simulation_residual_v1.json"
files = {"AGENT.md": b"instructions", "source/runtime.py": b"runtime",
config_path: (ROOT / config_path).read_bytes()}
for relative, payload in files.items():
for base in (root, prepared / "source_snapshot"):
path = base / relative
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(payload)
for relative in replay.REPLAY_SOURCES:
path = root / relative
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text("synthetic replay source")
manifest = {"contract": replay.CONTRACT, "task_id": replay.TASK_ID,
"features": replay.FEATURE_VERSION, "model_config": replay.MODEL_CONFIG,
"training": {"task_config": config_path},
"sources": {p: replay.sha256(v) for p, v in files.items()}}
write_json(prepared / "manifest.json", manifest)
monkeypatch.setattr(replay, "MANIFEST_SHA256", replay.sha256(replay.canonical(manifest).encode()))
policy = SimResidualActorCritic(**replay.MODEL_CONFIG)
with torch.no_grad():
policy.actor[-1].bias.copy_(torch.tensor([.1, -.2, .3]))
data = {"format": replay.CHECKPOINT_FORMAT, "contract": replay.CONTRACT,
"features": replay.FEATURE_VERSION, "model_config": replay.MODEL_CONFIG,
"update": 256, "accepted_skill": False, "model": policy.state_dict(),
"identity": {"manifest": manifest, "model_config": replay.MODEL_CONFIG, "seed": 91501},
"optimizer": {"ignored": "must never instantiate or restore"},
"rng": {"ignored": "must never restore"}}
checkpoint = prepared / "candidate_u0256.pt"
torch.save(data, checkpoint)
monkeypatch.setattr(replay, "CANDIDATE_SHA256", replay.sha256(checkpoint.read_bytes()))
monkeypatch.setattr(cli, "ROOT", root)
return SimpleNamespace(root=root, prepared=prepared, checkpoint=checkpoint, manifest=manifest, data=data)
def test_frozen_loading_is_inference_only_and_deterministic(bundle):
before = bundle.checkpoint.read_bytes()
manifest, binding = replay.verify_bundle(bundle.root, bundle.checkpoint)
rng = torch.get_rng_state().clone()
policy = replay.load_frozen_policy(bundle.checkpoint, manifest)
assert torch.equal(rng, torch.get_rng_state())
assert not policy.training and not any(p.requires_grad for p in policy.parameters())
x = torch.zeros(2, 46)
action, mean, std = replay.inference_action(x, "learned", policy)
assert torch.equal(action, policy.act(x, deterministic=True)[0])
assert torch.equal(action, mean.tanh()) and action.any() and std.shape == (3,)
assert not action.requires_grad
assert torch.equal(action, replay.inference_action(x, "learned", policy)[0])
assert bundle.checkpoint.read_bytes() == before
assert binding["snapshot_files_verified"] == 3 and not binding["live_source_exceptions"]
assert set(binding["replay_sources"]) == set(replay.REPLAY_SOURCES)
def test_agent_live_drift_is_the_only_explicit_exception(bundle):
(bundle.root / "AGENT.md").write_text("changed live instructions")
_, binding = replay.verify_bundle(bundle.root, bundle.checkpoint)
exception, = binding["live_source_exceptions"]
assert exception["path"] == "AGENT.md" and exception["reason"]
assert exception["snapshot_sha256"] == bundle.manifest["sources"]["AGENT.md"]
assert exception["live_sha256"] == replay.sha256(b"changed live instructions")
@pytest.mark.parametrize("relative", ["AGENT.md", "source/runtime.py",
"configs/contact_cycle/simulation_residual_v1.json"])
def test_any_snapshot_tampering_fails_including_agent(bundle, relative):
(bundle.prepared / "source_snapshot" / relative).write_text("tampered")
with pytest.raises(ValueError, match="snapshot mismatch"):
replay.verify_bundle(bundle.root, bundle.checkpoint)
@pytest.mark.parametrize("relative", ["source/runtime.py", "configs/contact_cycle/simulation_residual_v1.json"])
def test_live_runtime_and_config_drift_fail_closed(bundle, relative):
(bundle.root / relative).write_text("changed")
with pytest.raises(ValueError, match="Live bound source/config mismatch"):
replay.verify_bundle(bundle.root, bundle.checkpoint)
def test_manifest_tampering_rejected(bundle):
write_json(bundle.prepared / "manifest.json", {**bundle.manifest, "features": "policy32"})
with pytest.raises(ValueError, match="manifest SHA256"):
replay.verify_bundle(bundle.root, bundle.checkpoint)
def test_candidate_sha_checked_before_deserialization(bundle, monkeypatch):
bundle.checkpoint.write_bytes(b"not the frozen candidate")
monkeypatch.setattr(torch, "load", lambda *a, **k: pytest.fail("Must verify SHA before deserialization"))
with pytest.raises(ValueError, match="candidate SHA256"):
replay.load_frozen_policy(bundle.checkpoint, bundle.manifest)
with pytest.raises(ValueError, match="candidate SHA256"):
replay.verify_bundle(bundle.root, bundle.checkpoint)
@pytest.mark.parametrize("fault", ["legacy", "features32", "update0", "update_bool", "model_config",
"manifest", "seed", "shape32", "dtype", "nan", "normalization", "keys"])
def test_checkpoint_contract_rejects_incompatible_payload(bundle, monkeypatch, fault):
data = copy.deepcopy(bundle.data)
if fault == "legacy":
data["format"] = "old32"
elif fault == "features32":
data["features"] = "policy32"
elif fault == "update0":
data["update"] = 0
elif fault == "update_bool":
data["update"] = True
elif fault == "model_config":
data["model_config"]["hidden"] = 32
elif fault == "manifest":
data["identity"]["manifest"] = {}
elif fault == "seed":
data["identity"]["seed"] = 1
elif fault == "shape32":
data["model"]["actor.0.weight"] = torch.zeros(128, 32)
elif fault == "dtype":
data["model"]["actor.0.weight"] = data["model"]["actor.0.weight"].double()
elif fault == "nan":
data["model"]["actor.0.bias"][0] = float("nan")
elif fault == "normalization":
data["model"]["scale"][0] += 1
else:
del data["model"]["log_std"]
torch.save(data, bundle.checkpoint)
monkeypatch.setattr(replay, "CANDIDATE_SHA256", replay.sha256(bundle.checkpoint.read_bytes()))
with pytest.raises(ValueError):
replay.load_frozen_policy(bundle.checkpoint, bundle.manifest)
@pytest.mark.parametrize("shape,dtype", [((1, 32), torch.float32), ((0, 46), torch.float32),
((1, 46), torch.float64), ((46,), torch.float32)])
def test_invalid_observation_never_migrated(shape, dtype):
with pytest.raises(ValueError, match="46"):
replay.inference_action(torch.zeros(shape, dtype=dtype), "reference")
def test_invalid_actions_and_missing_policy_never_fall_back():
x = torch.zeros(1, 46)
with pytest.raises(ValueError, match="fallback"):
replay.inference_action(x, "learned")
for action in (None, [float("nan"), 0, 0], [float("inf"), 0, 0], [1.01, 0, 0], [0, 0]):
with pytest.raises(ValueError, match="Script requires"):
replay.inference_action(x, "script", script_action=action)
x[0, 0] = float("nan")
with pytest.raises(ValueError):
replay.inference_action(x, "reference")
def test_controller_identity_cannot_confuse_script_reference_and_learned():
identities = [replay.controller_identity("learned"), replay.controller_identity("reference"),
replay.controller_identity("script", [.5, 0, -.5])]
assert len({row["controller_kind"] for row in identities}) == 3
assert [row["trained_residual_policy"] for row in identities] == [True, False, False]
assert all(row["optimizer_steps"] == 0 and not row["accepted_skill"] for row in identities)
x = torch.zeros(2, 46)
assert not replay.inference_action(x, "reference")[0].any()
assert torch.equal(replay.inference_action(x, "script", script_action=[.5, 0, -.5])[0],
torch.tensor([[.5, 0, -.5]]).expand(2, 3))
with pytest.raises(ValueError):
replay.inference_action(x, "reference", policy=object())
with pytest.raises(ValueError):
replay.controller_identity("learned", [0, 0, 0])
@pytest.mark.parametrize("protected", ["releases/run", "logs/contact_cycle/sim_residual_training_v1/new"])
def test_output_cannot_modify_historical_trees(bundle, protected):
with pytest.raises(ValueError, match="independent"):
replay.create_output(bundle.root, bundle.root / protected, bundle.checkpoint)
assert not (bundle.root / protected).exists()
def test_output_exclusive_and_symlink_protected(bundle, tmp_path):
output = replay.create_output(bundle.root, tmp_path / "new", bundle.checkpoint)
(output / "evidence").write_text("preserve")
with pytest.raises(FileExistsError):
replay.create_output(bundle.root, output, bundle.checkpoint)
assert (output / "evidence").read_text() == "preserve"
link = tmp_path / "link"
link.symlink_to(bundle.prepared, target_is_directory=True)
with pytest.raises(ValueError, match="independent"):
replay.create_output(bundle.root, link / "new", bundle.checkpoint)
def test_cli_preflight_is_cpu_only_and_preserves_failure(bundle, tmp_path, monkeypatch):
# A fake launcher turns any accidental Kit path into a test failure.
monkeypatch.setitem(sys.modules, "isaaclab.app", SimpleNamespace(
AppLauncher=lambda *a, **k: pytest.fail("CPU preflight imported Kit")))
output = tmp_path / "check"
args = ["--check-only", "--output", str(output), "--checkpoint", str(bundle.checkpoint)]
assert cli.main(args) == 0
result = json.loads((output / "result.json").read_text())
assert result["preflight_passed"] and not result["physics_executed"]
assert result["trained_residual_policy"] and result["optimizer_steps"] == 0
assert (output / "identity.json").is_file()
bundle.checkpoint.write_bytes(b"bad checkpoint")
failed = tmp_path / "failure"
args[2] = str(failed)
assert cli.main(args) == 1
result = json.loads((failed / "result.json").read_text())
assert not result["passed"] and not result["physics_executed"]
assert result["controller_mode"] == "learned" and "SHA256 mismatch" in result["error"]
assert (output / "result.json").is_file()
def test_cli_bad_script_recorded_without_launch(bundle, tmp_path):
output = tmp_path / "bad_script"
assert cli.main(["--replay", "--controller", "script", "--checkpoint", str(bundle.checkpoint),
"--output", str(output)]) == 1
result = json.loads((output / "result.json").read_text())
assert not result["physics_executed"] and not result["passed"]
def synthetic_recorder():
spec = importlib.util.spec_from_file_location(
"synthetic_functional", ROOT / "tests/test_contact_cycle_functional.py")
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
trace = module.example()
from SkillFactory.legs.contact_cycle.task import FAILURE_NAMES
for name, shape in {"policy_snapshot": (46,), "actor_input": (46,), "requested_action": (3,),
"actor_mean": (3,), "processed_target": (3,), "reference_used_normalized": (3,),
"effective_residual_rad": (3,)}.items():
trace[name] = torch.zeros(4500, 1, *shape)
trace["failure_flags"] = torch.zeros(4500, 1, len(FAILURE_NAMES), dtype=torch.bool)
trace["would_fail"] = torch.zeros(4500, 1, dtype=torch.bool)
recorder = SimpleNamespace(initial_state={k: v[0] for k, v in trace.items()}, stops=[4500],
early=[False], frames=[{k: v[i] for k, v in trace.items()} for i in range(4500)])
return recorder, module.CFG
@pytest.mark.parametrize("mode", ["reference", "script", "learned"])
def test_recording_full_six_phases_and_explicit_controller(tmp_path, mode):
recorder, functional = synthetic_recorder()
if mode == "learned":
for frame in recorder.frames:
frame["actor_metadata_available"].fill_(True)
rows = cli.record_episodes(recorder, tmp_path, mode, functional, torch.zeros(3),
[{"reason": "timeout", "control_step": 900}])
assert rows[0]["success"] and all(rows[0]["phase_samples"].values())
trace = torch.load(tmp_path / "first_episodes.pt", weights_only=True)["0"]
assert {"normal", "gap", "root_position_error_m", "root_velocity_error_m_s", "requested_action",
"reference_used_normalized", "effective_residual_rad", "failure_flags"} <= trace.keys()
assert len(trace["time"]) == 4500 and rows[0]["terminal_causes"] == []
assert json.loads((tmp_path / "episodes.json").read_text())["controller_mode"] == mode
def test_recording_keeps_failure_and_never_splices_reset_episode(tmp_path):
recorder, functional = synthetic_recorder()
recorder.stops, recorder.early = [12], [True]
recorder.frames[10]["failure_flags"][0, 0] = True
rows = cli.record_episodes(recorder, tmp_path, "reference", functional, torch.zeros(3),
[{"reason": "physical_failure", "control_step": 3}])
assert not rows[0]["success"] and rows[0]["terminal_causes"]
assert rows[0]["first_failure_time_s"] == pytest.approx(.022)
trace = torch.load(tmp_path / "first_episodes.pt", weights_only=True)["0"]
assert len(trace["time"]) == 12
def test_recording_exception_partial_trace_stays_failed(tmp_path):
recorder, functional = synthetic_recorder()
recorder.stops = [None]
recorder.frames = recorder.frames[:7]
rows = cli.record_episodes(recorder, tmp_path, "reference", functional, torch.zeros(3),
[{"reason": "incomplete", "control_step": None}])
assert not rows[0]["success"] and rows[0]["first_episode_samples"] == 7
assert (tmp_path / "first_episodes.pt").is_file()
def test_actual_frozen_candidate_cpu_only_when_artifacts_present():
checkpoint = ROOT / replay.CANDIDATE
if not checkpoint.is_file():
pytest.skip("Frozen training artifacts must be copied separately; never synthesize a candidate")
manifest, binding = replay.verify_bundle(ROOT, checkpoint)
policy = replay.load_frozen_policy(checkpoint, manifest)
action, _, _ = replay.inference_action(torch.zeros(1, 46), "learned", policy)
assert action.shape == (1, 3) and torch.isfinite(action).all()
assert binding["candidate_sha256"] == "c088bb3aecaca751867118858626fd508f7a3983303802d7524353f80802cf99"
def test_snapshot_symlink_rejected_even_with_identical_bytes(bundle, tmp_path):
path = bundle.prepared / "source_snapshot/AGENT.md"
copy_path = tmp_path / "same_bytes"
copy_path.write_bytes(path.read_bytes())
path.unlink()
path.symlink_to(copy_path)
with pytest.raises(ValueError, match="Unsafe bound source"):
replay.verify_bundle(bundle.root, bundle.checkpoint)
def test_cli_startup_failure_is_not_success_or_reference_fallback(bundle, tmp_path, monkeypatch):
def fail_launcher(**kwargs):
raise RuntimeError("synthetic launcher failure, no Kit instantiated")
monkeypatch.chdir(tmp_path)
monkeypatch.setitem(sys.modules, "isaaclab.app", SimpleNamespace(AppLauncher=fail_launcher))
output = tmp_path / "startup_failure"
assert cli.main(["--replay", "--output", str(output), "--checkpoint", str(bundle.checkpoint)]) == 1
result = json.loads((output / "result.json").read_text())
assert result["preflight_passed"] and not result["passed"] and not result["physics_executed"]
assert result["controller_mode"] == "learned" and "synthetic launcher failure" in result["error"]
def test_cli_constructor_failure_records_possible_physics_before_entry(bundle, tmp_path, monkeypatch):
output = tmp_path / "constructor_failure"
closed = []
monkeypatch.chdir(tmp_path)
manifest = {**bundle.manifest, "training": {**bundle.manifest["training"], "validation_seed": 91502}}
monkeypatch.setattr(replay, "verify_bundle", lambda *args: (manifest, {}))
monkeypatch.setattr(replay, "load_frozen_policy", lambda *args: object())
monkeypatch.setitem(sys.modules, "isaaclab.app", SimpleNamespace(
AppLauncher=lambda **kwargs: SimpleNamespace(app=SimpleNamespace(
close=lambda **kwargs: closed.append(kwargs)))))
monkeypatch.setitem(sys.modules, "SkillFactory.tasks.manager_based.contact_cycle.recording",
SimpleNamespace(PhysicalSafetyAudit=object))
monkeypatch.setitem(sys.modules, "SkillFactory.tasks.manager_based.contact_cycle_sim.cfg", SimpleNamespace(
SimContactCycleEnvCfg=lambda **kwargs: SimpleNamespace(scene=SimpleNamespace(), sim=SimpleNamespace())))
def fail_constructor(**kwargs):
# Persisted before entry, including if construction never returns to Python.
entered = json.loads((output / "result.json").read_text())
assert entered["initialization_entered"] is True
assert entered["physics_executed"] is None and entered["status"] == "initializing"
raise RuntimeError("synthetic constructor failure after possible PhysX warmup")
monkeypatch.setitem(sys.modules, "SkillFactory.tasks.manager_based.contact_cycle_sim.env",
SimpleNamespace(SimContactCycleEnv=fail_constructor))
assert cli.main(["--replay", "--output", str(output), "--checkpoint", str(bundle.checkpoint)]) == 1
result = json.loads((output / "result.json").read_text())
assert result["initialization_entered"] is True and result["physics_executed"] is None
assert result["status"] == "failed" and not result["passed"]
assert result["controller_mode"] == "learned" and "synthetic constructor failure" in result["error"]
assert closed == [{"exit_code": 1}]
@pytest.mark.parametrize("fault", ["physical_failure", "step_exception", "guard_exception"])
def test_run_episode_failure_saves_partial_recording_without_second_episode(tmp_path, monkeypatch, fault):
recorder, functional = synthetic_recorder()
templates = recorder.frames
recorder.frames = []
recorder.stops, recorder.early = [None], [False]
class FakeRecorder:
def __init__(self, env):
self.__dict__.update(recorder.__dict__)
def __enter__(self):
return self
def __exit__(self, *args):
return False
def before_control(self, *args):
pass
def end_control(self, terminated, truncated, final):
if bool((terminated | truncated).any()):
self.stops[0], self.early[0] = len(self.frames), True
calls = {"step": 0, "reset": 0, "guard": 0}
def reset():
calls["reset"] += 1
return {"policy": torch.zeros(1, 46)}, {}
def step(action):
calls["step"] += 1
start = len(recorder.frames)
recorder.frames.extend(templates[start:start + 5])
if fault == "step_exception" and calls["step"] == 2:
raise RuntimeError("synthetic step failure")
terminated = torch.tensor([fault == "physical_failure" and calls["step"] == 2])
return {"policy": torch.zeros(1, 46)}, torch.zeros(1), terminated, torch.tensor([False]), {}
def guard():
calls["guard"] += 1
if fault == "guard_exception" and calls["guard"] == 4:
raise RuntimeError("synthetic safety guard failure")
state = SimpleNamespace(robot=SimpleNamespace(is_fixed_base=False), scenarios=torch.zeros(1),
stand_only=torch.zeros(1, dtype=torch.bool), nominal=torch.zeros(3))
monkeypatch.setitem(sys.modules, "SkillFactory.tasks.manager_based.contact_cycle_sim.mdp",
SimpleNamespace(state=lambda env: state))
monkeypatch.setitem(sys.modules, "SkillFactory.tasks.manager_based.contact_cycle_sim.recording",
SimpleNamespace(SimCycleRecorder=FakeRecorder))
cfg = SimpleNamespace(sim=SimpleNamespace(physics=SimpleNamespace(
solver_type=0, enable_external_forces_every_iteration=False)),
terminations=SimpleNamespace(failed=object()), episode_length_s=9)
env = SimpleNamespace(cfg=cfg, physics_dt=.002, step_dt=.01, num_envs=1, reset=reset, step=step)
args = SimpleNamespace(controller="reference", script_action=None, output=tmp_path)
if fault == "physical_failure":
result = cli.run_episode(env, args, None, functional, guard)
assert not result["passed"] and result["control_steps"] == 2
else:
with pytest.raises(RuntimeError, match="synthetic"):
cli.run_episode(env, args, None, functional, guard)
assert calls["reset"] == 1 and calls["step"] == 2
rows = json.loads((tmp_path / "episodes.json").read_text())["rows"]
assert not rows[0]["success"] and rows[0]["first_episode_samples"] == 10
assert rows[0]["termination"]["reason"] == ("physical_failure" if fault == "physical_failure" else "exception")
assert (tmp_path / "first_episodes.pt").is_file()