acceptodds
Under review as a conference paper at ICLR 2027

RGSM-GP: Reliability-Guided Semantic Memory for Iterative Graph Purification under Structural Attacks

Abstract

Iterative graph purification can repair adversarial edge perturbations before classification, but it typically reuses the same node-feature conditioning at every round. As connectivity changes, fixed feature conditioning cannot incorporate the semantic evidence exposed by progressively repaired neighborhoods. This paper introduces Reliability-Guided Semantic Memory for Graph Purification (RGSM-GP), which augments iterative graph purification with a semantic state that evolves across rounds. The method estimates classifier-free node reliability from structural correction residuals, edge-posterior uncertainty, and temporal instability across purification rounds. A budget-normalized soft gate limits updates to unreliable candidates, while reliability-weighted neighborhoods supply the replacement context. The updated memory conditions the next structural step, while raw features remain fixed anchors for training and final prediction. Under a common multi-seed evaluation pipeline on Cora, Citeseer, and PubMed, RGSM-GP attains the highest robust-average point estimate in six of six PRBCD/LRBCD settings among GPR-GAE, AT-GCN, RUNG, and GNNGuard, and also ranks first at the 50% perturbation budget in five settings. In the direct multi-seed comparison with baselines, all six completed robust-average differences favor RGSM-GP, including an improvement of 5.94 percentage points on Cora under PRBCD.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Graph Neural Networks, Graph Representation Learning, Graph Purification, Adversarial Robustness

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_a9ZhOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes Reliability-Guided Semantic Memory for Graph Purification (RGSM-GP), a framework for defending graph neural networks against structural adversarial attacks. Building on the iterative GPR-GAE purifier, RGSM-GP introduces evolving semantic memory to replace fixed feature conditioning across purification rounds. Node unreliability is estimated from structural correction residuals, edge-posterior uncertainty, and temporal instability. Candidate screening and budget-normalized soft gating determine which semantic states are updated, while reliability-weighted neighborhood aggregation provides update information. The updated memory subsequently guides structural purification and contributes to final prediction through bounded feature fusion. Experiments on Cora, Citeseer, and PubMed under PRBCD and LRBCD attacks compare RGSM-GP with four defenses. The reported results show the highest robust-average accuracy point estimates in all attack settings.

Critical strengths
  1. The paper identifies a meaningful limitation of iterative graph purification. While the adjacency structure is progressively refined, conventional methods may continue using unchanged feature conditioning. Introducing semantic feedback across purification rounds provides a reasonable way to exploit information from the evolving neighborhood structure.

  2. The experimental protocol makes a useful effort toward robust evaluation. Attacks are generated separately for each defense rather than simply transferred from another model.

  3. The paper is well-written and easy to follow.

Critical weaknesses
  1. The semantic branch is trained to reconstruct the original node features using cosine similarity, while the preservation loss penalizes deviations from those same features. Since the memory is initialized as Xp0=XX_p^0=X, an identity mapping that leaves memory unchanged could minimize both semantic objectives without learning to repair corrupted neighborhood information. It is therefore unclear what prevents the semantic network from learning to preserve raw features rather than extracting newly available reliable context.

  2. The semantic network is trained using a single update from the original features, with zero initial temporal instability. However, inference repeatedly feeds modified semantic memory into the structural purifier, and the reliability score depends partly on changes across previous rounds. In addition, gradients from the semantic objectives are detached from the structural purifier. Thus, it seems that the model is not explicitly optimized for the multi-round feedback behavior that constitutes its main contribution.

  3. The proposed unreliability score combines structural residuals, edge uncertainty, and temporal instability. However, substantial structural changes do not necessarily imply that a node’s semantic representation is corrupted. The reported touched-node ROC-AUC just measures agreement with attack-affected nodes, not the ability to identify semantically corrupted representations. A more direct evaluation could measure whether estimated reliability correlates with representation deviations or actual improvement after semantic updates.

  4. The experiments use only 3 very classical graph datasets: Cora, Citeseer, and PubMed, all of which are citation networks with predominantly homophilic characteristics. No heterophilic, substantially larger, or inductive graph benchmarks are considered. In addition, robustness is evaluated only under PRBCD and LRBCD. While these are meaningful attacks, it remains unclear whether the proposed reliability signals and semantic memory behave similarly on graphs with different structural or feature distributions.

