"""Pure PPO/interface tests; these fixtures are not physical standing acceptance.""" import copy import json from pathlib import Path import pytest import torch from SkillFactory.legs.standing_ppo import ( SHAPES, StandingActorCritic, bootstrap_values, canonical_hash, features, load_training_config, ppo_step, restore_checkpoint, save_checkpoint, selection_height_error, ) ROOT = Path(__file__).resolve().parents[1] CONFIG = ROOT / "configs/training/go2_fl_loaded_stand_ppo_v1.json" def observations(n=13): result = {k: torch.zeros(n, *shape) for k, shape in SHAPES.items()} result["joint_state"][:, :, 0] = torch.tensor([0.0, 0.8, -1.5]) result["goal"][:] = 0.3346 result["base_state"][:, 2] = 0.3346 result["base_state"][:, 6] = 1 # xyzw result["mount_wrench"][:, 2] = -29.43 result["foot_state"][:, 8] = 52.86 return result def test_features_include_six_axis_sensor_without_input_mutation(): obs = observations() old = {k: v.clone() for k, v in obs.items()} x = features(obs) assert x.shape == (13, 45) and (x[:, 11] == 0).all() assert torch.equal(x[:, 22:28], obs["mount_wrench"]) assert all(torch.equal(v, old[k]) for k, v in obs.items()) model = StandingActorCritic(hidden=32) assert (model.scale > 0).all() with torch.no_grad(): a, latent, logp, value = model.act(x) assert a.shape == (13, 3) and a.abs().max() <= 1 and torch.equal(a, latent.tanh()) torch.testing.assert_close(model.evaluate(x, latent)[0], logp) assert value.shape == (13,) assert torch.equal(model.act(x, True)[0], model.act(x, True)[0]) @pytest.mark.parametrize("mutation", ["missing", "dtype", "shape", "nan", "empty"]) def test_feature_contract_rejects(mutation): obs = observations(0 if mutation == "empty" else 2) if mutation == "missing": obs.pop("mount_wrench") if mutation == "dtype": obs["mount_wrench"] = obs["mount_wrench"].double() if mutation == "shape": obs["mount_wrench"] = obs["mount_wrench"][:, :3] if mutation == "nan": obs["mount_wrench"][0, 0] = torch.nan with pytest.raises(ValueError): features(obs) def test_selection_is_independent_of_post_failure_autoreset_trajectory(): failed = torch.tensor([False, True, True]) a = selection_height_error(torch.tensor([0.01, 0.02, 1.0]), failed) b = selection_height_error(torch.tensor([0.01, 9.0, 0.0]), failed) assert torch.equal(a, b) torch.testing.assert_close(a, torch.tensor([0.01, 0.1, 0.1])) def test_timeout_bootstrap_uses_terminal_sensor_not_reset_and_termination_wins(): class ValueFromSensor: def value(self, x): return x[:, 22].clone() reset = observations(3) reset["mount_wrench"][:, 0] = torch.tensor([1.0, 2.0, 3.0]) terminal = observations(2) terminal["mount_wrench"][:, 0] = torch.tensor([30.0, 99.0]) info = {"terminal_ids": torch.tensor([1, 2], dtype=torch.int32), "terminal_observation": terminal} value = bootstrap_values( ValueFromSensor(), features(reset), torch.tensor([False, False, True]), torch.tensor([False, True, True]), info ) assert value.tolist() == [1.0, 30.0, 0.0] with pytest.raises(RuntimeError, match="pre-reset"): bootstrap_values( ValueFromSensor(), features(reset), torch.zeros(3, dtype=torch.bool), torch.ones(3, dtype=torch.bool), {"terminal_ids": None}, ) def rollout(model): x = torch.randn(4, 13, 45) with torch.no_grad(): _, z, logp, value = model.act(x.flatten(0, 1)) return { "features": x, "latent": z.reshape(4, 13, 3), "log_prob": logp.reshape(4, 13), "value": value.reshape(4, 13), "next_value": torch.zeros(4, 13), "reward": torch.randn(4, 13), "done": torch.zeros(4, 13, dtype=torch.bool), } def test_optimizer_and_rng_exact_restore_for_same_next_batch(tmp_path): torch.set_num_threads(1) torch.manual_seed(123) cfg = load_training_config(CONFIG) cfg.update(minibatch_size=26, epochs=2, target_kl=1.0) model = StandingActorCritic(hidden=32) optimizer = torch.optim.Adam(model.parameters(), lr=cfg["learning_rate"], eps=1e-5) ppo_step(model, optimizer, rollout(model), cfg) data = rollout(model) identity = {"config": canonical_hash(cfg)} path = tmp_path / "checkpoint.pt" save_checkpoint(path, model, optimizer, identity, 1, 3.0, None) before = copy.deepcopy(model.state_dict()) a = ppo_step(model, optimizer, data, cfg) result_a, opt_a = copy.deepcopy(model.state_dict()), copy.deepcopy(optimizer.state_dict()) restored = restore_checkpoint(path, model, optimizer, identity) assert restored["update"] == 1 and restored["accepted_skill"] is False assert all(torch.equal(model.state_dict()[k], v) for k, v in before.items()) b = ppo_step(model, optimizer, data, cfg) assert a == b and any(not torch.equal(v, before[k]) for k, v in result_a.items()) assert all(torch.equal(model.state_dict()[k], v) for k, v in result_a.items()) for key, values in opt_a["state"].items(): for name, value in values.items(): assert torch.equal(optimizer.state_dict()["state"][key][name], value) with pytest.raises(ValueError, match="identity"): restore_checkpoint(path, model, optimizer, {"config": "wrong"}) @pytest.mark.parametrize( "key,value", [ ("seed", 82000), ("gamma", 2.0), ("epochs", 0), ("initial_std", 1.0), ("train_amplitude_scale", [0.0, 1.0]), ("train_time_shift_s", [-1.0, 0.0]), ("num_envs", 12), ("learning_rate", float("nan")), ("horizon", True), ], ) def test_training_config_rejects_invalid(tmp_path, key, value): cfg = load_training_config(CONFIG) cfg[key] = value path = tmp_path / "cfg.json" path.write_text(json.dumps(cfg)) with pytest.raises(ValueError): load_training_config(path)