Graph Learning via Class-Consistent Filtering

• The paper presents a technique that filters and reweights neighboring nodes based on predicted class-label compatibility, enhancing tasks like graph unlearning and semi-supervised classification.
• It leverages multiple mechanisms—including hard selection, soft weighting, and label-consistency graph reconstruction—to replace raw connectivity with more reliable, same-class neighbor relationships.
• Empirical results demonstrate improved accuracy and efficiency in sparse-label and high-noise settings, validating the paradigm’s effectiveness across various graph learning tasks.

Class-consistent Neighbor Node Filtering is a family of graph-learning mechanisms that select, reweight, or reconstruct neighborhood relations according to estimated class consistency rather than raw graph connectivity alone. In this view, a neighbor is treated as reliable when it is likely to belong to the same class as the anchor node, or when its local structure and predictions indicate label compatibility. The idea appears explicitly as a named method in graph unlearning and more broadly as a design principle in semi-supervised node classification, noisy-label learning, graph self-supervised learning, heterophily-robust representation learning, and graph clustering (Guan et al., 5 Sep 2025).

1. Conceptual basis

Graph neural networks are commonly motivated by the assumption that connected nodes tend to have the same label. “Label consistency” was defined in LC-GNN as “the proportion of neighboring nodes that have the same label with target node,” and the paper reported that node classification accuracy with GCN on Cora increases as label consistency increases (Xu et al., 2020). This makes neighbor selection a central issue: if neighborhoods are class-consistent, aggregation is beneficial; if neighborhoods are heterophilous, noisy, or imbalanced, aggregation can propagate harmful signals.

Several later methods recast this issue in explicitly filtering-oriented terms. BLNN treats one-hop neighbors as noisy positives under homophily, but assigns each neighbor a supportiveness score so that likely intra-class neighbors contribute more strongly to representation learning (Liu et al., 2024). NeuCGC generalizes the same intuition by introducing neutral pairs, which are weighted neither as fully positive nor fully negative, and by constructing a high-confidence graph whose edge weights encode how trustworthy a neighborhood relation is under varying homophily levels (Peng et al., 17 Dec 2025). NCGCN approaches the same problem from a node-centric perspective: its Neighborhood Confusion metric measures how mixed the local label distribution is, so high-NC nodes are those whose neighborhoods are less class-consistent (Zhou et al., 2023).

This suggests three recurring interpretations of class-consistent neighbor filtering. First, it can be an edge-level mechanism, where neighbors are directly weighted or discarded. Second, it can be a node-selection mechanism, where only reliable nodes or neighborhoods provide supervision. Third, it can be a graph-reconstruction mechanism, where a new adjacency is induced from label consistency or pseudo-label agreement rather than from the original topology.

2. Formal mechanisms

A direct formulation appears in the graph unlearning method explicitly named Class-consistent Neighbor Node Filtering (CNNF). For an unlearning node $v$, CNNF filters its neighborhood to nodes that are not in the training set and have the same class as $v$: $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$ If this set is nonempty, CNNF computes the mean posterior of those filtered neighbors,

$$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$

and replaces the unlearning node’s target by that distribution; otherwise it falls back to a class-wise test mean (Guan et al., 5 Sep 2025). Here filtering is hard, local, class-aware, and training-independent.

A softer formulation appears in BLNN. For anchor $v_i$ and neighbor $v_j \in \mathcal{N}_i$, BLNN computes a cosine-based supportiveness score,

$$e_{ij} = \frac{\boldsymbol{h}^1_i \cdot \boldsymbol{h}^2_j}{ \|\boldsymbol{h}^1_i\| \, \|\boldsymbol{h}^2_j\|}, \qquad w_j = \frac{\exp(e_{ij}/\tau)}{\sum_{k \in \mathcal{N}_i} \exp(e_{ik}/\tau)}.$$

These weights are used in a bootstrap objective that aligns the anchor not only with itself across views but also with a supportiveness-weighted average of neighbors (Liu et al., 2024). In this setting, all neighbors remain in the sum, but many receive negligible weight.

LC-GNN implements filtering through graph reconstruction. It first predicts label distributions $Z$, then forms the label-consistency matrix $ZZ^\top$, row-normalizes it to obtain

$P = \text{Row-Normalize}(ZZ^\top),$

and performs label aggregation

$v$0

The matrix $v$1 defines a new graph $v$2 whose edges connect nodes with similar label distributions, including unconnected same-label nodes, while label-inconsistent relations receive very small weights (Xu et al., 2020).

NeuCGC uses an intermediate design based on neutral pairs. In its Adaptive Feature Consistency component, the high-confidence graph $v$3 is defined by

$v$4

so confident same-cluster pairs become fully trusted neighbors, original graph neighbors with uncertain consistency become partially trusted, and the rest are excluded from the positive set (Peng et al., 17 Dec 2025).

