Choosing an estimator

"Every filter is a bet about the shape of your uncertainty. The engineer who wins is not the one with the fanciest filter, but the one who knows which bet they are making."

A Decisive AI Agent

The four questions that pick the filter

Before comparing filters, characterize the problem. Four questions settle most decisions, and you can answer all four from the measurement model and a few minutes of thought about the physics, exactly the physics developed in Chapter 2.

1. How nonlinear are the dynamics and the measurement? A GNSS pseudorange is mildly nonlinear over a one-second step; a bearing-only measurement of a nearby target is violently nonlinear. The relevant quantity is not the function itself but how much it curves across one standard deviation of your state uncertainty. If a first-order Taylor expansion is accurate over that spread, an EKF suffices. If the curvature matters but the posterior stays roughly bell-shaped, a UKF captures it. The linearization error of the EKF grows with the second derivative of \(f\) and \(h\); the UKF's sigma points sample the function directly and capture curvature to second order with no Jacobian at all.

2. Is the posterior unimodal or multimodal? This is the decisive question, and it is independent of nonlinearity. A unimodal posterior, a single blob of probability, can be summarized by a mean and covariance, which is precisely what the Kalman family stores. A multimodal posterior, arising in global localization ("am I in room A or the identical room B?"), data association ("which of three targets produced this blip?"), or the wrapped-angle ambiguities common in RF sensing, cannot be summarized by one Gaussian. No amount of tuning rescues a Gaussian filter here; it will collapse onto one mode and discard the others. Multimodality forces a particle filter or a Gaussian mixture.

3. What is your compute and latency budget? An EKF and a UKF cost on the order of \(O(n^3)\) per step in the state dimension \(n\), dominated by the covariance update, and both run comfortably in microseconds for a modest state. A particle filter costs \(O(N\,n)\) for \(N\) particles plus the per-particle likelihood evaluation, and \(N\) often needs to be thousands. On a microcontroller (revisit Chapter 61) that gap is the difference between shipping and not shipping.

4. Can you evaluate a likelihood, or only sample? Particle filters need to score how well each particle explains the measurement. If your measurement model is a clean probability density this is trivial; if it is a black-box renderer or a neural network, you may need an approximate likelihood, which weakens the filter.

A comparison you can keep on your desk

The table below compresses the chapter into one glance. Read it as a ladder: start at the top and descend only when a question above forces you down. Each row costs materially more than the one above it, so every downward step should be justified by a failure of the cheaper filter, not by ambition.

Two refinements sit outside the ladder because they compose with any row. The robust and adaptive layer of Section 10.6 (outlier gating, adaptive noise estimation) should wrap whichever filter you chose; it fixes fragility, not the wrong choice of representation. And Rao-Blackwellization is a scalpel, not a default: it pays off dramatically only when a genuine linear-Gaussian substructure exists, such as landmark positions conditioned on a robot trajectory.

Measure the tradeoff, do not guess it

Intuition about accuracy-versus-cost is unreliable; the honest move is to run all the candidates on the same trajectory and plot error against wall-clock, on a leakage-safe split so the noise realizations in your test are not the ones you tuned on (the discipline from Chapter 5). The snippet below tracks a classic nonlinear benchmark, a range-and-bearing target, with an EKF, a UKF, and a bootstrap particle filter, then reports root-mean-square error and per-step time. It is the miniature of Lab 10.

import numpy as np
from filterpy.kalman import ExtendedKalmanFilter, UnscentedKalmanFilter, MerweScaledSigmaPoints
from filterpy.monte_carlo import systematic_resample
import time

def run_particle_filter(zs, N=2000):
    # bootstrap PF: predict via dynamics, weight by measurement likelihood
    parts = np.random.randn(N, 4) * 5.0          # [x, vx, y, vy]
    w = np.full(N, 1.0 / N)
    est = []
    for z in zs:
        parts[:, 0] += parts[:, 1]; parts[:, 2] += parts[:, 3]   # constant velocity
        parts[:, [1, 3]] += np.random.randn(N, 2) * 0.1          # process noise
        rng = np.hypot(parts[:, 0], parts[:, 2])
        brg = np.arctan2(parts[:, 2], parts[:, 0])
        resid = np.array([z[0] - rng, z[1] - brg]).T
        w *= np.exp(-0.5 * (resid**2 / np.array([1.0, 0.02])).sum(1))
        w += 1e-300; w /= w.sum()
        if 1.0 / np.sum(w**2) < N / 2:            # resample on degeneracy (10.4)
            idx = systematic_resample(w); parts = parts[idx]; w.fill(1.0 / N)
        est.append(np.average(parts, axis=0, weights=w))
    return np.array(est)

# ... EKF and UKF set up with the same f, h, Q, R (elided for space) ...
for name, fn in [("PF", run_particle_filter)]:
    t0 = time.perf_counter(); xhat = fn(measurements)
    dt = (time.perf_counter() - t0) / len(measurements)
    rmse = np.sqrt(np.mean((xhat[:, [0, 2]] - truth[:, [0, 2]])**2))
    print(f"{name}: RMSE={rmse:.3f}  time/step={dt*1e6:.1f} us")

When you run the complete harness, the pattern is remarkably stable across problems. On a mildly nonlinear leg the EKF and UKF tie the particle filter on accuracy while running orders of magnitude faster, so the particle filter is pure waste. On a leg where the target passes close to the sensor, where bearing becomes violently nonlinear, the EKF's RMSE blows up while the UKF and particle filter hold, and that single leg is your evidence for climbing one rung down the ladder.

When the answer is "none of the above"

Three exits from this chapter are worth naming so you recognize them. First, if you can afford to wait and want the smoothed trajectory rather than the causal filtered estimate, stop filtering and formulate the problem as a factor graph, which is the entire subject of Chapter 11; smoothing over a window beats any filter when latency is not sacred. Second, if your measurement model is a learned function with no analytic form, a differentiable or neural filter that learns the dynamics may outperform any hand-built one, a thread picked up in Chapter 16. Third, if the real difficulty is not the estimator but knowing whether to trust its output, the calibration and conformal machinery of Chapter 18 is the missing piece, because a filter that reports a covariance is not the same as a filter whose covariance is honest.

What's Next

In Chapter 11, we take the most important exit from the filtering ladder. When latency is not sacred and you want the best estimate of the whole trajectory rather than the causal one, the problem stops being a recursive filter and becomes a large optimization over a factor graph. That reframing powers modern SLAM and visual-inertial odometry, and it turns the question "which filter?" into the question "how do I solve one big nonlinear least-squares problem efficiently?"