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: 4,116 Bytes
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 | """Small adapters for plugging other models into WISP (and WISP features into PyTorch).
PyTorch is imported only when a torch adapter is used; the rest of the package works
without it.
"""
from __future__ import annotations
from typing import Any, Callable
import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin
__all__ = ["FunctionBlock", "TorchEncoderBlock", "to_torch_dataset"]
class FunctionBlock(TransformerMixin, BaseEstimator):
"""Wrap any function ``fn(X) -> (n, d)`` as a stateless representation block.
Use it for frozen feature extractors or to adapt layouts, e.g. a transformer that
expects ``(n, C, T)``: ``FunctionBlock(lambda X: model.transform(X.transpose(0, 2, 1)))``.
"""
def __init__(self, fn: Callable[[np.ndarray], Any] | None = None, kw_args: dict | None = None):
self.fn = fn
self.kw_args = kw_args
def fit(self, X, y=None):
if self.fn is None or not callable(self.fn):
raise ValueError("FunctionBlock needs a callable fn")
return self
def transform(self, X):
out = np.asarray(self.fn(X, **(self.kw_args or {})))
if out.ndim == 1:
out = out[:, None]
if out.ndim != 2 or len(out) != len(X):
raise ValueError(f"fn must return an (n, d) array for n={len(X)} windows; got shape {out.shape}")
return out
class TorchEncoderBlock(TransformerMixin, BaseEstimator):
"""A frozen PyTorch encoder as a representation block.
Windows arrive as ``(n, T, C)`` (``layout="NTC"``, the WISP convention) or ``(n, C, T)``
and are passed to the module as float32 ``(batch, C, T)`` tensors, the usual PyTorch
convention for 1-D convolutions. The module runs in ``eval()`` mode under
``torch.no_grad()`` in batches; its output is flattened to ``(n, d)``. ``fit`` does
not train the module.
"""
def __init__(self, module=None, batch_size: int = 256, device: str = "cpu", layout: str = "NTC"):
self.module = module
self.batch_size = batch_size
self.device = device
self.layout = layout
def fit(self, X, y=None):
import torch # noqa: F401 (fail early with a clear ImportError)
if self.module is None:
raise ValueError("TorchEncoderBlock needs a torch.nn.Module")
if self.layout not in ("NTC", "NCT"):
raise ValueError("layout must be 'NTC' or 'NCT'")
return self
def transform(self, X):
import torch
arr = np.asarray(X, dtype=np.float32)
if arr.ndim == 2:
arr = arr[:, :, None] if self.layout == "NTC" else arr[:, None, :]
if self.layout == "NTC":
arr = arr.transpose(0, 2, 1)
arr = np.ascontiguousarray(arr)
module = self.module.to(self.device)
was_training = module.training
module.eval()
outs = []
try:
with torch.no_grad():
for start in range(0, len(arr), int(self.batch_size)):
batch = torch.from_numpy(arr[start:start + int(self.batch_size)]).to(self.device)
out = module(batch)
if isinstance(out, (tuple, list)):
out = out[0]
outs.append(out.reshape(out.shape[0], -1).detach().cpu().numpy().astype(np.float64))
finally:
module.train(was_training)
return np.concatenate(outs, axis=0) if outs else np.empty((0, 0))
def to_torch_dataset(Z, y=None, *, dtype: str = "float32"):
"""``torch.utils.data.TensorDataset`` of features ``Z`` (and integer labels ``y``).
``y`` must already be encoded as integers ``0..K-1`` (e.g. with ``np.unique(..., return_inverse=True)``).
"""
import torch
from torch.utils.data import TensorDataset
Zt = torch.as_tensor(np.asarray(Z, dtype=dtype))
if y is None:
return TensorDataset(Zt)
yy = np.asarray(y)
if not np.issubdtype(yy.dtype, np.integer):
raise ValueError("y must be encoded integer class IDs")
return TensorDataset(Zt, torch.as_tensor(yy.astype(np.int64)))
|