AtomSurf: Surface Representation for Learning on Protein Structures

## Abstract

Abstract While there has been significant progress in evaluating and comparing different representations for learning on protein data, the role of surface-based learning approaches remains not well-understood. In particular, there is a lack of direct and fair benchmark comparison between the best available surface-based learning methods against alternative representations such as graphs. Moreover, the few existing surface-based approaches either use surface information in isolation or, at best, perform global pooling between surface and graph-based architectures. In this work, we fill this gap by first adapting a state-of-the-art surface encoder for protein learning tasks. We then perform a direct and fair comparison of the resulting method against alternative approaches within the Atom3D benchmark, highlighting the limitations of pure surface-based learning. Finally, we propose an integrated approach, which allows learned feature sharing between graphs and surface representations on the level of nodes and vertices across all layers . We demonstrate that the resulting architecture achieves state-of-the-art results on all tasks in the Atom3D benchmark, while adhering to the strict benchmark protocol, as well as more broadly on binding site identification and binding pocket classification. Furthermore, we use coarsened surfaces and optimize our approach for efficiency, making our tool competitive in training and inference time with existing techniques. Our code and data can be found online: https://github.com/Vincentx15/atomsurf

## 1 Introduction

Structural bioinformatics data is becoming available at an unprecedented pace. Advances in cryogenic Electron Microscopy (cryo-EM) in particular, have led to the production of evermore experimentally derived structures, as well as larger systems and better resolutions Fontana et al. (). The development of AlphaFold Jumper et al. () along with many subsequent works have made protein structures abundantly available, with over a million high-quality predictions in the Protein Data Bank (PDB) Berman () and over 600 million in the ESM Metagenomic Atlas (ESMatlas) Lin et al. (). There is thus a growing demand for machine learning techniques which can leverage this structural data to help advance the fields of structural bioinformatics and drug design.

Protein structures are complex objects characterized both by atomic coordinates as well as intricate bio-chemical interactions between them that depend on their geometry.
To be used in a learning pipeline, an initial modeling step transforming protein structures into a well-defined mathematical object is necessary. Different mathematical representations encode different structural and biological priors. For instance, the point cloud representation disregards the connectivity induced by chemical interactions, but allows for the most generic geometric description of the data. Protein surfaces choose to trade fine-grained information of the interior of a protein for an accurate depiction of its outer surface.
This representation is thought to be of particular interest to study active interaction sites that mostly depend on properties of the surface because of the screening effect.
However, even for interactions dominated by surface terms, the knowledge of the interior can encode the stability of the surface. These different representations are illustrated in Figure 1.

Figure: Figure 1: Diverse mathematical objects used to represent a protein structure, sequences, molecular surfaces (blue), atom-level and residue-level point clouds (red) and graphs (green). Effective machine learning for protein structures hinges on selecting the appropriate mathematical representation along by a compatible machine-learning technique.
Refer to caption: x1.png

The choice of representation is particularly prominent in the context of *learning-based* methods, as specialized architectures have been developed to process each type of data.
The range of approaches is studied within the field of geometric deep learning (Bronstein et al., ), and specialized methods have been developed to process different data types from graphs (Bruna et al., ; Kipf & Welling, ), to point clouds (Qi et al., ; Wang et al., ), surfaces (Masci et al., ; Monti et al., ), equivariant methods that respect a group symmetry of the data (Cohen & Welling, ; ), equivariant message passing (Fuchs et al., ; Satorras et al., ) and more.

A few pioneering works have applied geometric deep learning to structural biology data representations, using 3D convolutional networks (Jiménez et al., ), equivariant convolutional networks (Weiler et al., ), sequence (Rao et al., ), surfaces (Gainza et al., ), graphs (Aumentado-Armstrong, ) and equivariant discrete networks (Jing et al., ; Stärk et al., ).
They were followed by several others, traditionally classified based on the mathematical representation they use - see for instance Isert et al. ().
In addition, some methods were developed ad-hock to handle protein structure, where protein properties are baked into the network (Zhang et al., ; Hermosilla et al., ; Fan et al., ).

In this context, the seminal work of Atom3d (Townshend et al., ) aims for a fair comparison across both different representations and learning approaches, within a well-defined protocol. Specifically the benchmark includes a set of nine benchmark tasks for three-dimensional molecular structures and establishes a consistent set of input features and parameter count to be used across all tested methods. The authors also compare different representations by evaluating neural networks based on 3D grids, graphs, and equivariant networks on the proposed tasks.

Beyond using a single representation for proteins, the simultaneous representation of a protein as several mathematical objects holds promise. Indeed, different representations encode different biological priors of the data and present different computational advantages. A well-studied combination is the use of sequence information along with a graph representation of the structure. For instance, in Hermosilla et al. (); Fan et al. () the authors enrich the graph with additional edge types that encode the sequence. Another way to include sequence information in a graph, is to use sequence embeddings, especially ones derived from protein language models and hence benefiting from the large amounts of available sequence data (Wu et al., ; Zhang et al., ).

## 2 Motivation and Contribution

Despite this recent progress in comparing different representations for learning on protein data, relatively less focus has been given to surface-based representations, even though they have shown promising results
in several applications (Gainza et al., ; Sverrisson et al., ; Wang et al., ). Approaches based on the surface representation have typically followed the initial MaSIF paper validation (Gainza et al., ), and hence have never been directly compared to other representations in the context of a single well-established benchmark. At the same time, powerful surface-based encoders have recently been proposed in the geometry processing/computer graphics literature, such as DiffusionNet (Sharp et al., ) significantly outperforming, in terms of both robustness and accuracy, the early Geodesic-CNN based techniques Masci et al. (); Monti et al. () which formed the basis of (Gainza et al., ). Unfortunately, it is not currently known how the best currently available surface-based encoders compare to other learning-based paradigms in the protein analysis tasks (e.g., on the Atom3d benchmark).

We fill this gap by first adapting the current state-of-the-art surface-based learning architecture to protein analysis tasks. We then perform the first fair and comprehensive comparison of a pure surface-based learning method, while adhering to the benchmark protocol, with fixed input features and parameter count. A key finding of this analysis is that surface-based encoders are competitive, but do not provide state-of-the-art results.

We then focus on exploring whether surface-based learning for protein analysis can provide complementary information to that of other representations. Related efforts have been made in the recent literature; in Lee et al. (), the authors propose to use an implicit representation of the surface as a pretraining objective. Somnath et al. () proposed to first encode surface properties and use them as initial embeddings for the graph nodes, while Pegoraro et al. (); Xu et al. () averaged the predictions made by a surface-based and a graph-based model. Nevertheless, those efforts consider surface and other (e.g., graph-based) learning separately and only aggregate results in a global manner (early or late fusion (Karpathy et al., )). Instead, we show that by creating an integrated approach, in which the features are shared and passed between a surface and graph representation, even within the middle layers, allows to significantly boost performance and improve results. Crucially, by exploiting the natural spatial relations based on proximity that exist between graph nodes and surface vertices, we show that node-wise feature sharing creates a synergy between the two representations. Furthermore, we demonstrate that by using embeddings from text encoders as input features, coupled with careful and efficient architecture design, it is possible to achieve unprecedented state-of-the-art results on a wide range of tasks.

To summarize, our key contributions include:

- •
An adapted design of the recent state-of-the-art DiffusionNet architecture, which addresses some of its limitations (including instabilities and scale independence) in the context of protein analysis tasks.
- •
The first comprehensive comparison of surface-based learning against alternative representations such as graphs or grids within an established benchmark.
- •
A novel integrated approach, which is based on node-wise feature-sharing across all learned layers, between surface and graph-based encoders that are learned jointly.
- •
State-of-the-art results in a wide variety of challenging scenarios.
- •
Enhanced computational throughput by using residue graphs and coarsened meshes.

