| """Input signal families and the evaluation regimes (input protocol v2, 2026-10-25). |
| |
| Out-of-distribution means what it means for a deployed estimator: the input is BOUNDED |
| by fixed actuator limits (a pedal travels between released and fully pressed), and what |
| changes in deployment is its SHAPE or its SEQUENCE (a different driver on a different |
| road), never its amplitude. Therefore |
| |
| * every family, in every regime, realises v(t) in [-1, 1] by construction (no |
| clipping); the applied input is u(t) = u_scale * v(t), and plants that declare |
| ``u_bounds`` are additionally rescaled (never clipped) to stay inside them; |
| * training covers the whole box: constant / staircase levels are uniform on [-1, 1], |
| periodic families carry an offset drawn inside [-(1 - A), 1 - A], so they reach the |
| edges; |
| * all time-like parameters are in units of the plant's reference time ``t_ref`` |
| (seconds per signal time unit, configs/systems/*.yaml): a frequency w in RANGES is |
| applied as w / t_ref, a dwell / ramp time / correlation time as dwell * t_ref. |
| Fractions of the horizon T (step time, ramp fraction) are unchanged. |
| |
| Regimes (the evaluation tiers of configs/base.yaml ``eval.tiers``) |
| train / id the training families (TRAIN_FAMILIES) at the "train" ranges; id uses |
| independent seeds (and drops the zero input) |
| shape_ood waveform families NEVER used in training (chirp, filtered_noise, |
| triangle, sawtooth): same box, same frequency band (in t_ref units) |
| sequence_ood the 'drive' family (pedal-like event sequence), which IS a training |
| family, with a different event sequence: same level grid and box, |
| different transition structure and timing (RANGES["drive"]) |
| |
| The 'drive' family: a level on the grid LEVELS (9 levels in [-1, 1]) is held for a dwell, |
| then the next level is reached by a linear ramp (press / release). The next level is |
| drawn uniformly among the grid levels whose distance from the current one lies in |
| ``delta``: |
| |
| train 'smooth driver': |delta| in [0.25, 0.5] dwell U[2, 6] ramp U[0.5, 1.5] |
| sequence_ood 'stop-and-go': |delta| in [1.0, 2.0] dwell U[0.5, 2] ramp U[0.2, 0.5] |
| |
| (times in t_ref). Both start at a uniform grid level and both can visit every level, so |
| the marginal level RANGE is identical ([-1, 1], same grid); what differs is the order of |
| the levels (small steps vs large jumps between distant levels, e.g. full press <-> |
| release), the dwell between events (shorter: stop-and-go) and the press / release rate. |
| |
| Piecewise-constant families carry explicit switch times snapped to the integration |
| grid; piecewise-linear families (drive, triangle, sawtooth) carry knots snapped to the |
| grid (consecutive knots at least one step apart), so no RK4 step straddles a switch or a |
| kink and the integrator keeps its order (tests/test_verify_data.py). |
| """ |
|
|
| from __future__ import annotations |
|
|
| from dataclasses import dataclass, field |
|
|
| import numpy as np |
|
|
| |
| OFFSET = (-1.0, 1.0) |
|
|
| RANGES = { |
| |
| "constant": {"train": {"A": (-1.0, 1.0)}}, |
| "step": {"train": {"A": (-1.0, 1.0), "t_step": (0.15, 0.5)}}, |
| "staircase": {"train": {"A": (-1.0, 1.0), "dwell": (2.0, 8.0)}}, |
| "prbs": {"train": {"A": (0.1, 1.0), "offset_frac": OFFSET, "dwell": (0.5, 4.0)}}, |
| "square": {"train": {"A": (0.1, 1.0), "w": (0.5, 2.0), "duty": (0.3, 0.7), |
| "offset_frac": OFFSET}}, |
| "sinusoid": {"train": {"A": (0.1, 1.0), "w": (0.5, 3.0), "offset_frac": OFFSET}}, |
| "multisine": {"train": {"A": (0.1, 1.0), "w": (0.3, 3.0), "n_comp": (3, 6), |
| "offset_frac": OFFSET}}, |
| "ramp": {"train": {"A": (-1.0, 1.0), "frac": (0.3, 1.0)}}, |
| "am": {"train": {"A": (0.1, 1.0), "w_fast": (2.0, 5.0), |
| "w_slow": (0.05, 0.3), "m": (0.4, 1.0)}}, |
| "drive": {"train": {"n_levels": 9, "delta": (0.25, 0.5), |
| "dwell": (2.0, 6.0), "ramp": (0.5, 1.5)}, |
| "sequence_ood": {"n_levels": 9, "delta": (1.0, 2.0), |
| "dwell": (0.5, 2.0), "ramp": (0.2, 0.5)}}, |
| |
| "chirp": {"shape_ood": {"A": (0.1, 1.0), "w0": (0.5, 1.5), "w1": (1.5, 3.0), |
| "offset_frac": OFFSET}}, |
| "filtered_noise": {"shape_ood": {"A": (0.1, 1.0), "tau": (0.5, 5.0), "offset_frac": OFFSET}}, |
| "triangle": {"shape_ood": {"A": (0.1, 1.0), "w": (0.5, 2.0), "offset_frac": OFFSET}}, |
| "sawtooth": {"shape_ood": {"A": (0.1, 1.0), "w": (0.5, 2.0), "offset_frac": OFFSET}}, |
| } |
| TIME_KEYS = {"dwell", "ramp", "tau"} |
| FREQ_KEYS = {"w", "w0", "w1", "w_fast", "w_slow"} |
|
|
| TRAIN_FAMILIES = ["zero", "constant", "step", "staircase", "prbs", "square", |
| "sinusoid", "multisine", "ramp", "am", "drive"] |
| SHAPE_OOD_FAMILIES = ["chirp", "filtered_noise", "triangle", "sawtooth"] |
| SEQUENCE_OOD_FAMILIES = ["drive"] |
| TIERS = ("id", "shape_ood", "sequence_ood") |
| PIECEWISE_CONSTANT = {"zero", "constant", "step", "staircase", "prbs", "square"} |
| PIECEWISE_LINEAR = {"drive", "triangle", "sawtooth"} |
|
|
| assert not set(TRAIN_FAMILIES) & set(SHAPE_OOD_FAMILIES), "held-out waveforms leak" |
| assert set(SEQUENCE_OOD_FAMILIES) <= set(TRAIN_FAMILIES), "sequence_ood must reuse a training family" |
|
|
|
|
| def families_for(tier: str) -> list: |
| return {"train": TRAIN_FAMILIES, "id": [f for f in TRAIN_FAMILIES if f != "zero"], |
| "shape_ood": SHAPE_OOD_FAMILIES, "sequence_ood": SEQUENCE_OOD_FAMILIES}[tier] |
|
|
|
|
| def range_key(family: str, regime: str) -> str: |
| """Which RANGES entry a (family, regime) draws from; raises for a family the regime |
| does not use (e.g. a held-out waveform in training).""" |
| key = "train" if regime in ("train", "id") else regime |
| if family != "zero" and key not in RANGES.get(family, {}): |
| raise ValueError(f"family {family!r} has no {regime!r} regime") |
| return key |
|
|
|
|
| def regime_table() -> dict: |
| """The reviewable protocol: {tier: {family: ranges (t_ref units)}}.""" |
| return {t: {f: RANGES.get(f, {}).get(range_key(f, t), {}) for f in families_for(t)} |
| for t in ("train",) + TIERS} |
|
|
|
|
| @dataclass |
| class Signal: |
| """One fully specified input realisation u(t) (scalar input).""" |
| family: str |
| params: dict = field(default_factory=dict) |
| switch_times: np.ndarray = None |
| levels: np.ndarray = None |
| scale: float = 1.0 |
| knots: np.ndarray = None |
| knot_vals: np.ndarray = None |
|
|
| def __call__(self, t) -> np.ndarray: |
| t = np.asarray(t, dtype=np.float64) |
| if self.switch_times is not None: |
| i = np.searchsorted(self.switch_times, t, side="right") - 1 |
| return self.scale * self.levels[np.clip(i, 0, len(self.levels) - 1)] |
| if self.knots is not None: |
| return self.scale * np.interp(t, self.knots, self.knot_vals) |
| q, f = self.params, self.family |
| if f == "sinusoid": |
| v = q["A"] * np.sin(q["w"] * t + q["phi"]) + q["offset"] |
| elif f == "multisine": |
| v = q["offset"] + sum(a * np.sin(w * t + p) |
| for a, w, p in zip(q["amps"], q["freqs"], q["phases"])) |
| elif f == "ramp": |
| v = q["A"] * np.clip(t / max(q["frac"] * q["T"], 1e-9), 0.0, 1.0) |
| elif f == "am": |
| v = q["A"] / (1 + q["m"]) * (1 + q["m"] * np.sin(q["w_slow"] * t + q["ph_s"])) \ |
| * np.sin(q["w_fast"] * t + q["ph_f"]) |
| elif f == "chirp": |
| k = (q["w1"] - q["w0"]) / max(q["T"], 1e-9) |
| v = q["A"] * np.sin(q["w0"] * t + 0.5 * k * t ** 2 + q["phi"]) + q["offset"] |
| elif f == "filtered_noise": |
| v = np.interp(t, q["_t"], q["_v"]) |
| else: |
| raise ValueError(f) |
| return self.scale * v |
|
|
| def describe(self) -> dict: |
| p = {k: (v.tolist() if isinstance(v, np.ndarray) else v) |
| for k, v in self.params.items() if not k.startswith("_")} |
| return {"family": self.family, "scale": self.scale, **p} |
|
|
|
|
| def _strat(rng, lo, hi, stratum, n_strata): |
| """Stratified uniform: draw inside one of n_strata equal bins of [lo, hi].""" |
| if stratum is None or n_strata <= 1: |
| return float(rng.uniform(lo, hi)) |
| w = (hi - lo) / n_strata |
| k = stratum % n_strata |
| return float(rng.uniform(lo + k * w, lo + (k + 1) * w)) |
|
|
|
|
| def _pwc(times, levels, dt): |
| st = np.round(np.asarray(times, float) / dt) * dt |
| st[0] = 0.0 |
| |
| keep = np.concatenate([np.diff(st) > 0.5 * dt, [True]]) |
| return st[keep], np.asarray(levels, float)[keep] |
|
|
|
|
| def _pwl(times, vals, dt): |
| """Knots of a piecewise-linear signal snapped to the grid, at least one step apart. |
| |
| Knots before t = dt / 2 (a random phase) are replaced by the interpolated value at 0. The |
| value at each knot is kept, so the realised extremes are the knot values: a signal |
| whose knot values lie in [-1, 1] stays in [-1, 1] at every time.""" |
| times, vals = np.asarray(times, float), np.asarray(vals, float) |
| v0 = float(np.interp(0.0, times, vals)) |
| m = times >= 0.5 * dt |
| times, vals = np.concatenate([[0.0], times[m]]), np.concatenate([[v0], vals[m]]) |
| idx = np.round(times / dt).astype(np.int64) |
| idx[0] = 0 |
| for k in range(1, len(idx)): |
| idx[k] = max(idx[k], idx[k - 1] + 1) |
| return idx * dt, vals |
|
|
|
|
| def drive_events(sig: Signal) -> dict: |
| """Event statistics of one 'drive' realisation (t_ref units): levels, |delta level|, |
| dwell and ramp durations as SAMPLED (before grid snapping).""" |
| q = sig.params |
| lv = np.asarray(q["_levels"]) |
| return {"levels": lv, "delta": np.abs(np.diff(lv)), "dwell": np.asarray(q["_dwell"]), |
| "ramp": np.asarray(q["_ramp"])} |
|
|
|
|
| def sample_signal(family: str, regime: str, rng: np.random.RandomState, dt: float, |
| T: float, stratum: int = None, n_strata: int = 4, |
| scale: float = 1.0, t_ref: float = 1.0) -> Signal: |
| """Draw one realisation. ``regime`` in {train, id, shape_ood, sequence_ood}; |
| ``t_ref`` = seconds per signal time unit (frequencies / t_ref, durations * t_ref).""" |
| R = RANGES.get(family, {}).get(range_key(family, regime), {}) |
| tr = float(t_ref) |
|
|
| def conv(key, v): |
| return v * tr if key in TIME_KEYS else (v / tr if key in FREQ_KEYS else v) |
| s = lambda key: conv(key, _strat(rng, *R[key], stratum, n_strata)) |
| |
| |
| s2 = lambda key: conv(key, _strat(rng, *R[key], None if stratum is None else stratum // n_strata, |
| n_strata)) |
| u = lambda key: conv(key, float(rng.uniform(*R[key]))) |
| off = lambda a: u("offset_frac") * (1.0 - a) |
|
|
| if family == "zero": |
| st, lv = _pwc([0.0], [0.0], dt) |
| return Signal("zero", {}, st, lv, scale) |
| if family == "constant": |
| a = s("A") |
| st, lv = _pwc([0.0], [a], dt) |
| return Signal(family, {"A": a}, st, lv, scale) |
| if family == "step": |
| a, ts = s("A"), u("t_step") * T |
| st, lv = _pwc([0.0, ts], [0.0, a], dt) |
| return Signal(family, {"A": a, "t_step": float(st[-1])}, st, lv, scale) |
| if family in ("staircase", "prbs"): |
| times, vals, t = [0.0], [], 0.0 |
| if family == "prbs": |
| a0 = s("A") |
| o, sign = off(a0), rng.choice([-1.0, 1.0]) |
| while t < T: |
| if family == "staircase": |
| vals.append(s("A") if not vals else u("A")) |
| else: |
| vals.append(o + a0 * sign) |
| sign = -sign |
| t += u("dwell") |
| if t < T: |
| times.append(t) |
| st, lv = _pwc(times, vals[:len(times)], dt) |
| p = {"n_seg": len(lv)} if family == "staircase" else {"A": a0, "offset": o, "n_seg": len(lv)} |
| return Signal(family, p, st, lv, scale) |
| if family == "square": |
| a, w, duty = s("A"), s2("w"), u("duty") |
| o = off(a) |
| period = 2 * np.pi / w |
| times, vals, t = [], [], -rng.uniform(0.0, 1.0) * period |
| while t < T: |
| times.append(max(t, 0.0)); vals.append(a + o) |
| t += duty * period |
| if t < T: |
| times.append(max(t, 0.0)); vals.append(-a + o) |
| t += (1 - duty) * period |
| st, lv = _pwc(times, vals, dt) |
| return Signal(family, {"A": a, "w": w, "duty": duty, "offset": o}, st, lv, scale) |
| if family == "sinusoid": |
| a, w = s("A"), s2("w") |
| return Signal(family, {"A": a, "w": w, "phi": rng.uniform(0, 2 * np.pi), |
| "offset": off(a)}, scale=scale) |
| if family == "multisine": |
| n = int(rng.randint(R["n_comp"][0], R["n_comp"][1] + 1)) |
| a = s("A") |
| return Signal(family, {"A": a, "amps": rng.dirichlet(np.ones(n)) * a, |
| "freqs": rng.uniform(*R["w"], size=n) / tr, |
| "phases": rng.uniform(0, 2 * np.pi, size=n), |
| "offset": off(a)}, scale=scale) |
| if family == "ramp": |
| return Signal(family, {"A": s("A"), "frac": u("frac"), "T": T}, scale=scale) |
| if family == "am": |
| return Signal(family, {"A": s("A"), "w_fast": u("w_fast"), "w_slow": u("w_slow"), |
| "m": u("m"), "ph_s": rng.uniform(0, 2 * np.pi), |
| "ph_f": rng.uniform(0, 2 * np.pi)}, scale=scale) |
| if family == "drive": |
| L = np.linspace(-1.0, 1.0, int(R["n_levels"])) |
| dlo, dhi = R["delta"] |
| i = int(stratum % len(L)) if stratum is not None else int(rng.randint(len(L))) |
| times, vals, t = [0.0], [L[i]], 0.0 |
| seq, dwells, ramps = [L[i]], [], [] |
| while t < T: |
| d = float(rng.uniform(*R["dwell"])) |
| t += d * tr |
| times.append(t); vals.append(L[i]) |
| gap = np.abs(L - L[i]) |
| cand = np.flatnonzero((gap >= dlo - 1e-9) & (gap <= dhi + 1e-9)) |
| i = int(rng.choice(cand)) |
| r = float(rng.uniform(*R["ramp"])) |
| t += r * tr |
| times.append(t); vals.append(L[i]) |
| seq.append(L[i]); dwells.append(d); ramps.append(r) |
| kt, kv = _pwl(times, vals, dt) |
| return Signal(family, {"n_events": len(ramps), "t_ref": tr, "_levels": seq, |
| "_dwell": dwells, "_ramp": ramps}, scale=scale, knots=kt, knot_vals=kv) |
| if family in ("triangle", "sawtooth"): |
| a, w = s("A"), s2("w") |
| o = off(a) |
| period = 2 * np.pi / w |
| t0 = -rng.uniform(0.0, 1.0) * period |
| sgn = 1.0 if family == "triangle" else float(rng.choice([-1.0, 1.0])) |
| n = int(np.ceil((T - t0) / period)) + 2 |
| times, vals = [], [] |
| for k in range(n): |
| tk = t0 + k * period |
| if family == "triangle": |
| times += [tk, tk + period / 2]; vals += [o - a, o + a] |
| else: |
| times += [tk, tk + period - dt]; vals += [o - sgn * a, o + sgn * a] |
| kt, kv = _pwl(times, vals, dt) |
| p = {"A": a, "w": w, "offset": o} |
| if family == "sawtooth": |
| p["direction"] = sgn |
| return Signal(family, p, scale=scale, knots=kt, knot_vals=kv) |
| if family == "chirp": |
| a = s("A") |
| return Signal(family, {"A": a, "w0": u("w0"), "w1": u("w1"), "T": T, |
| "phi": rng.uniform(0, 2 * np.pi), "offset": off(a)}, scale=scale) |
| if family == "filtered_noise": |
| a, tau = s("A"), u("tau") |
| o = off(a) |
| n = int(np.ceil(T / dt)) + 2 |
| ph = np.exp(-dt / tau) |
| v = np.zeros(n) |
| for i in range(1, n): |
| v[i] = v[i - 1] * ph + np.sqrt(1 - ph ** 2) * rng.randn() |
| v = a * v / max(np.abs(v).max(), 1e-12) + o |
| return Signal(family, {"A": a, "tau": tau, "offset": o, "_t": np.arange(n) * dt, "_v": v}, |
| scale=scale) |
| raise ValueError(f"unknown signal family {family}") |
|
|
|
|
| def enforce_bounds(sig: Signal, dt: float, T: float, bounds) -> Signal: |
| """Rescale so the applied input stays inside the plant's admissible interval.""" |
| if not bounds: |
| return sig |
| lo, hi = float(bounds[0]), float(bounds[1]) |
| v = sig(np.arange(0.0, T + dt, dt / 2)) |
| f = 1.0 |
| if v.min() < lo < 0: |
| f = min(f, lo / v.min()) |
| if v.max() > hi > 0: |
| f = min(f, hi / v.max()) |
| if f < 1.0: |
| sig.scale *= f |
| sig.params["bound_rescale"] = f |
| return sig |
|
|
|
|
| def stage_inputs(sigs: list, t: np.ndarray) -> np.ndarray: |
| """u at the three distinct RK4 stage times of every step, shape (N, 3, n_ep). |
| |
| [u(t_k^+), u(t_k + h/2), u(t_{k+1}^-)]: because switches sit on grid points, the |
| one-sided offsets pick the value inside the step for piecewise-constant inputs. |
| """ |
| h = t[1] - t[0] |
| eps = 1e-9 * h |
| out = np.empty((len(t) - 1, 3, len(sigs))) |
| for j, s in enumerate(sigs): |
| out[:, 0, j] = s(t[:-1] + eps) |
| out[:, 1, j] = s(t[:-1] + 0.5 * h) |
| out[:, 2, j] = s(t[1:] - eps) |
| return out |
|
|
