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
File size: 6,835 Bytes
93a9282 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 | """WISPSearch(strategy="funnel"): public API against the engine, workers, fallback and >64 channels."""
import numpy as np
import pytest
from numpy.testing import assert_array_equal
from wisp import WISPClassifier, WISPSearch
from wisp.selection import _har
KW = dict(budget=10, population=4)
def _har_pair(train, valid, **info):
names = ["0", "1", "2"]
X, y, g, t = train
Xv, yv, gv, tv = valid
return _har(X, y, g, t, names, "train", **info), _har(Xv, yv, gv, tv, names, "validation", **info)
def test_funnel_api_equals_engine(train_windows, valid_windows, test_windows, tmp_path):
"""decoder="recipe": the public estimator predicts with the engine's own refitted winners."""
from wisp_fast.funnel.joint import fit_joint_funnel
X, y, g, t = train_windows
Xv, yv, gv, tv = valid_windows
Xq = test_windows[0]
info = dict(sampling_rate_hz=25.0, study_setting="free_living") # recording descriptors reach the fingerprint
search = WISPSearch("funnel", decoder="recipe", random_state=7, n_jobs=1, **KW).fit(
X, y, groups=g, time_index=t, validation=(Xv, yv, gv, tv), **info)
tr, va = _har_pair(train_windows, valid_windows, **info)
assert tr.metadata == {"study_setting": "free_living"} and tr.sampling_rate_hz == 25.0
models, summaries, receipt = fit_joint_funnel(tr, va, output=tmp_path / "engine", seed=7, evaluations=10,
population=4, workers=1)
for c in ("random", "evolution"):
est = search.funnel_estimators_[c]
assert search.funnel_summary_[c]["winner_id"] == summaries[f"wisp_{c}"]["best"]["id"]
assert_array_equal(est.predict_proba(Xq), models[f"wisp_{c}"].predict_proba(Xq))
assert est.decoder_reason_ == "fixed" and est.has_paper_results_ is False
assert search.best_estimator_ is search.funnel_estimators_["random"]
assert search.has_paper_results_ is False and search.selection_seconds_ > 0
assert len(search.history_) == 10 and search.funnel_receipt_["evaluations"] == 10
def test_funnel_workers_do_not_change_results(train_windows, valid_windows, test_windows):
X, y, g, t = train_windows
Xv, yv, gv, tv = valid_windows
a = WISPSearch("funnel", controller="evolution", n_jobs=1, **KW).fit(X, y, groups=g, time_index=t,
validation=(Xv, yv, gv, tv))
b = WISPSearch("funnel", controller="evolution", n_jobs=2, **KW).fit(X, y, groups=g, time_index=t,
validation=(Xv, yv, gv, tv))
assert a.best_estimator_ is a.funnel_estimators_["evolution"]
for c in ("random", "evolution"):
assert_array_equal(a.funnel_estimators_[c].predict_proba(test_windows[0]),
b.funnel_estimators_[c].predict_proba(test_windows[0]))
assert a.funnel_estimators_[c].decoder_ == b.funnel_estimators_[c].decoder_
@pytest.mark.parametrize("mode", ["tuple", "size"])
def test_funnel_no_candidate_fallback(mode, train_windows, valid_windows, test_windows, monkeypatch):
import wisp_fast.funnel.joint as joint
def fail(*args, **kwargs):
raise RuntimeError("No full-validation candidate passed; see verified.json")
monkeypatch.setattr(joint, "fit_joint_funnel", fail)
X, y, g, t = train_windows
Xv, yv, gv, tv = valid_windows
fit_kw = {"validation": (Xv, yv, gv, tv)} if mode == "tuple" else {"validation_size": 0.34}
with pytest.raises(RuntimeError, match="No full-validation candidate passed"):
WISPSearch("funnel", **KW).fit(X, y, groups=g, time_index=t, **fit_kw)
s = WISPSearch("funnel", on_no_candidate="default", decoder="recipe", **KW).fit(X, y, groups=g, time_index=t,
**fit_kw)
assert s.fallback_["reason"].startswith("No full-validation candidate passed")
assert s.best_recipe_.id == "cis" and s.funnel_estimators_["evolution"] is s.best_estimator_
if mode == "tuple":
ref = WISPClassifier("cis", decoder="recipe").fit(np.concatenate([X, Xv]), np.concatenate([y, yv]),
groups=np.concatenate([g, gv]),
time_index=np.concatenate([t, tv]))
else: # all of X in its original row order
ref = WISPClassifier("cis", decoder="recipe").fit(X, y, groups=g, time_index=t)
assert_array_equal(s.predict_proba(test_windows[0]), ref.predict_proba(test_windows[0]))
def test_funnel_options():
with pytest.raises(ValueError, match="sequence='subject'"):
WISPSearch("funnel", sequence="recording").fit(np.zeros((8, 16, 3)), np.arange(8) % 2,
groups=np.arange(8))
with pytest.raises(ValueError, match="controller"):
WISPSearch("funnel", controller="optuna").fit(np.zeros((8, 16, 3)), np.arange(8) % 2, groups=np.arange(8))
with pytest.raises(ValueError, match="on_no_candidate"):
WISPSearch("funnel", on_no_candidate="skip").fit(np.zeros((8, 16, 3)), np.arange(8) % 2,
groups=np.arange(8))
def test_feature_dictionary_channels(monkeypatch):
"""At most 64 channels: the compiled kernel (when built); above 64: the portable route."""
from wisp_fast.funnel import cis_lite
rng = np.random.default_rng(0)
wide = rng.normal(size=(20, 32, 70))
m = cis_lite.CISLite("wide", seed=3)
m._plan(wide.shape[1:])
calls = []
if cis_lite._cis_lite is not None:
real = cis_lite._cis_lite
class Spy:
def features(self, *args):
calls.append(args[0].shape)
return real.features(*args)
monkeypatch.setattr(cis_lite, "_cis_lite", Spy())
out = m.transform(wide)
x = m._inputs(wide)
ref = cis_lite._numpy_features(x, m.index_, m.channels_, m.dilation_, m.weights_, m.bias_, m.lags_, m.parts_,
cis_lite.PRESETS["wide"].stride, m.mask_)
assert_array_equal(out, ref) and not calls
narrow = rng.normal(size=(20, 32, 3))
m3 = cis_lite.CISLite("wide", seed=3)
m3._plan(narrow.shape[1:])
assert m3.transform(narrow).shape == (20, m3.n_features_)
assert len(calls) == (1 if cis_lite._cis_lite is not None else 0)
def test_funnel_more_than_64_channels():
rng = np.random.default_rng(1)
n, T, C = 60, 24, 66
y = np.resize(np.arange(3), n)
X = rng.normal(size=(n, T, C)) + y[:, None, None] * 0.8
g = np.repeat(np.arange(12), 5)
s = WISPSearch("funnel", budget=6, population=4, decoder="none").fit(X, y, groups=g, validation_size=0.25)
assert s.predict_proba(X[:5]).shape == (5, 3)
|