Scikit-learn
human-activity-recognition
wearable
wrist
time-series
cpu
scikit-learn
WISP / tests /test_api_classifier.py
Zipeng365's picture
wisp-har 0.4.0: WISP-Funnel search and the adaptive HMM switch (default decoder)
93a9282 verified
Raw History Blame Contribute Delete
7.04 kB
"""WISPClassifier: delegation to the frozen kernel (E1 on fixtures), labels, layout, decoder, readout."""
import warnings
import joblib
import numpy as np
import pytest
from numpy.testing import assert_array_equal
from sklearn.linear_model import LogisticRegression
from threadpoolctl import threadpool_limits
from wisp import WISPClassifier, recipes
from wisp._engine import build_kernel
FIXED = ("ss", "rc", "so", "gis", "cis", "cse", "ese")
@pytest.mark.parametrize("name", FIXED + ("cis:RS", "cis:I", "best:adl", "best:paal_adl", "best:harmes_left"))
def test_e1_delegation_matches_reference_kernel(name, train_windows, test_windows):
"""Catalog recipe without readout (decoder="recipe"): decoded labels equal the paper kernel (fixture data)."""
X, y, g, t = train_windows
Xq, _, gq, tq = test_windows
with threadpool_limits(1):
clf = WISPClassifier(name, decoder="recipe").fit(X, y, groups=g, time_index=t)
ref = build_kernel(recipes.get(name), use_hmm=clf.decoder_ == "hmm", engine="reference", seed=42)
ref.fit(X, y, groups=g, time_index=t, n_classes=3)
assert_array_equal(clf.predict(Xq, groups=gq, time_index=tq), ref.predict(Xq, groups=gq, time_index=tq))
assert_array_equal(clf.predict(Xq), ref.predict(Xq))
np.testing.assert_allclose(clf.predict_proba(Xq), ref.predict_proba(Xq), rtol=0, atol=1e-9)
assert clf.has_paper_results_ is True
assert clf.model_size_mb_ > 0 and clf.fit_seconds_ > 0
def test_string_labels_missing_class_and_classes(train_windows, test_windows):
X, y, g, t = train_windows
names = np.array(["sit", "stand", "walk"])[y]
clf = WISPClassifier("rc").fit(X, names, groups=g, time_index=t)
assert list(clf.classes_) == ["sit", "stand", "walk"]
assert set(clf.predict(test_windows[0])) <= {"sit", "stand", "walk"}
keep = names != "walk"
table = ["run", "sit", "stand", "walk"]
clf = WISPClassifier("cis", classes=table).fit(X[keep], names[keep], groups=g[keep], time_index=t[keep])
P = clf.predict_proba(test_windows[0])
assert P.shape == (len(test_windows[0]), 4)
assert_array_equal(P[:, [0, 3]], 0)
with pytest.raises(ValueError, match="not in the supplied classes"):
WISPClassifier("rc", classes=["a", "b"]).fit(X, names, groups=g)
def test_layout_nct_equals_ntc(train_windows, test_windows):
X, y, g, t = train_windows
a = WISPClassifier("cis").fit(X, y, groups=g, time_index=t)
b = WISPClassifier("cis", layout="NCT").fit(X.transpose(0, 2, 1), y, groups=g, time_index=t)
Xq = test_windows[0]
assert_array_equal(a.predict_proba(Xq), b.predict_proba(Xq.transpose(0, 2, 1)))
def test_groups_validation(train_windows):
X, y, g, t = train_windows
with pytest.raises(ValueError, match="one entry per window"):
WISPClassifier("rc").fit(X, y, groups=g[:-1])
clf = WISPClassifier("rc").fit(X, y, groups=g, time_index=t)
with pytest.raises(ValueError, match="one entry per window"):
clf.predict(X, groups=g[:-2])
with pytest.raises(ValueError, match="shape"):
clf.predict(X[:, :32])
def test_decoder_settings(train_windows, test_windows):
X, y, g, t = train_windows
Xq, _, gq, tq = test_windows
with pytest.raises(ValueError, match="needs groups"):
WISPClassifier("rc", decoder="hmm").fit(X, y)
with warnings.catch_warnings(record=True) as caught:
warnings.simplefilter("always")
auto = WISPClassifier("rc", decoder="recipe").fit(X, y)
assert auto.decoder_ == "none" and any("no groups" in str(w.message) for w in caught)
assert auto.has_paper_results_ is False and auto.decoder_reason_ == "fixed"
with warnings.catch_warnings():
warnings.simplefilter("error")
adaptive = WISPClassifier("rc").fit(X, y) # default "adaptive": no groups, no warning
assert adaptive.decoder_ == "none" and adaptive.decoder_reason_ == "no groups"
assert adaptive.decision_seconds_ == 0
with warnings.catch_warnings():
warnings.simplefilter("error")
none = WISPClassifier("rc", decoder="none").fit(X, y, groups=g, time_index=t)
assert none.decoder_ == "none"
assert_array_equal(none.predict(Xq, groups=gq), none.predict(Xq))
hmm = WISPClassifier("rc", decoder="hmm").fit(X, y, groups=g, time_index=t)
assert hmm.decoder_ == "hmm"
assert_array_equal(hmm.predict(Xq), np.argmax(hmm.predict_proba(Xq), 1)) # no groups: per window
# direct CIS is a paper variant (cis_ablation_RIS_direct); direct RC is not
assert WISPClassifier("cis", decoder="none").fit(X, y, groups=g).has_paper_results_ is True
assert none.has_paper_results_ is False
def test_readout_replacement(train_windows, test_windows):
X, y, g, t = train_windows
Xq, yq, gq, tq = test_windows
clf = WISPClassifier("cis", decoder="recipe", readout=LogisticRegression(max_iter=500)).fit(
X, y, groups=g, time_index=t)
assert clf.has_paper_results_ is False and clf.decoder_ == "hmm"
P = clf.predict_proba(Xq)
assert P.shape == (len(Xq), 3) and np.allclose(P.sum(1), 1)
assert clf.predict(Xq, groups=gq, time_index=tq).shape == (len(Xq),)
assert (clf.predict(Xq) == yq).mean() > 0.6
for name in ("cse", "ese"):
with pytest.raises(ValueError, match="single-readout"):
WISPClassifier(name, readout=LogisticRegression()).fit(X, y, groups=g)
def test_speed_fast_and_custom_recipe(train_windows, test_windows):
X, y, g, t = train_windows
fast = WISPClassifier("cis", speed="fast").fit(X, y, groups=g, time_index=t)
assert fast.has_paper_results_ is False
assert type(fast.model_.model_.steps[-1][1]).__name__ == "ScreenedRidgeClassifierCV"
custom = WISPClassifier({"name": "state_rocket_interval_hmm", "params": {"n_kernels": 64, "n_intervals": 8}})
custom.fit(X, y, groups=g, time_index=t)
assert custom.recipe_.source == "custom" and custom.has_paper_results_ is False
with pytest.raises(ValueError):
WISPClassifier("cis", speed="turbo").fit(X, y, groups=g)
def test_joblib_roundtrip(tmp_path, train_windows, test_windows):
X, y, g, t = train_windows
Xq, _, gq, tq = test_windows
for kwargs in ({"recipe": "gis"}, {"recipe": "rc", "readout": LogisticRegression(max_iter=300)}):
clf = WISPClassifier(**kwargs).fit(X, y, groups=g, time_index=t)
path = tmp_path / "m.joblib"
joblib.dump(clf, path)
back = joblib.load(path)
assert_array_equal(back.predict(Xq, groups=gq, time_index=tq), clf.predict(Xq, groups=gq, time_index=tq))
assert_array_equal(back.predict_proba(Xq), clf.predict_proba(Xq))
def test_recording_sequence_option(train_windows, valid_windows, test_windows):
X, y, g, t = train_windows
Xv, yv, _, _ = valid_windows
clf = WISPClassifier("rc", sequence="recording").fit(X, y, groups=g, time_index=t)
clf.fit_confidence_scale(Xv, yv)
assert clf.confidence_scale_ is None or clf.confidence_scale_ > 0
assert clf.has_paper_results_ is False