| """Next-generation backbones (2024-2026) under the same multi-task protocol. |
| |
| Every model here re-uses ``SequenceModel``'s multi-task heads (per-variable |
| heads, softmax phases, softplus densities) and the optional micro->macro |
| coupling, so the comparison against PI-Mamba / Mamba is apples-to-apples: |
| same inputs, same loss, same budget. |
| |
| Implemented |
| ----------- |
| llama modern decoder-only Transformer: RoPE + RMSNorm + SwiGLU + SDPA |
| xlstm mLSTM block (matrix memory, exponential input/forget gates), 2024 |
| gdn Gated DeltaNet: delta-rule fast weights with per-step decay, 2024-25 |
| hymba hybrid stack: Mamba block interleaved with attention (Jamba/Hymba) |
| koopman Deep Koopman: *linear* latent dynamics with a learnable eigen-spectrum |
| node Neural ODE: continuous-time latent dynamics, RK4 integration |
| rssm latent world model: deterministic h_t + stochastic z_t, ELBO training |
| flow conditional flow matching over the whole curve (generative) |
| """ |
| from __future__ import annotations |
|
|
| import math |
|
|
| import torch |
| import torch.nn as nn |
| import torch.nn.functional as F |
|
|
| from .models import FiLM, RMSNorm, MambaBlock, SequenceModel |
|
|
|
|
| |
| |
| |
| def _rope(t, dim, device, base=10000.0): |
| inv = base ** (-torch.arange(0, dim, 2, device=device).float() / dim) |
| fr = torch.outer(torch.arange(t, device=device).float(), inv) |
| emb = torch.cat([fr, fr], dim=-1) |
| return emb.cos(), emb.sin() |
|
|
|
|
| def _rot(x): |
| x1, x2 = x.chunk(2, dim=-1) |
| return torch.cat([-x2, x1], dim=-1) |
|
|
|
|
| class SwiGLU(nn.Module): |
| def __init__(self, d, mult=2): |
| super().__init__() |
| self.w1 = nn.Linear(d, mult * d) |
| self.w3 = nn.Linear(d, mult * d) |
| self.w2 = nn.Linear(mult * d, d) |
|
|
| def forward(self, x): |
| return self.w2(F.silu(self.w1(x)) * self.w3(x)) |
|
|
|
|
| class LLaMABlock(nn.Module): |
| """Pre-norm attention + SwiGLU FFN, RoPE positions, SDPA kernel.""" |
|
|
| def __init__(self, d, n_heads=4, dropout=0.1): |
| super().__init__() |
| assert d % n_heads == 0 |
| self.h, self.dh = n_heads, d // n_heads |
| self.n1 = RMSNorm(d) |
| self.qkv = nn.Linear(d, 3 * d) |
| self.o = nn.Linear(d, d) |
| self.n2 = RMSNorm(d) |
| self.ff = SwiGLU(d) |
| self.p = dropout |
|
|
| def forward(self, x, cos, sin): |
| b, T, d = x.shape |
| q, k, v = self.qkv(self.n1(x)).chunk(3, dim=-1) |
| q = q.view(b, T, self.h, self.dh).transpose(1, 2) |
| k = k.view(b, T, self.h, self.dh).transpose(1, 2) |
| v = v.view(b, T, self.h, self.dh).transpose(1, 2) |
| q = q * cos + _rot(q) * sin |
| k = k * cos + _rot(k) * sin |
| y = F.scaled_dot_product_attention( |
| q, k, v, is_causal=True, |
| dropout_p=self.p if self.training else 0.0) |
| y = y.transpose(1, 2).reshape(b, T, d) |
| x = x + self.o(y) |
| return x + self.ff(self.n2(x)) |
|
|
|
|
| class LLaMAModel(SequenceModel): |
| def __init__(self, n_static, n_out, seq_dim=5, d_model=64, n_layers=2, |
| n_heads=4, **kw): |
| super().__init__(n_static, n_out, d_model=d_model, **kw) |
| self.inp = nn.Linear(seq_dim, d_model) |
| self.blocks = nn.ModuleList([LLaMABlock(d_model, n_heads, kw.get("dropout", 0.1)) |
| for _ in range(n_layers)]) |
| self.norm = RMSNorm(d_model) |
| self.film = FiLM(d_model, d_model) |
|
|
| def forward(self, static, x): |
| b, T, _ = x.shape |
| cond = self.static_enc(static) |
| |
| cos, sin = _rope(T, self.blocks[0].dh, x.device) |
| h = self.inp(x) + cond.unsqueeze(1) |
| for blk in self.blocks: |
| h = blk(h, cos, sin) |
| h = self.film(self.norm(h), cond) |
| pred, micro = self.head(h, static) |
| return {"pred": pred, "micro": micro, "h": h} |
|
|
|
|
| class mLSTMBlock(nn.Module): |
| """Matrix-memory LSTM (xLSTM, 2024) in recurrent form.""" |
|
|
| def __init__(self, d, n_heads=4, dropout=0.1, expand=2): |
| super().__init__() |
| self.h, self.dh = n_heads, d // n_heads |
| self.qkv = nn.Linear(d, 3 * d) |
| self.gates = nn.Linear(d, 2 * n_heads) |
| self.out = nn.Linear(d, d) |
| self.n = RMSNorm(d) |
| self.ff = SwiGLU(d, expand) |
| self.drop = nn.Dropout(dropout) |
| self.record = False |
| self.trace = [] |
|
|
| def forward(self, x): |
| b, T, d = x.shape |
| q, k, v = self.qkv(x).chunk(3, dim=-1) |
| q = q.view(b, T, self.h, self.dh) |
| k = F.normalize(k.view(b, T, self.h, self.dh), dim=-1) |
| v = v.view(b, T, self.h, self.dh) |
| g = self.gates(x).view(b, T, 2, self.h) |
| i_gate = torch.exp(g[:, :, 0]) |
| f_gate = torch.sigmoid(g[:, :, 1]) |
| C = x.new_zeros(b, self.h, self.dh, self.dh) |
| n = x.new_zeros(b, self.h, self.dh) |
| outs = [] |
| for t in range(T): |
| ft = f_gate[:, t].unsqueeze(-1) |
| it = i_gate[:, t].unsqueeze(-1) |
| kt = k[:, t] |
| C = ft.unsqueeze(-1) * C + it.unsqueeze(-1) * (v[:, t].unsqueeze(-1) @ kt.unsqueeze(-2)) |
| n = ft * n + it * kt |
| qt = q[:, t].unsqueeze(-1) |
| num = (C @ qt).squeeze(-1) |
| den = (n.unsqueeze(-1) * qt).sum(-2).abs().clamp(min=1.0) |
| outs.append(num / den) |
| if self.record: |
| self.trace.append((float(C.norm()), float(f_gate[:, t].mean()))) |
| y = torch.stack(outs, 1).reshape(b, T, d) |
| x = x + self.drop(self.out(y)) |
| return x + self.ff(self.n(x)) |
|
|
|
|
| class xLSTMModel(SequenceModel): |
| def __init__(self, n_static, n_out, seq_dim=5, d_model=64, n_layers=2, |
| n_heads=4, **kw): |
| super().__init__(n_static, n_out, d_model=d_model, **kw) |
| self.inp = nn.Linear(seq_dim, d_model) |
| self.blocks = nn.ModuleList([mLSTMBlock(d_model, n_heads, |
| kw.get("dropout", 0.1)) |
| for _ in range(n_layers)]) |
| self.norm = RMSNorm(d_model) |
| self.film = FiLM(d_model, d_model) |
|
|
| def forward(self, static, x): |
| cond = self.static_enc(static) |
| h = self.inp(x) + cond.unsqueeze(1) |
| for blk in self.blocks: |
| h = blk(h) |
| h = self.film(self.norm(h), cond) |
| pred, micro = self.head(h, static) |
| return {"pred": pred, "micro": micro, "h": h} |
|
|
|
|
| class GatedDeltaBlock(nn.Module): |
| """Gated delta rule: S <- a*S(I - b k k^T) + b v k^T (fast weights).""" |
|
|
| def __init__(self, d, n_heads=4, dropout=0.1, expand=2): |
| super().__init__() |
| self.h, self.dh = n_heads, d // n_heads |
| self.qkv = nn.Linear(d, 3 * d) |
| self.gates = nn.Linear(d, 2 * n_heads) |
| self.out = nn.Linear(d, d) |
| self.n = RMSNorm(d) |
| self.ff = SwiGLU(d, expand) |
| self.drop = nn.Dropout(dropout) |
| self.record = False |
| self.trace = [] |
|
|
| def forward(self, x): |
| b, T, d = x.shape |
| q, k, v = self.qkv(x).chunk(3, dim=-1) |
| q = F.normalize(q.view(b, T, self.h, self.dh), dim=-1) |
| k = F.normalize(k.view(b, T, self.h, self.dh), dim=-1) |
| v = v.view(b, T, self.h, self.dh) |
| g = self.gates(x).view(b, T, 2, self.h) |
| alpha = torch.sigmoid(g[:, :, 0]) |
| beta = torch.sigmoid(g[:, :, 1]) |
| S = x.new_zeros(b, self.h, self.dh, self.dh) |
| outs = [] |
| for t in range(T): |
| a = alpha[:, t].unsqueeze(-1).unsqueeze(-1) |
| bt = beta[:, t].unsqueeze(-1).unsqueeze(-1) |
| kt = k[:, t] |
| S = a * S |
| Sk = (S * kt.unsqueeze(-1)).sum(-2) |
| S = S - bt * (Sk.unsqueeze(-1) * kt.unsqueeze(-2)) |
| S = S + bt * (v[:, t].unsqueeze(-1) * kt.unsqueeze(-2)) |
| outs.append((S * q[:, t].unsqueeze(-1)).sum(-2) / math.sqrt(self.dh)) |
| if self.record: |
| self.trace.append((float(S.norm()), float(alpha[:, t].mean()), |
| float(beta[:, t].mean()))) |
| y = torch.stack(outs, 1).reshape(b, T, d) |
| x = x + self.drop(self.out(y)) |
| return x + self.ff(self.n(x)) |
|
|
|
|
| class GatedDeltaModel(SequenceModel): |
| def __init__(self, n_static, n_out, seq_dim=5, d_model=64, n_layers=2, |
| n_heads=4, **kw): |
| super().__init__(n_static, n_out, d_model=d_model, **kw) |
| self.inp = nn.Linear(seq_dim, d_model) |
| self.blocks = nn.ModuleList([GatedDeltaBlock(d_model, n_heads, |
| kw.get("dropout", 0.1)) |
| for _ in range(n_layers)]) |
| self.norm = RMSNorm(d_model) |
| self.film = FiLM(d_model, d_model) |
|
|
| def forward(self, static, x): |
| cond = self.static_enc(static) |
| h = self.inp(x) + cond.unsqueeze(1) |
| for blk in self.blocks: |
| h = blk(h) |
| h = self.film(self.norm(h), cond) |
| pred, micro = self.head(h, static) |
| return {"pred": pred, "micro": micro, "h": h} |
|
|
|
|
| class HybridModel(SequenceModel): |
| """Interleaved Mamba + attention (Jamba / Hymba style hybrid).""" |
|
|
| def __init__(self, n_static, n_out, seq_dim=5, d_model=64, n_layers=2, |
| d_state=16, n_heads=4, **kw): |
| super().__init__(n_static, n_out, d_model=d_model, **kw) |
| self.inp = nn.Linear(seq_dim, d_model) |
| self.mamba = nn.ModuleList([MambaBlock(d_model, d_state) |
| for _ in range(n_layers)]) |
| self.attn = nn.ModuleList([LLaMABlock(d_model, n_heads, |
| kw.get("dropout", 0.1)) |
| for _ in range(n_layers)]) |
| self.norm = RMSNorm(d_model) |
| self.film = FiLM(d_model, d_model) |
|
|
| def forward(self, static, x): |
| b, T, _ = x.shape |
| cond = self.static_enc(static) |
| cos, sin = _rope(T, self.attn[0].dh, x.device) |
| h = self.inp(x) + cond.unsqueeze(1) |
| for mb, ab in zip(self.mamba, self.attn): |
| h = ab(mb(h), cos, sin) |
| h = self.film(self.norm(h), cond) |
| pred, micro = self.head(h, static) |
| return {"pred": pred, "micro": micro, "h": h} |
|
|
|
|
| class KoopmanModel(SequenceModel): |
| """Deep Koopman: latent state evolves *linearly*, z_{t+1} = A z_t + B u_t. |
| |
| A is block-diagonal with learnable (radius r, angle theta) pairs, so the |
| spectrum is explicit: tau = -1/ln r is the memory time of each mode. |
| """ |
|
|
| def __init__(self, n_static, n_out, seq_dim=5, d_model=64, n_layers=1, |
| d_lat=32, **kw): |
| super().__init__(n_static, n_out, d_model=d_model, **kw) |
| self.d_lat = d_lat |
| self.enc = nn.Sequential(nn.Linear(seq_dim + d_model, d_model), nn.GELU(), |
| nn.Linear(d_model, d_lat)) |
| self.r_raw = nn.Parameter(torch.zeros(d_lat // 2)) |
| self.theta = nn.Parameter(torch.linspace(0, 1.5, d_lat // 2)) |
| self.B = nn.Linear(seq_dim + d_model, d_lat, bias=False) |
| self.dec = nn.Sequential(nn.Linear(d_lat, d_model), nn.GELU(), |
| nn.Linear(d_model, d_model)) |
| self.film = FiLM(d_model, d_model) |
|
|
| def spectrum(self): |
| r = torch.exp(-F.softplus(self.r_raw)) |
| return r, self.theta |
|
|
| def forward(self, static, x): |
| b, T, _ = x.shape |
| cond = self.static_enc(static) |
| u = torch.cat([x, cond.unsqueeze(1).expand(-1, T, -1)], dim=-1) |
| r, th = self.spectrum() |
| a = (r * torch.cos(th)).view(1, -1, 1) |
| c = (r * torch.sin(th)).view(1, -1, 1) |
| z = self.enc(u[:, 0]) |
| Bu = self.B(u) |
| zs = [] |
| for t in range(T): |
| z2 = z.view(b, -1, 2) |
| zr = z2[..., 0].unsqueeze(-1) |
| zi = z2[..., 1].unsqueeze(-1) |
| z = torch.cat([a * zr - c * zi, c * zr + a * zi], dim=-1).reshape(b, -1) |
| z = z + Bu[:, t] |
| zs.append(z) |
| z = torch.stack(zs, 1) |
| h = self.film(self.dec(z), cond) |
| pred, micro = self.head(h, static) |
| return {"pred": pred, "micro": micro, "h": h, "z": z} |
|
|
|
|
| class NODEModel(SequenceModel): |
| """Neural ODE on a coarse grid (RK4), upsampled back to the strain grid.""" |
|
|
| def __init__(self, n_static, n_out, seq_dim=5, d_model=64, n_layers=1, |
| d_lat=32, substep=4, **kw): |
| super().__init__(n_static, n_out, d_model=d_model, **kw) |
| self.sub = substep |
| self.d_lat = d_lat |
| d_in = d_lat + seq_dim + d_model |
| self.f = nn.Sequential(nn.Linear(d_in, 128), nn.Tanh(), |
| nn.Linear(128, 128), nn.Tanh(), |
| nn.Linear(128, d_lat)) |
| self.enc = nn.Linear(seq_dim + d_model, d_lat) |
| self.dec = nn.Sequential(nn.Linear(d_lat, d_model), nn.GELU(), |
| nn.Linear(d_model, d_model)) |
| self.film = FiLM(d_model, d_model) |
| self.record = False |
| self.trace = [] |
|
|
| def _f(self, z, u, c): |
| return self.f(torch.cat([z, u, c], dim=-1)) |
|
|
| def forward(self, static, x): |
| b, T, _ = x.shape |
| cond = self.static_enc(static) |
| c = cond |
| z = self.enc(torch.cat([x[:, 0], cond], dim=-1)) |
| dt = 1.0 / max(1, T // self.sub) |
| zs = [] |
| idx = list(range(0, T, self.sub)) |
| for i in idx: |
| zs.append(z) |
| u = x[:, i] |
| k1 = self._f(z, u, c) |
| k2 = self._f(z + 0.5 * dt * k1, u, c) |
| k3 = self._f(z + 0.5 * dt * k2, u, c) |
| k4 = self._f(z + dt * k3, u, c) |
| if self.record: |
| self.trace.append(float(k1.norm(dim=-1).mean())) |
| z = z + dt / 6.0 * (k1 + 2 * k2 + 2 * k3 + k4) |
| zc = torch.stack(zs, 1) |
| zc = F.interpolate(zc.transpose(1, 2), size=T, mode="linear", |
| align_corners=True).transpose(1, 2) |
| h = self.film(self.dec(zc), cond) |
| pred, micro = self.head(h, static) |
| return {"pred": pred, "micro": micro, "h": h, "z": zc} |
|
|
|
|
| class RSSMModel(SequenceModel): |
| """Latent world model: deterministic GRU state + stochastic latent (ELBO).""" |
|
|
| needs_y = True |
|
|
| def __init__(self, n_static, n_out, seq_dim=5, d_model=64, n_layers=1, |
| d_det=64, d_stoch=16, **kw): |
| super().__init__(n_static, n_out, d_model=d_model, **kw) |
| self.d_det, self.d_stoch, self.n_out = d_det, d_stoch, n_out |
| self.inp = nn.Linear(seq_dim, d_model) |
| self.cell = nn.GRUCell(d_model + d_model, d_det) |
| self.prior = nn.Linear(d_det, 2 * d_stoch) |
| self.post = nn.Linear(d_det + n_out, 2 * d_stoch) |
| self.dec = nn.Sequential(nn.Linear(d_det + d_stoch, d_model), nn.GELU(), |
| nn.Linear(d_model, d_model)) |
| self.film = FiLM(d_model, d_model) |
| self.record = False |
| self.trace = [] |
|
|
| def _q(self, h, y=None): |
| if y is not None: |
| return self.post(torch.cat([h, y], dim=-1)) |
| return self.prior(h) |
|
|
| def forward(self, static, x, y=None, m=None): |
| b, T, _ = x.shape |
| cond = self.static_enc(static) |
| hd = x.new_zeros(b, self.d_det) |
| kl = x.new_zeros(()) |
| hs, zs = [], [] |
| for t in range(T): |
| hd = self.cell(torch.cat([self.inp(x[:, t]), cond], dim=-1), hd) |
| pr = self.prior(hd) |
| pm, plv = pr.chunk(2, dim=-1) |
| if self.training and y is not None: |
| po = self._q(hd, y[:, t]) |
| qm, qlv = po.chunk(2, dim=-1) |
| kl = kl + _kl_diag(qm, qlv, pm, plv) |
| eps = torch.randn_like(qm) |
| z = qm + torch.exp(0.5 * qlv) * eps |
| else: |
| z = pm |
| if self.record: |
| self.trace.append(float(torch.exp(0.5 * plv).mean())) |
| hs.append(hd) |
| zs.append(z) |
| hd = torch.stack(hs, 1) |
| z = torch.stack(zs, 1) |
| h = self.film(self.dec(torch.cat([hd, z], dim=-1)), cond) |
| pred, micro = self.head(h, static) |
| aux = kl / max(1, T) * 1e-3 |
| return {"pred": pred, "micro": micro, "h": h, "aux_loss": aux} |
|
|
|
|
| def _kl_diag(qm, qlv, pm, plv): |
| """KL( N(qm, exp(qlv)) || N(pm, exp(plv)) ), summed over the last dim.""" |
| qv, pv = torch.exp(qlv), torch.exp(plv) |
| return 0.5 * ((qlv - plv) + (qv + (qm - pm) ** 2) / pv - 1.0).sum(-1).mean() |
|
|
|
|
| class FlowModel(SequenceModel): |
| """Conditional flow matching over the whole (T, 13) curve. |
| |
| The velocity field is a gated 1-D convolutional U-net conditioned on the |
| static descriptor and on the strain/time channel. Training minimises the |
| CFM objective; at inference the ODE is integrated with Euler steps. |
| """ |
|
|
| needs_y = True |
|
|
| def __init__(self, n_static, n_out, seq_dim=5, d_model=64, n_layers=3, |
| steps=8, **kw): |
| super().__init__(n_static, n_out, d_model=d_model, **kw) |
| self.n_out, self.steps = n_out, steps |
| self.cond = nn.Sequential(nn.Linear(n_static, d_model), nn.GELU(), |
| nn.Linear(d_model, d_model)) |
| ch = n_out + seq_dim + d_model + 1 |
| self.inp = nn.Conv1d(ch, d_model, 1) |
| self.blocks = nn.ModuleList([ |
| nn.Sequential(nn.Conv1d(d_model, d_model, 5, padding=2), |
| nn.GELU(), |
| nn.Conv1d(d_model, d_model, 5, padding=2)) |
| for _ in range(n_layers)]) |
| self.norms = nn.ModuleList([nn.GroupNorm(1, d_model) for _ in range(n_layers)]) |
| self.out = nn.Conv1d(d_model, n_out, 1) |
|
|
| def _v(self, xt, u, c, tau): |
| b, T, _ = xt.shape |
| cc = c.unsqueeze(1).expand(-1, T, -1) |
| tt = tau.view(b, 1, 1).expand(-1, T, 1) |
| z = self.inp(torch.cat([xt, u, cc, tt], dim=-1).transpose(1, 2)) |
| for blk, nrm in zip(self.blocks, self.norms): |
| z = z + blk(nrm(z)) |
| return self.out(z).transpose(1, 2) |
|
|
| def forward(self, static, x, y=None, m=None): |
| b, T, _ = x.shape |
| c = self.cond(static) |
| if self.training and y is not None: |
| tau = torch.rand(b, device=x.device) |
| x0 = torch.randn_like(y) |
| xt = (1 - tau.view(b, 1, 1)) * x0 + tau.view(b, 1, 1) * y |
| v = self._v(xt, x, c, tau) |
| w = (1.0 if m is None else m) |
| cfm = (((v - (y - x0)) ** 2) * w).sum() / w.sum().clamp(min=1.0) |
| else: |
| cfm = x.new_zeros(()) |
| |
| z = torch.randn(b, T, self.n_out, device=x.device) |
| for k in range(self.steps): |
| tau = torch.full((b,), k / self.steps, device=x.device) |
| z = z + self._v(z, x, c, tau) / self.steps |
| |
| return {"pred": z, "micro": z[..., 1:], "h": z, "replace_loss": cfm} |
|
|
| @torch.no_grad() |
| def sample(self, static, x, k: int = 8): |
| """Draw k curves per sample; returns (k, b, T, n_out) in raw units? -> normalised.""" |
| b, T, _ = x.shape |
| c = self.cond(static) |
| out = [] |
| for _ in range(k): |
| z = torch.randn(b, T, self.n_out, device=x.device) |
| for j in range(self.steps): |
| tau = torch.full((b,), j / self.steps, device=x.device) |
| z = z + self._v(z, x, c, tau) / self.steps |
| out.append(z) |
| return torch.stack(out, 0) |
