Download tests/test_t6.py from velvet-pine-22/PULSE-code: direct link, hf CLI and curl.
- Browser
- Download file 15.2 kB
-
https://huggingface.co/velvet-pine-22/PULSE-code/resolve/main/tests/test_t6.py
- Command line
-
hf download hf://velvet-pine-22/PULSE-code/tests/test_t6.py
-
curl -L -o test_t6.py https://huggingface.co/velvet-pine-22/PULSE-code/resolve/main/tests/test_t6.py
15.2 kB
| """T6 (cross-modal pressure prediction): signal processing, configs, end to end.""" | |
| import json | |
| from pathlib import Path | |
| import numpy as np | |
| import pytest | |
| from conftest import REPO, mini_split, real_root, realdata | |
| from pulse.config import load_config | |
| from pulse.tasks import t6 | |
| T6_CONFIGS = sorted(p for p in (REPO / "configs" / "t6").glob("t6*_*.yaml") | |
| if not p.stem.endswith("_base")) | |
| def _torch_numpy_ok(): | |
| try: | |
| import torch | |
| torch.from_numpy(np.zeros(2, np.float32)) | |
| return True | |
| except Exception: # torch missing or built against another numpy ABI | |
| return False | |
| needs_torch = pytest.mark.skipif(not _torch_numpy_ok(), reason="torch with numpy interop needed") | |
| def test_moving_rms_matches_reference(): | |
| rng = np.random.default_rng(0) | |
| x = rng.normal(0, 1, (57, 3)) | |
| win = t6.envelope_window(100, 200) | |
| assert win == 21 | |
| h = win // 2 | |
| xp = np.concatenate([x[:h][::-1], x, x[-h:][::-1]]) # half-sample symmetric | |
| ref = np.sqrt(np.stack([(xp[i:i + win] ** 2).mean(0) for i in range(x.shape[0])])) | |
| assert np.allclose(t6.moving_rms(x, win), ref) | |
| try: | |
| from scipy.ndimage import uniform_filter1d | |
| except Exception: | |
| return | |
| assert np.allclose(t6.moving_rms(x, win), | |
| np.sqrt(uniform_filter1d(x ** 2, size=win, axis=0, mode="reflect"))) | |
| def test_dilation_and_segments(): | |
| a = np.zeros(30, bool) | |
| a[[3, 10, 29]] = True | |
| d = t6.dilate(a, 2) | |
| ref = np.zeros(30, bool) | |
| for i in np.where(a)[0]: | |
| ref[max(0, i - 2):i + 3] = True | |
| assert np.array_equal(d, ref) | |
| assert np.array_equal(t6.dilate(np.ones(3, bool), 5), np.ones(3, bool)) # shorter than kernel | |
| total = np.zeros(200) | |
| total[50:52] = 500 # dilated by 20 -> [30, 72), padded by 20 -> [10, 92) | |
| total[100:101] = 500 # -> [80, 121) -> [60, 141): overlaps the first -> merged | |
| total[180:181] = 50 # below threshold | |
| segs = t6.active_segments(total, 100.0, 20, 12, 20) | |
| assert segs == [(10, 141)] | |
| assert t6.active_segments(np.zeros(10), 100.0, 20, 12, 20) == [] | |
| def test_hand_mocap_features(): | |
| cols = ["Hips_X", "Hips_Y", "Hips_Z", "RightHand_X", "RightHand_Y", "RightHand_Z", "RightHand_QX", | |
| "RightInHandIndex_X", "RightInHandIndex_Y", "RightInHandIndex_Z", | |
| "LeftHand_X", "LeftHand_Y", "LeftHand_Z", "LeftForeArm_X", "LeftForeArm_Y", | |
| "LeftForeArm_Z"] | |
| v = np.arange(4 * len(cols), dtype=np.float64).reshape(4, len(cols)) | |
| v[2, 7] = np.nan | |
| f = t6.hand_mocap_features(v, cols) | |
| # kept: 13 columns (no Hips), 12 position columns -> +12 velocities | |
| assert f.shape == (4, 13 + 12) | |
| assert np.allclose(f[:, 0:3], v[:, 3:6]) # wrist stays absolute | |
| assert np.allclose(f[[0, 1, 3], 4:7], v[[0, 1, 3], 7:10] - v[[0, 1, 3], 3:6]) | |
| assert f[2, 4] == 0.0 # NaN -> 0 after the transform | |
| assert np.allclose(f[:, 10:13], v[:, 13:16] - v[:, 10:13]) # forearm wrist-relative | |
| assert np.all(f[0, 13:] == 0) # first velocity frame | |
| def test_t6_configs_valid(): | |
| assert len(T6_CONFIGS) == 14 # 9 T6a + 5 T6b rows | |
| for p in T6_CONFIGS: | |
| cfg = load_config(p) | |
| assert cfg["task"] == "t6", p | |
| t6.check_config(cfg) | |
| assert cfg["preprocess"]["calibration"]["seconds"] == 30 | |
| if "g4" in p.stem: | |
| assert len(cfg["gate_modalities"]) == 3 | |
| ens = load_config(REPO / "configs" / "t6" / "ensemble.yaml") | |
| assert ens["task"] == "t6ens" and ens["members"]["seeds"] == [42, 43, 44] | |
| def test_t6_tables_registered(): | |
| from pulse import aggregate as A | |
| reg = A.load_registry() | |
| t6_tables = {k: v for k, v in reg.items() if v.get("task") in ("t6", "t6ens")} | |
| assert {"11a", "11b", "11a-ens", "11b-ens", "11b-b19"} <= set(t6_tables) | |
| # author decision 2026-10-18: no T6b Transformer row, no B19 hand-MoCap control row | |
| assert [r["key"] for r in reg["11b"]["rows"]] == [ | |
| "pham_mocap", "latefusion_emg_mocap", "pham_emg_mocap", "ghorbani_mocap"] | |
| assert [r["key"] for r in reg["11b-b19"]["rows"]] == ["ghorbani_m4"] | |
| assert reg["11b-b19"]["reference_row"] is None | |
| for tid, spec in t6_tables.items(): | |
| assert spec["split"] == "splits/pool27.json" | |
| if spec["task"] == "t6ens": | |
| assert spec["seeds"] == ["ens"] and spec["resources"] == "cpu" | |
| members = reg[[x.split("=", 1)[1] for x in spec["rows"][0]["set"] | |
| if x.startswith("members.table=")][0]] | |
| assert {r["key"] for r in spec["rows"]} == {r["key"] for r in members["rows"]} | |
| else: | |
| assert spec["seeds"] == [42, 43, 44] | |
| def _mini_setup(mini_root, tmp_path): | |
| from pulse.data.availability import build_availability | |
| from pulse.paths import DataRoot | |
| av = tmp_path / "availability.json" | |
| av.write_text(json.dumps(build_availability(DataRoot.from_arg(mini_root))), encoding="utf-8") | |
| return av, mini_split(tmp_path / "mini_split.json") | |
| SMALL = ["train.epochs=2", "model.hidden_dim=8", "preprocess.calibration.seconds=0.4", | |
| "active.threshold_g=5", "load_workers=0"] | |
| def _run_t6(mini_root, av, split, cfg, out, seed=42, extra=()): | |
| args = ["--root", str(mini_root), "--split", str(split), "--fold", "0", "--seed", str(seed), | |
| "--config", str(REPO / "configs" / "t6" / cfg), "--availability", str(av), | |
| "--out", str(out), "--device", "cpu"] | |
| for kv in list(SMALL) + list(extra): | |
| args += ["--set", kv] | |
| return t6.main(args) | |
| def test_t6_end_to_end(mini_root, tmp_path, cfg): | |
| from pulse.provenance import load_results | |
| av, split = _mini_setup(mini_root, tmp_path) | |
| out = tmp_path / "run" | |
| assert _run_t6(mini_root, av, split, cfg, out) == 0 | |
| r = load_results(out / "results.json") | |
| prov = r["provenance"] | |
| assert prov["inner_val_volunteers"] == ["v2"] and prov["seed"] == 42 | |
| assert prov["loaded_recordings"]["test"] == ["v1s1", "v1s2"] | |
| if "mocap" in cfg or "m4" in cfg: | |
| assert "v5s1" not in prov["loaded_recordings"]["train"] # v5: no MoCap / IMU | |
| else: | |
| assert prov["loaded_recordings"]["train"] == ["v5s1", "v5s2", "v6s1", "v6s2"] | |
| assert set(r["per_recording"]["test"]) == {"v1s1", "v1s2"} | |
| key = "pearson" if cfg.startswith("t6a") else "pearson_max" | |
| assert key in r["metrics"]["test"] and "mae_g" in r["metrics"]["test"] | |
| assert r["selection"]["swa_start_epoch"] == 1 and len(r["selection"]["history"]) == 2 | |
| cal = r["extra"]["calibration"]["frames_per_recording"] | |
| assert cal["v1s1"] == 8 and cal["v1s2"] == 0 # 0.4 s at 20 Hz, S1 first | |
| z = np.load(out / "predictions.npz") | |
| assert sorted(set(z["rec_index"].tolist())) == [0, 1] | |
| assert z["frame"][z["rec_index"] == 0].min() >= 8 # calibration frames not scored | |
| assert str(mini_root) not in json.dumps(r) | |
| def test_t6_manifest_mismatch_refused(mini_root, tmp_path, monkeypatch): | |
| from pulse.errors import ManifestMismatchError | |
| av, split = _mini_setup(mini_root, tmp_path) | |
| real = t6.load_many | |
| def drop_one(dr, rids, *a, **k): | |
| out = real(dr, rids, *a, **k) | |
| out.pop("v6s2", None) | |
| return out | |
| monkeypatch.setattr(t6, "load_many", drop_one) | |
| with pytest.raises(ManifestMismatchError, match="v6s2"): | |
| _run_t6(mini_root, av, split, "t6a_pham_emg.yaml", tmp_path / "run") | |
| assert not (tmp_path / "run" / "results.json").exists() | |
| def test_t6_seed_ensemble_and_aggregate(mini_root, tmp_path): | |
| from pulse import aggregate as A | |
| from pulse.provenance import load_results | |
| from pulse.tasks import t6ens | |
| av, split = _mini_setup(mini_root, tmp_path) | |
| runs = tmp_path / "runs" | |
| for s in (42, 43): | |
| assert _run_t6(mini_root, av, split, "t6b_pham_mocap.yaml", | |
| A.run_dir(runs, "11b", "pham_mocap", 0, s), seed=s) == 0 | |
| out = A.run_dir(runs, "11b-ens", "pham_mocap", 0, "ens") | |
| rc = t6ens.main(["--split", str(split), "--fold", "0", "--seed", "ens", "--config", | |
| str(REPO / "configs" / "t6" / "ensemble.yaml"), "--out", str(out), | |
| "--set", "members.table=11b", "--set", "members.row=pham_mocap", | |
| "--set", "members.seeds=[42, 43]", "--set", "members.allow_subset=true", | |
| "--set", "members.allow_dirty=true"]) | |
| assert rc == 0 | |
| e = load_results(out / "results.json") | |
| assert e["provenance"]["seed"] == "ens" and e["provenance"]["members"]["seeds"] == [42, 43] | |
| assert e["provenance"]["members"]["all_table_seeds"] is False | |
| # without the explicit opt-in a subset of the table's seeds 42/43/44 is refused | |
| with pytest.raises(ValueError, match="averages all of them"): | |
| t6ens.main(["--split", str(split), "--fold", "0", "--seed", "ens", "--config", | |
| str(REPO / "configs" / "t6" / "ensemble.yaml"), "--out", str(tmp_path / "x"), | |
| "--set", "members.table=11b", "--set", "members.row=pham_mocap", | |
| "--set", "members.seeds=[43, 44]", "--set", "members.allow_dirty=true"]) | |
| m = [load_results(A.run_dir(runs, "11b", "pham_mocap", 0, s) / "results.json") for s in (42, 43)] | |
| assert e["provenance"]["loaded_recordings"] == m[0]["provenance"]["loaded_recordings"] | |
| # averaging the predictions: MAE of the mean is at most the mean MAE | |
| assert e["metrics"]["test"]["mae_g"] <= np.mean([x["metrics"]["test"]["mae_g"] for x in m]) + 1e-9 | |
| spec = {"id": "11b-ens", "title": "t", "task": "t6ens", "split": str(split), "folds": [0], | |
| "seeds": ["ens"], "reference_row": None, | |
| "metrics": [{"key": "pearson_max", "label": "r", "digits": 3, "better": "higher"}], | |
| "rows": [{"key": "pham_mocap", "label": "Pham"}]} | |
| got, missing = A.collect(spec, runs) | |
| assert not missing | |
| summ = A.aggregate(spec, got, allow_dirty=True) | |
| assert summ["rows"]["pham_mocap"]["own"]["pearson_max"]["n_runs"] == 1 | |
| # a member from another commit is refused | |
| p = A.run_dir(runs, "11b", "pham_mocap", 0, 43) / "results.json" | |
| d = json.loads(p.read_text(encoding="utf-8")) | |
| d["provenance"]["git_sha"] = "0" * 40 | |
| p.write_text(json.dumps(d), encoding="utf-8") | |
| from pulse.errors import ProvenanceError | |
| with pytest.raises(ProvenanceError, match="git_sha"): | |
| t6ens.main(["--split", str(split), "--fold", "0", "--seed", "ens", "--config", | |
| str(REPO / "configs" / "t6" / "ensemble.yaml"), "--out", str(out), | |
| "--set", "members.table=11b", "--set", "members.row=pham_mocap", | |
| "--set", "members.seeds=[42, 43]", "--set", "members.allow_subset=true", | |
| "--set", "members.allow_dirty=true"]) | |
| def test_t6_ensemble_refuses_foreign_predictions(mini_root, tmp_path): | |
| """A predictions.npz that does not reproduce its results.json is refused.""" | |
| from pulse import aggregate as A | |
| from pulse.errors import ProvenanceError | |
| from pulse.tasks import t6ens | |
| av, split = _mini_setup(mini_root, tmp_path) | |
| runs = tmp_path / "runs" | |
| for s in (42, 43): | |
| assert _run_t6(mini_root, av, split, "t6a_pham_emg.yaml", | |
| A.run_dir(runs, "11a", "pham_emg", 0, s), seed=s) == 0 | |
| npz = A.run_dir(runs, "11a", "pham_emg", 0, 43) / "predictions.npz" | |
| z = dict(np.load(npz)) | |
| z["pred"] = z["pred"][::-1].copy() # same frames, other predictions | |
| np.savez_compressed(npz, **z) | |
| out = A.run_dir(runs, "11a-ens", "pham_emg", 0, "ens") | |
| with pytest.raises(ProvenanceError, match="stale or foreign"): | |
| t6ens.main(["--split", str(split), "--fold", "0", "--seed", "ens", "--config", | |
| str(REPO / "configs" / "t6" / "ensemble.yaml"), "--out", str(out), | |
| "--set", "members.table=11a", "--set", "members.row=pham_emg", | |
| "--set", "members.seeds=[42, 43]", "--set", "members.allow_subset=true", | |
| "--set", "members.allow_dirty=true"]) | |
| assert not (out / "results.json").exists() | |
| def test_t6_refuses_when_checkout_changes_during_run(mini_root, tmp_path, monkeypatch): | |
| from pulse.errors import ProvenanceError | |
| av, split = _mini_setup(mini_root, tmp_path) | |
| states = iter([{"git_sha": "a" * 40, "git_dirty": False, "git_diff_md5": None}, | |
| {"git_sha": "b" * 40, "git_dirty": False, "git_diff_md5": None}]) | |
| monkeypatch.setattr(t6, "git_state", lambda: next(states)) | |
| with pytest.raises(ProvenanceError, match="repository changed"): | |
| _run_t6(mini_root, av, split, "t6a_pham_emg.yaml", tmp_path / "run") | |
| assert not (tmp_path / "run" / "results.json").exists() | |
| def test_t6_trim_window_refuses_unplaceable_stream(monkeypatch): | |
| """Re-trimmed (n rows) and full-timeline streams are aligned; a stream of any | |
| other length cannot be placed and raises instead of being cut from the start.""" | |
| from pulse.data import io as dio | |
| from pulse.errors import DataQualityError | |
| lengths = {} | |
| def fake_stream(dr, rid, stream): | |
| cols = {"emg": list(t6.M.EMG_COLS), "pressure": list(t6.M.PRESSURE_COLS), | |
| "imu": [f"WT{s}_{f}" for s in range(10) for f in range(18)]}[stream] | |
| vals = np.ones((lengths[stream], len(cols))) | |
| return dio.Stream(rid, stream, f"{stream}.csv", cols, vals, None, cols) | |
| monkeypatch.setattr(dio, "load_stream", fake_stream) | |
| monkeypatch.setattr(dio, "load_alignment_metadata", | |
| lambda dr, rid: {"n_samples": 1000, | |
| "mocap_padding": {"mocap_sq": {"front_samples": 100, | |
| "n_frames": 800}}}) | |
| lengths.update(emg=800, pressure=800, imu=1000) | |
| r = t6.load_t6_recording(None, "v13s2", ["emg", "imu"], "hand", ["pressure"], 5) | |
| assert r["offsets"] == {"imu": 100} and r["n100"] == 800 | |
| lengths.update(imu=850) # neither 800 nor >= 900 rows | |
| with pytest.raises(DataQualityError, match="cannot align"): | |
| t6.load_t6_recording(None, "v13s2", ["emg", "imu"], "hand", ["pressure"], 5) | |
| def test_t6_loader_on_real_data(): | |
| """460 hand-MoCap columns; release trim window for v13s2 (MoCap / IMU sliced).""" | |
| from pulse.paths import DataRoot | |
| dr = DataRoot.from_arg(real_root()) | |
| r = t6.load_t6_recording(dr, "v25s1", ["emg", "mocap"], "hand", ["pressure"], 5) | |
| assert r["dims"] == {"emg": 8, "mocap": 460} and r["offsets"] == {} | |
| assert r["pressure"].shape == (int(np.ceil(r["n100"] / 5)), 50) | |
| r = t6.load_t6_recording(dr, "v13s2", ["emg", "mocap", "imu"], "hand", ["pressure"], 5) | |
| assert r["offsets"] == {"mocap": 393, "imu": 393} and r["n100"] == 3790 | |
| assert r["emg100"].shape[0] == 3790 | |