acceptodds
Under review as a conference paper at ICLR 2027

Calibrated Bounded Message Passing for Robust Graph Learning

Abstract

Message-passing graph neural networks learn node representations by aggregating information from their neighbours. However, widely used layers construct messages that depend linearly on neighbouring states, allowing a single anomalous or injected node to arbitrarily shift the aggregate. We introduce Calibrated Bounded Message Passing (CBMP), which normalises node inputs on both the message and residual streams and applies a calibrated saturating map before neighbourhood aggregation. Per-channel scales are estimated on the clean training graph and frozen, anchoring saturation thresholds to typical clean messages. We prove that changes in a node’s aggregate scale with the total aggregation weight assigned to corrupted neighbours, and derive injection bounds under explicit degree conditions. Across five node-classification graphs with ten paired seeds (five on ogbn-arxiv), CBMP matches or exceeds GCN’s clean performance and consistently improves robustness over GCN to feature outliers and node injection. Under degree-targeted, feature-adaptive injection, it gains 4–66 percentage points over GCN and outperforms the GRB LayerNorm defence on both heterophilous graphs and ogbn-arxiv while matching it on the other two graphs. Ablations isolate the benefit of bounding each incoming message and normalising both streams. These results establish pre-aggregation message control as an effective design principle for robust graph learning.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Graph Neural Networks, Message Passing, Adversarial Robustness, Node Injection Attack, Bounded Message Function, Calibration

Reviews

Among:
Shape:
1234this paper, Bottom 2%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.33 over 3 reviews, above 2% of the others.
Reviewer_SERyOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes Calibrated Bounded Message Passing (CBMP), a graph neural network framework designed to improve robustness against anomalous features and node injection attacks. CBMP combines two-stream input normalization, bounded nonlinear message transformations, and clean-data-based calibration to limit the influence of corrupted neighbors before aggregation. The paper provides theoretical bounds on message perturbations and conduct extensive experiments on five node classification datasets to demonstrate improved robustness over existing baselines.

Critical strengths
  1. Extensive experimental evaluation. The paper conducts comprehensive experiments across five datasets under various feature corruption and node injection attacks. The authors also include numerous baselines and ablation studies to investigate the effectiveness of different components.

  2. Clear presentation and theoretical analysis. The paper is generally well-written and logically organized, with clear explanations of the motivation and proposed method.

Critical weaknesses
  1. The proposed CBMP consists of three core components: RMSNorm, an MLP with a tanh activation, and channel statistics derived from a graph used for "clean" training. None of these components are entirely novel in themselves. The primary innovation of the paper lies in combining them to constrain the magnitude of messages prior to their aggregation from neighboring nodes. However, a question arises: given that using tanh to achieve a bounded mapping is a straightforward and common design choice, why does this specific combination constitute a sufficiently significant algorithmic contribution?

  2. Although CBMP offers significant improvements over the original GCN, its advantage narrows considerably when compared against baseline models that employ robust normalization techniques. This raises the question: to what extent can these improvements be attributed to the proposed "bounded message mechanism"? Furthermore, the baselines used are not sufficiently up-to-date.

  3. Limited Methodological Novelty. The proposed CBMP primarily combines existing normalization techniques, a standard bounded nonlinear message function, and a calibration mechanism. Prior work has already explored bounded message functions before aggregation (e.g., Deep Tensor Neural Networks, 2017), normalization-based defenses against graph attacks (e.g., GRB, NeurIPS 2021), and robust neighborhood aggregation (e.g., Geisler et al., NeurIPS 2020). Although their specific formulations differ, the paper does not sufficiently clarify the fundamental novelty of CBMP beyond combining these established techniques. Moreover, the ablation results suggest that calibration provides limited or inconsistent improvements, further weakening the claimed methodological contribution.

Questions for authors

Please see the weakness.

1 comment
AuthorsOpenReview ↗

Point-by-Point Response to Reviewer SERy

We thank the reviewer. We agree with the premise of each weakness and revised the paper to claim only what the measurements support; please also see the general response.

W1. None of the three components is new; tanh⁡\tanh is a common way to bound a map. We agree. The introduction states that each part exists, and Section 2 names the prior uses:

  • a tanh⁡\tanh message in Deep Tensor Neural Networks;
  • the LayerNorm defence of GRB;
  • robust aggregation by Soft Median.

