Distributed Sensing

"I am a camera in a mesh of ten thousand, reporting only what changed. Alone I see a corner; together we see the room, and no one of us ever holds the whole picture."

A Sensor Node Pruning Its Own Telemetry

The chapters before this one treated the edge as a place to run a model that was trained elsewhere. Distributed sensing inverts the emphasis. Here the edge is not a deployment target but a measurement instrument with thousands of apertures, and the central question is how to assemble a coherent view from observations that are scattered across space, arriving at different times, corrupted by different noise, and far too voluminous to centralize in full. A single traffic camera infers vehicle positions in its own frame; a city's worth of cameras, fused, infers a live traffic state that drives signal timing. A single vehicle's radar sees the car ahead; vehicles exchanging messages see around the blind corner. The pattern is always the same. Many sensors produce observations, and those observations must be combined into intelligence under constraints that make naive centralization impossible.

1. Many Apertures, One World Model Beginner

Call a deployment a sensor network when its nodes both observe and communicate: a camera mesh watching a stadium, motes measuring soil moisture across a farm, microphones localizing a sound, or vehicles broadcasting their kinematics over vehicle-to-everything (V2X) links. Each node carries a perception model, often the same on-device network discussed earlier in this chapter, that turns a raw signal into a compact observation: a bounding box, a detection, an embedding, an estimate of some physical quantity with an attached uncertainty. The observations are partial by construction. A camera sees only its frustum; a vehicle sees only what is not occluded; a microphone hears a time-of-arrival, not a position. No node has the data to answer the question the fleet is actually asked.

Multi-view perception is the canonical case. Several cameras with overlapping fields of view each detect the same pedestrian from a different angle; fusing their detections recovers a 3D track that no single 2D view determines. The same logic drives V2X: a vehicle that cannot see a crossing pedestrian receives a detection from a roadside unit or another car that can, and acts on a world model assembled from messages rather than from its own sensors alone. We treat these systems as a stream-processing problem (the observations are an unbounded, time-stamped flow, the subject of Chapter 9) layered on a graph (the nodes and their communication links form exactly the kind of network analyzed in Chapter 13). The fusion that sits on top is what this section adds.

2. In-Network Aggregation: Decide Locally What to Transmit Intermediate

The defining constraint of distributed sensing is bandwidth. Ten thousand cameras cannot stream raw video to a datacenter; the uplink does not exist, and even if it did, the bill and the latency would. The remedy is to push computation to the sensor and transmit only what fusion actually needs. This is in-network aggregation: each node, and each intermediate fog aggregator, decides locally what is worth sending. A node that sees nothing new sends nothing, the dashed link in Figure 34.5.1. A node that detects an event sends the detection, not the frame. An aggregator that receives ten overlapping detections of the same object fuses them into one and forwards the single fused result, so traffic shrinks as it climbs the hierarchy rather than growing.

The central design choice is what abstraction to ship. At one extreme, send raw data: maximum information for the fusion center, maximum bandwidth. At the other, send final decisions: minimum bandwidth, but the center cannot re-fuse what it never saw, and early hard decisions discard the soft evidence that good fusion depends on. The productive middle is to ship detections or embeddings with attached uncertainty, compact enough to fit the budget yet soft enough to fuse correctly. A bounding box with a covariance, or a fixed-length feature vector, is typically two to four orders of magnitude smaller than the frame it summarizes, and it preserves exactly the quantities the next section needs.

3. Distributed Data Fusion: Combining Partial Observations Intermediate

Once compact observations arrive, fusion combines them into one estimate. The principle is that a measurement should count in proportion to its reliability, and reliability is the inverse of variance. Suppose $K$ sensors each report a noisy estimate $x_k$ of the same scalar quantity, with the estimate from sensor $k$ modeled as the truth plus zero-mean noise of variance $\sigma_k^2$. The minimum-variance unbiased combination is the inverse-variance weighted mean,

Two facts make this the workhorse of distributed sensing. First, a precise sensor (small $\sigma_k^2$) dominates a noisy one automatically; no thresholding or hand-tuning is needed, the weights $\sigma_k^{-2}$ do it. Second, the fused variance $\sigma_{\hat{x}}^2$ is strictly smaller than every individual variance, because adding any positive precision $\sigma_k^{-2}$ to the denominator only shrinks the result. The fleet is genuinely more certain than its best member. The vector form replaces variances with covariance matrices and inverse-variances with precision (inverse-covariance) matrices; this is exactly the update a Kalman filter performs, fusing a prediction with a new measurement, and it is also the Bayesian posterior when the priors and likelihoods are Gaussian. We treat these as one idea at a high level: a covariance-weighted combination of partial observations, equation above, that any node can compute from messages alone.