The rest of the paper is organized as follows: in Section 3.1, we present the surface representation we use and the specialized networks used to process it.
Section 3.2 highlights a challenge for surface networks learning on various scales and presents solutions to mitigate these issues.
In Section 3.3, we propose to synergistically integrate graph and surface information within a unified architecture, harnessing the power of both representations.
We provide the details regarding the chosen architecture in Section 3.4 and analyze its computational aspects in Section 3.5.

## 3 Methods

### 3.1 Surface Representation Learning

Our first objective is to study the utility of the best existing surface encoders for learning on protein data. To generate the surface representation $\mathcal{S}_{\mathbf{P}}$ of the protein $\mathbf{P}$, our initial step involves computing the protein surface using MSMS (Sanner et al., ). The resulting meshes are usually quite large, but in the rare cases of small proteins, we incrementally increase sampling density until we achieve a minimum number of 256 vertices. Then, we employ quadratic decimation (Garland & Heckbert, ), to embed our surfaces into coarser and more compact meshes, again ensuring a minimum vertex count. Coarsening the mesh has an impact on computational efficiency and on performance, assessed in Sections 3.5 and 4. Finally, we ensure mesh quality by removing non-manifold edges, duplicated or degenerate vertices and faces, as well as small disconnected components. We compute several surface features: the Gaussian and mean curvature, as well as the shape index at each vertex. We also include the normal as well as the heat kernel signature (Sun et al., ) at each point.

At the basis for our surface-based learning method, we employ the DiffusionNet approach (Sharp et al., ). This method has been proven to be highly robust and effective across a diverse set shape analysis tasks (e.g., Attaiki et al. (); Cao & Bernard (); Sun et al. (); Li et al. () among others). In particular, DiffusionNet avoids using local patch parametrizations, which can lead to instabilities across different mesh structures and enables long range and multi-scale information propagation by using learned diffusion for information sharing. The mathematical foundation of DiffusionNet is the heat equation, which simulates the diffusion of heat, or, equivalently, the behavior of Brownian motion on a surface over time.
For a surface $S$, let $\mathbf{f}_{t}:S\to\mathbb{R}$ be the function that defines the heat distribution over $S$ at time $t$ and $\Delta_{S}$ the Laplace-Beltrami operator (Meyer et al., ; Vallet & Levy, ) of the surface. The heat equation is the linear differential equation:

$$ $\displaystyle\frac{\partial\mathbf{f}}{\partial t}$ $\displaystyle=\Delta_{S}\mathbf{f}.$ (1) $$

Its solution is obtained by diagonalizing the Laplace-Beltrami. In practice, we store the $k=128$ smallest eigenvalues of $\Delta_{S}$ in a diagonal matrix $\Lambda\in\mathbb{R}^{k\times k}$, with the corresponding eigenvectors in $\Phi\in\mathbb{R}^{n\times k}$, and vertex area weights $M\in\mathbb{R}^{n\times n}$. The spectrally truncated solution to the heat equation is given as $\mathbf{f}_{t}=\Phi e^{-\Lambda t}(\Phi^{T}M)\mathbf{f}_{0}$.

In DiffusionNet, this equation is used to perform information propagation on a surface using a feature map as $\mathbf{f}_{0}$ and learning the diffusion time in a task-specific manner. This mechanism relies on dense linear algebra operations, offering straightforward differentiation with respect to both $\mathbf{f}$ and $t$. The diffusion layers are combined with features based on $\mathbf{f}_{t}$, their spatial gradients and standard, point-wise MLPs. This leads to an architecture, which can capture multi-scale geometric details of a surface in a task-specific manner. To establish a benchmark method for surface analysis on Atom3d, we utilize three DiffusionNet blocks, applying them to the protein surfaces $\mathcal{S}_{\mathbf{P}}$ under consideration.

### 3.2 Adapting to Protein Surfaces of Diverse Scales

As we demonstrate in Section 4 below, our first empirical observation is that applying the DiffusionNet architecture directly to protein datasets, without modifications, yields relatively poor performance. We attribute this primarily to the fact that the initial DiffusionNet architecture targeted applications involving related near-isometric shapes (e.g., humans in different poses). A key technical issue is that most existing approaches using DiffusionNet’s normalize all shapes to a uniform surface area. This step ensures that shapes have the same global scale which stabilizes learning. Unfortunately, in the context of protein analysis, tasks such as ligand-binding preference determination depend critically on the relative sizes of proteins and ligands, making considerations on the scale of proteins essential, and global scale normalization would lose this precious information.

On the other hand, the efficacy of DiffusionNet’s receptive field is contingent upon the diffusion times learned within each diffusion layer. Without scale normalization variations in the sizes input shapes can lead to discrepancies in the network’s learned receptive field. This is elucidated by the following well-known proposition, whose proof is provided in the supplementary material for completeness:

###### Proposition 3.1 .

Let $X$ be a shape and $Y=\alpha X$ its scaled version by a factor $\alpha>0$. Denoting by $E_{\cdot}(t,x)$ the expected geodesic distance for a Brownian motion starting from point $x$ after time $t$, it holds that: $E_{Y}(t,x)=\alpha E_{X}\left(\frac{t}{\alpha^{2}},x\right).$

Importantly, this result suggests that the time parameter of diffusion must be adapted depending on the scale, whereas in DiffusionNet the learned time parameters are shape independent. We also remark that in scenarios involving non-isometric surfaces, such as proteins that might have different scales, learned diffusion, especially if it is learned without biological considerations, can generalize poorly across highly diverse shapes, and lead to instabilities during training.

To address this issue, we enhance the original DiffusionNet framework in two ways. First, we enable support for batch (the original model was limited to batch sizes of one) and incorporate a Batch Normalization layer Ioffe & Szegedy () after each diffusion layer to stabilize learning. Second, we facilitate the optimization process by incorporating biological priors relevant to spatial scales. Consequently, we determined that diffusion times around 10 resulted in receptive fields around 10 Å (see Supplementary Figure 6), which aligns with the spatial scale of binding sites. Inspired by the inherent multi-scale nature of protein structures, we opted to draw samples from a normal distribution $t\sim\mathcal{N}(10,5)$, characterized by a relatively high variance. The absolute values of these samples were then utilized as the initial values for our diffusion timescales. Both the large scale and the large variance are retained during training, as illustrated in Figure 7), enabling efficient multi-scale and long-distance message passing. These enhancements to DiffusionNet implementation mitigate the instabilities in the training process (as seen in Figure 13) and are available in the provided code repository and as a pip package.

###### Proposition 3.1 .

### 3.3 Hybrid Representation Learning

As mentioned earlier, beyond assessing the efficacy of surface-based learning compared to other representations for protein learning, we explore the benefits of integrating different representations in a unified framework, harnessing their distinct strengths. Intuitively, surface representations can capture the intricate geometric details critical for tasks involving protein interactions, while graph representations detail the specific atomic interactions within a protein’s interior that indirectly influence its surface dynamics and interaction capabilities. Furthermore, these representations facilitate complementary approaches to learning: local message passing through graphs and global information dissemination for surfaces via learned diffusion. Inspired by these considerations, we propose a method that enables feature sharing between graph and surface-based representations. As emphasized below, unlike previous related approaches Somnath et al. (); Pegoraro et al. (), we enable communication between the two representations across all learned layers of the network.

As a basis for our hybrid representation, in addition to the surface $\mathcal{S}_{\mathbf{P}}$, we construct a graph representation $\mathcal{G}_{\mathbf{P}}=(\mathcal{V}_{g},\mathcal{E}_{g})$. To ensure consistency and fairness in comparison within the Atom3d benchmark, we follow their conventions: each node in the graph corresponds to an atom within the protein and edges $\mathcal{E}_{g}$ are defined between pairs of atoms that are within a 4.5 angstrom radius cutoff. The only initial node features are one-hot encoding of atom types.