The contribution is a measured account of when a bounded message bounds anything and what it adds:

  1. When the bound is active. Without input normalisation, an unconstrained tanh⁡\tanh message keeps its layer-1 arguments in the linear range on four of five graphs (mean ∣z∣|z| 0.004–0.226; Table 7). Its bound is then inactive, and calibration or input normalisation is what activates it.
  2. Both streams must be normalised. CBMP minus the variant that normalises only the message stream is +3.5, +1.9, +2.8, +14.5, +5.1 points under targeted injection.
  3. Combination with robust aggregation. Under Soft Median, the bounded message adds to the aggregator on three graphs (Table 14).

W2. The advantage narrows against normalised baselines; how much is due to the bounded message? The factorial design (Table 3; intervals in Table 17) gives every cell its own tuning:

  • Input normalisation is the dominant factor: +5.7 to +57.1 points under targeted injection.
  • With input normalisation, the bounded message adds +4.5, +8.7, +0.4, +2.2, +0.4 points over a linear message with the same parameter count. The intervals include zero on Tolokers and ogbn-arxiv.
  • Against GCN + two-stream RMSNorm, CBMP is ahead on Amazon-ratings and Roman-empire, cannot be distinguished on ogbn-arxiv, and is behind on Tolokers and Computers (+3.7, +3.8, -1.8, -0.6, -0.1; §6.1, limitations).

Baselines not up to date.

  • GCORN (ICLR 2024). We added it with its official orthonormalisation routine, under the same tuning budget and attacks (Table 13). GCORN is designed for feature perturbations.
    • Under feature PGD, CBMP is ahead on Amazon-ratings, Roman-empire and ogbn-arxiv, and cannot be distinguished on Tolokers and Computers (CBMP minus GCORN: +1.0, +2.2, 0.0, +0.3, +1.3).
    • Under targeted injection, CBMP is ahead by +2.0 to +66.6 points.
    • With two-stream RMSNorm added, GCORN is ahead of CBMP on Tolokers and Computers (CBMP minus GCORN + RMSNorm: +1.5, +3.0, -2.9, -1.0, +6.0).
  • Other defences. EGNNGuard, FLAG and the official TDGIA attack of GRB run in the same shared scaffold (Table 12).
  • Not run. RUNG and AirGNN were not run in their original pipelines (Section 7).

W3. Novelty relative to DTNN, GRB and Soft Median; calibration gives limited or inconsistent improvements.

Relation to prior work. Section 2 states what differs from each:

  • DTNN passes a tanh⁡\tanh message, but nothing keeps that message in its saturating range.
  • GRB normalises the layer input, but the message remains linear in the normalised input.
  • Soft Median acts on the aggregate after the messages are formed.

Calibration. The reviewer is right, and the paper now says so directly.

  • With two-stream input normalisation, calibration adds no robustness. CBMP minus CBMP without calibration is -0.5, -6.5, +0.1, -0.6, +0.3 points under targeted injection. On Roman-empire, omitting calibration is better (-6.5 [-6.9,-6.0]), and validation accuracy is higher without it there too (+1.2 points).
  • Without input normalisation, calibration is what activates the bound. It raises targeted-injection accuracy by +8.7, +1.4, +56.7 and +4.7 points on Amazon-ratings, Tolokers, Computers and ogbn-arxiv. On Roman-empire it lowers it by -10.8 (Table 3).
  • The operating point explains the difference (Table 7).
layer-1 saturation (%)Amazon-r.Roman-e.TolokersComputersogbn-arxiv
uncalibrated, with input norm.28.240.025.310.614.2
CBMP4.12.51.71.53.9
uncalibrated, no input norm.0.05.00.80.00.0
  • What the table shows. With input normalisation, the uncalibrated message already saturates by itself. Without it, the message stays linear except on Roman-empire.
  • How the paper now presents calibration. It is the safeguard for unnormalised inputs and can be omitted under two-stream normalisation (Section 3, Section 6.2). The method and CBMP's numbers are unchanged.