3. Methodological families

The literature organizes class-consistent neighbor filtering into several recurring families.

Family	Representative mechanism	Example papers
Hard neighbor selection	Same-class or rule-filtered neighbors only	CNNF (Guan et al., 5 Sep 2025)
Soft neighbor weighting	Attention or supportiveness over candidate neighbors	BLNN (Liu et al., 2024)
Label-consistency graph reconstruction	Replace or augment topology with label-similarity graph	LC-GNN (Xu et al., 2020)
Node/group separation	Filter by neighborhood confusion or reliability class	NCGCN (Zhou et al., 2023)
Confidence-based edge scoring	Estimate same-class likelihood and repel low-confidence edges	ConSM (Choi et al., 2023)
Homophily-aware neutral filtering	Neutral-pair weights and trustworthy neighborhood mining	NeuCGC (Peng et al., 17 Dec 2025)

In semi-supervised node classification, LC-GNN enlarges the receptive field with unconnected same-label nodes and weakens noise from connected nodes with different labels (Xu et al., 2020). NCGCN does not filter edges by label directly, but separates nodes into low-NC and high-NC groups and restricts second-layer message passing to intra-group channels, which acts as a coarse class-consistency filter (Zhou et al., 2023). ConSM learns edge coefficients as same-class probabilities through confidence-based subgraph matching and then uses them to attract high-confidence pairs and repel low-confidence pairs in the representation space (Choi et al., 2023).

In self-supervised and contrastive settings, BLNN treats one-hop neighbors as candidate positives and uses supportiveness weighting to mitigate false positives (Liu et al., 2024). HLCL does not explicitly identify class-consistent neighbors, but its low-pass and high-pass graph filters separate smooth, homophily-favoring components from non-smooth, heterophily-favoring components, which functions as an implicit distinction between class-consistent and class-inconsistent neighbor relations (Yang et al., 2023). NeuCGC extends this line by estimating both a graph-level neutral factor $v$5 and edge-level weights in $v$6, thereby mining trustworthy neighborhoods under varying homophily (Peng et al., 17 Dec 2025).

In noisy-label learning, CSGNN introduces “Class-wise Selection for Graph Neural Networks,” uses a neighbor-aggregated latent space, and employs dynamic class-wise selection to identify clean nodes across classes, explicitly to avoid biased sampling from global thresholds and to exploit the memorization effect (Li et al., 2023). This suggests a node-filtering interpretation in which class-consistent neighborhoods help identify reliable supervisory nodes.

4. Representative formulations across tasks

In graph unlearning, CNNF is notable because class-consistent neighbor filtering is the central operation rather than an auxiliary bias. The new target for an unlearning node is the posterior mean of same-class, non-training neighbors when available, and otherwise a class-wise test mean (Guan et al., 5 Sep 2025). The purpose is to make an unlearned node behave like a typical test-like node of its class, rather than like a memorized training exemplar.

In LC-GNN, the filtering criterion is not explicit same-label matching but similarity in predicted label distributions. Because

$v$7

nodes with similar class distributions become strong neighbors in $v$8, while dissimilar nodes are effectively filtered out by row normalization. The model is regularized so that the learned label-consistency matrix matches ground-truth label consistency among labeled nodes (Xu et al., 2020).

In BLNN, the filtered objects are not graph edges in the original training graph but node–neighbor positive pairs in a bootstrap objective. The total loss is

$v$9

Here, class-consistent neighbor filtering enters as a differentiable weighting of noisy positives (Liu et al., 2024).

In NeuCGC, filtering is distributed across two levels. The Neutral Contrastive Neighborhood Distribution Alignment term scales all neighbor contributions by a homophily-aware neutral contrastive factor $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$0, while Adaptive Feature Consistency uses the high-confidence graph $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$1 to promote only trustworthy neutral pairs (Peng et al., 17 Dec 2025). This creates a contrastive analogue of class-consistent neighbor filtering suitable for clustering without labels.

ConSM provides a different route: it first estimates whether a pair of nodes is same-class via confidence-based subgraph matching, then uses those coefficients in a modified label-propagation regularizer. High-confidence pairs are pulled together through $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$2, whereas low-confidence pairs are penalized through $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$3, which prevents suspicious edges from making nodes closer (Choi et al., 2023). This is filtering by attraction–repulsion rather than by graph reconstruction.

5. Empirical behavior

Empirical results across tasks consistently indicate that class-consistent filtering is most useful when raw neighborhoods are unreliable. LC-GNN reported gains over reimplemented GCN and GAT backbones on Cora, Citeseer, and PubMed. For example, on Cora the reported test accuracies were $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$4 for GCN*, $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$5 for LC-GCN (w/o RL), and $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$6 for the full LC-GCN; on Citeseer the corresponding GAT* and LC-GAT accuracies were $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$7 and $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$8 (Xu et al., 2020). In sparse-label settings, LC-GCN’s advantage widened, such as $$\mathcal{N}(v_u) = \{u \mid u \notin idx_{\text{train}} \wedge u\in \mathcal{N}(v) \wedge Y_u = Y_v\}.$$9 versus $$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$0 on Cora with 5 labeled nodes (Xu et al., 2020).

