Geometric deep learning KDD 2022

Turn the chain. The numbers hold still, the arrows turn with it.

GBPNet: Universal Geometric Representation Learning on Protein Structures

Sarp Aykent^*
Tian Xia^*

Affiliation at the time of publication

Auburn University, Auburn, AL, USA (both authors). ^*Both authors contributed equally to this research.

The paper introduces a drop-in block that updates a protein’s scalar features and its 3D vector features together, built so that rotating the protein leaves the scalars unchanged and rotates the vectors with it, and reports it on three protein tasks.

Read the paper (opens in a new tab) Try the block

Figure 1Illustration

Drag to turn or pick a point

Point 9 of 28

A number: distance to the nearest neighbour 1.14 unchanged by turning

An arrow: direction to it (x, y, z) (−0.55, +0.51, +0.66) turns with the chain

Turn 0°

Tilt 0°

IllustrationA made-up chain of 28 points, not a real protein. Each point stands in for one amino acid residue. Both values are computed in your browser from this toy. Click a point, or use the point stepper, to pick another.

01 The problem

In a folded protein, residues far apart along the chain can sit side by side in space.

The paper turns a protein into a graph: every amino acid residue is a node, and each node is joined to its k nearest neighbours in space, measured between Cα atoms. It notes that “amino acids pairs that are sequentially far apart might be spatially in contact”, so the range of interaction a network has to cover is large.

Figure 2Illustration

Pick a point and see who its neighbours are

Along the chain the same 28 points laid out in order; arcs join the selected point to its neighbours

In space drag to turn, click a point to select it

Point 9 has 6 neighbours in space. 2 of them sit more than 8 positions away along the chain. Across the whole toy graph, 19 of 168 edges do.

Selected point 9

Neighbours per point, k 6

Neighbours chosen by

Nearest in space Nearest along the chain

IllustrationThe same made-up chain of 28 points as above, not a real protein. The counts are computed in your browser from this toy and say nothing about how often this happens in real proteins. k and the threshold of 8 positions are toy settings. “Nearest along the chain” is shown for contrast only; it is not a description of any earlier method.

How to read it. Long arcs on the ruler are contacts that only exist because the chain is folded. Switch to “nearest along the chain” and they disappear: a graph built from chain order alone never joins point 9 to point 25, although they sit next to each other in space. Source for the graph construction: Section 3, p.3.

Every residue and every contact carries two kinds of features, and neither is complete alone.

The paper describes each node and each edge with a tuple: plain numbers that do not care how the protein is held, and 3D arrows that do. On this page a number is always a square or a bar, and an arrow is always an arrow.

Figure 2bIllustration

What the network is given for point 9 and one of its contacts

Contact of point 9 with

Follows the point and k chosen in Figure 2. An arc on its ruler selects the same contact. Turn its fold and the arrows below turn too.

Residue point 9 (a node)

Numbers

Identity embedding: Named in Section 3. Section 4.4 uses “identity” for the amino acid type of a residue.; not in the toy: the chain has no amino acid types
Dihedral angles: Three backbone angles (φ, ψ, ω) from the C, N and Cα atoms, each kept as a sine and a cosine: “six features per amino acid”.; not in the toy: it has no backbone atoms

Arrows

Orientations: Two unit vectors, one towards the next Cα along the chain and one towards the previous.; toynext (+0.65, +0.51, −0.56); toyprevious (−0.55, +0.51, +0.66)
Sidechain direction: A unit vector for the direction of Cβ seen from Cα.; not in the toy: it has no backbone atoms

Contact 9 · 25 (an edge)

Numbers

Relative distance: The distance between the two residues, passed through RBF kernels so the network sees an approximation, not the raw value.; toy1.44 toy units, the plain distance
Relative position: The difference of the two residues’ sinusoidal position embeddings, P_i − P_j.; toy+16 positions, the plain offset along the chain

Arrow

Direction unit vector: The difference of the two Cα positions, normalised to length one.; toy(+0.32, −0.85, −0.41)

