ice-skaters 0.1.0__tar.gz

ice_skaters-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2026 Peter Cotton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ice_skaters-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: ice-skaters
+Version: 0.1.0
+Summary: skaters on a river: calibrated forecast features for streaming ML pipelines. Each numeric stream becomes what the forecaster expected and how surprising the value was.
+Author-email: Peter Cotton <peter.cotton@microprediction.com>
+License: MIT
+Project-URL: Homepage, https://github.com/microprediction/ice-skaters
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: skaters>=0.12.1
+Requires-Dist: river>=0.21
+Dynamic: license-file
+
+# ice-skaters
+
+[skaters](https://github.com/microprediction/skaters) on a
+[river](https://riverml.xyz): calibrated forecast features for streaming
+ML pipelines.
+
+Every numeric stream is replaced by two scalars from its own online
+Laplace forecaster: the predictive mean (what the forecaster expected
+this value to be) and the standardized surprise z (how unexpected the
+actual value was, bounded near |z| = 7 by construction). The mean
+carries the level, the z carries the news. A wild observation can move
+the pair only so far, and that bounded influence is where the robustness
+comes from.
+
+```
+pip install ice-skaters
+```
+
+```python
+from river import datasets, linear_model, metrics, preprocessing
+from ice_skaters import LaplaceFeatures, LaplaceTarget
+
+model = LaplaceTarget(
+    regressor=preprocessing.TargetStandardScaler(
+        regressor=LaplaceFeatures()
+        | preprocessing.StandardScaler()
+        | linear_model.LinearRegression()))
+
+mae = metrics.MAE()
+for x, y in datasets.TrumpApproval():
+    pred = model.predict_one(x)
+    mae.update(y, pred if pred is not None else 0.0)
+    model.learn_one(x, y)
+```
+
+`LaplaceFeatures` is a river Transformer for the input streams.
+`LaplaceTarget` wraps any regressor, in the style of
+`TargetStandardScaler`, to add the target's own (mean, surprise) pair,
+which a transformer cannot do since it never sees y. The target itself
+stays raw. Both estimators pipe, pickle and deep-copy like any river
+estimator. Non-numeric values pass through untouched, and NaN is imputed
+by the forecast itself with z = 0: the model receives "expected value,
+no news" instead of a poisoned pipeline.
+
+## Why
+
+On TrumpApproval with river's recommended pipeline (progressive
+validation MAE, burn-in 100, `examples/trump_approval.py`):
+
+| | clean | 2% corrupted readings |
+|---|---|---|
+| `StandardScaler` pipeline | 0.328 | 0.597 |
+| + Laplace front-end | 0.382 | 0.407 |
+
+The front-end pays a small toll on clean data and holds its footing when
+the inputs misbehave. In controlled simulation the same substitution
+beats raw features, a running z-score, a median/MAD winsorizer and a
+Huberised loss 30/30 seeds under every contamination type tested, at a
+small clean-data toll. Full protocols, numbers and the study design live
+in the [timemachines](https://github.com/microprediction/timemachines)
+repo, `benchmarks/RESULTS.md` section 6.
+
+## Boundaries, stated plainly
+
+- Distance-based learners (KNN) do not benefit: neighbour averaging is
+  already spike-robust and the extra dimensions degrade the metric.
+- Entity-interleaved streams (many units multiplexed into one key) want
+  per-entity bodies; a single body per key is handicapped there.
+- If your heavy tails are signal rather than noise, taming them costs
+  accuracy. Whether the extremes are informative decides the coordinates.
+
+## Relation to the stack
+
+`skaters` does one thing: fast univariate distributional forecasting,
+stdlib-only, and this package is deliberately a thin adapter over it.
+`timemachines` builds anomaly detection on the same calibrated surprise
+streams. ice-skaters is the bridge from those streams to river's
+estimator protocol, and nothing more.

ice_skaters-0.1.0/README.md

@@ -0,0 +1,78 @@
+# ice-skaters
+
+[skaters](https://github.com/microprediction/skaters) on a
+[river](https://riverml.xyz): calibrated forecast features for streaming
+ML pipelines.
+
+Every numeric stream is replaced by two scalars from its own online
+Laplace forecaster: the predictive mean (what the forecaster expected
+this value to be) and the standardized surprise z (how unexpected the
+actual value was, bounded near |z| = 7 by construction). The mean
+carries the level, the z carries the news. A wild observation can move
+the pair only so far, and that bounded influence is where the robustness
+comes from.
+
+```
+pip install ice-skaters
+```
+
+```python
+from river import datasets, linear_model, metrics, preprocessing
+from ice_skaters import LaplaceFeatures, LaplaceTarget
+
+model = LaplaceTarget(
+    regressor=preprocessing.TargetStandardScaler(
+        regressor=LaplaceFeatures()
+        | preprocessing.StandardScaler()
+        | linear_model.LinearRegression()))
+
+mae = metrics.MAE()
+for x, y in datasets.TrumpApproval():
+    pred = model.predict_one(x)
+    mae.update(y, pred if pred is not None else 0.0)
+    model.learn_one(x, y)
+```
+
+`LaplaceFeatures` is a river Transformer for the input streams.
+`LaplaceTarget` wraps any regressor, in the style of
+`TargetStandardScaler`, to add the target's own (mean, surprise) pair,
+which a transformer cannot do since it never sees y. The target itself
+stays raw. Both estimators pipe, pickle and deep-copy like any river
+estimator. Non-numeric values pass through untouched, and NaN is imputed
+by the forecast itself with z = 0: the model receives "expected value,
+no news" instead of a poisoned pipeline.
+
+## Why
+
+On TrumpApproval with river's recommended pipeline (progressive
+validation MAE, burn-in 100, `examples/trump_approval.py`):
+
+| | clean | 2% corrupted readings |
+|---|---|---|
+| `StandardScaler` pipeline | 0.328 | 0.597 |
+| + Laplace front-end | 0.382 | 0.407 |
+
+The front-end pays a small toll on clean data and holds its footing when
+the inputs misbehave. In controlled simulation the same substitution
+beats raw features, a running z-score, a median/MAD winsorizer and a
+Huberised loss 30/30 seeds under every contamination type tested, at a
+small clean-data toll. Full protocols, numbers and the study design live
+in the [timemachines](https://github.com/microprediction/timemachines)
+repo, `benchmarks/RESULTS.md` section 6.
+
+## Boundaries, stated plainly
+
+- Distance-based learners (KNN) do not benefit: neighbour averaging is
+  already spike-robust and the extra dimensions degrade the metric.
+- Entity-interleaved streams (many units multiplexed into one key) want
+  per-entity bodies; a single body per key is handicapped there.
+- If your heavy tails are signal rather than noise, taming them costs
+  accuracy. Whether the extremes are informative decides the coordinates.
+
+## Relation to the stack
+
+`skaters` does one thing: fast univariate distributional forecasting,
+stdlib-only, and this package is deliberately a thin adapter over it.
+`timemachines` builds anomaly detection on the same calibrated surprise
+streams. ice-skaters is the bridge from those streams to river's
+estimator protocol, and nothing more.

ice_skaters-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ice-skaters"
+version = "0.1.0"
+description = "skaters on a river: calibrated forecast features for streaming ML pipelines. Each numeric stream becomes what the forecaster expected and how surprising the value was."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "Peter Cotton", email = "peter.cotton@microprediction.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "skaters>=0.12.1",
+    "river>=0.21",
+]
+
+[project.urls]
+Homepage = "https://github.com/microprediction/ice-skaters"
+
+[tool.setuptools.packages.find]
+where = ["src"]

ice_skaters-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ice_skaters-0.1.0/src/ice_skaters/__init__.py

@@ -0,0 +1,205 @@
+"""ice-skaters: skaters on a river.
+
+Calibrated forecast features for `river <https://riverml.xyz>`_
+pipelines, built on the online Laplace forecaster of the ``skaters``
+package. ``LaplaceFeatures`` replaces each numeric feature stream with
+two scalars from its own forecaster: the one-step predictive mean (what
+the forecaster expected this value to be) and the standardized surprise
+z (how unexpected the actual value was, bounded by construction near
+|z| = 7). The mean carries the level, the z carries the news, and a wild
+input can move the pair only so far, which is where the robustness comes
+from. Non-numeric values pass through untouched; non-finite numeric
+values are imputed by the forecast itself (mean = the body's prediction,
+z = 0: no news), which is more than ``StandardScaler`` can say for NaN.
+
+    from river import linear_model, preprocessing
+    from ice_skaters import LaplaceFeatures, LaplaceTarget
+
+    model = LaplaceTarget(
+        regressor=preprocessing.TargetStandardScaler(
+            regressor=LaplaceFeatures()
+            | preprocessing.StandardScaler()
+            | linear_model.LinearRegression()))
+    # ...then the usual river loop:
+    # model.predict_one(x); model.learn_one(x, y)
+
+``LaplaceTarget`` adds the same pair for the target's own history, which
+a transformer cannot do since it never sees y; it wraps any regressor in
+the style of ``TargetStandardScaler`` and leaves the target itself raw.
+
+Evidence, protocols and boundaries (distance-based learners do not
+benefit; entity-interleaved streams want per-entity bodies; genuinely
+informative heavy tails should not be tamed): the regression front-end
+study in the timemachines repo, ``benchmarks/RESULTS.md`` section 6.
+
+Implementation notes:
+
+- river's ``Pipeline.learn_one`` updates unsupervised transformers
+  *before* calling ``transform_one`` for the downstream steps. A naive
+  stateful transformer would therefore hand the model fresher features
+  at learn time than it predicted with. ``LaplaceFeatures`` caches the
+  pre-update feature dict during ``learn_one`` and serves it to the
+  immediately following ``transform_one`` for the same sample, so the
+  predict path and the learn path see identical features. Bodies advance
+  exactly once per sample, in ``learn_one``; ``transform_one`` alone
+  (the predict path) is pure.
+- Instances hold only plain state data (dicts, Dists), never the skater
+  closure itself: skaters' state purity lets one module-level ``laplace``
+  callable serve every stream with state passed per stream, so both
+  estimators pickle and deep-copy like any river estimator.
+- Observations are winsorized before a body consumes them (1e60
+  absolute, plus a magnitude-relative window twelve orders above the
+  current predictive level). skaters >= 0.13 carries the same gate in
+  the parade; keeping it here too protects users on earlier releases.
+"""
+
+from __future__ import annotations
+import math
+from river import base
+from skaters import laplace
+from skaters.dist import Dist
+
+__version__ = "0.1.0"
+__all__ = ["LaplaceFeatures", "LaplaceTarget"]
+
+_STD_NORMAL = Dist.gaussian(0.0, 1.0)
+_EPS = 1e-12          # parade's PIT clamp: |z| <= ~7.03, never infinite
+
+_SKATER = None        # shared, stateless given per-stream state; not pickled
+
+
+def _skater():
+    global _SKATER
+    if _SKATER is None:
+        _SKATER = laplace(1)
+    return _SKATER
+
+
+def _is_number(v) -> bool:
+    return isinstance(v, (int, float)) and not isinstance(v, bool)
+
+
+def _winsorize(v: float, pending) -> float:
+    """Clamp absurd finite magnitudes before a body consumes them.
+
+    Magnitude-relative, NOT sigma-relative: after a degenerate-variance
+    stretch (missing-data zeros, say) a legitimate value sits billions of
+    sigmas out and must pass. Twelve orders above the current level is
+    unreachable by data, far below the ~1e77 jump ratio where double
+    arithmetic actually dies, so this is exact identity on sane streams.
+    """
+    v = min(max(v, -1e60), 1e60)
+    if pending is not None:
+        m, s = pending.mean, pending.std
+        if math.isfinite(m) and math.isfinite(s):
+            w = 1e12 * (1.0 + abs(m) + s)
+            v = min(max(v, m - w), m + w)
+    return v
+
+
+class LaplaceFeatures(base.Transformer):
+    """Replace each numeric feature with (predictive mean, surprise z).
+
+    Args:
+        emit: which scalars to emit per stream, ``"both"`` (default),
+            ``"mu"`` or ``"z"``.
+        prefix: feature-name prefixes, ``(mean_prefix, z_prefix)``.
+    """
+
+    def __init__(self, emit: str = "both", prefix=("mu_", "z_")):
+        if emit not in ("both", "mu", "z"):
+            raise ValueError(f"emit must be 'both', 'mu' or 'z', got {emit!r}")
+        self.emit = emit
+        self.prefix = prefix
+        self._bodies = {}          # key -> (state dict, pending Dist)
+        self._pending_out = None   # features cached by learn_one
+        self._last_x = None
+
+    def _features(self, x):
+        """Pure: read the pending predictives, never advance a body."""
+        out = {}
+        mu_p, z_p = self.prefix
+        for k, v in x.items():
+            if not _is_number(v):
+                out[k] = v
+                continue
+            entry = self._bodies.get(k)
+            pending = entry[1] if entry else None
+            if pending is None:
+                mu = float(v) if math.isfinite(v) else 0.0
+                z = 0.0
+            elif not math.isfinite(v):
+                mu, z = pending.mean, 0.0          # forecast-imputed, no news
+            else:
+                mu = pending.mean
+                u = pending.cdf(float(v))
+                u = min(max(u, _EPS), 1.0 - _EPS)
+                z = _STD_NORMAL.quantile(u)
+            if self.emit in ("both", "mu"):
+                out[mu_p + k] = mu
+            if self.emit in ("both", "z"):
+                out[z_p + k] = z
+        return out
+
+    def learn_one(self, x):
+        self._pending_out = self._features(x)
+        self._last_x = dict(x)
+        f = _skater()
+        for k, v in x.items():
+            if not _is_number(v) or not math.isfinite(v):
+                continue                            # non-finite: no update
+            st, pending = self._bodies.get(k) or (None, None)
+            dists, st = f(_winsorize(float(v), pending), st)
+            self._bodies[k] = (st, dists[0])
+
+    def transform_one(self, x):
+        if self._pending_out is not None and x == self._last_x:
+            out, self._pending_out = self._pending_out, None
+            return out
+        return self._features(x)
+
+
+class LaplaceTarget(base.Regressor):
+    """Augment features with the TARGET stream's own (mean, surprise) pair.
+
+    Transformers never see y, so the target's calibrated history features
+    need a regressor wrapper, in the style of ``TargetStandardScaler``:
+
+        model = LaplaceTarget(
+            regressor=LaplaceFeatures()
+                      | preprocessing.StandardScaler()
+                      | linear_model.LinearRegression())
+
+    At prediction time the inner regressor receives, alongside x, the
+    body's forecast of the y it is about to predict (``mu_y``) and the
+    surprise of the previous y (``zy``). The same pre-update pair is used
+    at learn time, then the body consumes the new y. The target itself
+    stays raw: this wrapper never transforms y, it only adds features.
+    """
+
+    def __init__(self, regressor, keys=("mu_y", "zy")):
+        self.regressor = regressor
+        self.keys = keys
+        self._state = None
+        self._pending = None       # predictive Dist for the next y
+        self._zy = 0.0
+
+    def _augment(self, x):
+        mu_key, z_key = self.keys
+        mu = self._pending.mean if self._pending is not None else 0.0
+        return {**x, mu_key: mu, z_key: self._zy}
+
+    def predict_one(self, x):
+        return self.regressor.predict_one(self._augment(x))
+
+    def learn_one(self, x, y):
+        self.regressor.learn_one(self._augment(x), y)
+        y = float(y)
+        if math.isfinite(y):
+            # laplace is parade-wrapped: state["z"][0] is the surprise of
+            # this y against the predictive issued before it arrived
+            dists, self._state = _skater()(
+                _winsorize(y, self._pending), self._state)
+            self._pending = dists[0]
+            z = self._state["z"][0]
+            self._zy = z if z is not None else 0.0

ice_skaters-0.1.0/src/ice_skaters.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: ice-skaters
+Version: 0.1.0
+Summary: skaters on a river: calibrated forecast features for streaming ML pipelines. Each numeric stream becomes what the forecaster expected and how surprising the value was.
+Author-email: Peter Cotton <peter.cotton@microprediction.com>
+License: MIT
+Project-URL: Homepage, https://github.com/microprediction/ice-skaters
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: skaters>=0.12.1
+Requires-Dist: river>=0.21
+Dynamic: license-file
+
+# ice-skaters
+
+[skaters](https://github.com/microprediction/skaters) on a
+[river](https://riverml.xyz): calibrated forecast features for streaming
+ML pipelines.
+
+Every numeric stream is replaced by two scalars from its own online
+Laplace forecaster: the predictive mean (what the forecaster expected
+this value to be) and the standardized surprise z (how unexpected the
+actual value was, bounded near |z| = 7 by construction). The mean
+carries the level, the z carries the news. A wild observation can move
+the pair only so far, and that bounded influence is where the robustness
+comes from.
+
+```
+pip install ice-skaters
+```
+
+```python
+from river import datasets, linear_model, metrics, preprocessing
+from ice_skaters import LaplaceFeatures, LaplaceTarget
+
+model = LaplaceTarget(
+    regressor=preprocessing.TargetStandardScaler(
+        regressor=LaplaceFeatures()
+        | preprocessing.StandardScaler()
+        | linear_model.LinearRegression()))
+
+mae = metrics.MAE()
+for x, y in datasets.TrumpApproval():
+    pred = model.predict_one(x)
+    mae.update(y, pred if pred is not None else 0.0)
+    model.learn_one(x, y)
+```
+
+`LaplaceFeatures` is a river Transformer for the input streams.
+`LaplaceTarget` wraps any regressor, in the style of
+`TargetStandardScaler`, to add the target's own (mean, surprise) pair,
+which a transformer cannot do since it never sees y. The target itself
+stays raw. Both estimators pipe, pickle and deep-copy like any river
+estimator. Non-numeric values pass through untouched, and NaN is imputed
+by the forecast itself with z = 0: the model receives "expected value,
+no news" instead of a poisoned pipeline.
+
+## Why
+
+On TrumpApproval with river's recommended pipeline (progressive
+validation MAE, burn-in 100, `examples/trump_approval.py`):
+
+| | clean | 2% corrupted readings |
+|---|---|---|
+| `StandardScaler` pipeline | 0.328 | 0.597 |
+| + Laplace front-end | 0.382 | 0.407 |
+
+The front-end pays a small toll on clean data and holds its footing when
+the inputs misbehave. In controlled simulation the same substitution
+beats raw features, a running z-score, a median/MAD winsorizer and a
+Huberised loss 30/30 seeds under every contamination type tested, at a
+small clean-data toll. Full protocols, numbers and the study design live
+in the [timemachines](https://github.com/microprediction/timemachines)
+repo, `benchmarks/RESULTS.md` section 6.
+
+## Boundaries, stated plainly
+
+- Distance-based learners (KNN) do not benefit: neighbour averaging is
+  already spike-robust and the extra dimensions degrade the metric.
+- Entity-interleaved streams (many units multiplexed into one key) want
+  per-entity bodies; a single body per key is handicapped there.
+- If your heavy tails are signal rather than noise, taming them costs
+  accuracy. Whether the extremes are informative decides the coordinates.
+
+## Relation to the stack
+
+`skaters` does one thing: fast univariate distributional forecasting,
+stdlib-only, and this package is deliberately a thin adapter over it.
+`timemachines` builds anomaly detection on the same calibrated surprise
+streams. ice-skaters is the bridge from those streams to river's
+estimator protocol, and nothing more.

ice_skaters-0.1.0/src/ice_skaters.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/ice_skaters/__init__.py
+src/ice_skaters.egg-info/PKG-INFO
+src/ice_skaters.egg-info/SOURCES.txt
+src/ice_skaters.egg-info/dependency_links.txt
+src/ice_skaters.egg-info/requires.txt
+src/ice_skaters.egg-info/top_level.txt
+tests/test_ice_skaters.py

ice_skaters-0.1.0/src/ice_skaters.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ice_skaters-0.1.0/src/ice_skaters.egg-info/requires.txt

@@ -0,0 +1,2 @@
+skaters>=0.12.1
+river>=0.21

ice_skaters-0.1.0/src/ice_skaters.egg-info/top_level.txt

@@ -0,0 +1 @@
+ice_skaters

ice_skaters-0.1.0/tests/test_ice_skaters.py

@@ -0,0 +1,113 @@
+"""Alignment, robustness, serialization."""
+
+import copy
+import math
+import pickle
+import random
+
+import pytest
+from river import linear_model, preprocessing
+
+from ice_skaters import LaplaceFeatures, LaplaceTarget
+
+
+def _pipeline():
+    return LaplaceTarget(
+        regressor=preprocessing.TargetStandardScaler(
+            regressor=LaplaceFeatures()
+            | preprocessing.StandardScaler()
+            | linear_model.LinearRegression()))
+
+
+def test_predict_and_learn_see_identical_features():
+    """river's Pipeline updates transformers before transforming in
+    learn_one; the cache must hand both paths the same features."""
+    seen = []
+    orig = LaplaceFeatures.transform_one
+
+    def spy(self, x):
+        out = orig(self, x)
+        seen.append(dict(out))
+        return out
+
+    lf = LaplaceFeatures()
+    pipe = lf | preprocessing.StandardScaler() | linear_model.LinearRegression()
+    rng = random.Random(0)
+    LaplaceFeatures.transform_one = spy
+    try:
+        for _ in range(30):
+            x = {"a": rng.gauss(0, 1), "b": rng.gauss(5, 2)}
+            pipe.predict_one(x)
+            pipe.learn_one(x, rng.gauss(0, 1))
+    finally:
+        LaplaceFeatures.transform_one = orig
+    predict_path, learn_path = seen[0::2], seen[1::2]
+    assert predict_path == learn_path
+
+
+def test_surprise_is_bounded_on_wild_spike():
+    lf = LaplaceFeatures()
+    for t in range(100):
+        lf.learn_one({"a": math.sin(t)})
+    out = lf.transform_one({"a": 1e9})
+    assert abs(out["z_a"]) < 7.1
+    assert math.isfinite(out["mu_a"])
+
+
+def test_non_finite_values_are_forecast_imputed_and_ignored():
+    lf = LaplaceFeatures()
+    for t in range(50):
+        lf.learn_one({"a": float(t % 5)})
+    out = lf.transform_one({"a": float("nan")})
+    assert math.isfinite(out["mu_a"]) and out["z_a"] == 0.0
+    lf.learn_one({"a": float("inf")})       # must not corrupt the body
+    out = lf.transform_one({"a": 1.0})
+    assert all(math.isfinite(v) for v in out.values())
+
+
+def test_non_numeric_passthrough():
+    lf = LaplaceFeatures()
+    lf.learn_one({"a": 1.0, "tag": "x", "flag": True})
+    out = lf.transform_one({"a": 1.1, "tag": "x", "flag": True})
+    assert out["tag"] == "x" and out["flag"] is True
+    assert set(out) == {"tag", "flag", "mu_a", "z_a"}
+
+
+def test_emit_modes_and_validation():
+    assert set(LaplaceFeatures(emit="mu")._features({"a": 1.0})) == {"mu_a"}
+    assert set(LaplaceFeatures(emit="z")._features({"a": 1.0})) == {"z_a"}
+    with pytest.raises(ValueError):
+        LaplaceFeatures(emit="nope")
+
+
+def test_full_model_pickles_and_deepcopies():
+    model = _pipeline()
+    rng = random.Random(1)
+    for _ in range(40):
+        x = {"a": rng.gauss(0, 1)}
+        model.predict_one(x)
+        model.learn_one(x, rng.gauss(0, 1))
+    probe = {"a": 0.3}
+    expected = model.predict_one(probe)
+    assert pickle.loads(pickle.dumps(model)).predict_one(probe) == expected
+    assert copy.deepcopy(model).predict_one(probe) == expected
+
+
+def test_keys_may_appear_and_vanish_mid_stream():
+    lf = LaplaceFeatures()
+    lf.learn_one({"a": 1.0})
+    lf.learn_one({"a": 1.1, "c": 9.0})
+    out = lf.transform_one({"c": 9.1})
+    assert set(out) == {"mu_c", "z_c"}
+
+
+def test_target_wrapper_learns_and_predicts_finite():
+    model = _pipeline()
+    rng = random.Random(2)
+    preds = []
+    for t in range(120):
+        x = {"a": rng.gauss(0, 1)}
+        p = model.predict_one(x)
+        preds.append(p if p is not None else 0.0)
+        model.learn_one(x, 0.5 * x["a"] + rng.gauss(0, 0.1))
+    assert all(math.isfinite(p) for p in preds)