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,543 Bytes
4731b11 93a9282 4731b11 | 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 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 | """Input checks shared by the public interface: window layout, labels, groups and splits."""
from __future__ import annotations
import contextlib
from typing import Any
import numpy as np
LAYOUTS = ("NTC", "NCT")
SPEEDS = ("exact", "fast")
SEQUENCES = ("subject", "recording")
DECODERS = ("adaptive", "recipe", "hmm", "none", "auto") # "auto": deprecated alias of "recipe"
def check_choice(name: str, value: Any, choices: tuple) -> Any:
if value not in choices:
raise ValueError(f"{name} must be one of {', '.join(map(repr, choices))}; got {value!r}")
return value
def as_windows(X: Any, layout: str = "NTC") -> np.ndarray:
"""Return windows as a finite float64 ``(n, T, C)`` array (the kernel convention).
``layout="NCT"`` accepts ``(n, C, T)`` and transposes it. A 2-D array is read as
``(n, T)``, i.e. single-channel windows, as in the kernel. Values must be finite:
impute missing samples before windowing (the kernel would silently zero them).
"""
check_choice("layout", layout, LAYOUTS)
try:
from scipy import sparse
if sparse.issparse(X):
raise TypeError("Sparse input is not supported: WISP needs dense arrays of windows")
except ImportError: # pragma: no cover
pass
arr = np.asarray(X)
if np.iscomplexobj(arr):
raise ValueError("Complex data not supported")
try:
arr = np.asarray(arr, dtype=np.float64)
except (TypeError, ValueError) as exc:
raise TypeError(f"X must be a numeric array of windows ({exc})") from None
if arr.ndim == 1:
raise ValueError("Expected windows of shape (n, T, C) or (n, T), got a 1-D array. Reshape your data, "
"e.g. X[None, :] for a single window.")
if arr.ndim == 2:
if arr.shape[1] == 0:
raise ValueError(f"0 feature(s) (shape={arr.shape}) while a minimum of 1 is required.")
arr = arr[:, :, None] if layout == "NTC" else arr[:, None, :]
if arr.ndim != 3:
raise ValueError(f"X must have shape (n, T, C) for layout='NTC' or (n, C, T) for layout='NCT'; got {arr.shape}")
if arr.shape[0] == 0:
raise ValueError(f"Found array with 0 sample(s) (shape={arr.shape}) while a minimum of 1 is required.")
if layout == "NCT":
arr = arr.transpose(0, 2, 1)
if min(arr.shape) < 1:
raise ValueError(f"X must be nonempty; got shape {arr.shape}")
if not np.isfinite(arr).all():
raise ValueError("Input X contains NaN or infinity; WISP expects finite windows (impute missing samples first)")
return np.ascontiguousarray(arr)
def check_input_shape(estimator: Any, X_raw: Any, Xw: np.ndarray) -> None:
"""Fitted (T, C) must match; 2-D input gets scikit-learn's feature-count message."""
expected = tuple(estimator.input_shape_)
if Xw.shape[1:] != expected:
raw = np.asarray(X_raw) if not hasattr(X_raw, "shape") else X_raw
if getattr(raw, "ndim", 3) == 2:
raise ValueError(f"X has {raw.shape[1]} features, but {type(estimator).__name__} is expecting "
f"{estimator.n_features_in_} features as input.")
raise ValueError(f"Fitted on windows of shape (T, C)={expected}; got {Xw.shape[1:]}")
def check_targets(estimator: Any, y: Any) -> np.ndarray:
"""1-D classification targets (scikit-learn conventions for errors and warnings)."""
from sklearn.utils.multiclass import check_classification_targets
from sklearn.utils.validation import assert_all_finite, column_or_1d
if y is None:
raise ValueError(f"{type(estimator).__name__} requires y to be passed, but the target y is None.")
y = column_or_1d(y, warn=True)
if y.dtype.kind in "fc":
assert_all_finite(y, input_name="y")
check_classification_targets(y)
return y
def check_aligned(name: str, values: Any, n: int) -> np.ndarray | None:
if values is None:
return None
arr = np.asarray(values)
if arr.ndim != 1 or len(arr) != n:
raise ValueError(f"{name} must be one-dimensional with one entry per window ({n}); got shape {arr.shape}")
return arr
def encode_labels(y: Any, classes: Any | None = None) -> tuple[np.ndarray, np.ndarray]:
"""Encode arbitrary hashable labels as ``0..K-1``.
With ``classes`` the order of that global class table is used and every label in
``y`` must belong to it; otherwise the sorted unique labels of ``y`` are used.
"""
y = np.asarray(y)
if y.ndim != 1 or y.size == 0:
raise ValueError("y must be a nonempty one-dimensional array")
if classes is None:
table, codes = np.unique(y, return_inverse=True)
return table, codes.astype(np.int64)
table = np.asarray(classes)
if table.ndim != 1 or table.size == 0:
raise ValueError("classes must be a nonempty one-dimensional table")
if len(np.unique(table)) != table.size:
raise ValueError("classes must not contain duplicates")
lookup = {_key(c): i for i, c in enumerate(table.tolist())}
try:
codes = np.fromiter((lookup[_key(v)] for v in y.tolist()), dtype=np.int64, count=y.size)
except KeyError as exc:
raise ValueError(f"label {exc.args[0]!r} is not in the supplied classes table") from None
return table, codes
def _key(value: Any) -> Any:
if isinstance(value, (np.generic,)):
return value.item()
return value
def check_disjoint_groups(train_groups: Any, valid_groups: Any) -> None:
if train_groups is None or valid_groups is None:
raise ValueError("Selection and search need groups for both training and validation windows")
a = set(np.asarray(train_groups).astype(str).tolist())
b = set(np.asarray(valid_groups).astype(str).tolist())
shared = a & b
if shared:
raise ValueError(f"Training and validation groups overlap ({len(shared)} shared IDs, e.g. "
f"{sorted(shared)[:3]}); validation must come from different sequences")
@contextlib.contextmanager
def kernel_context():
"""Run frozen-kernel code with scikit-learn metadata routing switched off.
The kernel passes ``clf__sample_weight`` to its internal pipelines, which scikit-learn
rejects when a caller has enabled metadata routing globally. Routing of ``groups`` to
the public estimators is unaffected; this only scopes the kernel's own calls
(``sklearn.config_context`` is thread-local).
"""
import sklearn
with sklearn.config_context(enable_metadata_routing=False):
yield
|