Letting a Node Read Its Neighbours’ Measurements

One pump reports low pressure. Its neighbours might reveal whether the whole region is affected or just that instrument. We need a calculation that gathers measurements from connected nodes.

Neighbour aggregation collects those values with a sum, mean, or another declared rule. It is the information-sharing step on which many graph models build.

Change one node's reading and check which neighbouring outputs respond. The calculation must retain node identities even when it replaces individual readings with local averages.

In our undirected graph, a node receives from every adjacent node. Multiplying adjacency by a feature vector sums neighbouring values. For directed graphs, row orientation must match the intended message direction.

A message may later include edge features or a learned transform. Begin with raw scalar readings so you can check which values reached each node.

Node feature order and adjacency order must match exactly.

A sum changes with both neighbour values and neighbour count. A mean removes that direct degree scaling. Neither is universally better: total load and typical neighbouring pressure are different questions.

Readings = [2,8,4]
Neighbour sums = [8,6,8]
Degrees = [1,2,1]
Neighbour means = [8,3,8]

An isolated node has no neighbour mean; our implementation returns zero with that policy stated.

The node’s own measurement may remain valuable even when neighbours disagree. A learned model can concatenate own features with the aggregate or add a separately transformed self contribution.

Adding self-loops before averaging is another rule, but it changes the denominator and the meaning of the summary. Do not silently substitute one for another.

This lesson excludes self from the neighbour mean. The next lesson introduces self-loops explicitly.

import numpy as np
adjacency_row = np.array([0, 1, 1])
readings = np.array([20., 4., 10.])
neighbour_readings = readings[adjacency_row.astype(bool)]
print(neighbour_readings.tolist())
print(float(neighbour_readings.mean()))

[4.0, 10.0]
7.0

Repeated averaging spreads information farther across the graph. It can also make different nodes’ representations increasingly similar, reducing the distinctions needed for prediction.

Useful context depends on the edge definition. Connected nodes do not always share labels or operating modes. Evaluate whether the chosen aggregation helps the actual task.

The workshop returns neighbour context, not a trained node classifier.

Renumbering the neighbours should not change their summed or averaged message. A learned operation applied to each neighbour followed by a sum or mean preserves that order independence.

A flattened list fed into an ordinary dense layer generally treats positions differently. That can be appropriate if positions have roles, but arbitrary neighbour enumeration should not create those roles. Keep edge direction and edge attributes when they carry relevant information.

Averaging nearby readings provides context, but repeated averaging can make connected nodes increasingly alike. That is useful for smoothing noise and harmful when the prediction depends on a local contrast.

Retaining a separate self representation, using a limited number of layers or designing another message rule can preserve information. Those are modelling choices to evaluate, not guarantees that every graph benefits from deeper aggregation.

import numpy as np
mix = np.array([[.5,.5],[.5,.5]])
features = np.array([[0.],[10.]])
once = mix@features
twice = mix@once
print(once[:,0].tolist())
print(twice[:,0].tolist())

[5.0, 5.0]
[5.0, 5.0]

A supply pump may connect to a demand pump whose normal behaviour is different. Averaging them as though neighbours should agree can erase useful roles. This situation is often described as heterophily when linked nodes tend to have different labels or features.

Inspect what the edges actually represent and compare with a model using each node's own features. For an isolated node, define an empty-neighbour policy and preserve its self information rather than creating an undefined mean.