Independently, we construct another graph representation to be used outside of the benchmark setting. We choose to use residue graphs for computational efficiency: each node in this graph represents an amino-acid residue and edges are introduced between pairs of atoms that are within a 12 Å radius cutoff. For each residue, we add a one hot encoding of its type, its secondary structure annotation and its hydrophobicity. We also compute sequence embeddings using the ESM-650M (Rives et al., ) pretrained model and include them as node features.

To construct our hybrid approach, we start by building a bipartite graph $G=(V,E)$, where $V=\mathcal{V}_{g}\cup\mathcal{V}_{s}$ represents graph nodes and surface vertices, respectively. For each vertex on the surface, we find its 16 nearest neighbors in the graph and add the corresponding bidirectional edges in the bipartite graph. We also experimented with edges based on a geometric neighborhood of 8 Å, corresponding to the value widely used to define contact maps (Fariselli et al., ). However, distance-based cutoffs result in a varying number of neighbors which we found to make learning less stable.

Outside of the benchmark setting, we add edge features to our bipartite graph. Given an edge $e_{g,s}$ tying a graph node to a surface vertex with normal $\vec{n}_{s}$, we use its direction $\vec{u}_{g,s}=\frac{x_{s}-x_{g}}{||x_{s}-x_{g}||}$ as a vector edge feature. The associated distance and angle, $\langle\vec{n}_{s},\vec{u}_{g,s}\rangle$ are encoded using sixteen radial basis Gaussian functions, and used as scalar edge features in the bipartite graph. We follow a similar protocol for edges going from a vertex to a graph node.

We now define block operations to encode a protein using $\mathcal{S}_{\mathbf{P}},\mathcal{G}_{\mathbf{P}}$ and $G$.
Denote encoders on surfaces and graphs as $s_{\theta}$ and $g_{\theta}$, respectively, and the set of input features as $\mathcal{X}=\{x_{n},n\in\mathcal{V}\}$.
The corresponding encoded features are $\mathcal{H}=\{h_{n},n\in\mathcal{V}\}$ with $h_{n}=s_{\theta}(x_{n})$ for nodes $n\in\mathcal{V}s$ and $h_{n}=g_{\theta}(x_{n})$ for nodes $n\in\mathcal{V}_{g}$.
Our general methodology incorporates message-passing neural networks, denoted $\text{MP}_{\theta}$, over the bipartite graph $G$, such that at a layer $l$, we get $\mathcal{X}^{l+1}=\text{MP}^{l}_{\theta}(\mathcal{H}^{l})$.
By employing distinct sets, $\theta_{sg}$ and $\theta_{gs}$, the architecture handles messages traversing from the surface to the graph and vice versa. Those block operations can be stacked as shown in Figure 2. We emphasize that our feature sharing occurs on the local (node) level and is enabled by the proximity relations in 3D space. Moreover, our hybrid approach trains both representations jointly, while enabling information sharing across all network layers, which is crucial to its success.

Figure: Figure 2: Illustration of our approach integrating surface and graph information. We ensure joint learning across the two representations and enable information propagation across all layers of the network. Our information sharing is based on the spatial proximity relations between individual graph nodes and surface vertices (not shown here).
Refer to caption: x2.png

### 3.4 Proposed architectures

Our framework incorporates surface encoding blocks, $s_{\theta}$, which consist of a diffusion operation followed by a pointwise neural network with two hidden layers of a specified width. The first network we propose, Surface Diff is only based only on those surface blocks. It is used to assess the relevance of the surface representation used in isolation. Note that Surface Diff is based on DiffusionNet but incorporates our modifications mentioned in Section 3.2. For all other methods that use a hybrid approach, the widths for both encoding blocks $s_{\theta}$ and $g_{\theta}$ were consistently set to equal values.

We introduce AtomSurf-bench, a model aimed at comparing representations in a fair way by following the Atom3d benchmark protocol. Its graph encoder $g_{\theta}$ consists of Graph Convolutional Networks (GCN) (Kipf & Welling, ), intertwined with Batch Normalization operations and its message-passing over the bipartite graph is a Graph Attention Layer (Veličković et al., ). Following the Atom3d benchmark standards, AtomSurf-bench has 200k learnable parameters and does not use surface input features, only considering the atom type onto its atomic-level graph representation.

In addition, we introduce AtomSurf that makes use of the aforementioned residue graph, along with the recently-proposed ProNet (Wang et al., ) encoder. Despite acting on residue graphs, ProNet adds a featurization of the geometric conformation of the atoms composing each residue, based on relative local coordinate systems that uniquely and equivariantly identify the conformation, allowing for completeness (as introduced in ComeNet (Wang et al., )). Those features are then embed using spherical harmonics, and ProNet relies on the message passing introduced in GraphConv (Morris et al., ) to perform learning. In addition, we perform our message passing using the aforementioned bipartite graph features and a GVP (Jing et al., ) encoder.

Different bipartite message passing networks and organization are possible, encompassing as special cases several existing approaches. We provide the implementation details in Appendix C. We evaluate these configurations and conduct several ablation studies on our final model, in Section 4.6.

### 3.5 Computational enhancements

Surface-methods are traditionally thought to be compute-expensive methods, motivating approaches to side-step their intrinsic complexity (Sverrisson et al., ). Through a complexity analysis presented in Section D.1, we found the number of vertices to be critical in DiffusionNet runtime, which we addressed by coarsening our meshes. In this coarse surface regimen, the graph encoding with ProNet is the computational bottleneck, which is smaller than when used in isolation. Hence, we claim that our method is faster than this efficient graph encoder in the coarse surface regimen.

From the storage and memory perspectives however, the memory footprint of the surface-related operations dominate the ones originating from the graphs, especially because of stochasticity. We did not find it to be limiting in terms of I/O, but rather in terms of batch size. We implemented a dynamic batching procedure, alleviating our memory issues. Further details are provided in D.2. Finding ways to reduce the memory footprint of surface networks remains an important direction.

## 4 Results

### 4.1 Performance of Surface Representation

We start by validating our surface encoder on the RNA segmentation benchmark (Poulenard et al., ) for surface methods. The task is to segment 5s ribosomal RNA molecules into functional components.
We assess the impact of the proposed enhancements to DiffusionNet by showing the learning curves of the enhanced models on the RNA segmentation task (see Figure 13). Moreover, we compare their performance to other recent surface encoders, DGCNN (Wang et al., ) and DeltaConv (Wiersma et al., ) and report results in Figure 13. Our experiments show that our adjustments significantly improve the DiffusionNet stability issues, and allow it to converge to a model with a test accuracy of 84.1% instead of of 80.9%. This accuracy is significantly higher than DGCNN (74.7%) and DeltaConv (78%).

Then, to compare the performance of our surface encoder to the use of other representations, we turn to the Atom3d benchmark, focusing on its three tasks exclusive to proteins. The Protein Interaction Prediction (PIP) task aims to predict which part of a protein interacts with another, and holds about 120k examples. The Mutation Stability Prediction (MSP) task is to determine if a mutation enhances the stability of protein-protein interaction, with about 5k examples. Finally, the Protein Structure Ranking (PSR) task aims to assign a quality score to predicted protein structures with around 10k proteins. A more detailed description of our datasets is available in Appendix E

We anticipate that the surface representation will excel in tasks involving interactions, like PIP, but may underperform in the PSR task, which is heavily influenced by subtle internal changes in the protein volume that might not affect the surface. The results are presented in Table 1.