IllustrationValues tagged “toy” are computed in your browser from the made-up chain. The paper passes distances through RBF kernels, and gives relative position as the difference of two sinusoidal position embeddings, P_i − P_j. The toy shows the plain distance and the plain offset along the chain instead, in toy units. Three features need information this toy chain does not have, the amino acid type and the backbone atoms, so they are listed, not computed. Source for the feature definitions: Section 3 and Appendix A.1, p.3 and p.10.

“the scalar and vector features for nodes and edges are mutually related, so a module with the ability to learn scalar and vector features jointly is essential”

The paper, Section 1, p.2.

02 The idea

Inside the block, arrows reach the numbers only as lengths.

The paper’s Geometric Bottleneck Perceptron (GBP) updates both kinds of features at once. The arrows are mixed down into a few latent arrows and mixed back up. The numbers get to see those latent arrows, but only how long they are. Turning an arrow does not change its length, so turning the protein cannot change the numbers, and the arrows that come out have turned by exactly the same amount.

Figure 3Illustration

Turn the input arrows and watch what moves

IllustrationThe paper’s Equations 1 to 5 running in your browser on made-up features with random weights: it is not the trained network, nothing computed here is a result, and the two counter-examples are blocks broken on purpose by this page, not ablations from the paper and not any earlier method.

Weights in this toy block

Latent arrows2of 8r / λ

Arrows path32weightsa direct 8 × 8 map has 64

Numbers layer48weights(t + r / λ) × t′

Toy arithmetic, counted from the shapes printed in Eqs. 1, 2 and 5 with r = r′ = 8 and t = t′ = 6. Not the model’s parameter count. The paper uses λ = 4 for its protein design experiments.

MeasuredIn the paper, protein design task, Table 4, p.8

Scalar Only

The paper: “The Scalar Only variation removes the (V) paths for nodes and edges. The model performance decreases severely on both perplexity and recovery scores.” In the toy, the arrows lane and the bridge are removed and s′ is computed from s alone.

- Vector Projection

The paper: “The Vector Projection variation removes the bottleneck down-scaling and up-scaling operations on the V path when possible.” This toy reads that as keeping both maps and removing only the squeeze (λ = 1); the reading is this page’s. The toy’s weight counter is hidden here, so that no toy count is read as an explanation of the parameter cell in Table 4.

- Vector Identity

The paper: “The Vector Identity variation removes the element-wise multiplication is used to calculate V′ in the GBP block.” In the toy, V′ is V_u with no gate. Eq. 3 has no learnable weight; Table 4 prints 1.677M parameters with and without the gate. Computed by this page from Table 4, the three recovery cells differ by 1.02, 1.65 and 0.59 percentage points, which is 3.1%, 5.0% and 1.4% of the full model’s cells (mean 3.1%); the paper describes the drop as “3% on average” and does not say which of the two it means.

None of the three measured variants breaks the turning rule in the toy. What they change is how well the model does, and only the paper’s experiments can show that. The full table is in section 05.

How to read the drawing

Arrows are drawn from the centre of each dial, fainter when they point away from you. The ring shows how far the input has been turned. Part names are the paper’s (Figure 3, p.5); the arrangement and the drawing are this page’s own. Toy choices: 8 arrows and 6 numbers in and out, no bias terms because none are printed, a sigmoid gate (the case the paper calls a gating mechanism) and tanh for the numbers, where Eq. 5 says “the non-linearity”. In this toy a gate dial never reads below one half, because a length is never negative. With only 8 arrows the toy’s squeeze is very tight: at λ = 4 two latent arrows remain, so all eight output arrows lie in one plane, and at λ = 8 on one line.

Equations 1 to 5, in plain words

Downsampling Layer (Eq. 1). The r input arrows are mixed by learned weights w_d into r/λ new arrows, the latent representation z. Each new arrow is a weighted sum of the input arrows.
The bridge (Eq. 4). The lengths of the latent arrows (their L2 norms) are appended to the input numbers s. Lengths, not directions.
The numbers update (Eq. 5). A linear map w_s and a non-linearity turn the t + r/λ numbers, s and the lengths together, into the t′ output numbers s′.
Upsampling Layer (Eq. 2). The r/λ latent arrows are mixed again, by w_u, into r′ arrows, V_u.
The gate (Eq. 3). Each arrow of V_u is scaled by a number that depends only on its own length. Its direction is untouched. That gives the output arrows V′.

