Sequential Probabilistic Inference Schema

This is the sequential (state-space) companion to the Full Probabilistic Inference Schema. We now have a sequence of time steps $t = 1, \ldots, T$. The state $\boldsymbol{u}_t$ evolves according to a dynamical model (the transition distribution), and observations $\boldsymbol{y}_t$ are generated from the current state $\boldsymbol{u}_t$ via the observation operator $\mathbf{H}$.

The same two model tracks carry over — a simulator (state evolves directly) and an emulator (a latent state $\boldsymbol{z}_t$ evolves in a compressed space) — and the same three inference regimes (exact, variational, amortized), now joined by the classical recursive filtering and smoothing algorithms.

Notation¶

Sequential Generative Model¶

The joint distribution over the full sequence factorises as

Components¶

• Initial state prior — $p(\boldsymbol{u}_0 \mid \boldsymbol{\theta}, \boldsymbol{x}_0)$: distribution over the state before any observations.

• Transition model (dynamics) — $p(\boldsymbol{u}_t \mid \boldsymbol{u}_{t-1}, \boldsymbol{\theta}, \boldsymbol{x}_t)$: how the state evolves from $t-1$ to $t$. May be a physical simulator, a learned emulator, or both. $\boldsymbol{x}_t$ carries the forcing/controls at time $t$; $\boldsymbol{\theta}$ governs the dynamics (diffusion, advection, …).

• Observation model — $p(\boldsymbol{y}_t \mid \boldsymbol{u}_t, \boldsymbol{\theta}, \boldsymbol{x}_t)$: how the state generates observations, the same operator $\mathbf{H}$ applied at each $t$. Observations are gappy and noisy at every step.

• Parameter prior — $p(\boldsymbol{\theta} \mid \boldsymbol{x}_{1:T})$: static parameters shared across all time steps.

Graphical Structure¶

• $\boldsymbol{u}_t$ depends on $\boldsymbol{u}_{t-1}, \boldsymbol{\theta}, \boldsymbol{x}_t$ — a Markov transition.

• $\boldsymbol{y}_t$ depends on $\boldsymbol{u}_t, \boldsymbol{\theta}, \boldsymbol{x}_t$ — conditional independence given $\boldsymbol{u}_t$.

• $\boldsymbol{\theta}$ is shared across all time steps (a plate over $t$); $\boldsymbol{x}_t$ is observed at each step.

Target Posteriors¶

Filtering posterior (online, causal) — state at $t$ given observations up to and including $t$; uses no future observations and is updated recursively as each $\boldsymbol{y}_t$ arrives:

Smoothing posterior (offline, non-causal) — state at $t$ given all observations, including future ones; requires the full sequence $\boldsymbol{y}_{1:T}$:

Prediction posterior — state $k$ steps ahead given observations up to $t$ (none from $t+1$ onward):

Parameter posterior — static parameters inferred from the full sequence, marginalising the state trajectory:

Joint smoothing posterior — the full joint over all states and parameters:

Track 1 — Simulator¶

The simulator generative model is (1) above: the state $\boldsymbol{u}_t$ evolves directly, with no internal latent variable.

1A · Exact Posteriors¶

1B · Filtering Algorithms¶

Recursive algorithms that process observations one at a time and maintain a running approximation to the filtering posterior.

1C · Smoothing Algorithms¶

Offline algorithms that use the full sequence.

• Kalman / RTS Smoother (linear-Gaussian — exact). Run the Kalman filter forward, then a backward pass to fold in future observations:

  $$p(\boldsymbol{u}_t \mid \boldsymbol{y}_{1:T}, \boldsymbol{x}_{1:T}, \boldsymbol{\theta}) = p(\boldsymbol{u}_t \mid \boldsymbol{y}_{1:t}, \boldsymbol{x}_{1:t}, \boldsymbol{\theta}) \int \frac{p(\boldsymbol{u}_{t+1} \mid \boldsymbol{u}_t, \boldsymbol{\theta}, \boldsymbol{x}_{t+1}) \, p(\boldsymbol{u}_{t+1} \mid \boldsymbol{y}_{1:T}, \boldsymbol{x}_{1:T}, \boldsymbol{\theta})} {p(\boldsymbol{u}_{t+1} \mid \boldsymbol{y}_{1:t}, \boldsymbol{x}_{1:t+1}, \boldsymbol{\theta})} \, \mathrm{d}\boldsymbol{u}_{t+1}$$

  (12)

• Particle Smoother (nonlinear — Monte-Carlo). Run the particle filter forward, then a backward pass that reweights particles using future information.

