Mitigating Interaction Noise in Graph Collaborative Filtering

16 concepts16 papers1 proposal

Graph Neural Networks (GNNs) have become the dominant paradigm for modern recommendation systems. By framing users and items as nodes in a bipartite graph, GNNs leverage message passing to aggregate information from a node’s local neighborhood. The underlying intuition is elegant: if a user interacts with an item, their latent representations should move closer together in the embedding space. Through multi-hop propagation, the model learns high-order collaborative signals—essentially discovering that if you share preferences with a group of users, you will likely enjoy other items they interacted with.

However, this elegant formulation relies on a fragile assumption: that every observed edge in the interaction graph represents a genuine user preference.

In reality, user-item interaction data is highly contaminated. Users frequently click on items by accident, fall victim to click-bait, or interact with products purely due to popularity bias rather than intrinsic interest. When standard GNNs treat these noisy edges as ground-truth signals, a fundamental flaw emerges: multi-hop message passing propagates and amplifies the noise across the entire network.

[User A] --(Accidental Click)---> [Item X (Clickbait)]
    |                                   |
(True Preference)               (Message Passing)
    |                                   v
[Item Y]                         [User B (Contaminated)]

If User A accidentally clicks an irrelevant item, that item's features are aggregated into User A's representation. In the next layer of graph convolution, User A passes this contaminated signal to all of their legitimately preferred items, which in turn pass it to other users. As a result, distinct user identities wash out, representations become distorted, and recommendation accuracy degrades.

To solve this problem, a major research direction focuses on denoising graph collaborative filtering. Rather than accepting the observed graph as ground truth, these approaches dynamically identify, down-weight, or prune spurious interactions during the learning process.


The Mechanics of Noise Propagation

To understand why interaction noise is uniquely destructive in GNNs, we must look at how neighborhood aggregation scales. As Chen observes, standard GNNs lack a selective filter; they blindly smooth representations across high-order connections.

When the neighborhood aggregation size expands, irrelevant entities introduce severe semantic contamination. Zhong et al. and Wu et al. demonstrate that because implicit feedback (clicks, views) does not guarantee actual user interest, multi-hop aggregation inevitably dilutes a user's specific preference profile with unrelated historical actions. This problem is exacerbated in specialized domains; for instance, Wang et al. show that in point-of-interest (POI) recommendation, overly large neighborhoods introduce spatial-temporal noise that misrepresents a user's true travel tolerance.

When a model treats an accidental interaction as a core structural pattern, it fails to distinguish between intentional preferences and random perturbations (Fang et al.). To counteract this, researchers have developed three primary methodologies: structural pruning, information bottlenecks, and self-supervised contrastive learning.


Strategy 1: Structural Pruning and Topological Filtering

The most direct way to handle interaction noise is to alter the graph topology itself, removing or down-weighting edges that appear anomalous or uninformative.

Instead of treating all edges uniformly, models can evaluate the "collaborative quality" of an interaction before allowing messages to pass through it. Wang introduces a topological metric called the Common Interacted Ratio (CIR) to measure the strength of a shared neighborhood between a user and an item. If a user clicks an item but shares very few historical overlaps with other users who liked that item, the CIR is low, signaling an accidental or irrelevant interaction. The model can then prioritize high-quality collaborative signals and suppress the noise.

High Overlap (True Signal):  [User A] <---> [Shared Neighbors] <---> [Item X]  (Keep/Weight High)
Low Overlap (Noise Edge):    [User A] -----------------------------> [Item Y]  (Prune/Weight Low)

Other approaches apply mathematical optimization or structural heuristics to clean the graph:

  • Trend Filtering: Fan et al. utilize an $L_1$-norm trend filtering mechanism within the propagation layers. This acts as an adaptive smoother that automatically penalizes and down-weights sudden, unreliable variations in the graph signal.
  • Degree-Sensitive Pruning: Zhou et al. introduce edge-pruning techniques based on node degrees to eliminate noisy connections, which simultaneously accelerates training convergence by removing computational bloat.
  • Graph Freezing: In multimodal settings where visual or textual features can also introduce noise, Shen et al. propose freezing the item-item structural graph while explicitly denoising the user-item interaction graph to prevent cross-modal signal contamination.