Source: Section 4.2, Eqs. 1 to 5, p.4 to p.5. The paper says the block “can be stacked ω times”.

Why turning cannot leak into the numbers

The paper’s Appendix B gives the argument for one GBP block and for rotations. Mixing arrows with fixed weights and then rotating gives the same arrows as rotating first and then mixing. Rotating an arrow does not change its length, so the lengths that cross the bridge are the same before and after, and so is s′. The gate depends only on lengths too, so V′ turns exactly as the input turns.

The bench above checks that argument numerically, for the toy block only. The two readouts are what is left after the subtraction, and they sit at the level of floating point rounding.

Source: Appendix B, Eqs. 15 to 18, p.10.

03 One example, followed

One contact, followed from two residues to a prediction.

Take points 9 and 25 of the toy chain: 16 positions apart along the chain, next to each other in space. This is the path one message between them takes through GBPNet, as the paper describes it. Every box opens its own detail.

Figure 4Diagram

Step through one message, or select any box

The example what happens to points 9 and 25 at this step

The architecture where this step happens; every box opens its detail

Start from coordinates

Nodes are amino acid residues. Edges join each residue to its k nearest neighbours, found from the 3D coordinates of the Cα atoms. That is how points 9 and 25 become connected although they are far apart along the chain.

In
3D coordinates, one Cα per residue
Out
a k nearest neighbour graph
Describe the two residues

Each residue gets a tuple. Numbers: an identity embedding, and its dihedral angles as six numbers per residue. Arrows: the forward and backward orientation and the sidechain direction.

In
residues 9 and 25
Out
two tuples (numbers, arrows)
Describe the contact

The edge between them gets a tuple of its own. Numbers: the relative distance, through RBF kernels, and the relative position P_i − P_j. Arrow: the unit direction from one Cα to the other.

In
the edge 9 to 25
Out
one tuple (numbers, arrow)
Write the message

The contact and its two residues are concatenated, numbers with numbers and arrows with arrows, and passed through one GBP block (Eq. 7). This is the block on the bench above.

In
three tuples
Out
one message (numbers, arrows)
Refine it ω times

GBP is applied again to its own output, ω times in all (Eq. 8). The base model in Table 5 uses γ = 9, δ = 1 and ω = 6.

In
the message
Out
the message after ω GBP layers
Gather the neighbourhood

Messages from all of a residue’s neighbours are combined by a function that ignores their order: the paper names mean, sum or max (Eq. 9). The result is added to what the residue already held, a skip connection (Eq. 10).

In
one message per neighbour
Out
updated features for the residue
Think per residue, then repeat

A position-wise feed-forward network with shared weights follows, again built from GBP layers (Eq. 11). Then the whole layer repeats: nine encoder blocks for protein design, five for structure ranking, eight for binding affinity.

In
features of every residue
Out
the same shape, one layer deeper
Answer the question

One design, three kinds of question, each with its own depth and head. Protein design predicts an amino acid for every residue. Structure ranking and binding affinity average the final numbers of all nodes (Eq. 12) and turn that average into one value. Select a head for its detail.

In
final node features
Out
20 classes per residue, or one number

Select any box in the drawing to read what it does. Arrow keys move between boxes.

Cα points

Only the Cα atom of each residue places the node. The paper’s reason for building a graph at all: to represent the structure “without handcraft features to avoid bias”.

Section 3, p.3

kNN edges

The paper names two ways to choose neighbours: the k nearest, or all nodes within a given radius. The toy in Figure 2 opens with k = 6, a toy setting.

Section 3, p.3; Section 4.3.1, p.5

Residue tuple

The six dihedral numbers are a sine and a cosine for each of three backbone angles, kept that way to “keep the circular property of the angles”. The sidechain arrow is computed from the N, C and Cα positions (Eq. 14). Figure 2b lists every feature.

