Instructions to use Zipeng365/WISP with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Scikit-learn
How to use Zipeng365/WISP with Scikit-learn:
from huggingface_hub import hf_hub_download import joblib model = joblib.load( hf_hub_download("Zipeng365/WISP", "sklearn_model.joblib") ) # only load pickle files from sources you trust # read more about it here https://skops.readthedocs.io/en/stable/persistence.html - Notebooks
- Google Colab
- Kaggle
Download tests/test_api_classifier.py from Zipeng365/WISP: direct link, hf CLI and curl.
- Browser
- Download file 7.04 kB
-
https://huggingface.co/Zipeng365/WISP/resolve/main/tests/test_api_classifier.py
- Command line
-
hf download hf://Zipeng365/WISP/tests/test_api_classifier.py
-
curl -L -o test_api_classifier.py https://huggingface.co/Zipeng365/WISP/resolve/main/tests/test_api_classifier.py
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") | |
| 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 | |