Bridge: RNNs as Learned Kalman Filters

"In a previous life I computed my gain from a covariance and a Riccati equation, and I could prove I was optimal. Then they fed me a million sequences, replaced my proof with a sigmoid, and told me to learn the gain myself. I no longer know my own variance, but I can finally track a turn I was never told about."

A Hidden State That Used to Be a Kalman Filter

In Section 10.2 and Section 10.3 we built the LSTM and the GRU as engineering answers to the vanishing-gradient problem of Section 9.4: gates that let gradients flow and let the cell choose what to remember. That is the right way to derive them. It is not the only way to understand them. This section offers a second reading, the one the temporal thread of Chapter 1 has been promising since Part II: a gated RNN is the learned descendant of the Kalman filter, and its gates are the place where the filter's hand-computed gain became a trainable function. The closing bridge of Part II, Section 7.6, established the first half of this claim by mapping the Kalman mean update onto a linear RNN. The piece it deferred, and that this section delivers, is the role of the gate: why a constant input weight is not enough, and how the LSTM and GRU restore the data-dependent gain that made the Kalman filter adaptive. We keep the unified notation of Appendix A: $\mathbf{x}_t$ the input, $\mathbf{h}_t$ the hidden state, $\mathbf{c}_t$ the cell state, $\hat{\mathbf{y}}_t$ the prediction.

This reading earns its place because it changes what you do at the desk. Seen as an opaque bundle of gates, an LSTM is something you tune by trial. Seen as a learned Kalman filter, it is something you reason about: you know its cell state is a running estimate, you know its forget gate is choosing a memory horizon, you know its input gate is setting a trust level on each measurement, and you know the one thing it does not give you for free is a calibrated error bar, because that is exactly the covariance the Kalman recursion carried and the plain RNN dropped. Every design choice in the rest of Part III (when to add a probabilistic head in Chapter 19, when to reach for the linear-recurrence efficiency of Chapter 13) is clearer once you hold this correspondence in mind.

The four concrete competencies this bridge installs: to restate the Kalman predict-update recurrence and read it as a data-dependent gain on a carried state; to align that recurrence term by term with the LSTM and GRU gate equations and identify which gate plays the gain; to state precisely the gain-and-loss ledger of replacing the analytic filter with a learned cell, calibrated uncertainty being the central casualty; and to implement both a Kalman update and a gated cell on one tracking problem and show the learned cell approximating the optimal estimate from data. These close the arc that runs from Section 7.6 through this chapter.

1. Recall: The Kalman Filter Is a Recurrence With a Data-Dependent Gain Beginner

Before we can align the Kalman filter with a gated cell we need its recurrence in front of us, in the same notation we use for RNNs. Section 7.6 wrote the Kalman mean update as a single linear recurrence; we restate it here and, crucially, foreground the one feature that the linear-RNN reading of Part II had to set aside: the gain is recomputed every step from the filter's own uncertainty, so the effective input weight is not constant but data-dependent.

The Kalman filter tracks a latent state through two moves per step. The predict step propagates the previous posterior mean $\hat{\mathbf{m}}_{t-1}$ through the transition matrix $\mathbf{F}$ and inflates the covariance by the process noise; the update (correct) step nudges the predicted mean toward the new measurement $\mathbf{x}_t$ in proportion to the Kalman gain $\mathbf{K}_t$:

The quantity $\mathbf{x}_t - \mathbf{H}\hat{\mathbf{m}}_t^{-}$ is the innovation, the surprise: the gap between what the filter expected to measure and what it actually measured. The gain $\mathbf{K}_t$ sets how much of that surprise is admitted into the state. As Section 7.6 showed, collecting terms turns the mean update into one linear recurrence,

which is exactly the shape $\mathbf{h}_t = \mathbf{W}_t\mathbf{h}_{t-1} + \mathbf{U}_t\mathbf{x}_t$ of a recurrent cell, with recurrent weight $\mathbf{W}_t = (\mathbf{I} - \mathbf{K}_t\mathbf{H})\mathbf{F}$ and input weight $\mathbf{U}_t = \mathbf{K}_t$. The subscript $t$ on those weights is the whole story of this section. In a vanilla RNN the weights are constant; in the Kalman filter they breathe with the gain, which itself breathes with the covariance $\mathbf{P}_t^{-}$ (the Riccati recursion is the covariance update $\mathbf{P}_t^{-} = \mathbf{F}\mathbf{P}_{t-1}\mathbf{F}^{\top}+\mathbf{Q}$ that propagates uncertainty, from Section 7.6). When the filter is uncertain the gain is large and the new measurement is trusted; when the filter is confident the gain shrinks toward zero and the state coasts on its prediction. That single adaptive coefficient is what a vanilla RNN cannot represent and what a gate restores.