Appendix A.1, p.10

Contact tuple

Why the distance is not given raw: “if the absolute values are provided to a network, it tends to memorize than learn the structure”. The number of RBF kernels is left as a hyper-parameter.

Appendix A.1, p.10

Concatenate

In the paper’s words: “Both vector and scalar representations are concatenated then integrated by the GBP layer.”

Eq. 7, Section 4.3.1, p.5

GBP, the message

The Geometric Bottleneck Perceptron: two lanes and one bridge that carries lengths only. Run it on the bench above.

Section 4.2, Figure 3, p.4 to p.5

ω times

“The GBP module can be stacked ω times to enhance further the feature blending and expressiveness of the geometric feature representations in the neural network.” Table 5 tries ω from 4 to 10.

Section 4.2.2 and Eq. 8, p.5; Table 5, p.8

Aggregate

The messages for a node are combined by “a permutation invariant function including MEAN, SUM or MAX”.

Eq. 9, Section 4.3.1, p.5

Skip connection

The aggregated message is added to the node’s previous features. The paper’s reason: “to allow the non-synchronicity of changes in the feature representation space”.

Eq. 10, Section 4.3.1, p.5

Feed-forward

For each node “a linear function with shared weights is applied”, then p layers of GBP.

Eq. 11, Section 4.3.2, p.5

Repeat γ times

Encoder blocks per task: nine for protein design, five for structure ranking, eight for binding affinity. The paper reads Table 5 as improving “slightly until nine, and then the performance drops” (Section 7.3.1); γ = 11 is the only deeper setting it tested.

Appendix C, p.10; Table 5 and Section 7.3.1, p.8

Computational protein design (CPD)

Decoder layers follow the encoder. The sequence is predicted one residue at a time, and edges from a residue to later residues are masked “to prevent information leakage”. A linear layer gives 20 outputs, one per amino acid, trained with cross-entropy loss.

Definition 3.1, p.3; Section 4.4, p.6

Structure ranking (PSR)

The final numbers of all nodes are averaged (Eq. 12), and a prediction function U, which the paper says can be an MLP, turns the average into one quality score for the predicted structure. Only the numbers are read out. Trained with mean squared error.

Definition 3.2, p.3; Eq. 12 and Section 4.5, p.6

Binding affinity (LBA)

The same readout gives one binding strength for a protein and ligand complex, which Definition 3.3 speaks of modelling as an atom-level graph. Trained with mean squared error.

Definition 3.3, p.3; Eq. 12 and Section 4.5, p.6

How to read it. Two original drawings of the architecture described in Sections 3 and 4 of the paper. The upper one follows points 9 and 25 of the same made-up chain as above; the lower one shows where that step sits in the network. Inside a token a square stands for numbers and an arrow for arrows; how many are drawn is schematic. The dashed line is the repeat of the encoder layer, a different kind of link from the solid data flow. The address bar follows the step, so a copied link reopens it.

04 The evidence

On three protein tasks, the paper reports the best value in every column of its comparison tables.

One classification task and two regression tasks, each with its own depth and head. The bars below are the paper’s printed cells, drawn from zero so that a small margin looks small. Point at a row to set it beside GBPNet.

Figure 5Measured, Tables 1 to 3

Choose a task and a metric, then compare any method with GBPNet

Computational protein design (CPD): Table 1

Table 1, p.7. “Comparison of the proposed GBPNet with the benchmarks on the CPD task.”
	Perplexity lower is better			Recovery higher is better
Method	Short	Single	All	Short	Single	All
STran	8.54	9.03	6.85	28.30	27.60	36.40
SGNN	8.31	8.88	6.55	28.40	28.10	37.30
GVP	7.10	7.44	5.29	32.10	32.00	40.20
GBPNet	6.14	6.46	5.03	33.22	33.22	42.70

Bold underlined cells are the ones the paper prints in bold, the best value in the column. Method names as the table prints them.