• Variational Smoother — see §1D below.

1D · Variational Inference¶

For nonlinear / non-Gaussian models where filtering and smoothing are too expensive or unavailable, introduce a variational distribution over the full state sequence (and parameters). Here $\boldsymbol{\psi}$ is optimised once per observed sequence — no generalisation.

Filtering variational posterior — maintained recursively, with $\boldsymbol{\psi}_t$ updated at each step as new $\boldsymbol{y}_t$ arrives:

Smoothing variational posterior — two ways to structure the family:

Joint smoothing + parameter inference — Hierarchical:

1E · Amortized Inference¶

Train a network once on many sequences; at test time a single forward pass over a new sequence gives the posterior — no per-sequence optimisation.

Amortized filtering — a recurrent network (RNN, LSTM, S4, Mamba) processes $\boldsymbol{y}_{1:t}$ sequentially and emits a distribution over $\boldsymbol{u}_t$; causal, generalises across sequences:

Amortized smoothing — an encoder that reads the full sequence (transformer, bidirectional RNN) and emits a distribution over $\boldsymbol{u}_t$ at each step; non-causal, uses past and future observations:

Amortized joint — Hierarchical:

Track 2 — Emulator¶

Generative Model¶

The emulator introduces an internal latent $\boldsymbol{z}_t$ at each time step. The transition now operates in latent space and decodes to $\boldsymbol{u}_t$.

The latent dynamics $p(\boldsymbol{z}_t \mid \boldsymbol{z}_{t-1}, \boldsymbol{\theta}, \boldsymbol{x}_t)$ operate in the compressed space $\mathbb{R}^{D_z}$ ($D_z \ll D_u$); the decoder $p(\boldsymbol{u}_t \mid \boldsymbol{z}_t, \boldsymbol{\theta}, \boldsymbol{x}_t)$ maps back to the full field at each step.

• $\boldsymbol{z}_t$ evolves via learned latent dynamics (transition in $\boldsymbol{z}$-space).

• $\boldsymbol{u}_t$ is decoded from $\boldsymbol{z}_t$ at each step (no direct $\boldsymbol{u}$-to-$\boldsymbol{u}$ transition).

• $\boldsymbol{y}_t$ is observed from $\boldsymbol{u}_t$ via $\mathbf{H}$.

2.0 · Emulator Training¶

Train the emulator on simulator output sequences $\{\boldsymbol{u}_{1:T}, \boldsymbol{x}_{1:T}, \boldsymbol{\theta}\}$; it learns latent dynamics in $\boldsymbol{z}$-space. This introduces an encoder $q(\boldsymbol{z}_t \mid \boldsymbol{u}_t, \boldsymbol{x}_t, \boldsymbol{\theta}, \boldsymbol{\psi}_{\mathrm{em}})$, decoder $p(\boldsymbol{u}_t \mid \boldsymbol{z}_t, \boldsymbol{\theta}, \boldsymbol{x}_t)$, and transition $p(\boldsymbol{z}_t \mid \boldsymbol{z}_{t-1}, \boldsymbol{\theta}, \boldsymbol{x}_t)$.

2.1 · Emulator Uncertainty Characterization¶

Characterise the per-step simulator–emulator discrepancy,

2A · Exact Posteriors¶

2B · Filtering Algorithms (latent space)¶

Run the recursion in $\boldsymbol{z}$-space, then decode to $\boldsymbol{u}$-space.

2C · Smoothing Algorithms (latent space)¶

• Kalman / RTS Smoother in z (linear-Gaussian — exact): forward Kalman filter in $\boldsymbol{z}$-space, RTS backward pass, then decode the smoothed $\boldsymbol{z}_{1:T}$ to $\boldsymbol{u}_{1:T}$.

• Particle Smoother in z: forward particle filter in $\boldsymbol{z}$-space, backward reweighting pass, then decode the smoothed particles.

• Variational Smoother — see §2D below.

2D · Variational Inference¶

Filtering variational posterior — updated recursively as new $\boldsymbol{y}_t$ arrives:

Smoothing variational posterior — Structured (Markov):

Joint smoothing over $\boldsymbol{u}, \boldsymbol{z}, \boldsymbol{\theta}$ — Hierarchical:

2E · Amortized Inference¶

Amortized filtering in latent space — a recurrent network processes $\boldsymbol{y}_{1:t}$ and emits a distribution over $\boldsymbol{z}_t$; causal:

Amortized smoothing in latent space — a bidirectional encoder reads the full sequence; non-causal:

Amortized joint — Hierarchical:

Summary Table¶