Questions for authors

Please response to my mentioned weaknesses, and add more types of datasets or large-scale datasets for more comprehensive model analysis.

2 comments

Response to Q1

Purified edge weights and neighbor reliability jointly determine the weights for neighborhood aggregation, guiding the network toward using reliable context. However, this does not guarantee that the network will use such context. We therefore empirically test whether the trained network relies on context and whether semantic updates improve prediction performance.

To test whether the network merely copies its input, we shuffled only the node–context correspondence, keeping all else fixed. Relative changes in first-round candidates (Euclidean distance divided by the pre-shuffle candidate norm) were 31.64%±2.80%/34.70%±0.43% on Cora/Citeseer (mean±SD across seeds). This shows that the network uses context. With structure and classification fusion weights fixed, first-round semantic updates improved test accuracy by 0.366/0.697 percentage points, respectively, compared with no update. This supports context use and first-round prediction gains.

Response to Q2

Training does not explicitly optimize the full feedback trajectory, consistent with our modular design. The structural loss trains the purifier. Reconstruction and preservation losses train the local semantic candidate generator with original features as fixed targets. Semantic gradients do not update the purifier. This retains each module's objective and avoids multi-round unrolling costs. At inference, memory conditions the next purification round without updating purifier parameters.

The rationale for multi-round inference is: updated memory informs the next structure estimate; new edge weights, reliability, and context then inform semantic updates. Each round performs the same local task: generating candidates from memory and reliable context. Thus, the same network can use new feedback. Single-step training learns a local mapping; multi-round inference uses new states arising from its interaction with structural purification.

In the paper's repeated paired ablations, we retained memory updates and final feature fusion but stopped feeding updated memory into the next purification round. Disabling this feedback reduced robust average accuracy by 2.00/2.48 percentage points on Cora/Citeseer. This supports the benefit of multi-round feedback under the current training scheme in the evaluated settings.

Response to Q3

We agree that touched-node ROC-AUC measures score alignment with attack-affected nodes, but cannot establish its relation to representation deviation. We therefore added paired clean/perturbed graph experiments.

Using the same trained model and the actual classification fusion scheme, we extracted classifier hidden representations before the first semantic update. Deviation is the cosine distance between the same node's representations on clean and perturbed graphs. Clean graphs are used only for post-hoc evaluation, not for updates or node selection on perturbed graphs. Spearman correlations between scores and deviations on Cora/Citeseer were 0.631±0.023/0.468±0.055 for all nodes and 0.688±0.049/0.401±0.061 for test nodes (mean±SD over three seeds; positive for every seed). Higher scores thus generally correspond to larger representation deviations, supporting an association.

Response to Q4

We added Chameleon-filtered, a heterophilic Wikipedia link network with duplicate nodes removed. It has 890 nodes, 2,325 features, and 5 classes. It tests reliable aggregation in a non-citation network where neighbors may have different classes.

We reevaluated all five methods under PRBCD/LRBCD using the official splits for three seeds. Splits, attack-budget definitions, evaluation loss, and attack iteration settings were shared across methods. Tables report mean±sample SD over three runs. Robust average accuracy excludes clean graphs.

Chameleon-filtered — PRBCD