The question: Given a protein’s 3D structure and the sequence so far, predict the next amino acid, from the first position to the last. A classification task.
The data: Chains from the CATH classification: 18024 for training, 609 for validation and 1120 for testing, with every test topology removed from training and validation.
The metrics: Perplexity, the exponential of the cross-entropy: lower is better. Recovery (%), the median over test sequences of a per-sequence score (Eq. 13): higher is better. Short, Single and All are test subsets named in the paper.

Protein structure ranking (PSR): Table 2

Table 2, p.7. “Comparison of the proposed GBPNet with the benchmarks on the PSR task.”
	Local higher is better			Global higher is better
Method	p	Sp	K	p	Sp	K
3DCNN	0.491	0.431	0.272	0.643	0.769	0.481
ProQ3D	0.444	0.432	0.304	0.796	0.772	0.594
VoroMQA	0.412	0.419	0.291	0.688	0.651	0.505
RWplus	0.192	0.167	0.137	0.033	0.056	0.011
SBROD	0.431	0.413	0.291	0.551	0.569	0.393
Ornate	0.393	0.371	0.256	0.625	0.669	0.481
DimeNet	0.302	0.351	0.285	0.614	0.625	0.431
GraphQA	0.357	0.379	0.251	0.821	0.820	0.618
GVP	0.581	0.462	0.331	0.805	0.811	0.616
GBPNet	0.612	0.517	0.372	0.856	0.853	0.656

Bold underlined cells are the ones the paper prints in bold. Read from the cells by this page: the closest baseline is a different method on each side of the table, GVP on the Local columns and GraphQA on the Global ones.

The question: Given a predicted structure (a decoy), estimate its quality: a score called GDT_TS that measures how close a predicted structure is to the experimentally observed one. A regression task, also known as model quality assessment.
The data: Predicted 3D models submitted to nine CASP competitions, with the same splits as the earlier work the paper follows.
The metrics: Pearson (p), Spearman (Sp) and Kendall (K) correlation: higher is better. Local is computed per target and averaged. Global is computed over all samples in the test set.

Ligand binding affinity (LBA): Table 3

Metric

RMSE Pearson p Spearman Sp

Table 3, p.7. “Comparison of the proposed GBPNet with the baselines on the LBA task. The results are averaged over 3 independent runs.”
Method	RMSE	p	Sp
ENN
Cormorant	1.568 ± 0.012	0.389	0.408
CNN
3DCNN	1.416 ± 0.021	0.550	0.553
DeepAffinity	1.893 ± 0.650	0.415	0.426
Graph
GCN	1.570 ± 0.025	0.545	0.533
DGAT	1.719 ± 0.047	0.464	0.472
DGIN	1.765 ± 0.076	0.426	0.432
DGAT-GCN	1.550 ± 0.017	0.498	0.496
GVP	1.594 ± 0.073	0.434	0.432
Ours
GBPNet	1.405 ± 0.009	0.561	0.557

Bold underlined cells are the ones the paper prints in bold. Family labels (ENN, CNN, Graph, Ours) are as printed. The ± is as printed in Table 3, for RMSE only; the paper’s text calls it a standard deviation. The bars show the first number. On the RMSE chart a thin whisker under each bar end spans the printed ±; no whisker is drawn for p or Sp, because none is printed.

The question: Given the structure of a protein and ligand complex, predict their binding strength. A regression task.
The data: Complexes from the PDBBind database of experimentally measured binding affinities, with the same splits as the earlier work the paper follows.
The metrics: RMSE, printed without a unit: lower is better. Pearson (p) and Spearman (Sp) correlation: higher is better. Results are averaged over 3 independent runs.

How to read it. Every bar starts at zero and ends with the cell exactly as printed. The difference in the strip under a chart is a plain subtraction of two printed cells, made by this page. A diamond and the words “this paper” mark GBPNet.

05 Taken apart

Remove one part at a time, and the paper measured what each removal cost.

Table 4 removes one thing per row on the protein design task: a part of the block, or one of six input features. The paper calls the Direction Unit vector “the most salient feature”. The table shows that, and a nuance: which removal costs most depends on the column you read.

Figure 6Measured, Table 4

Remove one part and set the result beside the full model

On every residue

On every contact

Inside the GBP block select a part of the drawing or its chip

One part at a time, because that is what the paper measured. The struck-through piece is the one removed.

Show Table 4 as printed

Table 4, p.8. “Ablation study of proposed GBPNet.” Protein design task. Δt is the average time to complete a training epoch, in seconds.
			Perplexity lower is better			Recovery higher is better
Ablation	Parameters	Δt	Short	Single	All	Short	Single	All
Architecture
Scalar Only	1.588M	128s	7.281	7.567	7.247	28.71%	28.36%	31.99%
- Vector Projection	1.780M	146s	6.794	6.493	5.273	31.24%	33.16%	40.90%
- Vector Identity	1.677M	140s	6.157	6.486	5.026	32.20%	31.57%	42.11%
Node Features
- Scalar: Dihedral	1.677M	138s	7.855	8.301	5.386	29.87%	28.57%	39.87%
- Vector: Orientation	1.677M	139s	7.124	7.392	6.206	29.55%	28.57%	36.28%
- Vector: Sidechain	1.677M	139s	6.723	6.997	5.915	31.45%	29.96%	37.92%
Edge Features
- Scalar: Relative Distance	1.677M	137s	6.711	6.833	5.630	31.53%	30.43%	38.43%
- Scalar: Relative Position	1.677M	138s	6.187	6.477	5.090	32.01%	31.23%	41.49%
- Vector: Direction Unit	1.677M	141s	7.029	7.147	6.223	30.12%	29.42%	35.59%
Full model
GBP	1.677M	145s	6.144	6.458	5.025	33.22%	33.22%	42.70%

Rows and labels as printed; the last group heading, “Full model”, is this page’s (the paper leaves it blank). One part removed at a time. Bold underlined cells are the paper’s bold. The paper prints a direction for Perplexity and Recovery only, none for Parameters or Δt.

What to look for. Read from the printed cells by this page: on the All columns, Direction Unit is the most costly feature to remove (perplexity 6.223, recovery 35.59%). On Short and Single perplexity, removing Dihedral costs more (7.855 and 8.301). Removing every arrow, the Scalar Only row, is the most costly removal on the All columns overall (7.247 and 31.99%). Cells: Table 4, p.8. Among the features, the paper singles out Direction Unit (Section 7.2.2).

Figure 7Measured, Table 5

Change one depth setting at a time and compare it with the base model

Show Table 5 as printed

Table 5, p.8. “The parameter sensitivity analysis of the proposed GBPNet model.” Protein design task. PM is the number of trainable parameters, in millions.
				Perplexity lower is better			Recovery % higher is better
γ	δ	ω	PM	Short	Single	All	Short	Single	All
3	1	6	0.68	7.038	7.563	5.198	31.06	30.83	40.84
5	1	6	1.01	6.153	6.467	5.034	33.68	30.93	41.63
7	1	6	1.34	6.159	6.485	5.029	33.78	32.24	42.02
11	1	6	2.01	6.169	6.519	5.111	32.88	31.11	41.73
9	3	6	2.01	6.178	6.499	5.085	32.52	31.32	41.55
9	5	6	2.35	6.305	6.674	5.187	30.85	30.22	39.20
9	9	6	2.35	7.815	8.294	5.530	28.36	27.60	38.45
9	1	4	1.46	6.331	6.652	5.227	33.81	30.92	40.83
9	1	5	1.46	6.454	6.832	5.178	33.39	32.69	41.85
9	1	7	1.89	6.368	6.702	5.059	32.97	32.24	42.28
9	1	8	1.89	6.205	6.477	5.029	31.47	32.52	42.21
9	1	10	2.10	6.501	6.209	5.042	33.32	32.48	41.38
9	1	6	1.68	6.144	6.458	5.025	33.22	33.22	42.70

