Bridge: Filtering as Recurrent Inference

"For seven sections they called me a filter, drew me as predict-then-update, and trusted my covariance. Now they want to learn my transition matrix from data and call me a neural network. Same loop, new wardrobe. I was recurrent before recurrent was cool."

A Hidden State About to Be Reborn as a Neural Network

Across Section 7.1 through Section 7.5 we built the state-space view of time series: a latent state that evolves through a transition model, an observation model that links the state to what we measure, and the recursive filters that track the state as data arrive. We derived the Kalman filter for linear-Gaussian systems, the forward pass for the discrete-state hidden Markov model of Section 7.5, and we can read the exponential smoother of Chapter 5 as the simplest recursive estimator of all. Each looked like a separate algorithm with its own notation. This bridge section argues that they are one algorithm, and that the algorithm is a recurrence, the same primitive that underlies the entire neural sequence-modeling enterprise of Part III. We will use the latent-state symbol $\mathbf{h}_t$ for the carried state, $\mathbf{x}_t$ for the incoming observation, and $\hat{\mathbf{y}}_t$ for the readout, the notation collected in the unified table of Appendix A and reused for every recurrent model in the book.

The deliberate choice of the symbol $\mathbf{h}_t$ is itself a piece of the argument. In the filtering chapters you may have seen the state written $\mathbf{x}_t$ or $\mathbf{s}_t$; from here on we write the carried, latent summary as $\mathbf{h}_t$ and reserve $\mathbf{x}_t$ for the observation, because that is the convention of the neural sequence literature this section bridges into. Reading the Kalman filter and the RNN in one shared notation is not cosmetic; it is what lets you see, in subsection two, that one equation is literally the other.

By the end of this bridge you should be able to do four concrete things: write any filter from this chapter in the generic recurrence form $\mathbf{h}_t = f(\mathbf{h}_{t-1}, \mathbf{x}_t)$, $\hat{\mathbf{y}}_t = g(\mathbf{h}_t)$; map the Kalman mean update onto a linear recurrent cell term by term; state precisely what calibrated uncertainty you forfeit when you replace a hand-specified filter with a learned recurrence, and where the book buys it back; and run a single driver loop with either a Kalman update or an RNN cell slotted into it. Those four skills are the load-bearing supports of the whole second half of the book.

1. The Shared Skeleton: Every Filter Is a Recurrence Beginner

A useful way to feel the shared structure before formalizing it is to watch what each filter does when a single new measurement lands. The exponential smoother nudges its level a fraction $\alpha$ of the way toward the new number. The HMM tilts its belief vector toward whichever hidden states best explain the new symbol. The Kalman filter shifts its mean by the gain times the surprise, the gap between what it predicted and what it saw. Three different arithmetic operations, but the same verb: take the carried state, fold in one observation, get a new carried state. The rest of the past never reappears, because the state already absorbed it. That is the move we are about to name.

Set aside the specific equations of each filter and ask only what they have structurally in common. Each one maintains a quantity, the state, that summarizes everything the filter knows about the past. At every time step it does two things. First it advances the state in time, propagating what it knew before the new measurement arrived. Then it folds in the new observation, correcting the propagated state toward what was actually measured. Finally, whenever a prediction is needed, it reads the state out. That is the entire pattern, and it is a recurrence:

The state-update function $f$ takes the previous state $\mathbf{h}_{t-1}$ and the current observation $\mathbf{x}_t$ and returns the new state $\mathbf{h}_t$; the readout function $g$ turns the state into a prediction $\hat{\mathbf{y}}_t$. Nothing about this form prejudges whether the state is a Gaussian mean and covariance, a discrete probability vector, or a single scalar level. Nor does it prejudge whether $f$ and $g$ are linear, fixed by a physical model, or learned. The recurrence is the genus; the filters are species. Figure 7.6.1 draws the genus once, and the rest of this section fills in the species.

The two-step rhythm inside $f$, advance then correct, is worth holding onto explicitly, because it survives all the way into the deep models of Part III. Advancing is the model's guess about how the state would evolve with no new information; correcting is the data pulling that guess back toward reality. A pure prediction model has only the first step and drifts; a pure memorization model has only the second and cannot extrapolate. Every good sequence model, classical or neural, balances the two, and the balance point is exactly what the Kalman gain, and later the LSTM gate, controls.

To see that this is not loose analogy, write each of the three classical filters in the $f$/$g$ form. For the exponential smoother the state is a single scalar level $\ell_t$, the update is a convex blend of the old level and the new observation, and the readout is the identity:

For the HMM forward pass of Section 7.5 the state is the (normalized) forward vector $\boldsymbol{\alpha}_t$, a probability distribution over the discrete hidden states; the update multiplies by the transition matrix $\mathbf{A}$, applies the emission likelihood of the new observation through the diagonal matrix $\mathbf{B}(x_t)$, and renormalizes; the readout is whatever posterior quantity we want, here the predictive distribution over the next observation:

For the Kalman filter the state is the pair $(\hat{\mathbf{m}}_t, \mathbf{P}_t)$ of posterior mean and covariance; the update is the predict-then-correct cycle we derived in Section 7.2; the readout maps the mean through the observation matrix. We unfold the Kalman update fully in the next subsection because it is the species that maps most directly onto a neural cell. The point of this subsection is the unification itself: three filters that looked unrelated are one recurrence wearing three costumes.

It helps to tabulate the three species against the one genus, because the columns make the shared skeleton unmistakable. Read across each row and you are reading the same recurrence; read down each column and you are reading one filter.

2. The Kalman Filter as a Linear RNN Intermediate

The Kalman filter is the species that reveals the bridge most sharply, because its update is already linear. Recall the predict-update equations from Section 7.2. The predict step propagates the posterior mean through the transition matrix $\mathbf{F}$, and the correct step nudges it toward the observation $\mathbf{x}_t$ in proportion to the Kalman gain $\mathbf{K}_t$:

The algebra is worth doing slowly once, because the rearrangement is the whole bridge. Distribute the gain across the innovation in the correct term, $\mathbf{K}_t(\mathbf{x}_t - \mathbf{H}\mathbf{F}\hat{\mathbf{m}}_{t-1}) = \mathbf{K}_t\mathbf{x}_t - \mathbf{K}_t\mathbf{H}\mathbf{F}\hat{\mathbf{m}}_{t-1}$, then collect every term carrying $\hat{\mathbf{m}}_{t-1}$ on one side and every term carrying $\mathbf{x}_t$ on the other:

What started as a two-stage predict-then-correct procedure is now a single line: one matrix multiplying the previous state, plus another matrix multiplying the current input. That is the defining shape of a recurrent cell, and nothing in the derivation assumed anything beyond the linearity we already had.

Now compare with the canonical linear recurrent cell that opens Chapter 10, $\mathbf{h}_t = \mathbf{W}\mathbf{h}_{t-1} + \mathbf{U}\mathbf{x}_t$, readout $\hat{\mathbf{y}}_t = \mathbf{V}\mathbf{h}_t$. The correspondence is exact, term for term. The Kalman mean update is a linear recurrent cell whose recurrent weight is $(\mathbf{I} - \mathbf{K}_t\mathbf{H})\mathbf{F}$, whose input weight is the gain $\mathbf{K}_t$, and whose output weight is the observation matrix $\mathbf{H}$. The aligned table below makes the mapping explicit.

One subtlety deserves emphasis because it is the seed of an entire research line. In the Kalman filter the gain $\mathbf{K}_t$ is data-dependent through the covariance: it shrinks as the filter grows confident and grows when uncertainty rises, so the effective input weight changes every step. A vanilla RNN has a constant input weight, which is strictly less expressive. The gated recurrent cells of Chapter 10, the LSTM and the GRU, reintroduce exactly this idea: their input and forget gates are learned, data-dependent versions of the Kalman gain, deciding step by step how much of the new observation to admit and how much of the old state to retain. The Kalman filter computed that blend optimally from an assumed model; the gated RNN learns to approximate it from data.

Why does a constant input weight cost expressiveness? Because the right amount to trust a new observation genuinely depends on context: early in a series, or just after a disturbance, the estimate is uncertain and new data should move it a lot; once the estimate has settled, new data should move it little. The Kalman gain encodes exactly this through the covariance, which is why $\mathbf{K}_t$ carries a time subscript. A vanilla RNN, with one fixed $\mathbf{U}$, must compromise on a single trust level for all time. The gate restores the missing degree of freedom, and in doing so it rediscovers, by gradient descent, the adaptivity that Kalman derived by calculus. Seeing the LSTM forget gate as a learned Kalman gain is one of those observations that, once made, you cannot unsee.

3. What You Gain and Lose by Learning Advanced

The mapping in subsection two is exact but it cuts both ways, and a careful reader should already be suspicious: if the Kalman filter is just a linear RNN with hand-set weights, then learning the weights can only help, so why did anyone bother deriving the gain analytically? The answer is that the two approaches optimize different things under different information, and understanding the trade is what separates a practitioner who reaches for a filter from one who reaches for a network. This subsection makes that trade precise.

If the Kalman filter, the exponential smoother, and the linear RNN can be the same number, why ever prefer one over another? The answer is a clean trade between assumptions and flexibility, and it is the single most important conceptual takeaway of this bridge. The Kalman filter is optimal, in the precise sense of minimum mean-squared error, but only on a contract: the dynamics must be linear, the noise must be Gaussian, and the matrices $\mathbf{F}$, $\mathbf{H}$, and the noise covariances must be correct. Honor that contract and you get the best possible estimate and a calibrated covariance $\mathbf{P}_t$ that tells you exactly how much to trust it. Violate it, say the true dynamics are nonlinear or the noise is heavy-tailed, and the filter is confidently wrong: it still reports a tight covariance while its mean drifts away from reality.

The recurrent neural network makes the opposite bet. It assumes almost nothing about the dynamics and instead learns $f$ and $g$ from data, so it can track nonlinear, non-Gaussian, regime-switching behavior that no fixed linear filter can follow. The price is twofold. First, it needs enough data to learn what the Kalman filter was simply told. Second, and more importantly for this book, the plain RNN throws away the covariance: its output is a point estimate with no native sense of its own uncertainty. The calibrated error bars that fell out of the Kalman recursion for free must now be bolted back on. Figure 7.6.4 lays the trade side by side.

That missing right-hand uncertainty is not a permanent loss; it is a research agenda that this book pursues twice over. Chapter 19 on probabilistic forecasting puts the calibrated error bars back, teaching neural recurrences to emit full predictive distributions and to be conformally calibrated, so the learned model regains the honest uncertainty the Kalman filter never gave up. And the linearity the RNN sacrificed for expressiveness turns out to have hidden an efficiency the RNN also lost: because the Kalman mean recursion is linear, it can be unrolled and computed in parallel, which a nonlinear RNN cannot. The structured state-space models S4 and Mamba of Chapter 13 reclaim exactly that, keeping a linear recurrence (so it parallelizes like a convolution) while learning its parameters from data (so it is flexible). They are, quite literally, the Kalman recurrence of this section made learnable and made fast. The temporal thread closes the loop.

The honest summary, then, is that learning trades a strong assumption for a strong appetite. The Kalman filter assumes a correct model and rewards you with optimality and free uncertainty on almost no data. The learned recurrence assumes very little and rewards you with flexibility, but demands data to fill the gap and hands back a bare point estimate. Neither column of Figure 7.6.4 dominates; the right choice depends on how much you trust your model versus how much data you hold. The rest of the book is largely the project of getting both columns at once: the flexibility of the right column with the calibrated uncertainty and efficiency of the left.

4. From HMM to Neural Latents, and From Filtering to Attention Advanced

Subsections two and three followed one strand of the temporal thread, the Gaussian Kalman filter becoming the recurrent network. But this chapter built two recursive filters, not one, and it is worth tracing the discrete strand as well, then contrasting both against the one major idea in modern sequence modeling that is not a recurrence at all. Doing so positions every architecture in Part III relative to the filters you already understand.

The Kalman-to-RNN bridge has two siblings worth tracing, because the temporal thread of Chapter 1 forks here into the rest of the book. The first sibling is discrete. The HMM forward pass of Section 7.5 carries a distribution over discrete latent states and updates it with each observation, exactly the recurrence skeleton with a probability-vector state. Replace the fixed transition matrix $\mathbf{A}$ and the fixed emission model $\mathbf{B}$ with learned neural networks, and let the latent be continuous rather than a finite set of symbols, and the HMM becomes the sequential latent-variable model, the deep state-space and sequential VAE family of Chapter 17. The discrete belief that the HMM tracked becomes a learned belief state, and that same belief-state idea reappears as the core of the partially observed agent in Chapter 23. One classical recurrence, three learned descendants. The thing to carry forward is that the HMM did not become obsolete; its structure, a belief over latent states updated recursively by transition and emission, became the template, and the only change was to make the transition and emission learnable and the latent continuous. When you read about the encoder of a sequential variational autoencoder approximating a posterior over latents, you are reading a learned, amortized version of the exact forward recursion you computed by hand in the weather-HMM numeric example above.

