Message Passing and the Three Tasks

A graph is a beautiful way to store a financial network — banks as nodes, loans as edges, the whole tangled web of who-owes-whom laid out in one picture. But a picture just sits there. To learn from it — to predict which bank is fragile, which transfer is fraudulent, which whole network is about to seize up — you need an engine that turns the structure into numbers a model can score.

That engine has a single, almost suspiciously simple idea at its heart: message passing. Every node looks at its neighbours, listens to what they have to say, and updates its own description of itself. Do that once and a node knows its neighbourhood. Do it twice and it knows its neighbourhood’s neighbourhood. Stack a few rounds and a node carries a compressed summary of the slice of the network it can reach — exactly the thing you want when a shock two lending-hops away can still sink you.

This lesson builds the engine from the ground up, then shows the three jobs you can point it at. Get message passing right and every later architecture — GraphSAGE, GAT, the attention variants — is just a different choice of how a node listens.

The message-passing paradigm

Analogy. Your reputation is the company you keep. Picture a person who, every evening, takes the average mood of the friends they spoke to that day and nudges their own mood toward it — then tomorrow those friends do the same, having themselves been nudged by their friends. After a few evenings, gossip from across the social circle has quietly diffused into everyone’s mood. A node in a GNN does precisely this: it gossips with its neighbours and updates its own state from what it hears.

Definition. A graph neural network (GNN) computes a vector for every node — its embedding, a learned numerical summary of the node and its context. It does so in rounds called layers. Let $h_v^{(k)}$ be the embedding of node $v$ after layer $k$, and let $\mathcal{N}(v)$ be the set of $v$‘s neighbours (the nodes connected to it by an edge). One generic message-passing layer is:

$h_v^{(k)} = \text{UPDATE}\!\left( h_v^{(k-1)},\ \text{AGGREGATE}\big(\{\, h_u^{(k-1)} : u \in \mathcal{N}(v) \,\}\big) \right).$

Read it left to right. AGGREGATE is a function that swallows the set of neighbour embeddings and squeezes them into one summary vector — a sum, a mean, a max. UPDATE then combines that neighbour-summary with the node’s own previous embedding $h_v^{(k-1)}$ to produce the new one. The starting embeddings $h_v^{(0)}$ are just the node’s raw input features (a bank’s capital ratio, a wallet’s transaction count). Every layer the model learns weights inside UPDATE and AGGREGATE, so it discovers which neighbour information matters.

Worked example. Take a target node with embedding $h_v^{(0)} = 0.3$ and four neighbours holding the values $0.8,\ 0.2,\ 0.6,\ 0.4$. Use the simplest pair of functions: AGGREGATE = mean, and UPDATE = average-of-(self, aggregate).

Step 1 — aggregate the neighbours:

$\text{AGGREGATE} = \frac{0.8 + 0.2 + 0.6 + 0.4}{4} = \frac{2.0}{4} = 0.5.$

Step 2 — update by averaging the node’s own value with that aggregate:

$h_v^{(1)} = \frac{h_v^{(0)} + 0.5}{2} = \frac{0.3 + 0.5}{2} = \frac{0.8}{2} = 0.4.$

The node moved from $0.3$ to $0.4$ — pulled upward by neighbours that, on average, sit higher than it does. That is the entire engine in one number. Real GNNs do this with vectors and learned weight matrices instead of scalars, but the shape is identical: listen, pool, combine.

When to use it

Message passing is the right tool the moment the relationships carry signal you would lose by treating rows independently. If a bank’s risk depends on who it lends to, a wallet’s label depends on who it transacts with, or a transfer’s legitimacy depends on the pattern around it, you want a GNN. If every row is genuinely independent — features fully describe the outcome with no relational context — a plain tabular model is simpler and just as good. Reach for message passing when the edges mean something.

Why permutation invariance is non-negotiable

Analogy. Imagine totting up the cash in a jar of coins. It does not matter whether you pull out the quarter or the dime first — the total is the total. Now imagine instead you wrote each coin’s value into a row of boxes in the order you drew them, and your answer depended on which box held which coin. Shuffle the draw order and your “answer” changes, even though the jar never did. Neighbours in a graph are coins in a jar, not boxes in a row.

Definition. A function is permutation-invariant if reordering its inputs never changes its output: for any reordering, $f(\{x_1, x_2, \dots\}) = f(\{x_{\pi(1)}, x_{\pi(2)}, \dots\})$. The symmetric pools — sum, mean, and max — are all permutation-invariant, which is exactly why GNNs use them for AGGREGATE. They also gracefully handle variable degree: a node with 2 neighbours and a node with 200 neighbours both produce one summary vector of the same size.

