Measurement models as the bridge to AI

"They kept asking me to predict the future. I kept explaining that I had never once been told what the present actually was, only what a sensor felt like saying about it."

A Pedantic AI Agent

This section assumes the whole of Chapter 2: the observables of Section 2.1, the transfer function of Section 2.5, and the coupled, multivariable view of Section 2.6. It points forward to the probability and estimation machinery of Chapter 4, which formalizes the likelihood we build here, and to Chapter 9, where the measurement model becomes the observation equation of a Kalman filter.

The measurement model: one equation that eats the whole chapter

A measurement model, sometimes called a forward model or observation model, is the map from latent state to observed reading. In its general stochastic form,

where \(x_t\) is the quantity you actually care about, \(\mathbf{c}_t\) are the environmental interferers, \(\boldsymbol{\theta}\) are (mostly per-device) calibration parameters, and \(\varepsilon_t\) is the stochastic residual. Every pathology from this chapter is now a named piece of \(h\). Finite resolution and saturation are a quantizing, clipping nonlinearity on the output. Bias and drift are slow terms in \(\boldsymbol{\theta}\); hysteresis makes \(h\) depend on the history of \(x\), not just its current value. The transfer function and response time make \(h\) a dynamical operator (a convolution), so \(y_t\) is a smeared function of the recent trajectory of \(x\). Cross-sensitivity is the dependence on \(\mathbf{c}_t\). The noise lives in \(p_\varepsilon\), and its color (Section 2.3) means \(\varepsilon_t\) is generally not independent across time. The single most useful habit in sensor AI is to keep this equation explicit rather than letting each defect leak into your pipeline as an unlabeled surprise.

Three ways AI consumes a measurement model

Writing \(h\) down pays off in three distinct modes, and most systems use more than one.

Forward, as a generator. Run \(h\) on known states to synthesize realistic readings. This is how you build simulators, augment scarce data with physically valid corruptions, and stress-test a model against saturation or drift it has not seen in the field. Lab 2, below, is exactly this mode: inject bias, drift, saturation, and colored noise through the forward model and measure what they do downstream. Synthetic data and digital twins in Chapter 55 scale this idea into a full engineering discipline.

Inverse, as an estimator. Given \(y\), recover \(x\). When \(h\) is known and invertible, this is calibration and compensation. When \(h\) is a dynamical, noisy operator, the principled inverse is Bayesian filtering: the measurement model becomes the likelihood \(p(y_t \mid x_t)\), a motion model supplies the prior \(p(x_t \mid x_{t-1})\), and Bayes' rule fuses them. The Kalman family of Chapter 9 is precisely this pattern with \(h\) linear and \(p_\varepsilon\) Gaussian. The uncertainty propagation that makes the estimate trustworthy is the subject of Chapter 4.

As inductive bias, feeding a learned model. When \(h\) is only partly known, you keep the part you trust and learn the rest. Feed the interferer channels \(\mathbf{c}_t\) as explicit inputs so the network can learn the coupling it should undo; subtract the analytic forward prediction and let a model clean up the residual; or embed \(h\) inside a differentiable pipeline so gradients flow through the physics (physics-informed learning). This hybrid stance, physics where you have it, learning where you do not, is the theme running from the deep models of Chapter 13 through the fusion methods of Part X.

From model to likelihood: the exact hinge to inference

The step that turns a measurement model into something an inference engine can use is to stop treating \(h\) as producing a number and start treating it as producing a distribution. Rearranging the forward model, the probability of seeing reading \(y\) if the state were \(x\) is

This likelihood is the single most reused object in the book. Maximizing it over \(x\) gives the maximum-likelihood estimate; combining it with a prior gives the Bayesian posterior of Chapter 4; iterating it over time gives a filter. Crucially, the shape of \(p_\varepsilon\) is not a detail. If your noise is heavy-tailed because of occasional dropouts, a Gaussian likelihood will let a single outlier drag your estimate anywhere, whereas a heavy-tailed likelihood makes the estimator robust for free. The measurement model is where you get to state plainly how your sensor lies, and that statement is what lets the estimator not be fooled. The small program below composes several chapter-2 defects into one forward model, then recovers the state by maximizing the likelihood, and contrasts that with a naive readout.

import numpy as np
from scipy.optimize import minimize_scalar

rng = np.random.default_rng(0)

# Forward measurement model h(x): gathers chapter-2 defects
S, bias, drift_rate, sat = 2.0, 0.5, 0.01, 8.0   # sensitivity, bias, drift, saturation
def h(x, t):
    y = S * x + bias + drift_rate * t             # sensitivity + bias + slow drift
    return np.clip(y, -sat, sat)                   # saturation nonlinearity

# Simulate one reading at time t with heavy-tailed (Student-t) noise
x_true, t = 2.3, 40.0
y_obs = h(x_true, t) + 0.4 * rng.standard_t(df=3)  # colored, heavy-tailed residual

# Naive inverse: invert only the nominal sensitivity
x_naive = y_obs / S

# Model-based inverse: maximize a robust likelihood of the FULL model
def neg_log_lik(x):                                # Student-t is outlier-tolerant
    r = (y_obs - h(x, t)) / 0.4
    return np.sum(np.log1p(r**2 / 3))
x_hat = minimize_scalar(neg_log_lik, bounds=(-10, 10), method="bounded").x

print(f"true x            : {x_true:.3f}")
print(f"naive readout     : {x_naive:.3f}")
print(f"model-based x_hat : {x_hat:.3f}")

The point of the code is not the exact numbers; it is that the naive readout has no way to know about the bias or the drift, while the model-based estimate does, because we told it the forward map. That is the entire value proposition of a measurement model in one screen of Python.

When to write the model, when to learn it, and when to do both

An honest question hangs over this chapter: if a deep network can map raw readings to answers end to end, why write \(h\) at all? The answer is a tradeoff, not a dogma. Write the model when the physics is known, the calibration data is scarce, the deployment demands extrapolation beyond the training envelope, or safety requires that you can explain why the estimate is what it is. Analytic models are sample-efficient and extrapolate along the physics; a learned map is only trustworthy inside the distribution it saw. Learn the model when \(h\) is genuinely unknown or hopelessly complex (the mapping from raw radar returns to a scene, say), when abundant labeled data covers the operating conditions, and when raw performance beats interpretability in your priorities. The strongest systems are usually hybrid: an analytic forward model carries the known physics and reduces the sample complexity, while a learned residual absorbs the couplings, aging, and nonlinearities no one wrote an equation for. This is the substance of physics-informed and differentiable-simulation methods, and it recurs from the sensor-specific models of Part IX to the world models of Part X.

What's Next

In Chapter 3, we stop treating a reading as a single number and start treating it as a stream. Sampling, aliasing, timestamps, jitter, and multi-sensor synchronization all decide whether the measurement model you just built is even applied to the moment you think it is, and getting time wrong quietly corrupts every estimate that follows.