Reviewer_1YHnOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper propose a new message passing design for MPNNs, aimed at improving robustness by explicitly bounding individual messages before neighborhood aggregation. They provide theoretical analysis showing how the bounded message can limit the influence of corrupted neighbors. They also conduct experiments under multiple attack settings and ablation studies.

Critical strengths

The main idea is simple and intuitive Their empirical study is extensive, where the authors evaluate across diverse datasets, baseline and ablation studies.

Critical weaknesses

1.The theory part (Prop1 and 2) mainly says with bounded message the aggregated out is also bounded. This reads more like formalizing obvious consequences of their chosen design, rather than providing a genuinely new insight.
2. The empirical study shows the strongest gains are against vanilla GCN which is a relatively weak base line, and the proposed method does not consistently demonstrate substantial gains simple normalization-based baselines such as GCN + RMSNorm or GRB LayerNorm.

Questions for authors

see weakness

1 comment
AuthorsOpenReview ↗

Point-by-Point Response to Reviewer 1YHn

We thank the reviewer. We agree with both points and changed the paper accordingly; please also see the general response.

W1. The propositions formalise obvious consequences of the design. We agree. Section 4 now calls them direct consequences of the design and does not count them as a contribution. What they add is a node-level quantity, Δi\Delta_i: the aggregation weight that node ii moves to or between neighbours under an injection. We tested whether Δi\Delta_i predicts more than the degree does (Appendix C, Table 4; specified in an amendment before the run). The target is the event "the final prediction of the test node changes". We use this end-to-end event because the layer-1 drift is bounded by BcΔiB_c\Delta_i by construction.

ROC-AUC under the optimised random-connection injection:

Δi\Delta_idegreeki/(Di+ki)k_i/(D_i+k_i) (post hoc)
CBMP, range over five graphs0.72–0.900.45–0.790.69–0.89

Reading:

  • Δi\Delta_i against the degree. Δi\Delta_i ranks the nodes better than the degree on every graph; the paired difference is +0.09–+0.27, and every interval lies above zero.
  • Where the advantage comes from. Most of it comes from where the injected edges attach. The share of injected neighbours, ki/(Di+ki)k_i/(D_i+k_i), is only +0.01–+0.03 AUC below Δi\Delta_i. We added this comparison after the pre-specified one.
  • Lowest-degree targets. Under the attack on the lowest-degree nodes, almost every test node is a target, and the two scores are close (-0.02–+0.03).
  • Message function. The ranking is the same for the linear message. Δi\Delta_i describes where a graph is exposed, not what the message function does.

A second test, of the decay rates. Proposition 2 predicts faster decay under mean normalisation than under symmetric normalisation. CBMP with mean aggregation, tuned separately, loses less under targeted injection on Tolokers, Computers and ogbn-arxiv, and more on Amazon-ratings and Roman-empire: loss difference +2.0, +9.9, -6.0, -1.3, -2.6 (Table 13). The prediction therefore holds on three graphs, which we report as such.

W2. The strongest gains are over plain GCN; no consistent gain over GCN + RMSNorm or GRB LayerNorm. We agree. §6.1 and the limitations now state, graph by graph, where CBMP is ahead, cannot be distinguished, or is behind. Under targeted injection, CBMP minus the baseline (paired 95% intervals; Holm-corrected tests in Table 20):

Amazon-r.Roman-e.TolokersComputersogbn-arxiv
GCN + two-stream RMSNorm+3.7 [2.2,5.2]+3.8 [3.3,4.3]-1.8 [-2.6,-1.0]-0.6 [-0.9,-0.3]-0.1 [-0.5,0.3]
GRB LayerNorm+4.8 [3.4,6.0]+4.8 [4.1,5.6]-0.4 [-1.3,0.5]-0.5 [-1.4,0.5]+1.0 [0.3,1.6]

What the results show:

  • Where the robustness comes from. The factorial design attributes most of it to the input normalisation that CBMP shares with these baselines (+5.7 to +57.1 points; Table 3).
  • What the bounded message adds. It adds on Amazon-ratings and Roman-empire. On Roman-empire, no interpolation between the normalised GCN and a graph-free MLP is both more accurate and more robust than CBMP (Figure 2). On Tolokers and Computers, CBMP is below that frontier.
  • Scaling corruption. Under feature scaling, the normalised baselines are as stable as CBMP or more so. Prediction-flip rates are 0.4–2.6% for GCN + two-stream RMSNorm and 0.0–0.1% for GRB LayerNorm, against 0.5–5.0% for CBMP (Table 18).
  • A stronger normalised baseline. GCORN with two-stream RMSNorm is ahead of CBMP on Tolokers and Computers (CBMP minus GCORN + RMSNorm: +1.5, +3.0, -2.9, -1.0, +6.0; Table 13).