MethodClean10%25%50%Robust avg.
AT-GCN36.71±1.2412.72±5.402.96±2.360.39±0.345.36±2.66
RUNG39.05±1.7416.13±2.098.25±3.564.27±1.039.55±2.12
GNNGuard36.09±4.7923.63±2.8315.43±2.3310.55±4.2016.53±1.78
GPR-GAE37.40±1.6128.69±3.1327.28±1.7226.78±2.2527.58±2.29
RGSM-GP37.07±1.9332.59±0.9130.12±1.6728.66±1.2430.46±0.38

Chameleon-filtered — LRBCD

MethodClean10%25%50%Robust avg.
AT-GCN39.06±3.2921.53±1.7815.14±2.417.88±2.9114.85±0.91
RUNG39.05±1.7425.80±1.8118.84±5.3417.27±5.4820.64±3.86
GNNGuard36.09±4.7920.09±3.3017.36±1.6717.77±2.4418.40±2.45
GPR-GAE37.04±1.9131.58±3.1330.68±1.9729.53±2.0830.59±2.32
RGSM-GP39.27±1.6835.42±3.3634.01±2.3333.08±1.6634.17±2.41

RGSM-GP leads in robust average accuracy and mean accuracy at every nonzero budget under both attacks. This supports its effectiveness beyond the original citation datasets, on this heterophilic web network.

We will clarify these points in the revision. Thank you for your valuable comments.

Thanks for the reply. The authors’ responses and additional experiments have addressed most of my earlier concerns. The context-shuffling experiment and the feedback ablation provide more convincing evidence that the model uses contextual information and benefits from multi-round feedback. The added analysis relating reliability-related scores to representation deviations also provides a more direct justification for the scoring mechanism. Furthermore, the results on Chameleon-filtered strengthen the empirical evaluation by extending it beyond citation networks to a heterophilic graph. These additions improve my confidence in the proposed method, and I have increased my score accordingly.

Reviewer_UoBNOpenReview ↗
Rating
4
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies graph purification under structural attacks, focusing on how progressively improved neighborhood information can guide subsequent refinement. The proposed RGSM-GP incorporates semantic memory into the iterative purification process and selectively updates it according to node reliability. This allows structural and semantic information to interact while retaining the original features as a fixed reference. The experimental results and ablation studies support the effectiveness of this design in the evaluated settings.

Critical strengths

S1. Reliability estimation without clean-graph or classifier supervision. RGSM-GP uses signals from the purification process to guide semantic memory updates without access to the clean graph, attack locations, node labels, or classifier confidence. This allows the method to select nodes for refinement using information available at defense time, while keeping reliability estimation independent of the downstream classifier.

S2. Clear motivation and a well-matched design. The paper addresses the mismatch between evolving graph structure and fixed feature conditioning. Maintaining semantic memory across purification rounds allows subsequent structural updates to use information from progressively refined neighborhoods.

S3. Selective memory updates with explicit constraints. The method selects candidate nodes for memory updates and uses a budget-normalized soft gate to assign their update weights. It keeps the original features unchanged and limits the weight of semantic memory in the final classifier input. This design provides clear control over how updated semantic information enters the purification and prediction process.

Critical weaknesses

W1.Evidence for applicability across purification frameworks remains limited. The current evaluation uses only one underlying purification model, so applicability to other purification frameworks remains unverified. Additional experiments with different purification frameworks would help assess the generality of the approach. Alternatively, the corresponding claims should be narrowed.

W2.The additional computational and memory costs are insufficiently quantified. Compared with the underlying purification framework, the method maintains and updates semantic memory across rounds and introduces reliability estimation and neighborhood aggregation. These operations may increase inference time and memory usage. Reporting runtime and peak memory consumption under the same hardware and inference settings would help readers assess the trade-off between performance gains and additional costs.

Questions for authors

Q1.What evidence supports the method’s effectiveness across different purification frameworks? If evaluation is limited to the current framework, the corresponding claims should be narrowed accordingly.

Q2.How much additional inference time and peak memory usage are required when the semantic memory module is added to the underlying purification framework under identical hardware and inference settings?

1 comment

Response to Question 1

We thank the reviewer for highlighting the limited evidence for applicability across purification frameworks. Our method builds on GPR-GAE, a variant of the graph autoencoder (GAE) framework. It introduces reliability-guided semantic memory and feedback across rounds into structural purification. All current experiments use GPR-GAE; we have not evaluated the method across frameworks. Thus, our results support its effectiveness in this specific implementation, but do not establish its effectiveness in other purification frameworks.

We see potential for extending this mechanism. The idea is to update semantic memory using reliability signals from purification and use it for subsequent structural refinement. This idea is not necessarily limited to the specific encoder architecture of GPR-GAE. However, the current implementation requires the underlying purifier to provide comparable structural updates across rounds, edge predictions with a probabilistic interpretation, and a feature input interface that allows semantic memory to inform subsequent purification. Integration with methods meeting these conditions could be explored. Other methods may require changes to reliability estimation or feedback. These are only potential directions for extension. They cannot replace experiments across frameworks to verify actual effectiveness.

We accept the reviewer's suggestion to narrow our applicability claims. In the revision, we will explicitly limit the validated effectiveness to the GPR-GAE-based implementation. We will acknowledge the lack of experimental evidence across frameworks in the limitations discussion and identify adaptation and validation in other frameworks as future work.

Response to Question 2

We thank the reviewer for noting the insufficient quantification of computational and memory overhead. We agree that predictive performance alone does not fully reflect the benefits and costs of semantic memory. To quantify the additional overhead, we compared the base purification model, GPR-GAE, with the full method, RGSM-GP, using the same hardware and matched inference settings.

We used an NVIDIA RTX 4090 GPU, PyTorch 2.8.0, and CUDA 12.6. Both methods used the same fixed input graphs for Cora, Citeseer, and PubMed. Each dataset was evaluated with 3 random seeds and three nonzero perturbation budgets: 0.1, 0.25, and 0.5. For each condition, we performed 5 warm-up runs followed by 20 measurement runs, with GPU synchronization at the start and end of timing. Measurements covered graph purification and classification inference, excluding training, attack generation, and data loading. Both methods retained their normal stopping rules, and we recorded the actual number of iterations. The results therefore reflect the overhead of the full inference pipeline, including possible differences in the number of rounds before stopping.

Inference time is the mean of the average runtimes for individual conditions. Peak GPU memory is the mean of the measured peaks for individual conditions.

DatasetGPR-GAE inference timeRGSM-GP inference timeAdditional time (increase)GPR-GAE peak GPU memoryRGSM-GP peak GPU memoryAdditional GPU memory
Cora42.38 ms49.97 ms+7.59 ms (17.9%)84.41 MiB167.50 MiB+83.09 MiB
Citeseer36.28 ms49.93 ms+13.65 ms (37.6%)129.68 MiB497.28 MiB+367.60 MiB
PubMed162.97 ms186.22 ms+23.25 ms (14.3%)446.01 MiB600.80 MiB+154.79 MiB

The relative runtime increase is calculated as (RGSM-GP mean runtime / GPR-GAE mean runtime) - 1. GPU memory refers to peak allocated GPU memory recorded by PyTorch. It excludes CPU memory, GPU memory used by other processes, and the training and attack-generation overhead of the full experimental workflow.

These measurements show that operations such as semantic memory, reliability estimation, and neighborhood aggregation require additional inference resources. The increases vary by dataset. Citeseer shows a relatively pronounced runtime increase and additional GPU memory usage, so we do not consider these costs negligible. These results quantify overhead only for the current hardware and test settings. They do not imply the same relative runtime increase on other devices or under other workloads.

In the revision, we will add these comparison results, the measurement scope, and the definitions of the reported statistics. We will also discuss the benefits and resource costs alongside the existing predictive performance results to help readers assess the method's practical applicability.

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

This paper studies graph purification under structural attacks and proposes Reliability-Guided Semantic Memory for Graph Purification (RGSM-GP). Building on GPR-GAE, an enhanced variant of GAE, the method introduces an evolving semantic state into iterative structural purification. It estimates node reliability using structural correction residuals, edge-posterior uncertainty, and changes across purification rounds. Candidate screening, a budget-normalized soft gate, and reliability-weighted neighborhood aggregation jointly control memory updates. The updated memory conditions subsequent structural purification and is incorporated into final classification through bounded fusion. Experiments on Cora, Citeseer, and PubMed under PRBCD and LRBCD report the highest robust-average accuracy point estimates across all six dataset–attack settings, with the largest improvement on Cora under PRBCD. Paired ablations examine the contributions of temporal instability, gating, and semantic feedback.

Critical strengths

S1. The motivation is clear, and the design addresses the stated problem. As purification changes the graph structure, the available neighborhood information also changes. Maintaining semantic memory across rounds provides a reasonable way for subsequent structural updates to exploit progressively refined neighborhoods. Retaining raw features as fixed anchors, while controlling memory-update strength and final fusion, also reflects a thoughtful balance between revising semantic information and preserving the original observations. S2. The empirical results are promising, particularly under PRBCD. In Table 1, RGSM-GP improves robust-average accuracy over GPR-GAE from 66.99% to 72.93% on Cora and from 62.46% to 65.34% on Citeseer under PRBCD. Some advantages become larger at higher attack budgets. The main experiments report results across multiple random seeds with standard deviations, while Table 2 provides confidence intervals from 11 paired runs. These results support the method’s effectiveness within the evaluated settings.

Critical weaknesses

W1. The role of raw-feature anchoring in constraining multi-round semantic updates needs further explanation. The method retains raw features, bounds update coefficients, and limits final fusion to reduce the risk of semantic drift. However, the proposal in Eq. (5) is produced by an MLP whose output magnitude is not explicitly bounded. Bounded update coefficients therefore do not directly imply bounded memory displacement from the original features. Furthermore, anchoring in Eqs. (1) and (6) acts on the purifier and classifier inputs, respectively, rather than directly pulling the internal memory back toward the original features. The paper acknowledges that update coefficients do not measure actual feature displacement, but does not fully explain the protection provided by each constraint over repeated updates. A conditional explanation based on the update equations would clarify the role and limitations of raw-feature anchoring. W2. The connection between single-step reconstruction training and multi-round semantic updates is insufficiently explained. According to Section 4.4, semantic training starts from the original features and uses those same features as reconstruction targets, whereas inference repeatedly applies the network to evolving memory states. This is a simple design consistent with preserving observed information. However, the paper does not sufficiently explain how neighborhood context contributes useful updates when the target node’s own features are already provided as input, or why single-step training is suitable for repeated application. The roles of the reconstruction objective, architectural bottleneck, and preservation term should be clarified.

Questions for authors

Q1. Under what conditions can the bounded update coefficients in Eq. (5), together with raw-feature anchoring in Eqs. (1) and (6), control accumulated semantic-memory drift across rounds? Please distinguish their effects on update magnitude and state stability. Q2. When the semantic network receives both the target node’s original features and neighborhood context while reconstructing the original features, what role is the neighborhood branch intended to play? How do the existing objective and architecture support the transition from single-step training to multi-round inference? Q3. The temporal-instability term in Eq. (2) compares base scores normalized separately at each round. How should the combined effects of local-state changes and changing graph-wide normalization ranges be understood? Would it be more appropriate to interpret this term as a change in a node’s relative reliability score?

1 comment

Thank you for these questions. We will clarify the following in the revision.

Q1

Eq. (5) controls the fraction of movement from memory toward the network-generated candidate. For fixed memory and candidate vectors, smaller coefficients reduce updates. Yet distant vectors can still yield large changes. Limiting the update fraction differs from controlling accumulated deviation.