Cells as printed, including the repeated PM values (2.01 twice, 2.35 twice, 1.46 twice, 1.89 twice). “Each model variant only changes one parameter” against the base model in the last row, whose cells match the GBPNet row of Table 1 to the two decimals printed there; Appendix C describes the protein design model with three decoder blocks and eight stacked GBP blocks. Dots, not lines: the paper tested separate settings, and a line would suggest values in between.

The paper’s reading: with encoder depth γ, results improve “slightly until nine, and then the performance drops”, and the three layer encoder, at 0.68 million parameters, “could be a lightweight option for real-world applications”. The paper also trains on 10% to 100% of the training set and reports that performance rises with dataset size (its Figure 4). That figure is not redrawn here, because this page charts printed values only. Source: Section 7.3, p.8 to p.9.

The one idea

Arrows may speak to numbers only through their lengths.

Two kinds of features

Every residue and every contact carries plain numbers and 3D arrows, and one drop-in block updates both together.

One narrow bridge

The arrows are squeezed through a bottleneck and reach the numbers only as lengths, so turning the protein leaves the numbers unchanged and turns the arrows with it.

What is not tested

The paper tests three protein tasks. It reports no experiment outside proteins, none inside another backbone, and no speed or memory comparison with other methods.

06 Office hours

The night shift answers.

Written by Tian's agent while Tian slept and Pepper supervised. Pepper accepts no liability either.

Each answer says where in the paper it comes from, so you can check the agent's work.

Pepper, the tabby cat, supervising: fast asleep on his blanket on the sofa, beside the laptop.

How is this block different from GVP, the baseline it is compared with on all three tasks?

The paper lists GVP as a baseline and describes it in one line, as a method that “encodes protein structure as scalars and vectors and processes the features by message passing neural network”. It does not set the two blocks side by side.

What it does isolate are two parts of its own block. Without the bottleneck: perplexity All 5.273 against 5.025, recovery All 40.90% against 42.70%, and 1.780M parameters against 1.677M. Without the gate: perplexity is about the same (5.026 against 5.025) and recovery All is 42.11% against 42.70%.

Source: Appendix D, p.11; Table 4 and Section 7.2.1, p.7 to p.8

Does the bottleneck make the model faster?

Not measurably in what the paper reports. With the bottleneck an average training epoch takes 145 s; without it, 146 s. The measured difference is in size (1.677M against 1.780M parameters) and in quality.

The complexity section gives Θ(MD² + ND²), with M edges, N nodes and representation depth D, and says the bottleneck “reduces the representation D by λ times”. The paper reports no speed, memory or size comparison with any other method.

Source: Table 4, p.8; Section 5, p.6

Is the turning rule proven or tested? What about shifting the protein, or its mirror image?

It is argued on paper for rotations, in Appendix B, and the printed argument covers one GBP block; the paper calls the whole network SO(3)-equivariant without writing that longer argument out.

For shifts, the paper states the property and builds its features from differences between positions and from distances, but prints no separate proof. Mirror images are not discussed. No numerical test is reported. The bench on this page checks the rotation rule numerically, for the toy block only.

Source: Appendix B, p.10; Section 1, p.2; Section 3, p.3

How solid are the margins?

For binding affinity the paper averages three runs: GBPNet’s RMSE is 1.405 ± 0.009 and the closest baseline, 3DCNN, is 1.416 ± 0.021. The difference between the two, 0.011, is smaller than 3DCNN’s own printed ±.

The protein design and structure ranking tables print single values with no spread and no number of runs, and the paper does not say whether the baseline values were re-run or taken from the cited papers. It reports no significance tests.

Source: Tables 1 to 3, p.7; Section 6.2, p.6

The title says “universal”. What was actually tested?

Three protein tasks: one classification task and two regression tasks, which the paper says “span different use cases” of its framework, using the same block and layer design with a different depth and head for each (nine, five and eight encoder blocks).

The abstract says the block can be placed in other backbones and used in other domains; the paper reports no experiment outside proteins and none inside another backbone. The ablation and sensitivity studies are on protein design only.

Source: Abstract, p.1; Section 6, p.6; Sections 7.2 and 7.3, p.7 to p.9; Appendix C, p.10