The abstract, §6.1 and the limitations now present these results without the claim of a consistent gain.

Reviewer_9pkYOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes Calibrated Bounded Message Passing (CBMP), a GNN layer designed to reduce the influence of poisoned neighbours. CBMP combines input normalisation on both message and residual streams with a saturating message function applied before aggregation. Per-channel statistics estimated on the clean graph calibrate the saturation regime and remain frozen during inference and attacks. The authors derive single-layer influence bounds relating perturbations to the aggregation weight assigned to corrupted neighbours. Experiments on five node-classification datasets show improved robustness over standard GCN under feature corruption and adaptive node injection while largely preserving clean performance.

Critical strengths
  1. The paper provides single-layer influence bounds connecting message perturbations to the aggregation weight assigned to corrupted neighbours. The analysis also highlights degree-dependent vulnerability under node injection, giving a clear interpretation of the proposed design and its limitations.
  2. Experiments cover five datasets, multiple random seeds, and both random corruptions and adaptive attacks. Comparisons with normalisation-based defences, component ablations, and computational profiling help assess both the sources of robustness gains and their practical cost.
Critical weaknesses
  1. Formatting and writing. The paper clearly departs from explicit ICLR 2027 format: the title, abstract heading, and section headings use ordinary mixed case rather than the prescribed small caps. The AC should assess whether these formatting deviations are acceptable. Beyond formatting, excessively small tables, densely compressed proofs, and an appendix mixing historical variants with final results substantially hinder understanding and verification.
  2. Limited novelty. CBMP combines standard input normalization and a saturating message MLP with a calibration scheme. Section 3 explicitly states that calibration folds into the projection at inference without changing the function class.
  3. Proposition 2 seems incorrect. Equation (1) includes a message bias, but the injection proof bounds the absolute message using a constant that only bounds its centered component. Under symmetric normalization, injection changes aggregation-weight sums, so the bias does not cancel.
  4. Section 6.2 claims that removing calibration changes targeted-injection performance by at most 0.4 points, whereas Table 2 shows a 4.7-point difference on arxiv. Table 27 reports only a 0.2-point difference under the family hyperparameters, showing that the headline comparison does not isolate calibration from tuning. Moreover, Section 3 describes calibration before the gradient update, while Appendix H specifies the reverse order. These discrepancies require reconciliation before the component-level conclusions can be trusted.
  5. The added value over simple baselines is unclear. In Table 1, GCN with dual-stream RMSNorm achieves higher mean targeted-injection performance than CBMP on Tolokers, Computers, and arxiv. A graph-free MLP also exceeds CBMP on three datasets and approximately matches it on Computers. Although CBMP improves over normalized GCN on the two heterophilous graphs, these results limit the generality of its advantage and leave the practical value of the additional mechanisms insufficiently justified.
Questions for authors

Robust GNNs seem to face a recurring trade-off between benefiting from graph information and avoiding harmful propagation. How can we tell whether CBMP improves the clean–robustness Pareto frontier over MLP and normalized GCN, rather than simply choosing a different operating point? How should this comparison account for different attack strengths?

I am still not fully clear on CBMP’s intuitive advantage over methods that adaptively downweight unreliable neighbors. Could the authors explain when bounding messages should work better, and whether the two approaches might complement each other?

3 comments
AuthorsOpenReview ↗

(1/2)Point-by-Point Response to Reviewer 9pkY

We thank the reviewer for a careful reading. The revision fixed the points in the comments. Changed text is in blue; please also see the general response.