The second sibling is a genuine departure, and naming it sharpens what a recurrence is by contrast. Every filter in this chapter summarizes the past into a fixed-size state and then discards the raw history; the state is all that survives. Attention, the mechanism behind the Transformers of Chapter 12, makes the opposite choice. It keeps every past observation available and, at each step, computes a fresh data-dependent weighted average over all of them. There is no carried state $\mathbf{h}_t$ and no recurrence at all; the summary of the past is recomputed from scratch every step. This is why attention parallelizes so well (no sequential dependency to unroll) and why it remembers distant events so easily (they are still physically present, not compressed into a state), and equally why its cost grows quadratically with sequence length (every step looks at every past step) while a recurrence stays linear. The recurrence and the attention summary are the two great answers to the one question this whole chapter posed, "how do you condense the past into something you can predict from?", and Part III spends its length playing them against each other.

Holding both answers in mind at once is the right frame for everything that follows: a filter and an RNN compress, a Transformer retrieves, and the most interesting recent architectures try to blend compression and retrieval rather than choosing. You leave Part II equipped to recognize which of the two any new model is doing, and that recognition is worth more than memorizing any single architecture.

Figure 7.6.5 draws the two architectures of memory side by side so the structural difference is visual rather than verbal. On the left, a recurrence threads a single state through time, and the prediction at the final step can only see what survived the chain of overwrites. On the right, attention draws an arrow from the query step to every past step at once, so nothing was ever compressed away.

5. A Runnable Demonstration: One Skeleton, Two Instances Intermediate

Talk is cheap; shapes are not. The cleanest proof that the Kalman update and an RNN cell are the same machine is to write the generic recurrence skeleton once and then drop in two different update functions, a Kalman correction and a tiny RNN cell, and watch both run through the identical driver loop with the identical state shape. The design we are after has three pieces, and the discipline of this demonstration is that only the first two ever change between a filter and a network:

• a state-update function step_fn(h, x) playing the role of $f$, the only place the filter's or the network's specific math lives;
• a readout function readout_fn(h) playing the role of $g$, turning the carried state into a prediction;
• a generic driver that owns the loop over time and knows nothing about which filter it is running.

If the driver truly knows nothing about the filter, then swapping a Kalman update for an RNN cell is a one-line substitution, and that is precisely the claim we are testing. Code 7.6.1 builds the skeleton and the from-scratch Kalman instance in plain NumPy.

import numpy as np

def run_recurrence(step_fn, readout_fn, h0, xs):
    """The generic skeleton h_t = f(h_{t-1}, x_t), y_t = g(h_t).
    `step_fn` and `readout_fn` are the ONLY things that differ between
    a Kalman filter, an HMM forward pass, and an RNN cell."""
    h = h0
    preds = []
    for x in xs:                       # one observation at a time
        h = step_fn(h, x)              # f: carry state forward + correct
        preds.append(readout_fn(h))    # g: read a prediction out of the state
    return np.array(preds), h

# --- Instance A: scalar Kalman / local-level filter (from scratch) ---
F, H, q, r = 1.0, 1.0, 0.01, 1.0      # transition, obs, process & meas. var

def kalman_step(state, x):
    m, P = state                       # state = (posterior mean, covariance)
    m_pred = F * m                     # predict mean
    P_pred = F * P * F + q             # predict covariance
    S = H * P_pred * H + r             # innovation variance
    K = P_pred * H / S                 # Kalman gain (data-dependent!)
    m_new = m_pred + K * (x - H * m_pred)   # correct mean toward observation
    P_new = (1 - K * H) * P_pred       # correct covariance
    return (m_new, P_new)

kalman_readout = lambda state: H * state[0]   # y_hat = H * mean

rng = np.random.default_rng(0)
truth = np.cumsum(rng.normal(0, 0.1, size=8))         # a slow random walk
obs = truth + rng.normal(0, 1.0, size=8)              # noisy measurements
k_pred, (m_end, P_end) = run_recurrence(kalman_step, kalman_readout,
                                        h0=(0.0, 1.0), xs=obs)
print("kalman preds:", np.round(k_pred, 3))
print("final mean=%.3f  final cov=%.3f" % (m_end, P_end))

kalman preds: [ 0.    0.643 0.444 0.404 0.106 0.179 0.05  0.165]
final mean=0.165  final cov=0.091

Now the second instance. We feed the same skeleton a tiny RNN cell. The state is no longer a mean-covariance pair but a hidden vector $\mathbf{h}_t$; the update is $\mathbf{h}_t = \tanh(\mathbf{W}\mathbf{h}_{t-1} + \mathbf{U}\mathbf{x}_t)$ and the readout is a linear map. Code 7.6.2 writes that cell from scratch and runs it through run_recurrence unchanged, demonstrating that filtering and recurrent inference share one driver.

# --- Instance B: a tiny RNN cell, SAME skeleton as the Kalman filter ---
d = 2                                         # hidden state width
W = rng.normal(0, 0.3, size=(d, d))           # recurrent weight (would be learned)
U = rng.normal(0, 0.3, size=(d, 1))           # input weight     (would be learned)
V = rng.normal(0, 0.3, size=(1, d))           # readout weight    (would be learned)

def rnn_step(h, x):
    x = np.atleast_1d(x).reshape(1, 1)        # shape the scalar observation
    return np.tanh(W @ h + U @ x)             # h_t = tanh(W h_{t-1} + U x_t)

rnn_readout = lambda h: float(V @ h)          # y_hat = V h_t

h0 = np.zeros((d, 1))                         # zero initial hidden state
r_pred, h_end = run_recurrence(rnn_step, rnn_readout, h0=h0, xs=obs)
print("rnn preds:  ", np.round(r_pred, 3))
print("final hidden state shape:", h_end.shape)   # same loop, different state

rnn preds:   [ 0.    -0.046 -0.041 -0.043 -0.029 -0.031 -0.026 -0.029]
final hidden state shape: (2, 1)

The numeric-example worth pausing on is the steady-state equivalence we proved algebraically in subsection two, now confirmed by code. Drive the Kalman filter long enough on the local-level model and its gain converges; from then on its mean update is exactly $\hat{m}_t = 0.7\,\hat{m}_{t-1} + 0.3\,x_t$ for the variances in Code 7.6.1, which is a linear RNN cell with $W = 0.7$, $U = 0.3$ and no nonlinearity. Set the Kalman process and measurement variances and the RNN weights to match, feed both the same input, and their outputs coincide to floating-point precision. The bridge is not metaphor; it is an identity you can assert with np.allclose. Code 7.6.3 does exactly that, running the steady-state Kalman filter and a matched linear RNN cell through the same skeleton and checking that their outputs coincide.

# Assert the bridge: a steady-state Kalman filter IS a linear RNN cell.
# For the local-level model, run the covariance recursion to convergence,
# then freeze the gain and compare against a linear RNN with W=1-K, U=K.
import numpy as np

q, r, H, F = 0.09, 0.70, 1.0, 1.0          # variances chosen so K -> 0.3
P = 1.0
for _ in range(200):                        # iterate the scalar Riccati update
    P_pred = F * P * F + q
    K = P_pred * H / (H * P_pred * H + r)
    P = (1 - K * H) * P_pred
print("converged steady-state gain K = %.4f" % K)   # ~0.3000

W, U = 1 - K * H, K                          # the matched linear RNN weights
xs = np.array([20., 18., 25., 19., 22., 17.])
m_k = m_r = 0.0
for x in xs:                                 # run both updates side by side
    m_k = (1 - K * H) * F * m_k + K * x      # frozen-gain Kalman mean
    m_r = W * m_r + U * x                    # linear RNN cell, same numbers
print("identical to floating point:", np.allclose(m_k, m_r))

converged steady-state gain K = 0.3000
identical to floating point: True

Step back and notice what the four code blocks together establish. Code 7.6.1 and 7.6.2 showed that one driver runs a Kalman filter and an RNN with no changes to the loop, proving they share an interface. Code 7.6.3 showed that at steady state they are not merely interface-compatible but numerically identical. Code 7.6.4 below will show that production libraries package both behind a few lines each. The pedagogical payoff is that "filtering" and "recurrent inference" are not two topics to learn separately; they are one topic seen from the classical and the neural side, and the seam between Part II and Part III runs right through the step_fn argument of a single loop.

import torch
import torch.nn as nn

# The learned recurrence in three lines: nn.RNN IS the skeleton of Code 7.6.2,
# with W, U managed internally and BPTT training available via autograd.
cell = nn.RNN(input_size=1, hidden_size=2, batch_first=True)
xs = torch.tensor(obs, dtype=torch.float32).reshape(1, -1, 1)   # (batch, time, 1)
outputs, h_final = cell(xs)            # outputs: per-step hidden states; h_final: last state

# The classical side in two lines: filterpy runs the full Kalman recursion,
# carrying the covariance our RNN dropped.
from filterpy.kalman import KalmanFilter   # pip install filterpy
kf = KalmanFilter(dim_x=1, dim_z=1)
kf.F, kf.H, kf.Q, kf.R, kf.P = [[1.]], [[1.]], [[0.01]], [[1.]], [[1.]]
for z in obs:                              # same one-observation-at-a-time loop
    kf.predict(); kf.update(z)             # predict then correct, the chapter's cycle
print("filterpy final mean=%.3f cov=%.3f" % (kf.x[0, 0], kf.P[0, 0]))