TL;DR
This paper introduces the Message Passing Neural Network (MPNN) framework β a unified abstraction that subsumes most GNN architectures proposed before 2017. Applied to the QM9 dataset of 130k small molecules, MPNN learns to predict quantum mechanical properties (energy, polarizability, dipole moment, etc.) directly from molecular graphs, outperforming DFT-based fingerprint methods on most targets. The framework has three phases: message (aggregate neighbor features), update (refine node states), and readout (pool all nodes into a graph-level prediction).
1. Predicting Molecular Properties
Quantum chemistry aims to predict how molecules behave at the atomic level β their energy, how their electrons are distributed, how they interact with light, and so on. These properties govern everything from drug activity to materials design. The gold standard for computing them is Density Functional Theory (DFT), a physics-based simulation method. DFT is accurate but expensive: a single calculation can take hours even for a small molecule.
The question Gilmer et al. ask is: can a neural network learn to predict these quantum mechanical targets directly from the molecular structure, skipping the simulation entirely? If so, we get a model that runs in milliseconds instead of hours, enabling large-scale virtual screening of chemical libraries.
The key challenge is representation. Traditional machine learning on molecules uses hand-crafted features called molecular fingerprints β bit vectors encoding the presence of certain substructures. These are fixed and lossy. MPNN instead takes the raw molecular graph as input and learns its own representation end-to-end.
2. Molecules as Graphs
A molecule maps naturally onto a graph. Atoms are nodes; covalent bonds are edges. Each node carries features describing the atom (element type, charge, hybridization, aromaticity, number of hydrogens). Each edge carries features describing the bond (bond type: single/double/triple/aromatic, ring membership, stereo configuration).
Formally, a molecular graph is a tuple G = (V, E) where V is the set of atoms with initial feature vectors h_v^0, and E is the set of bonds with edge feature vectors e_{vw}. The goal is to learn a function f : G β Ε· mapping from the full graph to a scalar or vector of quantum properties.
3. The MPNN Framework
MPNN unifies a broad class of GNNs into a single parameterized framework with three components: a message function M_t, an update function U_t, and a readout function R. These operate in two phases β a message passing phase that runs for T steps, followed by a single readout.
3a. Message Phase
At each step t, every node v collects messages from all of its graph neighbors N(v). The message from neighbor w to v depends on both nodes' current hidden states and the edge feature between them:
Here M_t is a learned function (e.g., a small neural network) that can take any form. The sum aggregates all neighbor contributions into a single message vector m_v^{t+1}. Different GNN architectures differ in how they define M_t β but they all fit this template.
3b. Update Phase
After collecting the aggregated message, each node updates its own hidden state using an update function U_t:
U_t takes the node's old state and the incoming message, and produces a new state. The simplest U_t is just concatenation followed by a linear layer. A more powerful choice β used in the paper's best model β is a GRU cell, which provides gating to control how much new information to incorporate:
After T rounds of message passing, each node h_v^T has incorporated information from all nodes within T hops. With T = 3, a carbon atom in a benzene ring knows about its neighbors' neighbors' neighbors.
3c. Readout Phase
Molecule-level prediction requires pooling all node states into a single fixed-size vector, then mapping to the target. The readout function R does this:
R must be permutation-invariant β the prediction cannot depend on which order we list the atoms. Simple choices include sum pooling or mean pooling. The paper's best model uses set2vec (a learned, attention-based aggregation from Vinyals et al.) which is more expressive than simple sum/mean.
4. Worked Example: One Step of MPNN on Methane
Let's trace through one message passing step on methane (CHβ). Methane has 5 atoms: one carbon (C) at the center connected to four hydrogen (H) atoms. There are 4 CβH bonds (edges). We ignore direction for now.
Initial state (t = 0)
Each atom gets an initial hidden state h_v^0 from its atom features. Carbon's feature vector encodes: element=C, atomic number=6, not aromatic, spΒ³ hybridization, 0 explicit H. Each hydrogen: element=H, atomic number=1, 0 H neighbors. All edge features e_{CH} encode: bond type = single, not in ring.
Message computation for carbon (t = 0 β 1)
Carbon has 4 neighbors: Hβ, Hβ, Hβ, Hβ. For each neighbor H_i, we compute one message vector: M_0(h_C^0, h_{H_i}^0, e_{CH}). With the edge network message function, this equals A(e_{CH}) Β· h_{H_i}^0, where A is a small neural network that maps the edge feature to a matrix. Since all four hydrogens are identical and all CβH bonds are identical, all four messages are the same vector. The aggregated message is:
Message computation for each hydrogen (t = 0 β 1)
Each hydrogen H_i has exactly one neighbor: carbon C. So the aggregated message for H_i is simply the single message from C:
Update step
Each node feeds its old state and aggregated message into the GRU. Carbon's new state h_C^1 encodes 'I am a carbon atom that has 4 single-bonded hydrogen neighbors.' Each hydrogen's new state h_{H_i}^1 encodes 'I am a hydrogen atom bonded to carbon.' After step 2, carbon would see what those hydrogens saw in step 1 β i.e., that they are terminal hydrogens. This 2-hop reach captures the full connectivity of CHβ.
Readout
After T steps, set2vec aggregates {h_C^T, h_{H_1}^T, h_{H_2}^T, h_{H_3}^T, h_{H_4}^T} into a single graph embedding, which is passed through a final MLP to produce the predicted quantum properties (e.g., internal energy Uβ).
5. How Existing GNNs Fit This Framework
One of the paper's main contributions is showing that five previously disconnected GNN architectures are all special cases of MPNN. They differ only in their choice of M_t, U_t, and R.
Key insight: The MPNN framework is not just an architectural proposal β it is a taxonomy. By casting all prior GNNs into one template, it makes it easy to see exactly what each model does and does not capture. Most models before MPNN used simple, non-parametric message functions (e.g., sums or averages). MPNN's key contribution is making both M_t and U_t fully learned and making edge features first-class citizens.
6. Results on QM9
QM9 is a benchmark dataset of 133,885 small organic molecules (up to 9 heavy atoms: C, H, O, N, F), each labeled with 12 quantum mechanical properties computed via DFT. The properties span a wide range of physics: energetics (Uβ, Uβββ, Hβββ, Gβββ), electronic properties (HOMO, LUMO, gap, dipole moment ΞΌ), geometric properties (polarizability Ξ±, zero-point vibrational energy ZPVE), and others (RΒ², C_v).
The MPNN paper evaluates several variants and compares against: (1) fingerprint-based baselines using DFT-computed features, (2) DTNN (the then-strongest neural baseline), and (3) an ensemble of graph convolution models from Duvenaud et al. The key MPNN variant uses edge network messages + GRU update + set2vec readout, with T = 3 message passing steps.
Edge network message function:
where A : β^{d_e} β β^{d_h Γ d_h} is a neural network that maps the edge feature vector to a square matrix. This matrix then left-multiplies the neighbor's hidden state h_w. This is the most expressive message function in the paper β it allows the bond type to completely reshape how neighbor information flows.
GRU update function:
The GRU treats h_v^t as the hidden state and m_v^{t+1} as the input. Its forget/update gates learn to balance how much of the previous node state to retain vs. how much to incorporate from neighbors. This is the same GRU as in sequence modeling β the only difference is that the 'sequence' here is the T rounds of message passing.
Set2vec readout:
After T steps, set2vec runs M_r steps of attention-based aggregation over the final node states {h_v^T}. The output is a fixed-size vector passed through a final MLP to produce the 12 property predictions (one per target, trained separately).
Results: MPNN achieves state-of-the-art on 10 out of 12 QM9 targets, often by large margins over DTNN. On targets like Uβ (internal energy at 0K), MPNN reduces mean absolute error by ~40% compared to DTNN. Importantly, MPNN also beats DFT-based fingerprint baselines on most targets β meaning the learned graph representation is more informative than the hand-engineered physics features.
Two targets remain difficult: ΞΌ (dipole moment) and RΒ² (electronic spatial extent). Dipole moment is sensitive to the 3D geometry of the molecule β a property that MPNN only partially captures through bond types. The authors note that incorporating 3D coordinates as edge features (inter-atomic distances, angles) would likely close this gap, and subsequent work (e.g., SchNet, DimeNet) confirms this.
7. MPNN's Legacy in GNN Research
The MPNN paper (2017) arrived at a pivotal moment for graph neural networks. Before it, GNNs were a fragmented landscape of individually motivated architectures. MPNN provided the first clean, general framework that showed these methods were all doing the same thing β iterative neighborhood aggregation β with different parameterizations.
Its impact is twofold. First, practical: MPNN set strong benchmarks on molecular property prediction that shaped research in AI for science for years. Second, conceptual: the message-passing abstraction became the dominant vocabulary for GNN research. Papers like GraphSAGE, GAT, GIN, and PNA all define themselves in terms of their message and aggregation choices.
One fundamental limitation identified after the paper: all MPNNs are bounded in expressiveness by the 1-dimensional Weisfeiler-Lehman (1-WL) graph isomorphism test. They cannot distinguish certain pairs of non-isomorphic graphs that have the same local neighborhood structure. Higher-order GNNs (k-GNNs) and graph transformers address this, at the cost of increased computation.