W1. Formatting, small tables, dense proofs, historical variants in the appendix. We agree, and all four are fixed.

  • Style. The PDF is built with pdfLaTeX and the unmodified iclr2027_conference.sty, so the title and headings are in small caps.
  • Table size. Table 1 and Table 2 are set at 7 pt (pp. 6–7). Every appendix table is re-stacked by dataset at 7 pt or larger.
  • Proofs. They are written as numbered steps, one relation per step (Appendix A).
  • Historical variants. Every appendix result is now computed on the current checkpoints. The one exception is the operating-point intervention of Appendix H, which is labelled as using submitted-version checkpoints. The other submitted-version tables and figures (per-family hyper-parameters, earlier attack versions, synthetic controls) are in the supplementary material, Section S9. Table 8 lists one hyper-parameter row per model.

W2. Limited novelty; calibration folds into the projection. We agree that the three components exist separately; the introduction now says so. We also agree that calibration does not change the function class, and Section 3 states it.

What the paper now claims is what the measurements show:

  1. An unconstrained tanh⁡\tanh message stays linear in practice when the input is not normalised (Table 7).
  2. Both streams must be normalised. CBMP minus the variant that normalises only the message stream is +3.5, +1.9, +2.8, +14.5, +5.1 points under targeted injection.
  3. Bounded messages combine with Soft Median aggregation (Table 14).
  4. The weight term of Proposition 2 ranks the nodes whose prediction an injection changes (Table 4).

W3. Proposition 2. The reviewer is right: the submitted statement is false when the message has a bias and the normalisation is symmetric.

  • Correction. The corrected bound adds ∣bc∣ ∣si′−si∣|b_c|\,|s'_i-s_i| (Eq. 2, Section 4).
  • Proof. It is written in numbered steps, and a three-node example violates the uncorrected statement (Appendix A).
  • Check on trained checkpoints. Across 52 million node–channel pairs under the optimised injections, the corrected bound is violated 0 times (Table 5).

W4. §6.2 versus Table 2, "Table 27", and the order of calibration. The reviewer is right on all three points.

Cause. The discrepancy came from ablation variants that inherited their family's hyper-parameters. Table 27 of the submission, the full ablation with those inherited values, is replaced by Table 19, in which every row has its own tuning.

What changed. Every variant now has its own 12-trial validation search (Table 8), and every number in Section 6.2 is generated from the run records.

The calibration result, which we now state directly:

  • With two-stream input normalisation. CBMP minus CBMP without calibration is -0.5, -6.5, +0.1, -0.6, +0.3 points under targeted injection (Amazon-ratings to ogbn-arxiv; Table 2). Calibration adds no robustness. On Roman-empire, omitting it is better (-6.5 [-6.9,-6.0]), and validation accuracy is also higher without it there (+1.2 points).
  • Without input normalisation. Calibration raises targeted-injection accuracy by +8.7, +1.4, +56.7 and +4.7 points on Amazon-ratings, Tolokers, Computers and ogbn-arxiv. It lowers it by -10.8 on Roman-empire (Table 3).
  • Why. The operating-point measurement of Table 7 explains the difference. Without normalisation, an uncalibrated tanh⁡\tanh message stays in its linear range on four graphs. With normalisation it leaves that range by itself (layer-1 saturation 10.6–40.0%).
  • Positioning. Calibration is now presented as the safeguard for unnormalised inputs, which can be omitted under two-stream normalisation.

Order of calibration. The calibration order is now the same in §3, the pseudo-code (Appendix E; Appendix H of the submission) and the code. Each epoch takes the gradient step first, then the calibration pass, which also produces the validation metric.

W5. Value over simple baselines. We agree that the gain is graph-dependent. §6.1 and the limitations now state it per graph. Under targeted injection, CBMP minus the baseline:

Amazon-r.Roman-e.TolokersComputersogbn-arxiv
GCN + two-stream RMSNorm+3.7 [2.2,5.2]+3.8 [3.3,4.3]-1.8 [-2.6,-1.0]-0.6 [-0.9,-0.3]-0.1 [-0.5,0.3]
graph-free MLP-13.8 [-14.7,-12.9]-7.2 [-7.6,-6.6]-6.8 [-7.7,-6.0]-0.2 [-0.7,0.2]+0.8 [0.5,1.1]
  • Against GCN + two-stream RMSNorm, CBMP is ahead on Amazon-ratings and Roman-empire, cannot be distinguished on ogbn-arxiv, and is behind on Tolokers and Computers.
  • It is also behind on Minesweeper (-1.5 [-2.7,-0.5]).
  • The MLP is more robust than every message-passing model on Amazon-ratings, Roman-empire and Tolokers.

