Should Graph Convolution Trust Neighbors? A Simple Causal Inference Method

Fuli Feng, Weiran Huang, Xiangnan He, Xin Xin, Qifan Wang, Tat-Seng Chua

TL;DR

Graph Convolutional Networks (GCNs) assume that connected nodes are similar, but real-world "noise" in graph structures often breaks this rule. This paper introduces Causal GCN Inference (CGI), a model-agnostic method that uses causal intervention at test-time to decide whether a node should trust its neighbors' information or rely solely on its own features for a more accurate prediction.

What Problem Does This Paper Address?

The bread and butter of GCNs is homophily—the idea that "birds of a feather flock together." By aggregating features from a node's neighbors, GCNs create powerful representations. However, real-world graphs are rarely perfect. A node might be connected to "dissimilar" neighbors (local structure discrepancy), leading the GCN to produce an inferior or "poisoned" representation.

While existing solutions like Graph Attention Networks (GATs) try to learn which neighbors to ignore during training, they often struggle when labeled data is scarce. More importantly, these methods don't explicitly account for the discrepancy found in testing nodes, which might have connection patterns entirely different from those seen during training. The authors ask a fundamental question: During inference, how do we know if the local graph structure is helping or hurting?

Methods

The authors frame GCN prediction through the lens of causal inference. They model the prediction process as a causal graph where both the node's own features ($X$) and its neighbors ($N$) are "causes" of the final prediction ($\hat{Y}$).

To solve the discrepancy issue, they propose Causal GCN Inference (CGI):

  1. Causal Intervention: For any given testing node, they perform an intervention by "blocking" the neighbors (setting $N = \emptyset$). This forces the GCN to make a prediction based only on the node's own features, resulting in a "post-intervention" prediction ($\hat{y}^s$).
  2. The Choice Model: Instead of just using the standard GCN output, CGI uses a separate, lightweight classifier (a Support Vector Machine) to act as a referee. This "choice model" looks at factors like prediction confidence and "causal uncertainty" to decide whether to stick with the original neighbor-aware prediction or switch to the self-only prediction.
  3. Causal Uncertainty: To quantify how much the local structure can be trusted, they use a Monte Carlo approach. By randomly dropping edges (edge dropout) and measuring how much the prediction fluctuates, they calculate a "graph variance" score. High variance suggests the local structure is unreliable.

Datasets

The authors evaluated CGI across seven node classification datasets:

  • Real-world Citation Networks: Cora, Citeseer, Pubmed, and the large-scale OGB-arXiv.
  • Synthetic Discrepancy Benchmarks: They created three synthetic versions of Citeseer by intentionally adding 10%, 30%, and 50% "cross-category" edges to simulate varying levels of local structure discrepancy.
  • Enhanced Features: For OGB-arXiv, they replaced standard Word2Vec features with high-quality RoBERTa embeddings to better isolate the impact of the graph structure versus the node features.

Key Insights and Ideas

  • Adaptive Locality at Inference: Most GCN improvements happen during training. CGI is unique because it empowers the inference stage to be node-specific. It treats the GCN as a black box and decides on-the-fly how to use it.
  • The "Self-Trust" Safety Valve: The paper demonstrates that when the graph is noisy, "trusting oneself" is often better than aggregating neighbor data. CGI provides a formal mechanism to trigger this safety valve.
  • Uncertainty as a Signal: One of the most elegant ideas is using Monte Carlo edge dropout to measure causal uncertainty. If a prediction changes wildly when a few edges are removed, the GCN's reliance on those neighbors is likely "brittle" and untrustworthy.
  • Feature Quality Paradox: The authors found that as node features get better (e.g., moving from Word2Vec to RoBERTa), the relative gain from the graph structure decreases. This suggests that GCNs sometimes act as a "crutch" for poor feature engineering.

Key Results

  • Robustness to Noise: On the synthetic Citeseer(50%) dataset—where half the edges are misleading—CGI improved accuracy from 64.2% (standard APPNP) to 68.6%.
  • Consistent Gains: CGI consistently outperformed standard GCNs and simple ensemble methods across all real-world datasets. For example, on Cora, it achieved a 5.5% relative improvement over a neighbor-averaging ensemble.
  • Model Agnostic: The authors successfully applied CGI to several state-of-the-art GCN variants (APPNP, JKNet, DAGNN), proving it can be "plugged in" to almost any existing architecture.

Limitations and Future Work

  • The "Conflict" Constraint: CGI only makes a difference on "conflict nodes"—nodes where the self-only prediction and neighbor-aware prediction disagree. In OGB-arXiv, this was only about 14.4% of nodes. While CGI improves these cases, the overall accuracy gain is capped by the frequency of these conflicts.
  • Choice Model Complexity: The current implementation uses a linear SVM. The authors suggest that exploring non-linear choice models or integrating the choice mechanism more deeply into the GCN architecture could yield better results.
  • Beyond Classification: The study focuses on node classification. Future work is needed to see if this causal approach translates to other tasks like link prediction or graph-level classification.

Summary updated

Abstract

Graph Convolutional Network (GCN) is an emerging technique for information retrieval (IR) applications. While GCN assumes the homophily property of a graph, real-world graphs are never perfect: the local structure of a node may contain discrepancy, e.g., the labels of a node's neighbors could vary. This pushes us to consider the discrepancy of local structure in GCN modeling. Existing work approaches this issue by introducing an additional module such as graph attention, which is expected to learn the contribution of each neighbor. However, such module may not work reliably as expected, especially when there lacks supervision signal, e.g., when the labeled data is small. Moreover, existing methods focus on modeling the nodes in the training data, and never consider the local structure discrepancy of testing nodes. This work focuses on the local structure discrepancy issue for testing nodes, which has received little scrutiny. From a novel perspective of causality, we investigate whether a GCN should trust the local structure of a testing node when predicting its label. To this end, we analyze the working mechanism of GCN with causal graph, estimating the causal effect of a node's local structure for the prediction. The idea is simple yet effective: given a trained GCN model, we first intervene the prediction by blocking the graph structure; we then compare the original prediction with the intervened prediction to assess the causal effect of the local structure on the prediction. Through this way, we can eliminate the impact of local structure discrepancy and make more accurate prediction. Extensive experiments on seven node classification datasets show that our causality-based method effectively enhances the inference stage of GCN.
BibTeX
@inproceedings{feng2021should,
  author = {Fuli Feng and Weiran Huang and Xiangnan He and Xin Xin and Qifan Wang and Tat-Seng Chua},
  title = {{Should Graph Convolution Trust Neighbors? A Simple Causal Inference Method}},
  booktitle = {International ACM SIGIR Conference on Research and Development in Information Retrieval},
  year = {2021},
  doi = {10.1145/3404835.3462971},
}

Loading related content...

Figure