Strategy 2: The Graph Information Bottleneck

A more mathematically rigorous framework for denoising relies on information theory, specifically the Graph Information Bottleneck (GIB).

The core philosophy of GIB is simple: compress the input graph into a minimal latent representation that retains maximum predictive power for the recommendation task, while discarding irrelevant information. Because accidental clicks and popularity biases are uncorrelated with a user's long-term, stable preferences, an information bottleneck forces the network to drop these noisy bits first to save capacity.

Wei et al. and Xia et al. leverage this concept to build contrastive graph structure learning frameworks. By optimizing a mutual information objective, these models learn to generate a "purified" subgraph. The bottleneck ensures that only the edges containing genuine collaborative signals are allowed to influence the final user and item embeddings, effectively filtering out popularity biases and accidental interactions.

Taking this a step further, Jiang et al. implement trainable, task-aware view generators. Instead of relying on static rules, their model uses a generative component alongside a denoising component to adaptively separate the underlying preference signal from random data perturbations.


Strategy 3: Self-Supervised Contrastive Learning

When explicit edge removal is too risky or computationally expensive, researchers turn to Self-Supervised Learning (SSL) to build implicit noise immunity.

Contrastive learning works by creating multiple augmented "views" of the same interaction graph (for example, by randomly dropping a fraction of edges or nodes) and forcing the model to maximize the agreement between representations of the same node across different views.

Original Graph ----> View 1 (Drop Edges A, B) ----\
               ----> View 2 (Drop Edges C, D) ----+---> Maximize Agreement (InfoNCE Loss)

Why does this denoise the representations? If an edge represents random noise (like an accidental click), it will not align with the broader, latent structural patterns of the graph. When that specific edge is dropped in one view but kept in another, the contrastive loss forces the model to focus on invariant, robust structural features that persist across both views.

Wu et al. pioneered this with the Self-supervised Graph Learning (SGL) framework, demonstrating that contrastive structures dramatically increase a model's resilience against noisy data and accelerate convergence. This paradigm has been widely extended:

  • Zhong et al. employ a debiased contrastive loss over multi-view subgraphs to prevent the model from learning from irrelevant interaction paths.
  • Chen et al. introduce view-crossing contrastive learning to handle noise that occurs simultaneously in user interaction data and external knowledge bases.
  • Liu et al. use behavior graphs as a semantic filter to purify concept-level noise in micro-video recommendation, ensuring that random clicks do not dilute representations of a user's core interests.

Summary

The transition from treating interaction graphs as absolute ground truth to treating them as noisy, observed signals represents a major shift in graph-based recommendation. Whether through explicit topological pruning (Wang; Fan et al.), information-theoretic bottlenecks (Xia et al.), or contrastive invariance (Wu et al.), denoising techniques ensure that message passing amplifies true collaborative preferences rather than random errors.

Key Foundational Work

Learning Contrastive Multi-View Graphs for Recommendation (Student Abstract) (2022) — contributed 1 concept elements to this direction.
Contrastive Graph Structure Learning via Information Bottleneck for Recommendation (2022) — contributed 1 concept elements to this direction.
Layer-refined Graph Convolutional Networks for Recommendation (2022) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_interaction_noise_80f0ad53,
  title = {interaction noise},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/interaction-noise/rdr_80f0ad5377514e0ba281bcc41d75dc23},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 1, frozen text):

@misc{lacuna_interaction_noise_80f0ad53_v1,
  title = {interaction noise},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/interaction-noise/rdr_80f0ad5377514e0ba281bcc41d75dc23/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake