Modeling Proteins as Residue Proximity Graphs

203 concepts156 papers3 proposals

A protein's function is dictated by its three-dimensional shape. While a protein begins as a linear sequence of amino acids, it folds into a complex tertiary structure where residues that are hundreds of positions apart in the primary sequence come into direct physical contact. These spatial interactions form the active sites, binding pockets, and structural cores that drive biological machinery.

Traditional sequence-based models, such as standard transformers or recurrent networks, struggle to capture these long-range spatial relationships because they process the protein as a one-dimensional string. To bridge this gap, researchers represent proteins as residue proximity graphs (or residue interaction networks). By mapping physical 3D relationships into graph topologies, geometric deep learning models can reason directly about the spatial environments that govern protein behavior.


Defining the Graph: Nodes and Edges

To transform a 3D protein structure into a graph, we must define what constitutes a node and what constitutes an edge.

Nodes: Choosing the Granularity

In most architectures, nodes represent individual amino acid residues, typically parameterized by the 3D coordinates of their alpha-carbon ($\text{C}_\alpha$) atoms. For example, Fout et al. and Ceccarelli et al. model residues as nodes to capture local structural contexts and irregular geometric patterns.

However, when finer chemical detail is required—such as predicting mutation effects or detailed ligand binding—nodes can represent individual atoms. Dutta et al. and Liu et al. utilize atom-level granularity, allowing their models to capture subtle structural changes, covalent bonds, and precise non-covalent interactions that coarser residue-level models might miss.

Edges: Defining Proximity

Edges connect nodes that are physically close in 3D space. Researchers generally use three main strategies to construct these edges:

  1. Distance Thresholds: An edge is drawn if the Euclidean distance between two nodes is below a specified radius (e.g., 8 Ångstroms). Magner et al. and Chinery et al. use fixed spatial distance thresholds to capture the 3D topology independent of a global coordinate system.
  2. $K$-Nearest Neighbors ($K$-NN): To ensure a consistent graph density regardless of how tightly packed a local region is, edges can connect each node to its $K$ closest neighbors in physical space. This approach is favored in architectures like DPROQ by Morehead et al..
  3. Contact Maps: When experimental 3D coordinates are unavailable, sequence-based models can predict a 2D contact map (a matrix of pairwise proximity probabilities). As shown by Xiao et al. and Jiang et al., these predicted contact maps can be directly converted into graph structures, allowing models to leverage 3D structural intuition from sequence data alone.

Why It Works: Bypassing Linear Distance

The core intuition behind the residue proximity graph is that it transforms a geometric problem into a topological one. Consider an active site formed by three residues at positions 45, 112, and 280. In a linear sequence model, information must propagate through hundreds of intermediate tokens to link these three positions.

In a proximity graph, these three residues are directly connected by spatial edges. When a Graph Neural Network (GNN) applies message passing, information flows directly across these spatial shortcuts.

In the DeepFRI framework (Structure-based protein function prediction using graph convolutional networks), graph convolutional layers propagate features across distance-based edges. This allows the model to learn representations based on the local topological environment of each amino acid, significantly improving function prediction over sequence-only baselines. Similarly, Bayzid et al. introduced EGRET, which uses a graph attention network to dynamically weigh the importance of these spatial edges, enhancing the interpretability of protein-protein interaction site predictions.


Multi-Relational and Hybrid Graphs

Simple proximity graphs treat all edges equally, but physical proteins feature diverse interaction types. To capture this complexity, recent work utilizes multi-relational graphs, where edges carry distinct labels or weights based on the nature of the interaction.

[Residue A] --(Sequence Adjacency)--> [Residue B]
    |                                     ^
    +---------(Spatial Proximity)---------+
    |                                     |
    +---------(Hydrogen Bonding)----------+

For instance, Abdine et al. developed Prot2Text, which models proteins using heterogeneous graphs containing three distinct edge types: sequential adjacency along the backbone, 3D spatial proximity, and explicit hydrogen bonding. By processing these multi-type edges with relational graph convolutional networks, the model simultaneously preserves local sequence order and long-range structural interactions.

Similarly, Wu et al. and Tan et al. combine sequential neighbors, spatial radius-based neighbors, and $K$-NN connections into a hybrid graph structure. This multi-relational framing ensures that the network can distinguish between a covalent peptide bond and a transient non-covalent spatial contact, allowing models to learn highly nuanced "microenvironment" embeddings for individual residues.


Scaling and Geometric Constraints

While proximity graphs offer clear advantages, they introduce unique computational challenges. Physical structures must obey geometric constraints, such as the triangle inequality (if residue A is close to B, and B is close to C, A cannot be infinitely far from C).

In generative tasks, maintaining this physical realism can be computationally expensive. In AlphaFold, Jumper et al. addressed this by treating structure prediction as a graph inference problem, using specialized attention mechanisms and geometric updates to enforce physical consistency across residue pairs.

To scale these architectures to larger proteins without the cubic computational cost ($O(N^3)$) of global pairwise attention, Qu introduced Proteus, which restricts a graph-based "triangle attention" mechanism strictly to $K$-nearest neighbors. This reduces the computational complexity to $O(NK^2)$, enabling the efficient generation of large, physically viable protein backbones. By constraining the model's focus to the immediate spatial neighborhood, residue proximity graphs allow deep learning architectures to mirror the localized, physical forces that drive protein folding and function in nature.

History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_residue_proximity_graph_f3c8e919,
  title = {residue proximity graph},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/residue-proximity-graph/rdr_f3c8e91920ea4d8fb6e8c5c3fd301a29},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_residue_proximity_graph_f3c8e919_v1,
  title = {residue proximity graph},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/residue-proximity-graph/rdr_f3c8e91920ea4d8fb6e8c5c3fd301a29/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake