Graph Neural Networks: Graph Convolutional Networks and Applications
Graph neural networks learn from relationships, not just features. Read how message passing works and where it actually helps.
Most machine learning assumes the input is a neatly arranged vector. Graph data is not: a social network, a molecule, a citation graph, or a user-item interaction catalogue has a shape that carries information, and flattening it into rows throws that information away. Graph neural networks exist to learn directly from the structure.
Direct answer: A graph neural network learns a representation for each node by aggregating information from its neighbours, repeatedly, so that a node's vector comes to encode its position in the structure. The mechanism is message passing: collect information from neighbours, combine it with the node's own state, and update. It helps when relationships carry signal that node attributes alone do not — which is exactly the case in recommender systems, where the user-item interaction graph is the thing a matrix factorisation model used only as a training target.

The problem the graph solves
Kipf and Welling's semi-supervised graph convolutional network established the modern pattern, and its value is in what it changed about the input. A node is no longer described only by its features but by its features and the features of the nodes around it, with the graph determining how information flows.
This matters most when the data is relational in a way that features do not capture. In a citation network, a paper's neighbours tell you about its field. In a molecule, the bonds determine the behaviour. In a user-item catalogue, the exposure graph tells you which users have overlapping behaviour — a signal that is present in the structure but not in any user's attributes.
Message passing is the whole idea
GNNs follow a message-passing neural network paradigm, and the operation is simple enough to state in words:
- Each node starts with a vector — its features, or an embedding.
- In each layer, a node receives messages from its neighbours, typically a transformed version of their current vectors.
- The messages are aggregated — by sum, mean, or attention-weighted combination.
- The node's own vector is updated using its previous state and the aggregated message.
After $k$ layers, a node's representation incorporates information from nodes up to $k$ hops away. That is both the capability and a limitation: shallow GNNs cannot see long-range dependencies, and deep ones suffer from over-smoothing, in which all node representations converge toward the same vector and become useless.
Hamilton et al.'s GraphSAGE addresses the scaling side of the problem. Neighbour sampling means a node does not aggregate over its entire neighbourhood, which makes training on large graphs feasible and lets the model generalise to new nodes. Their framing — inductive representation learning on large graphs — is the right one for any production system where the graph keeps growing.
Veličković et al.'s graph attention networks add a learned weighting: instead of averaging neighbours uniformly, the model learns which neighbours matter for the current node. This is useful where neighbourhoods are heterogeneous, which is most real graphs.
The recommender connection
Wang et al. make the case that applies most directly to this publication's audience. They argue that a drawback of existing approaches — "ranging from early matrix factorization to recently emerged deep learning based methods" — is that a user's or item's embedding is obtained "by mapping from pre-existing features that describe the user (or the item), such as ID and attributes". The consequence is that "the collaborative signal, which is latent in user-item interactions, is not encoded in the embedding process" — so the resulting embeddings "may not be sufficient to capture the collaborative filtering effect".
Neural Graph Collaborative Filtering takes the interaction graph itself as an input to the embedding, so the representation is shaped by the relationships rather than only by the fit.
This is the clearest example of what graph methods add: they move a signal from the loss function into the representation.
Where they fail
Three failure modes are worth knowing before choosing a GNN.
Over-smoothing. With too many layers, node representations become indistinguishable. The number of layers is a modelling decision tied to the graph's diameter, not a depth to increase for its own sake.
Scale and neighbourhood explosion. Aggregating over all neighbours at every layer grows combinatorially. Sampling, as in GraphSAGE, is a practical necessity at production scale.
A wrong graph.
A recommender built on co-clicks will learn a different structure from one built on purchases, and the choice of edge is the modelling decision.
When to use one
Use a graph neural network when the relationship is part of the signal — when who is connected to whom, or what is bonded to what, carries information that attributes do not. Recommender systems, fraud detection over transaction graphs, molecular property prediction, and knowledge-graph reasoning are the natural cases.
Do not use one when the rows are independent, or when a simpler relational feature — a neighbour count, a graph-derived statistic — already captures the useful part. The extra machinery has to earn its place against that baseline.
For the recommender application, see Recommender Systems; for the relational features that provide a simpler baseline, see Feature Engineering.
A worked example
The following is hypothetical and illustrative. A recommender team considers a graph model over user-item interactions and tests the choice before building it. Check one, is the relationship the signal: the team asks whether who is connected to whom carries information that user attributes do not, echoing Wang et al., who argue that the collaborative signal latent in interactions is missed when embeddings come only from pre-existing features. Check two, is the graph right: edges are chosen deliberately, since a co-click graph and a purchase graph teach different structures and a wrong graph propagates noise, the failure mode the article names. Check three, does it beat the simple baseline and scale: a neighbour count and a graph-derived statistic are measured first, and if the extra machinery earns its place, GraphSAGE-style neighbour sampling keeps aggregation feasible as the graph grows, as Hamilton et al. describe. The bounded outcome is a decision to adopt or decline the graph; if the simpler statistic captures the gain, the GNN is not built, and attention-weighted variants are reserved for heterogeneous neighbourhoods where learned weighting has a reason to help.
A counterargument
A reasonable critic would argue that the case for graph methods is stacked by assuming the graph is already there and meaningful. The article's own rule says to use a GNN only when the relationship carries signal, and its failure section concedes that a wrong graph merely propagates noise - yet in practice the edges are the disputed thing, chosen from co-clicks or purchases rather than given. The simpler relational baseline it recommends may capture most of the gain, since the article itself says the machinery must earn its place against that baseline. GraphSAGE's neighbour sampling is framed as a practical necessity, hinting that full message passing is as much a liability as a capability at scale.
A GNN is a bet on edge quality, not a default.
References & Further Reading
- Thomas N. Kipf and Max Welling, 2017. Semi-Supervised Classification with Graph Convolutional Networks — The graph convolution that started modern graph neural networks.
- William L. Hamilton, Rex Ying, and Jure Leskovec, 2020. Inductive Representation Learning on Large Graphs — Neighbour sampling and aggregation for graphs larger than one batch.
- Petar Veličković et al., 2018. Graph Attention Networks — Attention-weighted message passing, the basis of most modern GNN architectures.
- Steffen Rendle et al., 2012. Neural Graph Collaborative Filtering — Graph collaborative filtering that propagates over the user-item graph.