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: 7,736 Bytes
ac7f7cb | 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 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 | """Search-scoped reuse of deterministic representation components on immutable splits."""
from collections import OrderedDict
from copy import copy
import hashlib
from threading import RLock
import weakref
from functools import lru_cache
import numpy as np
from wisp.cpu import features as ref
from . import features as fx
@lru_cache(maxsize=128)
def _dyadic(time):
# Mirrors the release order, including deduplication for short windows.
bounds = []
for parts in (2, 4, 8):
width = max(2, (time+parts-1)//parts)
bounds.extend((lo,min(lo+width,time)) for lo in range(0,time,width)
if min(lo+width,time)-lo >= 2)
return tuple(dict.fromkeys(bounds))
class SearchFeatures:
"""A private per-run LRU; share only deterministic blocks, never train labels or heads."""
def __init__(self, limit_mb, arrays):
self.limit = int(limit_mb * 1024**2)
self.known = {id(arr): (arr, i) for i, arr in enumerate(arrays)}
self.derived = {}
self.store = OrderedDict()
# Tile data have much greater cardinality than the stable feature
# blocks. Keep a separate bounded LRU to avoid flushing the hot set.
self.tiles = OrderedDict()
self.tile_limit = self.limit // 8
self.tile_bytes = self.tile_hits = self.rank_hits = self.dyad_hits = 0
self.bytes = self.peak = self.hits = self.misses = self.evictions = 0
self.lock = RLock()
def clear(self):
self.store.clear()
self.known.clear()
self.derived.clear()
self.tiles.clear()
self.tile_bytes = 0
self.bytes = 0
def stats(self):
return dict(limit_bytes=self.limit, peak_bytes=self.peak, hits=self.hits,
misses=self.misses, evictions=self.evictions, shapelet_tile_hits=self.tile_hits,
interval_rank_hits=self.rank_hits, dyadic_block_hits=self.dyad_hits)
def token(self, x):
val = self.known.get(id(x))
if val is not None and x is val[0]:
return val[1]
with self.lock:
entry = self.derived.get(id(x))
if entry is not None and entry[0]() is x:
return entry[1]
# Derived arrays (e.g. train-row cap and temporal downsampling) must
# never be keyed by shape alone. Their allocation may change each fit.
return (x.shape, x.dtype.str, x.strides,
hashlib.blake2b(np.ascontiguousarray(x).view(np.uint8), digest_size=16).digest())
def sampled(self, x, steps, sample):
key = (self.token(x),"time_sample",steps)
arr = self.get(key,sample)
# Weak entries tie identity to live allocations, even after eviction.
idx = id(arr)
def expired(ref):
with self.lock:
item = self.derived.get(idx)
if item is not None and item[0] is ref:
self.derived.pop(idx)
with self.lock:
self.derived[idx] = (weakref.ref(arr,expired),key)
return arr
def get(self, key, fn, *, tile=False):
store = self.tiles if tile else self.store
limit = self.tile_limit if tile else self.limit - self.tile_limit
with self.lock:
if key in store:
self.hits += 1
if tile:self.tile_hits += 1
if key[1]=="interval_rank":self.rank_hits += 1
if key[1]=="dyad":self.dyad_hits += 1
store.move_to_end(key)
return store[key]
self.misses += 1
arr = fn()
if arr.nbytes <= limit:
with self.lock:
if key not in store:
used = self.tile_bytes if tile else self.bytes
while used + arr.nbytes > limit:
_, old = store.popitem(last=False)
used -= old.nbytes
self.evictions += 1
store[key] = arr
used += arr.nbytes
if tile:self.tile_bytes = used
else:self.bytes = used
self.peak = max(self.peak, self.bytes+self.tile_bytes)
return arr
def transform(self, blocks, x):
token = self.token(x)
def zscore():
return self.get((token, "z"), lambda: fx._normalize(ref._as_3d(x)))
def interval(block, data, norm):
def native_plan(b, rank, evaluate):
order = self.get((token,"interval_rank",norm),rank)
fixed = _dyadic(data.shape[1]) if b.include_dyadic else ()
if not fixed or tuple(b.intervals_[:len(fixed)]) != fixed:
return evaluate(b.intervals_,order)
params = (norm,b.fast_profile,tuple(b.quantiles),fixed)
common = self.get((token,"dyad",params),lambda:evaluate(fixed,order))
suffix = b.intervals_[len(fixed):]
return np.concatenate((common,evaluate(suffix,order)),axis=1) if suffix else common
return block.transform_normalized(data,native_plan=native_plan)
features=[]
for b in blocks:
if type(b) is fx.WearableFeatureExtractor:
# Stateless window-local features. Constructor parameters fully
# specify columns, including turbo choices. Fitted names are
# cheap to copy and restored on warm hits for pickle-size parity.
params=tuple(b.get_params(deep=False).items())
key=(token, "wear", params)
def calculate():
return b.transform_normalized(zscore()) if x.flags.c_contiguous and b.zscore else b.transform(x)
value=self.get(key,calculate)
if not b.feature_names_:
b.transform(x[:1])
elif type(b) is fx.InvariantPhysicsFeatureExtractor and x.flags.c_contiguous and b.interval_ is not None:
# Upstream concatenates deterministic physics with a separate
# seeded random-interval branch. Share the former across seeds.
key=(token,"physics",b.segment_sizes,b.symbolic_bins,b.zscore,b.fast_profile,b.include_axis_features)
def fixed():
base=copy(b)
base.interval_=None
return base.transform(x)
common=self.get(key,fixed)
xn=zscore() if b.zscore else np.nan_to_num(ref._as_3d(x))
if b.interval_.zscore:
xn=self.get((token,"physics_second_z",b.zscore),lambda:fx._normalize(xn))
intervals=interval(b.interval_,xn,("physics",b.zscore,b.interval_.zscore))
value=np.concatenate((common,intervals),axis=1)
elif type(b) is fx.IntervalDistributionSketch and x.flags.c_contiguous and b.zscore:
value=interval(b,zscore(),"z")
elif type(b) is fx.RandomShapeletSketch and x.flags.c_contiguous and b.zscore:
def tile(key, fn):
return self.get((token,"shapelet_windows",key),fn,tile=True)
value=b.transform_normalized(zscore(),window_tile=tile)
elif type(b) is fx.RandomConvSketch and x.flags.c_contiguous and b.zscore:
value=b.transform_normalized(zscore())
else:
# Fitted shapelets depend on actual training examples; they
# are deliberately evaluated with the candidate's own object.
value=b.transform(x)
features.append(value)
capture=getattr(self,"capture",None)
if capture is not None:capture(x,blocks,features)
return features
|