**Table 1: Comparison of different representations, including surface performance. Dashes in the equivariant methods’ column indicate that these methods could not be used due to memory constraints.**
|  | PIP | MSP | PSR |  |
| --- | --- | --- | --- | --- |
|  | Auroc | Auroc | Local R | Global R |
| 3DCNN | 0.844 | 0.574 | 0.431 | 0.789 |
| ENN | - | 0.574 | - | - |
| Graph | 0.669 | 0.609 | 0.411 | 0.75 |
| Surface Diff | 0.837 | 0.5 | 0.33 | 0.643 |
| AtomSurf-bench | 0.876 | 0.707 | 0.452 | 0.831 |

Surprisingly, we observe that the surface method Surface Diff, despite using a state-of-the-art surface encoder, consistently falls short in its performance, even on the protein-protein interaction task. Such an observation challenges assertions in previous purely surface-based methods, and highlights the importance of direct benchmarking in general.
Despite promising modeling of protein interfaces, which are intrinsically surface objects, the network could not reach satisfactory test performance.
We emphasize that all networks are trained in a vanilla setting, in particular, unlike MaSIF, our input features are minimalistic.
Surface networks may excel when supplemented with richer information. However, when all input features are held constant, surface networks do not emerge as top performers.

### 4.2 Synergy in Combined Representations

In this section, we assess the performance of our proposed hybrid methods, which have the particularity of combining surface and graph representations.
First, we use the same experimental setup and compare our AtomSurf-bench to the previous models exclusively grounded in one representation. Our results are reported in the last row of Table 1.

Our method outperforms single modalities in all three tasks, while adhering to the Atom3d benchmark protocol. This result highlights the synergy between the two representations. Achieving this is noteworthy because, fist, the input features remain minimal, and second, to maintain a consistent parameter count, both the graph and surface encoders are considerably condensed. An interesting result is that even in the case of PSR, where surfaces do not intuitively seem relevant, the mixed model outperforms its graph counterpart with a comfortable margin. One possible interpretation for this result is DiffusionNet’s ability to perform long-range message passing.

In addition, we compare to popular, state-of-the-art models outside of the benchmark constraints. Namely, we compare against ProNet (Wang et al., ) and GearNet (Zhang et al., ), which are graph-based methods at the residue level, but encode the local geometry of residues as features; and to the atomic-level extension of GVP (Jing et al., ). Finally, we include their extension with features derived from protein language models (Zhang et al., ).
Please note that differing parameters and training procedures do not necessarily follow the protocol of the original benchmark.
For this reason, we also include the performance of our second proposed model, AtomSurf, which uses all input features and more recent encoders. The results are presented in Table 2.

**Table 2: Performance of our hybrid approach on benchmark tasks, compared to state-of-the-art models. Best result in bold, second best underlined.**
|  | Pretrained/ | PIP | MSP | PSR |  |
| --- | --- | --- | --- | --- | --- |
|  | Parameters | Auroc | Auroc | Local R | Global R |
| ProNet (Wang et al., ) | No/2M | 0.871 | - | 0.632 | 0.849 |
| GVP (Jing et al., ) | Yes/11M | 0.866 | 0.68 | 0.511 | 0.845 |
| GVP-ESM (Zhang et al., ) | Yes/11M | - | 0.617 | - | 0.866 |
| GearNet-ESM (Zhang et al., ) | Yes/42M | - | 0.685 | - | 0.829 |
| AtomSurf-bench | No/200k | 0.876 | 0.707 | 0.452 | 0.831 |
| AtomSurf | No/600k | 0.907 | 0.715 | 0.613 | 0.861 |

Our first result is that even AtomSurf-bench is competitive with more highly engineered approaches and outperforms them in two of the three evaluated tasks. The PSR task, which is aimed at detecting non-canonical protein structures, appears to benefit methods that integrate explicit biological insights into protein geometry, such as the computation of side-chain angles.

Moreover, AtomSurf successfully results in another performance boost on this benchmark, setting a new clear state-of-the-art performance on the PIP and MSP tasks, and closing the gap on PSR. Importantly, our method does not include any pretraining and uses less than half the number of parameters than any other method.

### 4.3 Evaluation of binding site detection

In addition to the Atom3d benchmark tasks, we evaluate our approach on the task of protein binding sites prediction. Binding sites are regions of protein surfaces where a partner (that can be another protein, an RNA molecule, a small molecule) interacts with the protein. A fine characterization of those regions helps in understanding protein functions and plays a significant role in drug design and discovery. In this section we focus on binding site prediction in the context of immunology: predicting the interaction between an antibody and its target, denoted as the antigen. Improved understanding and ability to predict such interactions has direct applications in antibody-based treatments, which represent a highly promising therapeutic avenue (Kaplon et al., ; Jamali et al., ).

Pegoraro et al. () introduced a dataset containing 235 antibody–antigen complexes, with 186 for training and 49 for testing. The task consists in predicting the the residues involved in the binding site on the antibody and antigen separately. Importantly, the network has access to both structures to perform its prediction, but not to how they interact. The performance on the antibody side is computed only on the Complementarity Determining Regions (CDRs). The method proposed in their article, MIXmean-egnn PiNet, is a relevant comparison to ours, because it averages the prediction made by a surface model, and the ones obtained with a graph-based model. We denote this method as GEP, and present the results in Figure 4 and Table 4.

Figure: Figure 3: Performance of our model on the binding site detection task.
Refer to caption: x3.png

As can be seen in our results, AtomSurf-bench has a similar performance on the antigen binding site prediction, but outperforms other methods with a comfortable margin on the antibody side (+0.19 MCC). An accurate prediction of the CDR residues involved in the recognition of an antigen is key for antibody specificity optimization.

### 4.4 Evaluation of Binding Sites Classification

We also evaluate our proposed approach on the task of ligand-binding preference prediction for protein binding sites, introduced in (Gainza et al., ). It holds 1459 protein structures bound to one of the seven most common ligands in the PDB. Given a binding site, the task amounts to predicting its corresponding co-factor. We benchmark our approach against MaSIF (Gainza et al., ) and HMR (Wang et al., ), with the latter being recognized as state-of-the-art on this task. Additionally, considering the notable performance of ProNet on the previous benchmark, we include it in this experiment. We use balanced accuracy (the average recall achieved for each class) as our performance metric consistent with prior studies.

As depicted in Table 4, our method surpasses the existing methods and sets a new state-of-the-art for this task.
ProNet achieves a disappointing AuROC of 0.75. Unlike HMR, which relies solely on surface representation, our results further validate the efficacy of synergistically combining surface and graph representations, showcasing that this integration leads to superior performance in ligand-binding pocket classification.

### 4.5 Qualitative Results

To visualize the predictions of our binding site model, we display the interaction probability predicted by our model across two protein surfaces, a homodimer and a heterodimer, an plot the results in Figure 5. Despite minor prediction errors, such as the misidentification of residues in the lower region of 3dbh, our results clearly show that the model effectively identifies binding sites on proteins.

Figure: Figure 5: A qualitative view of our results: The top row shows the ground truth with interaction sites marked in red, while the bottom row displays our predictions. On the left, the interaction between chains A and B of the system with PDB ID 4A0M is illustrated. The two rightmost columns depict chains E and F of the protein with PDB ID 3DBH from two rotated perspectives of 180^∘.
Refer to caption: extracted/5898834/figs/visual_2.png

#### Learned time analysis

In the supplementary (Figures 6 and 7) we provide visualizations showing both the relation between the effective receptive field and diffusion times, as well as the distribution of learned times on the MSP task. These visualizations demonstrate that long-range communication enabled by learned diffusion is indeed useful, and can contribute to overall performance, thus shedding light on the relative strengths of surface-based learning.

### 4.6 Ablation Study

Finally, we examine the impact of different design choices on our tasks. All of these results are obtained in benchmark settings, both in terms of features (only atom-type as input) and of graph encoders (GCNs). In Appendix C, we introduce the sequential and bipartite scenario, which amount to variations in the connectivity of the blocks. In particular, the HoloProt method proposed in Somnath et al. () falls into the sequential framework with just one encoding block and a MeshCNN (Hanocka et al., ) for protein encoder. For fairness, we replace MeshCNN with our encoder and refer to this setup as HoloProt.

Another major design choice is the choice of the Message Passing (MP) component. We explore the use of three possible message-passing networks. Motivated by the success of DGCNN (Wang et al., ), in our Att. setting, we discard the geometric notion of a neighborhood, allowing for potentially long-distance message passing. In this setting, all nodes from the graphs attend to all vertices from the surface. To deal with the incurred computational burden, we use the recent memory-efficient Flash Attention (Dao et al., ).
We also explore the use of more conventional Graph Convolutional Networks (GCN setting) (Kipf & Welling, ) and the use of Graph ATtention networks (Veličković et al., ; Brody et al., ) for our final GAT setting.
Our results are presented in Table 3.

**Table 3: Ablation study of our method: We compare various architectural designs, and message-passing methods for our task.**
|  |  | MSP | PIP | PSR |  |
| --- | --- | --- | --- | --- | --- |
| Method | MP | AuROC | AuROC | local R | global R |
| sequential | - | 0.609 | 0.855 | 0.319 | 0.71 |
| HoloProt | - | 0.537 | 0.824 | 0.383 | 0.715 |
|  | Att. | 0.689 | 0.791 | 0.402 | 0.792 |
| bipartite | GCN | 0.697 | 0.868 | 0.421 | 0.797 |
|  | GAT | 0.707 | 0.876 | 0.452 | 0.833 |

The sequential strategy displays underwhelming results, which could root from its incapacity to handle multi-scale, simultaneous message passing. Similarly, HoloProt does not display a top performance, suggesting that their results could be enhanced by using better-performing mixing strategies.

Among the bipartite settings, Att. is consistently outperformed by the localized message-passing networks. The other scenarios give an overall close performance, with an edge for the GAT network. This is especially true on PSR, where surface methods alone were failing. The mixed approach could simply use surface diffusion as an efficient long-distance communication, which could explain why an attentive mechanism results in a performance boost in this scenario.

In short, the best setting leverages several blocks of message passing, with enhanced results for the most interconnected networks. In addition, the geometry of the bipartite graph is important, and an attentive mechanism generally benefits the optimal mixing.

## 5 Conclusion & Limitations

In this paper, we analyzed the utility of the surface representation in machine learning on protein structures. We first adapted the design of the recent DiffusionNet in the context of protein analysis tasks, and compared it against other methods by adhering to the Atom3d benchmark protocol, revealing both the promise and the limitations of surface-only learning. We then introduced a novel integrated architecture that combines surface and graph representations and achieves state-of-the-art results across several benchmark tasks. Key to our approach is a node-wise information sharing mechanism, which allows for joint training of graph and surface representations, coupled with localized information propagation across all network layers. Our ablation analysis further highlights that simplistic approaches to combining different representations lead to suboptimal performance. We also demonstrated the performance of our approach in identifying antibody-antigen and ligand-binding preferences achieving state-of-the-art results.

Our work strongly supports the notion that leveraging multiple representations with unique strengths is a promising strategy for advancing protein analysis. Moreover integrating biological priors both within the learning frameworks and into information sharing across representations seems crucial for achieving high accuracy in challenging scenarios. Despite our optimizations, one of the current limitations of our approach is its significant memory requirements, highlighting the need for computationally more efficient surface-based pipelines, in line with suggestions by Sverrisson et al. (). Beyond addressing these challenges,
our work can help pave the way to more powerful integrated multi-modal solutions for additional tasks within structural bioinformatics, including generative modeling, but also investigating ways in which information sharing across both representations and tasks can lead to improvements in robustness and accuracy.

## Appendix

In this document, we compile all results and discussions that could not be included in the main manuscript due to page constraints.

More specifically, we first provide additional data illustrations in Appendix A.
Then, we provide a proof for Proposition 3.1 in Appendix B.
Following this, detail the specifics of our implementation in Appendix C.
Then, we provide an analysis of the computational aspects of our technique in Appendix D.
Finally, we provide additional results in Appendix F.

## Appendix A Additional data analysis

In Figure 6, we plot the results of diffusing a Dirac initial distribution for several diffusion times, over the surface of the MDM2 protein, involved in apoptosis and cancer treatment. On the figure we see its groove, which corresponds to its binding site. Orange vertices correspond to the ones that have the highest probabilities, such that their sum represents 90% of the probability mass. A diffusion time of ten seems to convey a relevant scale for this binding site.

Figure: Figure 6: Visualization of a Dirac delta function $\delta_{x}$ at a point, diffused for several diffusion times.
Refer to caption: x4.png

In Figure 7, we plot the diffusion times learnt by a network (on the MSP task). We see that the network keeps a variety of scales, and has learnt to use large scales, effectively enabling long-distance message passing.

Figure: Figure 7: Histogram of the diffusion times obtained after training.
Refer to caption: x5.png

## Appendix B Proof of Proposition 3.1

###### Proof.

For simplicity we use the computations in the discrete setting (on meshes). Everything remains the same in the smooth (surface) setting, however. Let $M_{1}$ represent a shape modeled as a triangular mesh, with $W_{1}$ and $A_{1}$ denoting its cotangent Laplacian and area matrices, respectively. Therefore, its eigenvalue decomposition satisfies:

$$ $W_{1}\phi^{\textbf{1}}=\lambda^{\textbf{1}}A_{1}\phi^{\textbf{1}}.$ $$

Suppose $M_{2}$ is another mesh that is a scaled version of $M_{1}$ by a scaling factor $a$. Then, according to Bronstein & Kokkinos ():

$$ $\displaystyle A^{\textbf{2}}$ $\displaystyle=a^{2}A^{\textbf{1}}$ $\displaystyle\lambda^{\textbf{2}}$ $\displaystyle=\lambda^{\textbf{1}}/a^{2}$ $\displaystyle\phi^{\textbf{2}}$ $\displaystyle=\phi^{\textbf{1}}/a$ $$

The heat kernel can be computed as per Sun et al. ():

$$ $k_{t}(x,y)=\sum_{i}\exp(-\lambda_{i}t)\phi_{i}(x)\phi_{i}(y).$ $$

Consequently, we have:

$$ $\displaystyle k^{\textbf{2}}_{t}(x,y)$ $\displaystyle=\sum_{i}\exp(-\lambda^{\textbf{2}}_{i}t)\phi^{\textbf{2}}_{i}(x) \phi^{\textbf{2}}_{j}(y)$ $\displaystyle=\sum_{i}\exp(-\lambda^{\textbf{1}}_{i}/a^{2}t)\phi^{\textbf{1}}_ {i}(x)\phi^{\textbf{1}}_{j}(y)/a^{2}$ $\displaystyle=k^{\textbf{1}}_{t/a^{2}}(x,y)/a^{2}$ $$

If $g(x,y)$ denotes the geodesic distance between two points on the surface $x$ and $y$, then:

$$ $g^{\textbf{2}}(x,y)=ag^{\textbf{1}}(x,y).$ $$

Denoting $E_{\cdot}(t,x)$ as the expected geodesic distance of a Brownian motion starting from $x$ after time $t$, we find:

