Graph Neural Networks

Most models assume a data point stands alone: a row of features in, a prediction out, with rows treated as interchangeable and unrelated. But a lot of financial data isn't like that. A company sits inside a supply chain of suppliers and customers; a trader's counterparties form a network; correlated stocks form clusters. Ignoring that structure means throwing away exactly the information that would tell you why one company's earnings miss dragged three others down with it.

A graph neural network treats data as nodes connected by edges — companies and their supply relationships, say — and instead of scoring each node in isolation, it lets nodes talk to their neighbors. Picture a room of people at a mixer, each holding a card describing themselves. In each round, everyone reads the cards held by the people standing next to them, and rewrites their own card to summarize both what it already said and what the neighbors said. After a few rounds, a person's card reflects not just who they are, but the flavor of the people around them, and the people around those people.

The mechanics, one symbol at a time

Let $h_v^{(l)}$ be node $v$'s representation after $l$ rounds of this "read and rewrite" process (its feature vector at layer $l$), and let $\mathcal{N}(v)$ be the set of $v$'s direct neighbors in the graph. One standard update rule:

$$h_v^{(l+1)} = \varphi\left(W_{\text{self}}\, h_v^{(l)} + W_{\text{nbr}} \sum_{u \in \mathcal{N}(v)} h_u^{(l)}\right)$$

In words: the new representation for node $v$ is built from two pieces — its own current representation, passed through weights $W_{\text{self}}$, and the sum of its neighbors' current representations, passed through a separate weight matrix $W_{\text{nbr}}$ — added together and squashed through a nonlinearity $\varphi$, the same as an ordinary neural network layer. This is called message passing: at each round, every node sends its current representation to its neighbors as a "message," and every node aggregates the messages it received to update itself. Stack $L$ such layers and a node's final representation has absorbed information from every node reachable within $L$ hops — its neighbors, its neighbors' neighbors, and so on.

Worked example 1: one round of message passing by hand

A tiny 3-node graph: node A (a bank) connects to node B (a hedge fund counterparty) and node C (another bank). Initial 1-dimensional features (a simplified "risk score"): $h_A = 2.0$, $h_B = 5.0$, $h_C = 1.0$. Weights: $W_{\text{self}} = 0.5$, $W_{\text{nbr}} = 0.3$, no bias, $\varphi =$ identity for simplicity.

Node A's neighbors are B and C, so the neighbor sum is $h_B + h_C = 5.0 + 1.0 = 6.0$.

$$h_A^{(1)} = 0.5(2.0) + 0.3(6.0) = 1.0 + 1.8 = 2.8$$

Node A's risk score rose from 2.0 to 2.8 after one round, purely from being connected to a higher-risk counterparty (B, at 5.0) — its own features didn't change, but its representation shifted because of who it's linked to. A node with the exact same original features but safer neighbors would end up with a lower updated score. That's the entire value proposition of a GNN: identical raw features can lead to different learned representations depending on network position.

Worked example 2: information reaching a 2-hop neighbor

Extend the graph: node D connects only to node C (D is a counterparty of C, not directly of A). After round 1 (computed the same way as above), suppose $h_C^{(1)} = 0.5(1.0) + 0.3(h_A + h_D) = 0.5(1.0)+0.3(2.0+3.0) = 0.5+1.5=2.0$ (using $h_D=3.0$ and original $h_A=2.0$).

Now run round 2 for node A, using round-1 values: $h_A^{(1)} = 2.8$ (from above) and $h_C^{(1)} = 2.0$, plus $h_B^{(1)}$ computed similarly, say $4.5$.

$$h_A^{(2)} = 0.5(2.8) + 0.3(4.5 + 2.0) = 1.4 + 1.95 = 3.35$$

Node D never directly touched node A, yet D's original value of $3.0$ has now flowed into A's representation — through C, over two rounds. This is exactly how a GNN captures second-order exposure: a bank's risk score can rise because of a counterparty's counterparty, without a single direct edge between them, purely from stacking two message-passing layers.

Each round of message passing is, at its core, a matrix operating on a vector — the explorer above shows how a single linear map reshapes a simple 2-D space; a GNN layer is the same kind of operation, applied per node and mixed with each node's neighbors, repeated layer after layer.

What this means in practice

GNNs are used in finance for counterparty risk contagion (whose default would ripple where), fraud detection on transaction networks, supply-chain risk propagation, and modeling correlated baskets of securities as a graph rather than treating each independently. The number of message-passing layers $L$ controls how many hops of the network a prediction can see — too few and distant but relevant risk is invisible, too many and every node's representation starts blending toward the same "average of the whole graph" value, a known failure mode called over-smoothing. Building the graph itself (deciding which edges exist and how strong they are) is often the hardest and most consequential modeling choice, arguably more important than the GNN architecture on top of it.