Files
SkillFactory/tests/test_four_skills_model.py
T

315 lines
14 KiB
Python

"""Synthetic CPU-only four-skills seam tests: no Kit, robot data, or physical claims."""
import hashlib
import importlib.util
from pathlib import Path
import sys
import types
import pytest
import torch
ROOT = Path(__file__).resolve().parents[1]
LEGS = ROOT / "source/SkillFactory/SkillFactory/legs"
SPEC = importlib.util.spec_from_file_location("_four_skills_model_test", LEGS / "four_skills/model.py")
model_module = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(model_module)
FourSkillActorCritic = model_module.FourSkillActorCritic
features = model_module.features
save_checkpoint = model_module.save_checkpoint
load_policy = model_module.load_policy
@pytest.fixture(autouse=True)
def cpu_only():
# Small synthetic matrices do not benefit from a large host thread pool.
previous = torch.get_num_threads()
torch.set_num_threads(1)
yield
torch.set_num_threads(previous)
def test_four_skills_model_shapes_zero_baseline_and_shared_inputs():
model = FourSkillActorCritic(hidden=16)
x = torch.randn(7, 48)
assert features(x) is x
action, latent, logp, value = model.act(x, deterministic=True)
assert action.shape == latent.shape == (7, 3)
assert logp.shape == value.shape == (7,)
assert not action.any() and not latent.any()
assert torch.isfinite(logp).all() and torch.isfinite(value).all()
assert torch.equal(value, model.value(x))
assert model.actor[0].in_features == model.critic[0].in_features == 48
assert model.feature_version == "four-skills-48-fixed-si-v1"
assert model.model_config == {"hidden": 16, "initial_std": 0.08}
assert model.critic[-1].weight.any()
assert not torch.optim.Adam(model.parameters()).state
def test_four_skills_model_fixed_si_order_and_actor_critic_normalization():
model = FourSkillActorCritic(hidden=8)
expected_offset = torch.zeros(48)
expected_offset[:3] = torch.tensor([0.0, 0.8, -1.5])
expected_scale = torch.tensor(
[0.5] * 3 + [10.0] * 3 + [50.0] * 3 + [5.0] * 3
+ [1.0] * 3 + [5.0] * 3 + [0.1] * 3 + [0.5] * 3
+ [0.4] * 3 + [1.0] * 3 + [50.0] * 3 + [0.05]
+ [1.0] * 4 + [0.4] * 3 + [1.0] + [1.0] * 3 + [1.0] * 3
)
assert torch.equal(model.offset, expected_offset)
assert torch.equal(model.scale, expected_scale)
seen = []
handles = [net[0].register_forward_pre_hook(lambda _, args: seen.append(args[0]))
for net in (model.actor, model.critic)]
normalized = torch.linspace(-2, 2, 48).expand(2, -1)
model.value(expected_offset + expected_scale * normalized)
for handle in handles:
handle.remove()
assert len(seen) == 2
assert torch.allclose(seen[0], normalized, atol=1e-6)
assert torch.equal(seen[0], seen[1])
def test_four_skills_model_latent_logp_tanh_and_std_bounds():
model = FourSkillActorCritic(hidden=8)
x = torch.randn(11, 48)
action, latent, logp, value = model.act(x)
assert latent.any() and action.abs().max() <= 1
assert torch.equal(action, latent.tanh())
evaluated_logp, evaluated_value = model.evaluate(x, latent)
assert torch.equal(logp, evaluated_logp) and torch.equal(value, evaluated_value)
expected = torch.distributions.Normal(torch.zeros_like(latent), 0.08).log_prob(latent).sum(-1)
assert torch.allclose(logp, expected, atol=1e-6)
for log_std, expected_std in [(-100.0, 0.02), (100.0, 0.5)]:
with torch.no_grad():
model.log_std.fill_(log_std)
assert torch.allclose(model.distribution_value(x)[0].stddev, torch.full_like(latent, expected_std))
@pytest.mark.parametrize("kwargs", [
{"hidden": True}, {"hidden": 8.0}, {"hidden": 7}, {"hidden": 0}, {"hidden": -1},
{"initial_std": True}, {"initial_std": "0.08"}, {"initial_std": 0.0},
{"initial_std": float("nan")}, {"initial_std": float("inf")},
{"initial_std": 0.019}, {"initial_std": 0.501},
])
def test_four_skills_model_rejects_invalid_args(kwargs):
with pytest.raises(ValueError):
FourSkillActorCritic(**kwargs)
@pytest.mark.parametrize("bad", [
torch.zeros(2, 46), torch.zeros(2, 32), torch.zeros(48), torch.zeros(0, 48),
torch.zeros(2, 48, dtype=torch.float64), torch.zeros(2, 48, dtype=torch.int64),
torch.full((2, 48), float("nan")), torch.full((2, 48), float("inf")), [[0.0] * 48],
torch.empty(2, 48, device="meta"), torch.zeros(2, 48).to_sparse(),
])
def test_four_skills_model_rejects_bad_features(bad):
model = FourSkillActorCritic(hidden=8)
for method in (features, model.act, model.value):
with pytest.raises(ValueError, match="features"):
method(bad)
@pytest.mark.parametrize("bad", [torch.zeros(2, 4), torch.zeros(3, 3),
torch.zeros(2, 3, dtype=torch.float64),
torch.full((2, 3), float("nan")), None,
torch.empty(2, 3, device="meta")])
def test_four_skills_model_rejects_bad_latents(bad):
with pytest.raises(ValueError, match="latent"):
FourSkillActorCritic(hidden=8).evaluate(torch.zeros(2, 48), bad)
def test_four_skills_model_exact_types_and_global_default_dtype():
with pytest.raises(ValueError, match="bool"):
FourSkillActorCritic(hidden=8).act(torch.zeros(2, 48), deterministic=1)
default = FourSkillActorCritic()
assert default.model_config == {"hidden": 128, "initial_std": 0.08}
for std in (0.02, 0.5):
assert FourSkillActorCritic(hidden=8, initial_std=std).model_config["initial_std"] == std
previous = torch.get_default_dtype()
try:
torch.set_default_dtype(torch.float64)
model = FourSkillActorCritic(hidden=8)
assert all(p.dtype == torch.float32 for p in model.parameters())
assert model.value(torch.zeros(2, 48, dtype=torch.float32)).dtype == torch.float32
finally:
torch.set_default_dtype(previous)
def test_four_skills_model_generic_standing_ppo_step_synthetic():
# Private test namespace avoids SkillFactory.__init__ (Kit registration), even
# when this test is invoked directly rather than through scripts/test_cpu.py.
name = "_four_skills_cpu_legs"
package = types.ModuleType(name)
package.__path__ = [str(LEGS)]
sys.modules[name] = package
try:
spec = importlib.util.spec_from_file_location(name + ".standing_ppo", LEGS / "standing_ppo.py")
standing = importlib.util.module_from_spec(spec)
spec.loader.exec_module(standing)
torch.manual_seed(23)
model = FourSkillActorCritic(hidden=8)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
x = torch.randn(3, 4, 48)
with torch.no_grad():
_, latent, logp, value = model.act(x.flatten(0, 1))
data = {"features": x, "latent": latent.reshape(3, 4, 3),
"log_prob": logp.reshape(3, 4), "value": value.reshape(3, 4),
"next_value": torch.zeros(3, 4), "reward": torch.randn(3, 4),
"done": torch.zeros(3, 4, dtype=torch.bool)}
cfg = {"gamma": 0.99, "gae_lambda": 0.95, "epochs": 2, "minibatch_size": 4,
"target_kl": 1.0, "clip_ratio": 0.2, "value_coefficient": 0.5, "max_gradient_norm": 1.0}
result = standing.ppo_step(model, optimizer, data, cfg)
assert result["minibatches"] == 6 and result["sampling_log_prob_error"] == 0
assert optimizer.state and model.actor[-1].weight.any()
assert all(torch.isfinite(p).all() for p in model.parameters())
finally:
for module in list(sys.modules):
if module == name or module.startswith(name + "."):
del sys.modules[module]
@pytest.fixture
def checkpoint(tmp_path):
torch.manual_seed(7)
model = FourSkillActorCritic(hidden=8)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
# Exercise nonempty Adam moments without robot data or a training run.
x = torch.randn(4, 48)
logp, value = model.evaluate(x, torch.randn(4, 3) * 0.08)
(value.square().mean() - logp.mean()).backward()
optimizer.step()
path = tmp_path / "policy.pt"
identity = {"task": "go2-fl-four-skills-v0.5.0", "source": "synthetic", "seed": 7}
save_checkpoint(path, model, optimizer, identity, 1, {"loss": 0.25})
return path, model, optimizer, identity, x
def assert_tree_equal(left, right):
assert type(left) is type(right)
if isinstance(left, torch.Tensor):
assert torch.equal(left, right)
elif isinstance(left, dict):
assert left.keys() == right.keys()
for key in left:
assert_tree_equal(left[key], right[key])
elif isinstance(left, (list, tuple)):
assert len(left) == len(right)
for a, b in zip(left, right):
assert_tree_equal(a, b)
else:
assert left == right
def test_four_skills_model_checkpoint_exact_roundtrip(checkpoint):
path, model, optimizer, identity, x = checkpoint
rng = torch.get_rng_state().clone()
digest = hashlib.sha256(path.read_bytes()).hexdigest()
loaded, payload = load_policy(path, expected_sha256=digest, expected_identity=dict(reversed(list(identity.items()))))
assert not loaded.training and next(loaded.parameters()).device.type == "cpu"
assert torch.equal(rng, torch.get_rng_state()) # loading does not reseed callers
assert payload["format"] == "skillfactory.four-skills-ppo.v1"
assert payload["features"] == model.feature_version and payload["feature_dim"] == 48
assert payload["update"] == 1 and payload["metrics"] == {"loss": 0.25}
assert_tree_equal(dict(model.state_dict()), dict(loaded.state_dict()))
assert_tree_equal(optimizer.state_dict(), payload["optimizer"])
assert torch.equal(payload["rng"]["cpu"], rng)
assert payload["rng"]["cuda"] == []
for a, b in zip(model.act(x, deterministic=True), loaded.act(x, deterministic=True)):
assert torch.equal(a, b)
with pytest.raises(ValueError, match="identity"):
load_policy(path, expected_identity={**identity, "source": "wrong"})
with pytest.raises(ValueError, match="device"):
load_policy(path, device="not-a-device")
def test_four_skills_model_digest_checked_before_torch_load(checkpoint, monkeypatch):
path, *_ = checkpoint
calls = []
monkeypatch.setattr(torch, "load", lambda *args, **kwargs: calls.append(args))
with pytest.raises(ValueError, match="SHA256"):
load_policy(path, expected_sha256="0" * 64)
assert not calls
@pytest.mark.parametrize("field,value", [
("format", "skillfactory.standing-ppo-checkpoint.v1"),
("features", "contact-cycle-sim-46-fixed-si-v1"), ("feature_dim", 46), ("feature_dim", 32),
("feature_dim", 48.0), ("model_config", {"hidden": True, "initial_std": 0.08}),
("model_config", {"hidden": 8, "initial_std": float("nan")}),
("model_config", {"hidden": 8, "initial_std": 0.08, "extra": 1}),
("update", True), ("update", -1), ("rng", {}), ("optimizer", {}), ("identity", {}),
("rng", {"cpu": torch.zeros(2, dtype=torch.uint8), "cuda": []}),
("identity", {"not_json": torch.zeros(1)}), ("metrics", {"loss": float("inf")}),
])
def test_four_skills_model_rejects_malformed_checkpoint(checkpoint, field, value):
path, *_ = checkpoint
payload = torch.load(path, weights_only=True)
payload[field] = value
torch.save(payload, path)
with pytest.raises(ValueError):
load_policy(path)
@pytest.mark.parametrize("corruption", ["nonfinite", "optimizer_nonfinite", "shape", "dtype", "scale", "missing", "extra"])
def test_four_skills_model_rejects_corrupt_state(checkpoint, corruption):
path, *_ = checkpoint
payload = torch.load(path, weights_only=True)
state = payload["model"]
if corruption == "nonfinite":
state["critic.0.weight"][0, 0] = float("inf")
elif corruption == "optimizer_nonfinite":
next(iter(payload["optimizer"]["state"].values()))["exp_avg"].flatten()[0] = float("nan")
elif corruption == "shape":
state["actor.0.weight"] = torch.zeros(8, 46)
elif corruption == "dtype":
state["log_std"] = state["log_std"].double()
elif corruption == "scale":
state["scale"][0] = 1.0
elif corruption == "missing":
del state["log_std"]
else:
state["extra"] = torch.zeros(1)
torch.save(payload, path)
with pytest.raises(ValueError):
load_policy(path)
@pytest.mark.parametrize("corruption", ["parameter", "optimizer", "metrics", "custom"])
def test_four_skills_model_atomic_nonfinite_and_custom_object_rejection(checkpoint, corruption):
path, model, optimizer, identity, _ = checkpoint
original = path.read_bytes()
metrics = None
if corruption == "parameter":
with torch.no_grad():
next(model.parameters()).flatten()[0] = float("nan")
elif corruption == "optimizer":
next(iter(optimizer.state.values()))["exp_avg"].flatten()[0] = float("inf")
elif corruption == "metrics":
metrics = {"loss": float("nan")}
else:
metrics = {"custom": object()}
with pytest.raises(ValueError):
save_checkpoint(path, model, optimizer, identity, 2, metrics)
assert path.read_bytes() == original
assert list(path.parent.iterdir()) == [path]
def test_four_skills_model_atomic_replace_failure_cleanup(checkpoint, monkeypatch):
path, model, optimizer, identity, _ = checkpoint
original = path.read_bytes()
def fail_replace(*args):
raise OSError("synthetic replace failure")
monkeypatch.setattr(model_module.os, "replace", fail_replace)
with pytest.raises(OSError, match="synthetic"):
save_checkpoint(path, model, optimizer, identity, 2)
assert path.read_bytes() == original
assert list(path.parent.iterdir()) == [path]
def test_four_skills_model_rejects_unreadable_checkpoint(tmp_path):
path = tmp_path / "bad.pt"
path.write_bytes(b"not a torch checkpoint")
with pytest.raises(ValueError, match="weights-only"):
load_policy(path)