Holm-corrected tests are in Table 20.

AuthorsOpenReview ↗

(2/2)Point-by-Point Response to Reviewer 9pkY

Q1. Does CBMP improve the clean–robust Pareto frontier, and how at different attack strengths?

How we test it. We interpolate the logits, α fMLP+(1−α) fGCN+RMSNorm\alpha\,f_{\rm MLP}+(1-\alpha)\,f_{\rm GCN+RMSNorm}, and attack each interpolation as one model. We then measure CBMP's vertical distance to the family's upper envelope at CBMP's clean accuracy. This is done at 12 attack strengths, 6 on ogbn-arxiv (Figure 2, p. 9; all strengths in Figure 4–Figure 6).

Results by graph:

  • Roman-empire. No interpolation is both more accurate and more robust than CBMP. Members with α≥0.6\alpha\ge0.6 are more robust, but less accurate. CBMP's clean accuracy lies outside the family's range, so the envelope there is extrapolated, and its distance to a family that could reach that accuracy is not measured. The distance to the extrapolated envelope is +1.8 to +3.5 points.
  • Amazon-ratings. CBMP cannot be distinguished from the frontier at any strength (+0.5 to +2.1).
  • ogbn-arxiv. CBMP is above the frontier at 2 of 6 strengths and cannot be distinguished from it at the other 4. Its envelope is extrapolated as well.
  • Tolokers and Computers. CBMP is below the frontier (-2.1 to -0.8 and -4.4 to -0.3).

Robustness to the attack itself (Appendix G):

  • With gradient-guided connections, the targeted attack is 8.0–9.2 points stronger on Tolokers. CBMP's lead over GCN + two-stream RMSNorm on Amazon-ratings shrinks from +3.7 to +2.4 points (Table 9).
  • Without a tolerance, which we added after seeing the results, the order of the four main models is unchanged in 13 of 14 (graph, attack-variant) cases.

Q2. When should bounding work better than adaptive down-weighting, and do they complement each other?

When each one works. Down-weighting works when corrupted neighbours look different from clean ones. A bound caps what any single neighbour can contribute, whatever it looks like, but cannot reduce the number of corrupted neighbours. In the bound 2Bc∑j∈Saij2B_c\sum_{j\in S}a_{ij} (Proposition 1), bounding acts on BcB_c and down-weighting on the corrupted weight (Section 2).

Do they complement each other?

  • Under targeted injection, the Soft Median version is ahead of CBMP on four graphs and the pruned version on all five. CBMP minus combination is -6.2, -0.6, -3.0, -2.8, -2.8 with Soft Median and -8.9, -4.6, -3.5, -2.3, -6.1 with pruning (Table 14).
  • Under Soft Median. Matched controls replace the bounded message by a linear one with the same aggregator, normalisation and size. Under Soft Median, the bounded message is ahead on Amazon-ratings, Roman-empire and Computers (bounded minus linear: +2.9, +2.3, -0.6, +0.9, -1.6). The two mechanisms add up only on Amazon-ratings and Computers, where the combination is ahead of both of its parts.
  • Under pruning, the gain comes from the pruning. The bounded message is never ahead of the linear one under pruning (+0.5, +0.9, -1.6, -1.8, -0.1). The pruned combination also loses clean accuracy on Roman-empire: CBMP minus it is +11.5 points.
  • Limitation. Both filters were attacked only through transfer from an unfiltered copy; no attack optimised against the filter itself (Section 7).

Thank you for the response. However, as shown in the revised PDF, this work would require significant revisions, and I do not believe it can be accepted at this stage. Therefore, I will maintain my score.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response to all reviewers and the AC

We thank the reviewers for detailed and fair reviews. They agreed on three concerns: the novelty of the components, the margin over normalised baselines, and the role of calibration. We have revised the paper; changed text is in blue in the revised PDF. Below we explain what changed and why.

1. The method did not change; some numbers did, because tuning is now matched.

  • In the submission, several ablation variants inherited the hyper-parameters of their model family.
  • In the revision, every model and every ablation variant has its own 12-trial, validation-only search (Table 8), and every model is attacked with the same protocol (true gradient, straight-through and transfer modes).
  • CBMP itself, its checkpoints and its row in Table 1 are identical to the submission.
  • Ablation numbers moved, and the calibration conclusion of the submitted §6.2 no longer held. Point 2 explains what replaces it.

