Spatial, process, and dynamic graphs

"Nobody handed me the wiring diagram, so I inferred one from the correlations. It was confident, tidy, and wrong in exactly the two places a leak would have shown up."

A Graph-Building AI Agent

Recall from Section 54.1 that message passing updates each node from its neighbors. The neighbor set is defined by \(A\). So constructing \(A\) is constructing the model's inductive bias: it declares, before any weight is trained, what "nearby in the world" means. The three families below answer that declaration differently.

Spatial graphs: geometry as the prior

What a spatial graph does is turn physical positions into edges. Why it works is the first law of geography: near things are more related than distant things, so two sensors a few meters apart usually see correlated phenomena. How you build one is a kernel over pairwise distance. The workhorse is a thresholded Gaussian on the distance \(d_{ij}\) between sensors \(i\) and \(j\):

where \(\sigma\) sets the correlation length scale and the threshold \(\kappa\) sparsifies the graph so distant pairs are simply disconnected. Two knobs, two jobs: \(\sigma\) controls how fast influence decays, \(\kappa\) controls how many neighbors survive. The alternative construction is a \(k\)-nearest-neighbor graph, which fixes the degree (every node keeps its \(k\) closest peers) rather than the radius; \(k\)-NN is the right call when sensor density varies wildly across the network, because a fixed radius would leave dense clusters over-connected and sparse regions isolated.

When spatial graphs shine is when the physical field is smooth and the medium is roughly homogeneous: air-quality monitors across a city, weather stations, seismic arrays, or the loop detectors of the METR-LA and PEMS-BAY traffic datasets you will meet in Section 54.3. A subtle but important refinement: for traffic and pipe flow, Euclidean distance lies. Two loop detectors on opposite sides of a highway median are meters apart yet functionally unrelated, while two detectors far apart along the same on-ramp are tightly coupled. The fix is to measure \(d_{ij}\) as road-network distance (shortest travel path) rather than straight-line distance, which quietly turns a spatial graph into a process graph.

The snippet below builds a thresholded Gaussian adjacency from raw sensor coordinates and reports the resulting sparsity, the number that decides whether message passing is cheap.

import numpy as np

# 12 sensors scattered in a 2 km square (positions in meters).
rng = np.random.default_rng(0)
pos = rng.uniform(0, 2000, size=(12, 2))

# Pairwise Euclidean distance matrix.
diff = pos[:, None, :] - pos[None, :, :]
dist = np.sqrt((diff ** 2).sum(-1))

sigma = 400.0                       # correlation length scale (meters)
kappa = 0.1                         # keep an edge only if the kernel >= 0.1
W = np.exp(-(dist ** 2) / (2 * sigma ** 2))
np.fill_diagonal(W, 0.0)           # no self-loops here; GNN layers add them back
A = np.where(W >= kappa, W, 0.0)   # sparsify

deg = (A > 0).sum(1)
print(f"edges kept      : {int((A > 0).sum() // 2)}")
print(f"mean degree     : {deg.mean():.1f} neighbors/node")
print(f"isolated nodes  : {int((deg == 0).sum())}")

Process graphs: topology from the plant

A process graph replaces "close in space" with "connected by the process." What defines an edge here is a real conduit for influence: a pipe segment between two pressure sensors, a busbar between two substations, a conveyor between two stations, a shared shaft between two bearings. Why this beats a spatial graph in engineered systems is that the process topology is the causal structure. Water pressure propagates along pipes, not across the parking lot the pipes happen to run under; a fault current follows the electrical one-line diagram, not the geographic layout of the poles. How you obtain the edges is by reading the system's own documentation: a piping-and-instrumentation diagram (P&ID), an electrical single-line diagram, a SCADA point-to-point map, or a bill of materials that lists which components are bolted to which.

Process graphs are typically directed and often weighted by a physical quantity. Flow has a direction, so an edge from an upstream to a downstream pressure sensor is not the same as its reverse; a weight might be pipe conductance, line admittance, or nominal flow rate. This directedness matters for message passing because it tells the GNN which way evidence should propagate, a distinction a symmetric spatial graph throws away. When the documentation is incomplete, you can recover process structure statistically: a partial-correlation or Granger-style test between sensor streams (the conditional-dependence machinery of Chapter 11) proposes edges where one sensor's variation predicts another's after controlling for the rest. This is exactly the fault-propagation backbone that Section 54.4 exploits to localize a failure to its source.

Dynamic and learned graphs: when the topology is unknown or moves

Sometimes no clean documentation exists, the true couplings drift over time, or the nodes themselves move. Dynamic graphs answer all three. There are two distinct notions worth separating. The first is a time-varying graph, where the node set or edge set genuinely changes: vehicles in a V2X network join and leave, a wearable body-sensor network re-routes as limbs occlude radio links, a swarm of robots re-forms neighbors as it moves. The adjacency becomes a sequence \(A^{(t)}\), and the GNN must consume a graph per timestep.

The second, more subtle notion is a learned adjacency, where you admit you do not know the true graph and let the model discover it. How this works in practice is a self-adaptive adjacency matrix: assign each node a learnable embedding \(\mathbf{e}_i \in \mathbb{R}^{c}\) and define

so the edge weights are trained end to end by gradient descent alongside the forecasting or detection loss. This is the mechanism inside Graph WaveNet (Wu et al., 2019), which you will study in Section 54.3; it lets the model find couplings the spatial graph missed, such as two distant traffic sensors linked by a commuter pattern rather than by road proximity. When to reach for a learned graph is when your prior graph is weak or suspect and you have enough data to fit the extra parameters; when to distrust it is the low-data regime, where a learned adjacency happily memorizes spurious correlations, the same leakage risk this book flags whenever a model is given freedom it cannot pay for out of data.

Choosing a family, and mixing them

The three families are not exclusive, and the strongest designs combine them. A common recipe fuses a fixed process (or spatial) adjacency with a learned adaptive one, letting the GNN use documented physics as a backbone and gradients to fill gaps: \(A = A^{\text{phys}} + A^{\text{adp}}\). Choose the starting point by asking what carries influence in your system. If it is a free medium, start spatial. If it is an engineered conduit and you have the drawings, start with a process graph, because it hands you directedness and interpretability for free. If the couplings are unknown, time-varying, or the nodes move, you need a dynamic or learned graph, and you should budget the data to justify the extra freedom. Whatever you pick, validate it the way Chapter 48 validates any fusion assumption: check that edges correspond to real dependence and that no node is silently orphaned, because an adjacency error is a modeling error that no amount of training will repair.

What's Next

In Section 54.3, we stop constructing graphs and start computing on them over time. Spatiotemporal GNNs such as DCRNN, Graph WaveNet, and BigST marry the adjacency structures of this section to temporal models, diffusing information across the graph at each timestep while a sequence model tracks how each node evolves. You will see the self-adaptive adjacency reappear as a trainable layer, and the spatial-versus-process choice you made here will set how far and how fast a signal can travel through the network.