2. The Explicit Mapping: Gates Are Learned Kalman Gains Intermediate

We now place the Kalman update and the gated-cell update side by side and read off the correspondence. The claim is not loose analogy but a structural alignment: the same three jobs, propagate the state, decide how much to trust the measurement, blend, are done by both, with the only difference being whether the trust coefficient is computed from a model or learned as a nonlinear function of the data. Recall the LSTM cell of Section 10.2, written for the cell state $\mathbf{c}_t$ and hidden state $\mathbf{h}_t$:

Read the cell-state line $\mathbf{c}_t = \mathbf{f}_t \odot \mathbf{c}_{t-1} + \mathbf{i}_t \odot \tilde{\mathbf{c}}_t$ next to the rearranged Kalman update $\hat{\mathbf{m}}_t = (\mathbf{I} - \mathbf{K}_t\mathbf{H})\mathbf{F}\,\hat{\mathbf{m}}_{t-1} + \mathbf{K}_t\mathbf{x}_t$. Both are a state carried forward by a multiplicative coefficient plus a new contribution admitted by another coefficient. The forget gate $\mathbf{f}_t$ sits where $(\mathbf{I} - \mathbf{K}_t\mathbf{H})\mathbf{F}$ sits: it is the learned state-propagation factor, deciding how much of the old estimate survives. The input gate $\mathbf{i}_t$ sits where the gain $\mathbf{K}_t$ sits: it is the learned trust on the new information $\tilde{\mathbf{c}}_t$, which plays the role of the innovation-carrying input $\mathbf{x}_t$. The decisive difference is that $\mathbf{K}_t$ is computed from the Riccati covariance recursion under an assumed linear-Gaussian model, while $\mathbf{f}_t$ and $\mathbf{i}_t$ are sigmoids of a learned affine function of the data, free to implement any trust schedule the training distribution rewards. Figure 10.5.1 aligns the two updates term by term.

The GRU of Section 10.3 makes the correspondence even tighter because it uses a single coupled gate. Its update is $\mathbf{h}_t = (1 - \mathbf{z}_t) \odot \mathbf{h}_{t-1} + \mathbf{z}_t \odot \tilde{\mathbf{h}}_t$, where $\mathbf{z}_t = \sigma(\mathbf{W}_z[\mathbf{h}_{t-1}, \mathbf{x}_t])$ is the update gate. This is a convex blend governed by one coefficient $\mathbf{z}_t$, exactly the form of the scalar Kalman steady-state update $\hat{m}_t = (1-K)\hat{m}_{t-1} + K x_t$ that Section 7.6 showed equals an exponential smoother with $\alpha = K$. The GRU update gate $\mathbf{z}_t$ is a learned, per-step, per-dimension, data-dependent Kalman gain. Where the scalar Kalman filter pinned $K$ to a single value by the ratio of process to measurement variance, and the exponential smoother fixed $\alpha$ by hand, the GRU lets that blend coefficient vary with the input: high $\mathbf{z}_t$ right after a detected change (trust the new data, the filter's high-gain regime), low $\mathbf{z}_t$ during a stable stretch (coast on memory, the filter's low-gain regime).

3. What Is Gained and What Is Lost Advanced

The mapping cuts both ways, and a clear-eyed practitioner needs the full ledger. Replacing the analytic Kalman gain with a learned gate buys a large gain in flexibility and pays for it with a real loss in guarantees. Section 7.6 drew this ledger for the linear RNN; the gated cell shifts the balance, because gating recovers some of what the linear cell lost (the adaptive gain) while still forfeiting the rest (the calibrated covariance). This subsection states the trade precisely.

What is gained is nonlinear, model-free dynamics. The Kalman filter is provably optimal, in the minimum-mean-squared-error sense, but only on a contract: the dynamics must be linear, the noise Gaussian, and the matrices $\mathbf{F}$, $\mathbf{H}$, $\mathbf{Q}$, $\mathbf{R}$ correct. Honor the contract and the filter is the best possible estimator. Break it, say the true dynamics turn nonlinearly or switch regime, and the filter is confidently wrong, lagging the truth while reporting a tight covariance. The gated RNN assumes almost none of this. Its forget and input gates are arbitrary nonlinear functions of the state and input, so it can learn trust schedules and propagation factors no fixed linear filter can express: it can slam its gain to near one at a detected change, hold a value for hundreds of steps through a near-saturated forget gate, or implement a different effective filter in different regions of state space. For the messy, nonstationary, non-Gaussian series of the real world, that flexibility is decisive, and it is why the field reaches for an LSTM rather than an extended Kalman filter when the dynamics are unknown.

What is lost is the closed-form, calibrated uncertainty. The Kalman filter carries a covariance $\mathbf{P}_t$ alongside its mean, and that covariance is a genuine, calibrated quantification of how much to trust the estimate, delivered for free by the same recursion that produces the mean. A plain gated RNN carries only the cell state, a point estimate with no native sense of its own error. The error bars that fell out of the Kalman recursion must now be bolted back on. This is not a permanent loss but a deferred one: Chapter 19 on probabilistic forecasting teaches recurrent models to emit full predictive distributions and to be conformally calibrated, recovering honest uncertainty inside a learned model. The thing to carry forward from this subsection is that the missing covariance is the single most important casualty of learning the filter, and that the book buys it back deliberately rather than pretending it was never lost. Figure 10.5.2 lays the ledger out.

4. The Modern Reconciliation: Deep State-Space Models Advanced

The trade of subsection three looks like a clean either-or: hand-built linear filter with optimality and free uncertainty, or learned nonlinear RNN with flexibility and no closed form. The most active line of recent sequence-modeling research refuses the choice, and it does so by going back to the very recurrence this section started from. The reconciliation matters here because it is the natural endpoint of the temporal thread: the Kalman filter, having become the RNN, becomes learnable and efficient at once.

The nonlinearity that bought the RNN its flexibility also cost it something the Kalman filter quietly had: because the Kalman mean update is linear, it can be unrolled and computed in parallel across time, whereas a $\tanh$-gated RNN is strictly sequential, step $t$ cannot start until step $t-1$ finishes. Deep state-space models reclaim the linear recurrence while keeping it learnable. S4 (Gu, Goel, and Ré, 2022) and Mamba (Gu and Dao, 2023) parameterize a linear state-space recurrence $\mathbf{h}_t = \mathbf{A}\mathbf{h}_{t-1} + \mathbf{B}\mathbf{x}_t$, $\mathbf{y}_t = \mathbf{C}\mathbf{h}_t$, that is exactly the Kalman state-propagation skeleton, but with $\mathbf{A}$, $\mathbf{B}$, $\mathbf{C}$ learned from data rather than derived from a physical model. Because the recurrence is linear, it trains as a long convolution (parallel, like attention) and runs at inference as a recurrence (cheap, like a filter), recovering the parallelism the nonlinear RNN forfeited. Mamba's central innovation, input-dependent $\mathbf{A}$ and $\mathbf{B}$ matrices, is the selectivity that lets the linear recurrence decide what to keep, which is the Kalman gain idea once more: a data-dependent coefficient on the state, now made parallelizable. These models, the subject of Chapter 13, are quite literally the Kalman recurrence of Section 7.6 made learnable and made fast.

5. Worked Example: A GRU Learns to Be a Kalman Filter Advanced

We now make the central claim executable: a gated recurrent cell, trained only on noisy measurements from a known linear-Gaussian system, learns to approximate the optimal Kalman estimate, because the optimal estimate is exactly what minimizing prediction error on that data rewards. The plan has three parts. First, implement a scalar Kalman filter from scratch in NumPy and run it on a simulated local-level system to get the optimal (oracle) estimate. Second, implement a minimal GRU cell from scratch and confirm its update is the gated blend of subsection two. Third, train a PyTorch GRU on the same measurements to predict the latent state, and compare its output against the Kalman estimate. Code 10.5.1 builds the data and the from-scratch Kalman oracle.

import numpy as np

rng = np.random.default_rng(0)
T = 400
F, H, Q, R = 1.0, 1.0, 0.01, 0.25     # local-level model: slow drift, noisy sensor

# Simulate the hidden state (random walk) and noisy measurements.
state = np.zeros(T)
for t in range(1, T):
    state[t] = F * state[t-1] + rng.normal(0, np.sqrt(Q))   # latent random walk
meas = state + rng.normal(0, np.sqrt(R), size=T)            # what we actually observe

def kalman_filter(meas, F, H, Q, R):
    """Scalar Kalman filter: the OPTIMAL estimate for this linear-Gaussian model."""
    m, P = 0.0, 1.0                                # initial mean, covariance
    est = np.zeros_like(meas)
    for t, x in enumerate(meas):
        m_pred = F * m                             # predict mean
        P_pred = F * P * F + Q                     # predict covariance
        K = P_pred * H / (H * P_pred * H + R)      # Kalman gain (data-dependent)
        m = m_pred + K * (x - H * m_pred)          # correct toward measurement
        P = (1 - K * H) * P_pred                   # correct covariance
        est[t] = m
    return est, K                                  # K has converged by the end

kf_est, K_ss = kalman_filter(meas, F, H, Q, R)
kf_mse = np.mean((kf_est - state) ** 2)
print("steady-state Kalman gain K = %.4f" % K_ss)
print("Kalman MSE vs true state  = %.5f" % kf_mse)
print("raw measurement MSE       = %.5f" % np.mean((meas - state) ** 2))

steady-state Kalman gain K = 0.1817
Kalman MSE vs true state  = 0.04300
raw measurement MSE       = 0.24668

Now the from-scratch gated cell, to confirm its update is the gated blend we aligned with the Kalman filter in subsection two. Code 10.5.2 implements a minimal scalar GRU forward pass by hand, with the update gate $z$ playing the Kalman gain.

def gru_step(h, x, params):
    """One scalar GRU step. The update gate z IS the learned Kalman gain:
    h_t = (1 - z) * h_{t-1} + z * h_tilde, a data-dependent convex blend."""
    Wz, Uz, Wr, Ur, Wh, Uh = params
    z = 1 / (1 + np.exp(-(Wz * h + Uz * x)))        # update gate (the gain)
    r = 1 / (1 + np.exp(-(Wr * h + Ur * x)))        # reset gate
    h_tilde = np.tanh(Wh * (r * h) + Uh * x)        # candidate (the new info)
    return (1 - z) * h + z * h_tilde                # blend: carry vs admit

# Untrained, hand-set params just to exercise the forward pass and its blend.
demo = (0.0, 1.0, 0.0, 1.0, 0.0, 1.0)
h = 0.0
for x in meas[:5]:
    h = gru_step(h, x, demo)
print("from-scratch GRU ran; example state after 5 steps: %.4f" % h)

from-scratch GRU ran; example state after 5 steps: 0.3142

Finally the library pair, which is where the claim is proven. Code 10.5.3 builds a PyTorch GRU, trains it to predict the latent state from the noisy measurements alone, and compares the trained network's estimate against the Kalman oracle. The from-scratch Kalman filter plus hand GRU step above ran roughly 35 lines of explicit recursion and gate arithmetic; the PyTorch version expresses the entire learned cell, its unrolled recurrence, and its backpropagation-through-time training in about a dozen, with nn.GRU and autograd handling the gates, the carry, and the gradients internally.

import torch
import torch.nn as nn

class GRUFilter(nn.Module):                          # a GRU that learns to filter
    def __init__(self, hidden=16):
        super().__init__()
        self.gru = nn.GRU(input_size=1, hidden_size=hidden, batch_first=True)
        self.readout = nn.Linear(hidden, 1)          # g: state -> state estimate
    def forward(self, x):
        h, _ = self.gru(x)                           # the gated recurrence, unrolled
        return self.readout(h).squeeze(-1)

x = torch.tensor(meas, dtype=torch.float32).reshape(1, -1, 1)   # (batch, time, 1)
y = torch.tensor(state, dtype=torch.float32).reshape(1, -1)     # target: TRUE state
model = GRUFilter()
opt = torch.optim.Adam(model.parameters(), lr=0.01)
for epoch in range(400):                             # train on noisy meas -> true state
    opt.zero_grad()
    loss = ((model(x) - y) ** 2).mean()              # BPTT runs inside .backward()
    loss.backward(); opt.step()

gru_est = model(x).detach().numpy().ravel()
gru_mse = np.mean((gru_est - state) ** 2)
print("GRU MSE vs true state     = %.5f" % gru_mse)
print("Kalman MSE vs true state  = %.5f" % kf_mse)
print("GRU-vs-Kalman agreement   = %.5f (mean abs diff of the two estimates)"
      % np.mean(np.abs(gru_est - kf_est)))

GRU MSE vs true state     = 0.04461
Kalman MSE vs true state  = 0.04300
GRU-vs-Kalman agreement   = 0.01935 (mean abs diff of the two estimates)

Step back and read what the three blocks establish together. Code 10.5.1 computed the provably optimal estimate from the known model. Code 10.5.2 showed the GRU's update is the same gated carry-and-admit blend, by hand. Code 10.5.3 trained that gated cell on noisy data with no knowledge of the model and watched it converge to within a few percent of the optimal filter. The pedagogical payoff is the bridge made concrete: a GRU is not merely like a Kalman filter, it learns to be one when the data come from a system the Kalman filter is optimal for, and it keeps going where the Kalman filter cannot, into the nonlinear and nonstationary regimes that no fixed gain can follow.

import torch.nn as nn
from filterpy.kalman import KalmanFilter

learned = nn.GRU(input_size=1, hidden_size=16, batch_first=True)   # the learned filter

kf = KalmanFilter(dim_x=1, dim_z=1)        # the analytic filter, covariance and all
kf.F, kf.H, kf.Q, kf.R = [[1.]], [[1.]], [[0.01]], [[0.25]]
kf.predict(); kf.update(z=meas[0])         # one predict-update cycle; kf.x is the mean, kf.P the covariance