From raw signal to decision: the sensing chain

"Nobody ever hands me a decision. They hand me a voltage and a deadline, and expect the rest to appear."

A Slightly Overworked AI Agent

You are handed a voltage \(x(t)\) and a deadline. Somewhere behind that voltage is a hidden physical state \(s\) you actually care about: a heart rhythm, a bearing about to fail, a pedestrian stepping off a curb. The measurement model from Section 1.3, \(x = h(s) + \eta\), says the sensor gives you \(s\) only through its own response \(h(\cdot)\) and its own noise \(\eta\). The job of the chain is to invert that relationship well enough, fast enough, to produce a trustworthy estimate \(\hat{s}\) and an action \(a\) before the deadline passes. What follows walks one measurement through all eight stages. The figure and table below name all eight in order, and the prose then dwells on the two earliest, conditioning and sampling, because that is where the chain's errors and delays first become permanent.

The eight stages, and the verb each one serves

The chain has eight links. Each maps to one of the book's six verbs (measure, clean, represent, infer, fuse, deploy) and to the Part that teaches it. Read the boxes in the diagram below left to right, then read the table as its legend; every row names a stage, the verb it advances, what enters and leaves it, and where in the book it lives.

Two stages deserve a pause, because beginners routinely skip them. Conditioning is the analog work before digitization: amplification, anti-alias filtering, and range matching. Sampling then turns the continuous \(x(t)\) into the discrete sequence \(x[n]\) that everything digital consumes. Neither is glamorous, yet both are where the most expensive mistakes happen, because they are the last places the true continuous signal still exists. Sample badly and it is gone for good.

Set this stage wrong and the failure is both spectacular and permanent: a wrist wearable that cries wolf a dozen times a day, or a bearing monitor that certifies a failing machine as healthy, with no downstream retraining run able to rescue either. That is what is at stake in the two unglamorous paragraphs of analog work below. Conditioning, precisely, is the set of analog operations applied to \(x(t)\) while it is still a continuous voltage: a gain stage that scales the signal's amplitude to match the converter's input range, and a low-pass anti-alias filter that removes energy above the Nyquist frequency (half the sampling rate, the highest frequency a given sample rate can faithfully represent) before the sampler ever runs. The failure this guards against, aliasing, is the frequency folding demonstrated under "Why upstream flaws are unrecoverable" below. It matters because it is the last moment at which the true continuous waveform is physically present, so every choice made here sets a hard ceiling on the fidelity of everything digital that follows. Mechanically, the anti-alias filter attenuates out-of-band frequencies by passing the signal through a resistor-capacitor or active op-amp network whose gain rolls off above a chosen cutoff. Reach for analog conditioning whenever the converter has limited resolution or the sampling rate sits close to the signal's bandwidth; you can lean on a purely digital pipeline instead only when the transducer is already band-limited and the analog-to-digital converter (ADC) has generous headroom. In short: the sensing chain forgives nothing it was never handed, so every guarantee you want at the end has to be bought at the start.

Why upstream flaws are unrecoverable

Aliasing is the cleanest example of an irreversible upstream flaw, so it is worth stating concretely. Suppose a bearing vibrates at 90 Hz and you sample at 100 Hz without an anti-alias filter. The Nyquist limit is 50 Hz, so the 90 Hz tone folds down and appears in \(x[n]\) as a perfectly convincing 10 Hz tone. Nothing in the sampled data separates the aliased 90 Hz from a genuine 10 Hz tone: both trace out the same 10 Hz sinusoid, and although they differ by a sign, they share an identical spectral magnitude, so any magnitude-based feature reads them as one tone. A downstream model that flags "10 Hz means healthy" will confidently clear a machine that is actually screaming at 90 Hz. The fix does not live downstream. It lives in the conditioning stage, in an analog low-pass filter that had to run before the sampler, once, and cannot be retrofitted afterward. Chapter 3 (Signals, Sampling, Time, and Synchronization) develops the sampling theorem that makes this precise. Figure 1.5.2 illustrates aliasing: a 90 Hz tone folding into a fake 10 Hz sinusoid under undersampling.

The same one-way logic governs errors in general. Model a small error \(\delta\) injected at some stage. Every later stage applies its own transform, so by the time the error reaches the decision it has been stretched or compressed but never erased. A miscalibrated bias in \(h(\cdot)\) at transduction propagates as a constant offset through conditioning, survives sampling untouched, and reappears as a shifted decision boundary at the end. This is why we treat calibration and leakage-safe data handling as first-class engineering, not afterthoughts. Chapter 5 (Sensor Data Engineering and Leakage-Safe Datasets) shows how a subtle upstream mistake, normalizing with statistics computed over the test window, silently poisons every metric downstream.

Latency budgets accumulate down the chain

Error is not the only quantity that piles up as a measurement travels down the chain; time accumulates the same way, and it is just as unforgiving of the stages upstream. The deadline in the epigraph is not decoration. Each stage costs time, and end-to-end latency is the plain sum of per-stage latencies, not the maximum. A 12 ms model is affordable only if the seven other stages leave room for it under the deadline. Because the costs add, a chain can miss its deadline even when no single stage looks slow. That is exactly the failure that surprises teams who profile stages in isolation. The short program below tabulates a per-stage latency budget for the fall detector and checks the accumulated total against the 50 ms deadline. The running cumulative column is the number that actually has to clear the deadline.

import numpy as np

stages = ["transduce", "condition", "sample", "represent",
          "infer", "fuse", "decide", "act"]
latency_ms = np.array([0.2, 1.5, 20.0, 3.0, 12.0, 4.0, 0.5, 8.0])

cumulative = np.cumsum(latency_ms)      # time at which each stage completes
end_to_end = cumulative[-1]
deadline_ms = 50.0

for name, done_at in zip(stages, cumulative):
    print(f"{name:<11} done at {done_at:6.1f} ms")

verdict = "MET" if end_to_end <= deadline_ms else "MISSED"
print(f"end-to-end: {end_to_end:.1f} ms  (deadline {deadline_ms:.0f} ms) -> {verdict}")

Notice that sampling, at 20 ms, dominates: to observe a full motion cycle the window has to be long, and the deadline clock runs the whole time it fills. The sampling window alone costs 20 ms, more than the 12 ms neural network that teams instinctively rush to shrink first. This is the tension that Chapter 59 (Edge AI Fundamentals and Model Optimization) exists to resolve, and it is why shrinking the model is often the wrong optimization: the budget was spent upstream. Fusion, the reconciliation of the accelerometer and barometer estimates, adds its own 4 ms and its own failure modes; the principled way to combine noisy estimates without double-counting evidence is the subject of Chapter 48 (Foundations of Sensor Fusion).

from scipy.signal import decimate
x_ds = decimate(x, q=5, ftype="iir", zero_phase=True)  # anti-aliased 250 Hz -> 50 Hz

What's Next

The chain in this section quietly assumed we could afford each stage. In Section 1.6, we promote the constraints themselves to first-class citizens: sampling rate, latency, bandwidth, power, cost, and privacy are not afterthoughts to optimize once the model works, but design axes that shape which chain is even buildable on a coin-cell wearable or a bandwidth-starved remote sensor.