$$ $\displaystyle E^{\textbf{2}}\left(t,x\right)$ $\displaystyle=\sum_{y}k^{\textbf{2}}_{t}(x,y)g^{\textbf{2}}(x,y)A^{\textbf{2}} (y)=\sum_{y}k^{\textbf{2}}_{t}(x,y)ag^{\textbf{1}}(x,y)a^{2}A^{\textbf{1}}(y)$ $\displaystyle=\sum_{y}k^{\textbf{2}}_{t}(x,y)ag^{\textbf{1}}(x,y)a^{2}A^{ \textbf{1}}(y)$ $\displaystyle=\sum_{y}(k^{\textbf{1}}_{t/a^{2}}(x,y)/a^{2})ag^{\textbf{1}}(x,y )a^{2}A^{\textbf{1}}(y)$ $\displaystyle=a\sum_{y}k^{\textbf{1}}_{t/a^{2}}(x,y)g^{\textbf{1}}(x,y)A^{ \textbf{1}}(y)$ $\displaystyle=aE^{\textbf{1}}(t/a^{2},x).$ $$

Interestingly, if we assume $E(t,x)=\sqrt{t}$ (as in the Euclidean setting), then:
$aE^{\textbf{1}}(t/a^{2},x)=a\sqrt{t/a^{2}}=\sqrt{t}=E^{\textbf{2}}(t,x).$
∎

###### Proof.

## Appendix C Implementation Details

In this section, we give more details on architectures that were explored during our investigations. All models rely on a PyTorch Geometric (Fey & Lenssen, ) implementation.

Our initial attempt involves a sequential alternation between surface and graph encoding, referred to as the sequential setting. This approach involves a two-step block: first, surface encoding is performed and its features are projected onto the graph via message passing, denoted as $h_{n}^{g}=\text{MP}_{sg}(s_{\theta}(\mathcal{X}))_{n}$. Denoting the intermediate graph node embeddings as $\mathcal{H}^{g}=\{h_{n}^{g},n\in\mathcal{V}_{g}\}$, they are propagated within the bipartite graph to derive surface embeddings again, using $\mathcal{X}_{out}=\alpha\mathcal{X}+\text{MP}_{gs}(g_{\theta}(\mathcal{H}^{g}))$, where $\alpha\in\mathbb{R}$ is a residual connection. The architecture proposed by (Somnath et al., ) fits within this sequential framework, employing just one block and sum pooling for message passing.

However, the sequential approach does not simultaneously leverage the distinct scales (local and global) offered by graph and surface processing. To overcome this, the bipartite approach processes graph and surface features concurrently in separate encoders, and merge them with a message passing incorporating learnable parameters, based on the equation: $\mathcal{X}_{out}=\alpha\mathcal{X}+\text{MP}_{gs}(\mathcal{H})+\text{MP}_{sg}
(\mathcal{H})$. Those architectures are illustrated in Figure 8.

Figure: Figure 8: Illustration of our approach integrating surface and graph information.
Refer to caption: x6.png

The architecture we used is outlined in the main text. We employ our modified version of DiffusionNet (by adapting the original implementation provided by the authors(^1^11[https://github.com/nmwsharp/diffusion-net](https://github.com/nmwsharp/diffusion-net))) for each surface encoder and utilize GCN for the graph networks (using the implementation provided by PyTorch Geometric(^2^22[https://pytorch-geometric.readthedocs.io/en/latest/](https://pytorch-geometric.readthedocs.io/en/latest/))). The surface methods were trained using only the surface encoder, whereas the mixed methods incorporated an additional graph encoder and a message-passing framework. When employing both encoders, we ensure the number of channels is equal for both. Thus, the variables are the number of "blocks" and the number of channels for each block. Our networks were trained in accordance with the parameter counts of other methods, strictly adhering to their optimization protocols, including the number of epochs, learning rate, and batch size.

For the surface methods, we consistently used 3 blocks, with 94, 90, and 96 channels for the PIP, MSP, and PSR tasks, respectively. For the bipartite methods, on the PIP task, we utilized 4 blocks with a width of 118; for MSP, 3 blocks with a width of 148; and for PSR, 4 blocks with a width of 160.
On the binding site classification task, our architecture featured 6 blocks, each with a width of 128. The repository used to conduct experiments and reproduce these results is enclosed and will be publicly released upon acceptance.

## Appendix D Computational analysis

### D.1 Complexity analysis

In a DiffusionNet, the first main operations consist in a diffusion step using the equation introduced in the main text: $\mathbf{f}_{t}=\Phi e^{-\Lambda t}(\Phi^{T}M)\mathbf{f}_{0}$, for each feature map. For a given hidden dimension $h$, the complexity of this operation is hence $\mathcal{O}(h|\mathcal{V}_{s}|^{\omega})$ with $\omega$ the matrix multiplication complexity. Then, the two subsequent operations are the pointwise gradient construction and mixing, as well as a point-wise MLP of complexity: $\mathcal{O}(h^{2}|\mathcal{V}_{s}|)$. Message passing layers complexity with regards to $h$ and their number of edges N is $\mathcal{O}(h^{2}N)$. In our case, $N=16|\mathcal{V}_{s}|$ for the bipartite graph.

Given additional time constants in a $k^{(1)}_{\text{diff}},k^{(2)}_{\text{diff}},k_{g},k_{bp}$ representing the time needed for spectral and point-wise operations in DiffusionNet, graph encoding operations and message passing over the bipartite graph, the overall model complexity is $\mathcal{O}(k^{(1)}_{\text{diff}}h|\mathcal{V}_{s}|^{\omega}+(k^{(2)}_{\text{
diff}}+16*k_{bp})h^{2}|\mathcal{V}_{s}|+k_{g}h^{2}|E|)$.

The spectral operation component ($k^{(1)}_{\text{diff}}$) does not depend strongly, but it has a strong dependency on the size of the mesh, which is not well addressed by reducing the number of parameters. Empirically, for the latent dimensions considered, this spectral component was the time bottleneck and thus, coarsening the graphs resulted in significant speedups. We adjusted the number of vertices to make the first term of similar magnitude to the others (obtained for a 0.1 coarsening rate). In this regimen, when dividing the parameter count equally between the three learnt components, we observed that the ProNet execution was the limiting operation, and hence conclude that our method has a similar throughput to graph-based method for a fixed parameter count. Moreover, we observed that our method seemed to require less parameters overall, and note that the parameter count is split between components, effectively resulting in smaller ProNets than in the pure ProNet network of the benchmark, and hence a slightly faster runtime overall.

### D.2 Memory and batching

From the storage and memory perspective however, the memory footprint of the surface-related operations dominate the ones originating from the graphs. We did not find it to be limiting in terms of I/O, but it effectively forbids the use of large batch sizes, which can be limiting.

In addition to individual objects being large, the large variance in the object size (see Figure 10) also prevents us from using large batch sizes. Indeed, due to the random composition of the batch, some unlucky batches contain several particularly large proteins, causing spikes in memory usage and out-of-memory errors. We validate in Figure 10 that using coarsened surfaces, we stay in the linear dependency on the number of vertices for the hidden sizes at stake.

Figure: Figure 9: Distribution of the number of vertices in a dataset.
Refer to caption: x7.png

This is illustrated in Figure 11, for which we tracked the memory consumption of our model through one epoch of learning. Observe the memory peaks that can result in over 20% excess memory consumption, keeping in mind that this is only one run over one epoch. When training several models for hours, the probability that one outlier results in a 50% increase forces user caution.

Figure: Figure 11: Memory consumption monitoring through an epoch, for different batch sizes.
Refer to caption: x9.png

A naive solution is to use a safety margin, aggravating our small batch size issue. We implemented a dynamic batching procedure to create batches that are balanced in size, alleviating the memory issues originating from batch size variability. Finding ways to reduce the memory footprint of surface networks remains an important direction.

### D.3 Computing resources used for the project

Depending on the task, the training takes between a few hours and up to four days (for PIP which is our largest data set) on a standard setting; 4 CPU workers and a single GPU such as NVIDIA V100. To achieve our results, and our ablation experiment, we performed about 100 model training (5 data sets, several settings per datasets and some failed experiments).

## Appendix E Validation dataset description

#### RNA segmentation :

This task aims to segment 5s ribosomal RNA molecules into functional components, as defined by aligned regions in a Multi-Sequence Alignment Poulenard et al. (). This dataset consists of 640 RNA surface meshes of about 15k vertices. It was introduced as a benchmark to compare surface encoders.

#### Protein Interaction Prediction (PIP) :

This task aims to predict which part of a protein interacts with which part of another. Framed as a classification task, pairs of residues from two proteins are labeled as positives if they interact and as negatives if they do not. The dataset comprises 87k, 31k, and 15k training, validation, and test examples.

#### Mutation Stability Prediction (MSP) :

The objective here is to determine if a mutation enhances the stability of protein-protein interaction. Given a protein-protein interaction structure and its mutated version, this classification task labels the pair as a positive example if it exhibits increased stability. This task includes 2864, 937, and 347 examples in each data split.
For both PIP and MSP, the performance metric is the Area under the Receiver Operating Characteristic curve (AuROC).

#### Protein Structure Ranking (PSR) :

PSR is a regression task and aims to assign a quality score to predicted protein structures from the Critical Assessment of Methods of Protein Structure Prediction (CASP) Kryshtafovych et al. () competition.
The PSR data train, validation, and test splits hold 25.4k, 2.8k, and 16k systems respectively.
The "global $R_{S}$" term represents the mean correlation across all systems and proposals. Meanwhile, "mean $R_{S}$" refers to the average correlation for each system.

Masif-ligand: In addition to the Atom3d benchmark tasks, we evaluate our proposed approach on the task of ligand-binding preference prediction for protein binding sites, introduced in Gainza et al. (). Binding sites are regions of protein surfaces where small molecules (ligands) interact with the protein. A fine characterization of those regions helps understanding protein functions and plays a significant role in drug design and discovery. This dataset consists of protein binding sites that accommodate one of seven co-factors. It comprises 1,634 training instances, 202 validation instances, and 418 test cases. Given a binding site, the task amounts to predicting its corresponding co-factor.

## Appendix F Supplementary results

### F.1 Performance of the proposed Surface Encoder

We validate our surface encoder on the task of segmenting 5s ribosomal RNA molecules into functional components, as defined by aligned regions in a Multi-Sequence Alignment Poulenard et al. (). This dataset consists of 640 RNA surface meshes of about 15k vertices, and was already used to compare modern surface encoders.

We assess the impact of the proposed enhancements to DiffusionNet by showing the learning curves of the enhanced models on the RNA segmentation task (see Figure 13). Moreover, we compare their performance to standard recent surface encoders, DGCNN Wang et al. () and DeltaConvWiersma et al. ().
Our experiments show that our adjustments significantly improve the network’s stability issues and allow it to converge to a model with better performance than other networks.

Figure: Figure 12: Evolution of the learning curve (loss) on the RNA segmentation task using the original and our enhanced DiffusionNet models. It is evident that the original implementation is unstable and exhibits peaks in the loss.
Refer to caption: x10.png

### F.2 Validation of the new model on PSR

We conduct a similar analysis of the proposed enhancements on the PSR task. We depict the obtained learning curves in Figure 15 and report performance in Figure 15.
Again, we observe that our suggested enhancements result in a more stable learning.

Figure: Figure 14: Global correlation learning curve on the PSR task before and after applying our enhancements to DiffusionNet.
Refer to caption: x11.png

### F.3 Performance on binding site detection

Below are the results for the binding site detection task, in the format of a table for exact comparisons.

**Table 4: Performance of our hybrid approach on AbAG task.**
|  | Antibodies | Antigens |  |  |
| --- | --- | --- | --- | --- |
|  | AuROC | MCC | AuROC | MCC |
| GEP (Pegoraro et al., ) | 0.80 | 0.28 | 0.72 | 0.18 |
| AtomSurf | 0.86 | 0.47 | 0.73 | 0.18 |

### F.4 Assessment of the impact of the threshold distance

To evaluate the sensitivity of our results to variations of the distance threshold used to construct the bipartite graph, we varied this parameter on the PSR task. We report our findings in table 5. Our investigation indicates that changes to the threshold have a moderate effect on the model’s performance. However, it is important to note that excessively large values may lead to out-of-memory errors.

**Table 5: Performance on the PSR task as a function of the threshold used.**
| Threshold (A) | 4 | 8 | 10 | 20 |
| --- | --- | --- | --- | --- |
| local R | 0.445 | 0.434 | 0.434 | OOM |
| global R | 0.812 | 0.833 | 0.815 | OOM |

## Peer Reviews

confidence: 5
contribution: 3
initial_rating: 6
presentation: 2
questions: 1. Could the author(s) include the uncertainty estimates, measured across 3 experiment runs. I presume running these would not be out-of-scope for the rebuttal timeline, given the small size of the model and the datasets. 

2. For the different benchmark tasks, it would be very beneficial to understand / detail how the training splits were constructed. A common practice is to construct splits based on sequence similarity, but these don't capture the structural nuances / differences which are more relevant for OOD generalization.
soundness: 3
strengths: 1. There is very limited work on understanding representation learning with protein surfaces, even though it is universally agreed upon as being a suitable choice for many tasks. In that light, the paper is original in its attempt to dissect and improve representation learning with protein surfaces, and their integration with other modalities.

2. The quality of this work is good, showing a careful study of protein surfaces, adapting existing encoders to capture biological mechanisms, and experimental performance with relevant baselines on a well-known (albeit old) benchmark. The text is also clearly written, and generally easy to follow. For experiments, both the experimental comparisons against other representation modalities, and the experiments on antibodies are interesting and promising. 

3. Ablation studies are also performed for the different experimental choices, which further helps improve our understanding of protein-surface learning.
summary: The paper aims to improve our understanding of surface-based learning for protein representations. This is achieved by first adapting the surface encoder from the graphics literature for protein-learning tasks, which is then compared against other representation modalities (graphs, convolutions, equivariance etc). Following this the authors consider learning on bipartite graphs comprising structure and surface, allowing information to be shared at every layer of learning, compared to previous multi-scale approaches. 

Experiments on the Atom3D benchmark showcase the improved performance of the method on PPI (Protein-Protein Interaction), MSP (Mutation-Stability Prediction), and PSR (Protein-Structure Ranking) tasks, while using a much smaller model. A further experiment on binding site classification sees the method performance favorably compared to previous surface-learning based approaches.
weaknesses: **Experiments**

1. Atom3D is an old benchmark, without known issues with regards to the strategies used for splitting datasets. There has been some recent efforts [1] in curating tasks and datasets and evaluating structure based protein learning methods. While I understand carrying out an evaluation with this is not feasible within the scope of the current rebuttal timeline, it would be very handy to have this in a future revision of the paper. 

[1] Evaluating Representation Learning on the Protein Structure Universe

2. For the BindingSite Identification experiment, there is a missing baseline from dMaSIF which also achieves a 0.87 AUROC.

3. For most of these tasks, the dataset sizes available are typically limited. This makes it paramount to include uncertainty estimates, measured across 3 experimental runs. 

**Presentation**
The experiments section should include the corresponding table for the ribosomes (rather than in the appendix), or reorder the sections such that it falls under Ablation studies. This would improve the readability and flow of the paper.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: 1. The authors modified the design of the DiffusionNet architecture, which is typically used with geometric representations like triangle meshes or point clouds, and applied it at each point (or vertex). Initially, the protein surface was computed using MSMS, which generates a surface by rolling a virtual sphere (representing a solvent molecule, usually water) over the protein's atoms. Were traditional geometric CV surface reconstruction methods, such as Poisson surface reconstruction, considered to enhance compatibility with the adapted approach (DiffusionNet)?
2. "We choose to use residue graphs for computational efficiency: each node in this graph represents an amino-acid residue and edges are introduced between pairs of atoms that are within a 12 $\unicode{x212B}$ radius cutoff. For each residue, we add a one hot encoding of its type, its secondary structure annotation and its hydrophobicity. We also compute sequence embeddings using the ESM-650M (Rives et al., 2021) pretrained model and include them as node features." How were ESM embeddings used for amino acid residue atoms?
3. The surface encoder is based on the DiffusionNet architecture, which is applied to vertices (either from a point cloud or mesh). However, a more intuitive approach for capturing surface representation could be to use a triangulated mesh-based encoder defined on edges of the surface, such as MeshCNN. While DiffusionNet outperformed MeshCNN in the original study, it would be interesting to include an analysis of MeshCNN's performance within the protein domain.
4. The ablation study lacks a comparison between random representations and ESM residue representations.
5. Table 2 presents the number of parameters and indicates if pretraining was performed. If Atomsurf uses ESM embeddings, why it was not indicated as pretrained?
soundness: 3
strengths: 1. The proposed method shows superior empirical performance on Protein Interaction Prediction (PIP) and Mutation Stability Prediction (MSP) tasks compared to existing methods.
2. The paper is easy to follow.
3. The code is provided.
summary: This work proposes a hybrid approach combining surface and graph-based encoders, an improved DiffusionNet architecture tailored for protein surface analysis, a comparison of protein surface-based representations against protein as graph-based representations and enhanced computational efficiency with residue graphs and coarsened meshes.
weaknesses: I believe the main weakness of the paper is that, in terms of the proposed method, the paper does not provide a significant novel contribution. While the authors argue that direct comparisons between protein surface representations and other forms of representation have not yet been conducted, the idea of using protein surface representations is not new. Additionally, the results for the Protein Structure
Ranking (PSR) task in the Atom3D benchmark demonstrate comparable performance with other approaches that incorporate different representations, such as GearNet and ProNet.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 4
questions: C.f. weaknesses above.
soundness: 3
strengths: 1. Writing: The paper was very well written overall and I enjoyed the read. Statements were clearly made and easy to follow -- well done on the writing and thank you for spending time on it!

2. Benchmarks select relevant baselines: The authors selected relevant baselines (e.g. GearNet for graph-level representation learning, HoloProt for graph-surface combinations, MaSIF for surface based representation learning) that I would have expected to see in such a work. 

3. Interesting case of cross-domain method transfer: The authors transfer the DiffusionNet method from the general surface representation learning literature to the protein representation learning literature. As someone from the protein community I was not previously familiar with the DiffusionNet work and found this a valuable bridge and interesting comparison. While the adaptations to the DiffusionNet approach for proteins were minor (essentially constrained to the update of sampling the t values at 10 Angstrom) this adaptation was well reasoned and makes sense from a domain-level perspective.

4. Ablations: I found the ablations to be informative and well constructed and described.
summary: ## Analysis of surface representations methods in protein representation learning

This paper studies the utility of a diffusion kernel based surface representation ideas, introduced in DiffusionNet (Sharp et al. 2020 preprint, 2022 published) for protein representation learning. The authors update the original DiffusionNet formulation to (1) allow for batching and (2) initialising the diffusion time parameters around a meaningful value in proteins (10 Angstrom). 

This protein-adapted version of DiffusionNet is then studied (1) in isolation and (2) in combination with residue graph-based representation learning on a handful of protein representation learning tasks:

Evaluated are the protein interaction prediction (PIP), mutational stability prediction (MSP) and protein structure ranking (PSR) tasks of the Atom3D benchmark, as well as an antibody-antigen interaction prediction and a protein-ligand binding site prediction task.

The contributions of this work are:
- (1) *Modelling contributions*: The above mentioned (batching, initialisation) adaptations to DiffusionNet and, for the models that work on both surface and residue graph level representations, a layer-wise cross-communication between surface & graph representations via cross attention.
- (2) *Insight contributions (ablations and benchmark comparisons)*: The authors ablate the use of DiffusionNet-style surface representation learning versus other surface based approaches, as well as combining surface and graph level approaches. They compare to adequate baseline representatives of each approach that are common in the literature. They find that in their hands & on the above mentioned benchmarks their DiffusionNet-style approach together with a residue graph representation based approach outperforms the other methods.
weaknesses: 1. Clarity in benchmark comparisons: When seeing the comparison to the benchmark methods, I was left with the question whether the authors re-ran training on the same datasets & splits for each method, or whether these numbers were quoted from a table? What are the levels of variation for each? (e.g. +/- resulting from 3-5 different runs). Were all approaches 'tuned' with equal attention to hyperparameters? I would have expected a short discussion of these points.

2. Limitation of these benchmarks: This is less of a direct critique of this paper, and more of the underlying benchmarks that were used (that I believe should be updated). Protein structures tend to not be rigid, and as a consequence surfaces tend not to be rigid either. While at a coarse grained level there is likely less variation (unless there are global conformation shifts), at a 3-8A level there can be significant reorganisation of side chains - relevant for ligand binding and polar interactions. Interaction prediction should therefore be done on 'relaxed' surfaces that were not extracted from protein complexes (as some of the benchmarks do) and holdout sets should be constructed in particular also based on structural similarities of surfaces rather than just sequence homology. I would highly recommend the authors to look into the pinder & plinder datasets & benchmarks, but I do acknowledge that these were just published briefly before this work was submitted. A comparison on these in the rebuttals would be of much interest. Without comparisons like these I doubt the real-world applicability of such surface representations for most practical tasks in biology.

---

confidence: 5
contribution: 2
initial_rating: 6
presentation: 4
questions: - Are the tables missing more recent results on ATOM3D? Eg. Table 1 only shows the results from the proposed models as well as the original ATOM3D benchmark. But there have been many other papers which have outperformed the original benchmark results. Is the rationale for not including them that they do not strictly conform to the benchmark protocol?

- I realise that the results on all the benchmarks show improvements and each table has the new model in bold -- this is good -- but how relevant are some of the ATOM3D and other tasks in the current state of the field? Eg. Tasks like PSR seem irrelevant in the post AlphaFold 2 era. For RNA segmentation: I personally don't think this is relevant for real-world problems, but I am  happy to be shown wrong here.

---

Minor comments:
- Line 287: typo 'embed'
soundness: 4
strengths: - The general ideas of share information across the various representations of a biomolecule is simple and appealing. Implementing a tighter coupling between the graph and surface track in the newly proposed networks is a sensible idea. The results support all these design decisions well. I think the community will find the ideas and results in the paper to be useful.

- Well written and well presented overall.
summary: The paper proposes a new model for protein structure representation learning and property prediction. The main idea is to take as input both the 3D point cloud graph as well as surface mesh, jointly process both modalities within the network with information sharing among them, and then use the joint representation to perform prediction tasks per residue or globally. Experimental results show improvements or match state of the art results on all benchmarks evaluated.
weaknesses: - There has been a recent focus in the community on purely sequence-based approaches and protein language models (see the last ICLR for several works on structure-aware pLMs). I would have been interested to see empirical comparisons to at least ESM2 or perhaps more recent structure-aware pLMs. In principle, the sequence contains all the information that represents a protein and pLMs could implicitly be able to learn surface representations. I would at least have liked to see an ablation on the use of ESM2 embeddings in the model. 
    - (In other words: Could the performance gain be coming from the use of ESM2 embeddings as node features? Perhaps yes, as these pLM embeddings have been shown to already be very strong at learning structural representations and for structure-based tasks: https://openreview.net/forum?id=sTYuRVrdK3, ICLR 2023.)

Meta-review: The paper received positive support from most of the reviewers, and the overall recommendation was positive. Thus an accept is recommended.

Decision: Accept (Poster)