A sufficient condition is a uniform bound across inference rounds: ∣x~i(t)−Xi∣2≤Ri\\|\widetilde{x}_i^{(t)}-X_i\\|_2\le R_i. Since memory is initialized at XiX_i and each update is a convex combination,

∣xp,i(T)−Xi∣2≤Ri[1−∏t=0T−1(1−ηi(t))]≤Ri.\\|x_{p,i}^{(T)}-X_i\\|_2\le R_i\left[1-\prod_{t=0}^{T-1}(1-\eta_i^{(t)})\right]\le R_i.

Memory deviation stays within this bound. Update coefficients refine it for finite rounds.

Eqs. (1) and (6) blend memory with raw features at the purifier and classifier inputs. Input deviations are αf\alpha_f times the current memory deviation and λi\lambda_i times the final memory deviation, respectively, with λi≤λmax⁡\lambda_i\le\lambda_{\max}. We set αf=λmax⁡=0.5\alpha_f=\lambda_{\max}=0.5. Thus, the purifier input deviation is half the current memory deviation; the classifier input deviation is at most half the final memory deviation. Anchoring preserves raw observations and reduces deviation passed to subsequent modules. It does not directly pull internal memory back toward raw features.

The preservation loss softly constrains deviation from raw features after one step. However, the MLP does not explicitly bound candidate magnitude. The uniform bound is an extra assumption, not guaranteed by training. Bounded deviation also does not imply convergence to a fixed state. Our finite-round iteration is heuristic: gating controls update fractions; anchoring reduces input deviation. We will add this conditional analysis to clarify each mechanism's role and conditions.

Q2

The structural attacks studied here leave raw attributes unchanged but alter neighborhoods, causing inappropriate aggregation and affecting representations. Raw features provide a fixed reference. The neighborhood branch aggregates neighboring memories using purified edge weights and neighbor reliability, then combines this with the node's own memory to generate a candidate. The aim is to preserve individual attributes and use relations in the purified structure to form an auxiliary representation for later purification.

The finite-width shared hidden layer integrates self and neighborhood information. Cosine reconstruction targeting raw features provides a directional alignment signal for candidates. The preservation term penalizes updated memory's deviation from raw features. These provide information integration, a semantic reference, and a deviation constraint, respectively.

Single-step training learns a local mapping from current memory and context to a candidate. Repeating the same task each round motivates network reuse. Updated memory feeds into the next purification round. Re-estimated edge weights, reliability, and context then inform the next semantic update. Later calls can thus use feedback unavailable in the first round. Gating controls the fraction of movement toward the candidate. Raw features remain in the purifier input as a fixed reference throughout the finite rounds.

Disabling only memory feedback to subsequent purification, while retaining memory updates and final fusion, reduces average robust accuracy by 2.00 and 2.48 percentage points on Cora and Citeseer, respectively. This supports feedback's role in the evaluated settings. We will clarify these roles and the rationale for multi-round use after single-step training.

Q3

We agree that this term is better interpreted as a change in a node's relative reliability diagnostic score. It computes the absolute difference across rounds in base unreliability scores normalized graph-wide separately each round, rather than directly measuring internal-state changes.

Local structural residuals and edge-posterior uncertainty determine the values before normalization. Each signal's graph-wide minimum and maximum determine its normalization scale. The two effects may reinforce each other or partly or fully cancel out. A changed range can alter the score even if the local signal is unchanged. When the local signal changes, a simultaneous scale change can also leave the score nearly unchanged.

The term reflects both effects. It uses larger diagnostic changes across rounds as additional evidence for unreliability scoring. Together with the current base score, it affects subsequent candidate selection and memory updates. This adds cross-round information, treating nodes with similar current scores but different change magnitudes differently. Removing the temporal term reduces classification accuracy, supporting its benefit in our experiments. We will clarify this interpretation and both effects, avoiding claims that it measures absolute node-state instability or convergence.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.