Worked example. Take three neighbour values $\{0.8,\ 0.2,\ 0.6\}$ and reorder them to $\{0.2,\ 0.6,\ 0.8\}$.

Mean of the first ordering:

$\frac{0.8 + 0.2 + 0.6}{3} = \frac{1.6}{3} \approx 0.533.$

Mean of the reordered set:

$\frac{0.2 + 0.6 + 0.8}{3} = \frac{1.6}{3} \approx 0.533.$

Identical — the mean does not care about order. Now try the broken alternative, concatenation, which just glues the values into one ordered vector. The first ordering gives the vector $[0.8,\ 0.2,\ 0.6]$; the reordering gives $[0.2,\ 0.6,\ 0.8]$. Those are different vectors, so a model reading them learns different things from the same neighbourhood. Worse, a node with four neighbours would produce a length-4 vector and a node with two neighbours a length-2 vector — the model cannot even accept both.

When to use it

You do not really choose permutation invariance — it is a hard requirement whenever the neighbours are an unordered set, which in financial networks they always are. Counterparties, transaction partners, and supply-chain links have no inherent first or last. The real choice is which invariant pool: mean when you care about the typical neighbour, sum when raw count and total exposure matter (sum grows with degree; mean does not), and max when one dominant neighbour should drive the signal. Order-sensitive aggregation only makes sense on genuinely sequenced data — a price time series — which is a different lesson entirely.

The receptive field grows one hop at a time

Analogy. Gossip spreads one conversation at a time. After one evening you know what your direct friends know. After two evenings you know what their friends told them — information from people you have never met has reached you, relayed one hop further each night. A GNN’s layers are evenings: each one lets information walk exactly one more edge.

Definition. The receptive field of a node is the set of other nodes whose information can influence its final embedding. After $K$ message-passing layers, a node’s receptive field is its $K$-hop neighbourhood — every node reachable by a path of at most $K$ edges. The reason is mechanical: layer 1 pulls in 1-hop neighbours; layer 2’s neighbours have already absorbed their 1-hop neighbours in layer 1, so layer 2 indirectly delivers 2-hop information; and so on. Number of layers equals number of hops.

Worked example — counting reach. Suppose every node has roughly 3 neighbours (a graph of average degree 3). Trace how many nodes a target can feel as you add layers:

The reach explodes because each hop multiplies by the degree. With 1 layer the node sees about 3 others; with 3 layers, about 39. (In a dense financial network with average degree 20, three hops can already touch thousands of institutions — which is both the power and the danger, as the next callout warns.)

Contagion preview. This is the whole reason GNNs suit interbank risk. A 1-layer model only feels a shock at a bank you lend to directly. A 2-layer model feels a shock two lending-hops away — a bank you lend to lends to the bank that failed, and the distress propagates back to you through the chain. Stacking layers literally encodes how far through the lending network a default can ripple before it reaches your door.

When to use it

Set the number of layers to the longest dependency you actually need to capture, not the largest you can fit. For interbank contagion where second-order exposures matter, 2 to 3 layers is typical. For fraud rings that span long chains of transfers, you may need more — but watch for over-smoothing and rising compute. The rule of thumb: choose $K$ to match the hop distance over which influence genuinely travels in your network, then stop.

Node-level tasks — score a single node

Analogy. A credit bureau hands every person a score. It does not score relationships or score the whole economy — it scores individuals, one at a time, using information about them and their financial associations. A node-level GNN task is the graph-native version of that bureau.

Definition. A node-level task attaches a prediction to each individual node. You run message passing to get the node’s final embedding $h_v^{(K)}$ — a vector that now encodes both the node’s own features and its $K$-hop context — and feed it through a small classifier or regressor to produce the answer. Formally:

$\hat{y}_v = \text{CLASSIFY}\big(h_v^{(K)}\big).$

The output can be a class (illicit vs. legitimate wallet) or a continuous score (a bank’s fragility rating from 0 to 1).

Worked example. Run a 2-layer GNN over a transaction graph and a particular wallet ends with embedding $h_v^{(2)}$. A final layer maps that embedding to a single number and a sigmoid squashes it into a probability — say $0.87$. With a decision threshold of $0.5$, the wallet is flagged illicit (since $0.87$ exceeds $0.5$). Crucially, that $0.87$ reflects not just the wallet’s own behaviour but the company it keeps: message passing folded in the fact that several of its 2-hop neighbours were known mixers. A plain tabular model looking only at the wallet’s own row would have missed that guilt-by-association signal.

When to use it

Choose node-level tasks whenever the unit of decision is a single entity: rate each bank’s fragility, label each wallet, score each customer’s default risk, classify each account as a bot. If your question starts with “for each X, predict…” and X is a node, this is your task type.

Edge-level tasks — predict a link