2. The role of calibration changed, and we report it directly.

  • Without input normalisation, calibration is what activates the bound. An uncalibrated tanh⁡\tanh message keeps its layer-1 arguments in the linear range on four of five graphs (mean ∣z∣|z| 0.004–0.226; Table 7). Calibration raises targeted-injection accuracy there by +8.7, +1.4, +56.7 and +4.7 points (Amazon-ratings, Tolokers, Computers, ogbn-arxiv). It lowers it by -10.8 on Roman-empire (Table 3).
  • With two-stream input normalisation, calibration adds no robustness. The uncalibrated message already leaves its linear range (layer-1 saturation 10.6–40.0%, against 1.5–4.1% for CBMP). CBMP minus CBMP without calibration is -0.5, -6.5, +0.1, -0.6, +0.3 points under targeted injection. On Roman-empire, omitting calibration is better (-6.5 [-6.9,-6.0]), and the validation split points the same way (validation accuracy +1.2 points higher without calibration).
  • The paper now presents calibration as the safeguard for unnormalised inputs, which can be omitted under two-stream normalisation (Section 3, Section 6.2, introduction, conclusion).

3. Comparisons with the strongest simple baseline are stated per graph. Under targeted injection, CBMP minus GCN with two-stream RMSNorm:

Amazon-ratingsRoman-empireTolokersComputersogbn-arxiv
+3.7 [2.2,5.2]+3.8 [3.3,4.3]-1.8 [-2.6,-1.0]-0.6 [-0.9,-0.3]-0.1 [-0.5,0.3]

CBMP is ahead on two graphs, cannot be distinguished on one, and is behind on two. It is also behind on Minesweeper (-1.5 [-2.7,-0.5]), and the graph-free MLP is more robust than every message-passing model on three graphs. Section 6.1, Section 6.3 and Section 7 say so.

New experiments in the revision. Each was specified before it ran. The factorial design, the frontier, FLAG, EGNNGuard and TDGIA are in the first-round protocol (protocol/REV5_PROTOCOL.yaml, protocol/REV5_AMENDMENTS.md); the other experiments are in protocol/REV7_AMENDMENTS.md. All three files are in the supplementary archive.

  • Factorial design over input normalisation × bounded message × calibration, every cell tuned separately: Table 3, Table 17.
  • Operating point of the tanh⁡\tanh message with and without normalisation and calibration: Table 7.
  • Clean–robust frontier against logit interpolations of the normalised GCN and a graph-free MLP, at 12 attack strengths (6 on ogbn-arxiv): Figure 2, Figure 4–Figure 6.
  • Attack-strength checks repeated on the current checkpoints (gradient-guided connections, a higher per-target cap, 200-step PGD with a margin objective): Appendix G, Table 9.
  • Matched controls for combining bounded messages with Soft Median or similarity pruning: Table 14.
  • Newer baselines: GCORN (ICLR 2024; alone and with two-stream RMSNorm), EGNNGuard, FLAG, and the official TDGIA attack of GRB: Table 12, Table 13.
  • Node-level test of Proposition 2 (does its weight term predict which nodes change their prediction?): Appendix C, Table 4.
  • CBMP with mean aggregation, a test of the decay rate that Proposition 2 predicts: Table 13.

Other changes.

  • Formatting: pdfLaTeX with the official style file, so the title and headings are in small caps; all table text at 7 pt or larger.
  • Proposition 2 corrected with a bias term, and the proofs written as numbered steps (Appendix A).
  • Every appendix result now uses the current checkpoints. The one exception is Appendix H, which is labelled as using submitted-version checkpoints. Other submitted-version material is in the supplementary material (Section S9).
  • Paired differences with Holm-corrected p-values: Table 20, Table 21.
  • Blue text marks every passage that is new or changed relative to the submission.

What we did not do.

  • No attack was run that optimises against the neighbour filters; the filter rows were attacked through transfer.
  • RUNG and AirGNN were not run in their original pipelines.

Both points are stated in Section 7.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.