Geometric Deep Learning (GDL)

Geometric deep learning (GDL) is the branch of deep learning that designs neural networks around the structure and symmetries of their data, whether that data lives on a pixel grid, a graph, a set of points, a sphere, or a curved surface. Its central idea is that a model should respond predictably when the input changes in a way that does not change its meaning, such as shifting an image, relabeling the atoms of a molecule, or rotating a 3D scan. Michael Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst popularized the name in their 2017 survey Geometric Deep Learning: Going Beyond Euclidean Data, and the 2021 proto-book by Bronstein, Bruna, Taco Cohen, and Petar Veličković organized the field around five domains: grids, groups, graphs, geodesics, and gauges.

Invariance, Equivariance, and the GDL Blueprint#

Two properties do most of the work. A function is invariant to a transformation when its output stays the same, as an image classification label should stay "cat" when the cat moves. It is equivariant when its output transforms along with the input, as a semantic segmentation mask should shift with the object. The GDL blueprint stacks equivariant layers that mix information between neighbors, pooling steps that coarsen the domain, and a final invariant readout when the task needs one answer. Choosing the symmetry group of the domain recovers familiar architectures:

Convolution shares one kernel across all pixel positions, so a convolutional neural network (CNN) is the translation-equivariant case on a grid. A graph neural network (GNN) applies the same function along every edge, so relabeling the nodes only reorders its outputs. A transformer treats its tokens as a fully connected graph, and because self-attention is permutation-equivariant, it needs positional encodings to know token order. GNNs are the best-known GDL models, and GDL is the wider framework that explains all three. Group-equivariant CNNs, introduced by Taco Cohen and Max Welling in 2016, extend weight sharing to rotations and reflections, and mesh and manifold networks define convolution in local coordinate frames on curved surfaces.

Ultralytics YOLO26 is the grid case: its convolutions share weights across pixel positions, and the symmetries the architecture does not build in are taught through data augmentation. By default, training mirrors each image horizontally with probability fliplr=0.5, while vertical flips (flipud) and random rotations (degrees) are switched off.

Message Passing on Graphs#

Graph models in GDL are built from message passing. Every node collects messages from its neighbors, combines them with an order-independent function such as a sum, mean, or maximum, and updates its own embedding. Justin Gilmer and colleagues at Google showed in 2017 that many graph architectures fit this message-passing scheme and used it to predict quantum-chemical properties of molecules. Relabeling the nodes of a small graph checks both symmetry properties directly:

import torch

torch.manual_seed(0)
nodes = torch.randn(5, 3)  # 5 atoms or users, 3 features each
adjacency = torch.zeros(5, 5)
edges = torch.tensor([[0, 1], [1, 2], [0, 2], [2, 3], [3, 4]])
adjacency[edges[:, 0], edges[:, 1]] = adjacency[edges[:, 1], edges[:, 0]] = 1
w_self, w_neighbors, w_dense = torch.randn(3, 4), torch.randn(3, 4), torch.randn(15, 4)

# Relabel the nodes in a random order: the same graph, listed differently
order = torch.randperm(5)
nodes_p, adjacency_p = nodes[order], adjacency[order][:, order]

# Message passing: each node combines its own features with the sum of its neighbors'
out = torch.relu(nodes @ w_self + adjacency @ nodes @ w_neighbors)
out_p = torch.relu(nodes_p @ w_self + adjacency_p @ nodes_p @ w_neighbors)
print(torch.allclose(out_p, out[order]))  # equivariant: outputs reorder with the nodes
print(torch.allclose(out_p.sum(dim=0), out.sum(dim=0)))  # invariant: graph-level readout unchanged

# A dense layer on the flattened node list treats the relabeled graph as new data
print(torch.allclose(nodes_p.flatten() @ w_dense, nodes.flatten() @ w_dense))

It prints True, True, and False. The message-passing layer's output reorders exactly with the nodes, the summed graph-level readout does not change, and an ordinary dense layer gives a different answer for the same graph listed in a different order. PyTorch Geometric packages dozens of such layers together with batching for graphs of different sizes.

Applications#

Molecules are graphs of atoms and bonds, so message-passing networks predict properties such as solubility and binding for drug discovery. Proteins add 3D geometry: AlphaFold 2 refines its predicted structures with invariant point attention, which gives the same result when the whole protein is rotated or translated in space.

LiDAR scans and depth sensors produce point clouds, unordered sets of 3D points. PointNet, by Charles Qi and colleagues at Stanford in 2017, applies one shared network to every point and max-pools the results, so its output does not depend on point order; this design underlies many 3D object detection systems for autonomous vehicles and robotics. Social and commercial graphs of users and items drive GNN-based recommendation systems such as PinSage at Pinterest, and knowledge graphs apply the same message passing to entities and their relations.

Weather models run on the sphere. GraphCast, published by Google DeepMind in Science in 2023, passes messages over a multiscale mesh built by refining an icosahedron around the globe and forecasts hundreds of variables 10 days ahead at 0.25° resolution in under a minute, outperforming the leading operational deterministic forecast, ECMWF's HRES, on 90% of 1,380 verification targets.