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,387 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 | """Construct the frozen-kernel estimator for a recipe and a speed tier (no fitting here).
``speed="exact"``: the 0.2.0 accelerated engine (``wisp_fast``) with the original Ridge
solver. Its decoded labels were verified identical to the paper code; see docs/SPEED.md
for the cells, score differences and timings behind this choice.
``speed="fast"``: the same engine with the screened Ridge solver (Ridge strength chosen on
a 512-row training subsample, then one fit on all rows). Only Ridge readouts change.
Every path below only *constructs* kernel objects through existing builders; the
numerical work is done by unmodified kernel code.
"""
from __future__ import annotations
from typing import Any
from .recipes import Recipe
#: speed tier -> Ridge solver name of the accelerated engine
RIDGE_SOLVER = {"exact": "original", "fast": "screened"}
def _reference_kernel(recipe: Recipe, *, use_hmm: bool, seed: int, n_jobs: int) -> Any:
"""Paper (unaccelerated) kernel object for a recipe."""
if recipe.source == "fixed":
from wisp.registry import build_method
return build_method(recipe.provenance["method_id"], seed=seed, n_jobs=n_jobs,
overrides={"use_hmm": bool(use_hmm)})
if recipe.source == "cis_subset":
from wisp.ablations import build_recipe
return build_recipe(recipe.provenance["paper_ids"]["hmm" if use_hmm else "none"], seed=seed, n_jobs=n_jobs)
from wisp.cis_algorithms import build_cpu_estimator
spec = recipe.kernel_spec(seed=seed, n_jobs=n_jobs)
spec["params"]["use_hmm"] = bool(use_hmm)
return build_cpu_estimator(spec)
def build_kernel(recipe: Recipe, *, use_hmm: bool, speed: str = "exact", sequence: str = "subject",
seed: int = 42, n_jobs: int = 1, engine: str | None = None) -> Any:
"""Kernel estimator for ``recipe`` with fit/predict/predict_proba on encoded labels.
``engine="reference"`` returns the paper code itself (used by the equivalence tests).
"""
if engine == "reference":
if speed != "exact" or sequence != "subject":
raise ValueError("The reference kernel supports speed='exact' and sequence='subject' only")
return _reference_kernel(recipe, use_hmm=use_hmm, seed=seed, n_jobs=n_jobs)
if engine not in (None, "accelerated"):
raise ValueError(f"Unknown engine {engine!r}")
if recipe.params.get("class_balance", "balanced") != "balanced":
# The accelerated engine implements the balanced heads of the paper grammar only.
if speed != "exact" or sequence != "subject":
raise ValueError("class_balance='none' recipes run on the reference kernel only")
return _reference_kernel(recipe, use_hmm=use_hmm, seed=seed, n_jobs=n_jobs)
solver = RIDGE_SOLVER[speed]
if recipe.source == "fixed":
from wisp_release.methods import build_family
return build_family(recipe.provenance["method_id"], seed=seed, n_jobs=n_jobs,
overrides={"use_hmm": bool(use_hmm)}, speed=speed, sequence=sequence)
if recipe.source == "cis_subset":
from wisp_fast.engine import build_recipe
return build_recipe(recipe.provenance["paper_ids"]["hmm" if use_hmm else "none"], seed=seed,
n_jobs=n_jobs, ridge_solver=solver if recipe.params.get("classifier") == "ridge"
else "original", sequence=sequence)
spec = recipe.kernel_spec(seed=seed, n_jobs=n_jobs)
spec["params"]["use_hmm"] = bool(use_hmm)
if recipe.family == "state_rocket_interval_hmm" and any(
k in spec["params"] for k in ("use_rocket", "use_intervals", "use_state", "class_balance", "use_anchor_stats")):
# CIS block subsets exist only in the wisp.cis_algorithms template (as for wisp.ablations);
# wrap it exactly as wisp_fast.engine.build_recipe does.
from wisp.cis_algorithms import build_cpu_estimator
from wisp_fast.engine import FastFamily
template = build_cpu_estimator(spec)
model = FastFamily(template, "exact", None, ridge_solver=solver if template.classifier == "ridge" else "original",
sequence=sequence)
model.recipe_id = "custom"
return model
from wisp_fast.engine import build_candidate
return build_candidate(spec, ridge_solver=solver, sequence=sequence)
|