The code below makes the variance-shrinking claim concrete. Four heterogeneous sensors, a precise lidar through a noisy radar, each report an estimate of one position. We fuse them by the equation above and check that the fused standard deviation is below the best single sensor's.

import numpy as np

rng = np.random.default_rng(7)
true_pos = 12.0                                   # the quantity every sensor estimates

# Four heterogeneous sensors: a precise lidar, two mid cameras, a noisy radar.
sigma = np.array([0.30, 0.90, 1.10, 2.50])        # per-sensor noise std dev
var = sigma ** 2                                  # per-sensor variance
est = true_pos + rng.standard_normal(len(sigma)) * sigma   # each node's local estimate

# Covariance-weighted (inverse-variance) fusion: the precision-weighted mean.
w = (1.0 / var) / np.sum(1.0 / var)               # weights sum to 1
fused = np.sum(w * est)                            # the shared estimate
fused_var = 1.0 / np.sum(1.0 / var)               # fused variance

print("true value           :", true_pos)
for i in range(len(sigma)):
    print(f"  sensor {i}  est={est[i]:6.3f}  sigma={sigma[i]:.2f}  weight={w[i]:.3f}")
print("fused estimate       :", f"{fused:.3f}")
print("fused error          :", f"{abs(fused - true_pos):.3f}")
print("best single sigma    :", f"{sigma.min():.3f}")
print("fused sigma          :", f"{np.sqrt(fused_var):.3f}")
print("fused var < best var :", fused_var < var.min())

true value           : 12.0
  sensor 0  est=12.000  sigma=0.30  weight=0.833
  sensor 1  est=12.269  sigma=0.90  weight=0.093
  sensor 2  est=11.698  sigma=1.10  weight=0.062
  sensor 3  est= 9.774  sigma=2.50  weight=0.012
fused estimate       : 11.980
fused error          : 0.020
best single sigma    : 0.300
fused sigma          : 0.274
fused var < best var : True

from filterpy.kalman import KalmanFilter   # pip install filterpy
import numpy as np

kf = KalmanFilter(dim_x=2, dim_z=2)        # state: 2D position
kf.x = np.array([0., 0.])                  # prior estimate
kf.P = np.eye(2) * 5.0                     # prior covariance (uncertain)
kf.H = np.eye(2)                           # sensor observes position directly
kf.R = np.diag([0.09, 6.25])              # sensor noise: precise in x, noisy in y

kf.predict()
kf.update(np.array([12.0, 11.0]))          # fuse one sensor's measurement
print(kf.x)                                # posterior is precision-weighted automatically

4. Consensus on a Shared Estimate Advanced

Fusion as written assumes one place that holds all $K$ observations. In a true mesh there is no such place; nodes see only their neighbors, and we still want every node to converge on the same fused estimate. Distributed averaging is the bridge. If each node repeatedly replaces its value with a weighted average of its own and its neighbors', then on a connected graph every node's value converges to the network-wide average, and no node ever needs the full set of observations. Iterating

drives all $x_i$ to the global mean for a suitable step size $\epsilon$, using only neighbor-to-neighbor messages. Carrying the precision $\sigma_k^{-2}$ as a second averaged quantity recovers the inverse-variance weighting of the equation in Section 3, so the mesh computes the same covariance-weighted fusion in a fully decentralized way. This is the same gossip and decentralized-averaging machinery that powers decentralized learning in Chapter 14; here it produces a shared world estimate rather than a shared model. Consensus also buys robustness: with no central fusion node, there is no single point of failure, and the trade is more rounds of communication for that resilience, the recurring tension of this book between bandwidth and reliability.

5. The Bandwidth Budget Sets the Design Intermediate

Every choice in the preceding sections reduces to one trade: how many bytes per observation, against how much fusion quality those bytes buy. Sending raw data maximizes fusion fidelity and saturates the link. Sending hard detections minimizes traffic and starves the fusion center of the soft evidence it needs to weigh sources well. Sending uncertainty-tagged detections or embeddings sits where most production systems land, small enough to fit the budget and soft enough that the covariance-weighted combine still behaves. The right point on this curve depends on the link, the event rate, and how much the application is hurt by a slightly worse estimate, and it is an engineering measurement rather than a default. These per-sensor world models feed directly into the action layer: a robot or autonomous vehicle consumes the fused estimate to plan and act, the subject of Section 34.8 on robotics and autonomous systems.

We now have the full distributed-sensing loop: per-sensor perception, in-network aggregation that decides locally what to transmit, covariance-weighted fusion that makes the fleet more certain than any node, and consensus that spreads the shared estimate without a center. The next section turns from sensing the world to acting on a model that was learned across many devices, continuing the chapter's edge story in Section 34.6.