Analogy. A dating app does not just describe each person — it predicts whether two people would match. The score lives on the pair, computed from both profiles. Edge-level tasks are matchmaking for nodes: given two entities, how likely is a link between them?

Definition. An edge-level task (or link prediction) predicts whether an edge exists between two nodes, or what its weight is. You first compute both endpoint embeddings $h_u^{(K)}$ and $h_v^{(K)}$ with message passing, then combine them into a single edge score. Two standard combiners:

• Dot product: $\ \hat{y}_{uv} = h_u^{(K)} \cdot h_v^{(K)}$ — large when the two embeddings point the same way, i.e. the nodes are “compatible.”
• MLP on the concatenation: $\ \hat{y}_{uv} = \text{MLP}\big([\, h_u^{(K)} \,\|\, h_v^{(K)} \,]\big)$ — feed both embeddings, glued together, to a small network that learns a more flexible scoring rule. (Here concatenating two specific endpoints is fine — there are exactly two, in a defined role, so the variable-degree and ordering problems from earlier do not apply.)

Worked example. Two firms have embeddings $h_u^{(K)} = [0.5,\ 0.2,\ 0.8]$ and $h_v^{(K)} = [0.4,\ 0.1,\ 0.6]$. Score the candidate edge with a dot product:

$h_u^{(K)} \cdot h_v^{(K)} = (0.5)(0.4) + (0.2)(0.1) + (0.8)(0.6) = 0.20 + 0.02 + 0.48 = 0.70.$

Pass $0.70$ through a sigmoid and you get a probability around $0.67$ — a moderately likely missing supply link, worth flagging an analyst to investigate. The same machinery predicts a fraudulent transfer (does an edge between these two accounts look like laundering?) or counterparty exposure (how large should the edge weight between these two banks be?).

When to use it

Reach for edge-level tasks when the question is about a relationship between two nodes: recommend or infer a missing counterparty link, flag a transfer as fraudulent, predict a future trade between two desks, estimate the weight (exposure size) of an interbank loan, or fill gaps in a partially observed supply network. If the answer attaches to a pair, it is edge-level.

Graph-level tasks — score a whole network

Analogy. A doctor does not diagnose you from a single cell — they take the whole body’s readings and render one verdict: healthy or not. A graph-level task is that whole-body verdict for a network: collapse everything you have learned about every node into one summary, then decide about the network as a whole.

Definition. A graph-level task produces a single prediction for an entire graph. After message passing gives every node its embedding, a readout (also called graph pooling) combines all node embeddings into one fixed-size graph vector, which a final classifier scores:

$h_G = \text{READOUT}\big(\{\, h_v^{(K)} : v \in G \,\}\big), \qquad \hat{y}_G = \text{CLASSIFY}\big(h_G\big).$

The READOUT must be permutation-invariant for the same reason AGGREGATE was — the nodes have no canonical order — so it is again a sum, mean, or max over every node. (Sum preserves a sense of size and total activity; mean normalises it away. Choose based on whether the graph’s scale should matter to the verdict.)

Worked example. A small suspected-laundering subgraph has three accounts whose final embeddings reduce to the scalars $0.9,\ 0.7,\ 0.8$ (in practice these are vectors). A mean readout gives the graph vector:

$h_G = \frac{0.9 + 0.7 + 0.8}{3} = \frac{2.4}{3} = 0.8.$

Push $0.8$ through the graph classifier and it crosses the laundering-pattern threshold — the whole subgraph is flagged, not any single account. That is the right granularity: laundering is a pattern across accounts (fan-in, fan-out, rapid round-tripping), so the verdict has to live on the graph, not on its individual nodes.

When to use it

Choose graph-level tasks when the object you are scoring is the network itself: classify a whole transaction subgraph as laundering or clean, score a portfolio’s systemic fragility, label the current market state as a stressed or calm regime, or compare two molecule-like network structures. If the answer is one verdict for the entire graph, you need a readout and a graph-level head.

The three tasks side by side

Every GNN application reduces to one of these three jobs. The difference is purely what you attach the final prediction to — one node, one pair of nodes, or the whole graph — and therefore what (if any) pooling you do at the end.

Recap

You built the engine. Message passing is just aggregate from your neighbours, then update yourself — repeat it layer by layer and a node’s embedding grows to encode its $K$-hop slice of the network. The aggregation must be permutation-invariant (sum, mean, max), because neighbours are an unordered, variable-sized set and concatenation breaks on both counts. Stacking $K$ layers reaches $K$ hops, which is exactly how a GNN can feel a shock travelling several lending-hops through an interbank network — though too many layers over-smooth everyone into mush. And whatever you point the engine at, the job is one of three: node-level (score an entity), edge-level (score a relationship), or graph-level (score the whole network, via a readout that pools every node).