BLNN’s ablations separated clean positives from noisy positives. The reported pattern was that treating all node–neighbor pairs as equal positives produced almost no improvement, whereas using only clean intra-class neighbors gave significant gains, and BLNN approached that oracle behavior through supportiveness weighting (Liu et al., 2024). On Computer, the intra-class compactness metric $$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$1 increased from approximately $$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$2 for raw features to $$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$3 for BGRL and $$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$4 for BLNN (Liu et al., 2024). This supports the claim that filtering noisy positives improves intra-class compactness.

NeuCGC reported that the neighborhood congener ratio $$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$5 in the high-confidence graph $$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$6 increased by approximately $$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$7 on Cora, $$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$8 on DBLP, $$\overline{Z'_v} = \frac{1}{|\mathcal{N}(v_u)|} \sum_{t\in \mathcal{N}(v_u)} Z_t,$$9 on Wisconsin, and $v_i$0 on Cornell relative to the original graph, indicating that trustworthy neighborhood mining can substantially increase effective class consistency (Peng et al., 17 Dec 2025). Its clustering results were also reported to remain strong on both high- and low-homophily datasets (Peng et al., 17 Dec 2025).

In graph unlearning, CNNF was evaluated against retraining, GraphEraser, GIF, CLR, and TNMPP. For model utility with GCN, reported examples included Cora at 20% unlearning, where Retrain achieved $v_i$1 and CNNF $v_i$2, and Cora at 80% unlearning, where Retrain achieved $v_i$3 and CNNF $v_i$4 (Guan et al., 5 Sep 2025). CNNF also converged in fewer than approximately 70 epochs, whereas retraining required approximately 500 epochs, and reported wall-clock time for GCN at 20% unlearning was about $v_i$5–$v_i$6 s for CNNF versus about $v_i$7–$v_i$8 s for Retrain (Guan et al., 5 Sep 2025).

6. Limitations, assumptions, and related directions

A central limitation is dependence on homophily or on pseudo-label quality. BLNN assumes that neighbors are noisy positives and reported experiments only on homophilic benchmarks with $v_i$9; it has no explicit heterophily mechanism beyond downweighting low-similarity neighbors (Liu et al., 2024). LC-GNN similarly depends on the predicted label distributions $v_j \in \mathcal{N}_i$0: if early pseudo-labels are poor, then the learned label-consistency graph $v_j \in \mathcal{N}_i$1 may be misleading (Xu et al., 2020). NeuCGC addresses this more directly through neutral pairs and homophily-aware weighting, but still relies on clustering confidence and similarity estimates (Peng et al., 17 Dec 2025).

Another limitation is that some methods filter at the node or group level rather than at the edge level. NCGCN’s separation by Neighborhood Confusion is effective because performance decreases monotonically with NC on most datasets and high-NC nodes benefit from specialized processing, but it remains a coarse proxy rather than a direct same-class edge selector (Zhou et al., 2023). HLCL likewise separates smooth and non-smooth components spectrally without explicit class-consistent edge identification (Yang et al., 2023). This suggests that “class-consistent neighbor filtering” spans a spectrum from exact same-class neighbor selection to indirect reliability-aware message passing.

Task-specific constraints also matter. CNNF in graph unlearning has no formal certified removal guarantee; its effectiveness is empirical and evaluated through membership inference accuracy, t-SNE visualization, utility, and efficiency (Guan et al., 5 Sep 2025). ConSM is sensitive to the confidence ratio $v_j \in \mathcal{N}_i$2, and its reported F1 for edge classification was strongest when $v_j \in \mathcal{N}_i$3 was near the actual homophily ratio $v_j \in \mathcal{N}_i$4, which implies nontrivial hyperparameter dependence (Choi et al., 2023). CSGNN’s abstract states that it uses dynamic class-wise selection in a neighbor-aggregated latent space and clustering-based clean-node identification, but the inaccessible paper body leaves the full mathematical specification unavailable in the present record (Li et al., 2023).

Taken together, these works indicate that class-consistent neighbor node filtering is not a single algorithm but a graph-learning paradigm. It can be instantiated by strict same-class neighbor averaging, label-consistency graph construction, supportiveness-weighted noisy-positive handling, confidence-based attraction–repulsion, or homophily-aware neutral contrastive weighting. The shared premise is that raw adjacency is an insufficient criterion for message passing, and that effective graph learning often depends on replacing “connected” with “class-consistent enough.”