Beyond Message-Passing GNN Generalization via Feature Perturbation for Semi-Supervised Node Classification — IEEE Transactions 2025 Base Paper Project

Flip-GNN is a feature-perturbation method for semi-supervised node classification: it flips both the sparse bag-of-words features and the first-layer hyperplane during training, so every weight dimension gets updated instead of only the dimensions seen in the few labelled nodes. On the paper's benchmarks it lifts accuracy by up to 27.03% on Cornell.

Most graph neural networks improve by changing how messages pass between neighbours — better filters, better aggregation. Flip-GNN asks a different question: what if the features themselves are the problem? In citation and WebKB graphs the node features are bag-of-words vectors that are mostly zeros, and with only a handful of labelled training nodes, whole dimensions of the first weight matrix never see a gradient. The paper by Choi, Choi, Ko and Kim, published in IEEE Transactions on Neural Networks and Learning Systems in 2025, shows that this sparse-feature overfitting is the bottleneck, and fixes it by flipping both the initial features and the hyperplane — a perturbation that creates extra training variability, reduces prediction variance, and updates the entire weight matrix. The paper's own reported result, labelled as such, is up to 27.03% higher classification accuracy on the Cornell dataset, and an average 3.21% improvement on link prediction. This project implements that method for a student build, evaluated on the public Cora, Citeseer, Pubmed, Cornell, Texas and Wisconsin graphs, and adds a clearly separate Indian contribution: an Indian academic citation-graph extension with a low-label-budget study and a sparsity-robustness dashboard.

Graph neural networks collect information from neighbours, and a decade of work has refined how that information is filtered and aggregated. But when node features are sparse bag-of-words vectors and only a few nodes carry labels, the first projection matrix overfits in the dimensions the training nodes never exercise — a test node with an unseen feature dimension is classified by a weight that was never trained. The paper demonstrates this failure mode, then solves it without touching message passing at all: flip the initial features and the hyperplane, train in both spaces, and the gradient reaches every dimension. The student build then faces the variant the paper does not cover: the same method on an Indian academic citation graph, where vocabulary, sparsity and label budget all differ from the paper's benchmarks.

This is a built-to-order software project: the Flip-GNN model, demo consoles, report, presentation, and viva Q&A are prepared fresh for you. Starting price: Rs 28,000 (final price confirmed after topic, base paper and compute scope are locked).

Related built-to-order IEEE base-paper projects on this site: GNN and Transformer anomaly detection in graph networks (https://projectech.in/projects/gnn-transformer-anomaly-detection-graph-networks/), graph kernel neural networks for graph classification and regression (https://projectech.in/projects/graph-kernel-neural-networks-graph-classification-regression/), DER-GCN multimodal dialog emotion recognition (https://projectech.in/projects/der-gcn-multimodal-dialog-emotion-recognition-graph-convolution/), and privacy-preserving collaborative knowledge graph creation with LLMs (https://projectech.in/projects/privacy-preserving-collaborative-knowledge-graph-llms-federated/).

The Problem

Semi-supervised node classification is the task of labelling every node in a graph when only a small fraction carries labels — a citation network where a few papers are tagged by topic, a campus network where a few students are tagged by interest. Graph neural networks are the standard tool, and they work by passing messages between neighbours. But their input features are usually bag-of-words vectors: thousands of dimensions, almost all zero for any single node. With only 60 to 140 labelled training nodes, as in the paper's citation-graph setups, most feature dimensions never appear in training, so the corresponding rows of the first weight matrix never receive a gradient update. At test time a node that carries one of those unseen dimensions is classified by a weight that was never trained — the model overfits the dimensions it saw and fails on the ones it did not. Aggregation research does not fix this: reweighting messages cannot train a weight that no message ever reaches. The gap this project addresses is a training-side fix — perturb the features and the hyperplane together so that every dimension is exercised — and then the variant the paper does not cover: the same fix on an Indian academic citation graph, where sparsity, vocabulary and label budget differ from the paper's benchmarks.

Base paper at a glance

Base paper

• Paper: "Beyond Message-Passing: Generalization of Graph Neural Networks via Feature Perturbation for Semi-Supervised Node Classification", Yoonhyuk Choi, Jiho Choi, Taewook Ko, Chong-Kwon Kim, IEEE Transactions on Neural Networks and Learning Systems, 2025, vol. 36, no. 6, pp. 10271–10282.
• DOI: https://doi.org/10.1109/TNNLS.2024.3472897 (IEEE Xplore document 10767362; free preprint https://arxiv.org/abs/2211.15081).
• Problem the paper tackles: graph neural networks overfit when node features are sparse bag-of-words vectors and labelled training nodes are scarce — whole dimensions of the first projection matrix (hyperplane) never receive a gradient, because the training samples do not cover the full range of learnable parameters, so test nodes carrying unseen feature dimensions are misclassified.
• What is implemented from the paper: the feature-and-hyperplane flipping perturbation, applied to MLP, GCN, GAT, GIN and APPNP backbones as the paper's Flip-MLP, Flip-GCN, Flip-GAT, Flip-GIN and Flip-APPNP variants; the dual-space training that updates the entire weight matrix and reduces prediction variance; and evaluation on the public Cora, Citeseer, Pubmed, Cornell, Texas and Wisconsin benchmark graphs with accuracy and per-class recall.
• What is deliberately not claimed: no numeric accuracy figure is quoted as this build's result beyond the two numbers the published abstract itself reports (up to 27.03% on Cornell, 3.21% average on link prediction), both labelled as the paper's own claims; the preprint's older 46.5% figure is not used, because the published abstract supersedes it; demo console read-outs are illustrations from a small synthetic citation graph, not measured results; the preprint (arXiv:2211.15081) is cited as a free copy of the paper, not as this build's code.
• Paper-reported results (the paper's own findings, not this build's measured results): the authors report that comprehensive experiments on real-world datasets and ablation studies affirm the method significantly improves classification accuracy by up to 27.03% on the Cornell dataset, and that the model generalises to the link prediction task with an average improvement of 3.21%. The paper also claims, as its own statement, to be the first to address the overfitting issue in GNNs precipitated by sparse node features. The student build's report records only the figures its own evaluation runs actually produce.

Own features

These are the student's own contribution, clearly distinct from the base paper:

• [Indian academic citation-graph extension] The same Flip-GCN applied to a small Indian academic citation graph built for the demo — Indian university papers with an Indian-English bag-of-words vocabulary — so the method is tested on a graph whose sparsity pattern and vocabulary differ from the paper's benchmarks. The paper evaluates its nine benchmark graphs only.
• [Low-label-budget study] A student-run study that measures accuracy at 5, 10 and 20 labelled nodes per class on the Indian citation graph and on Cora, showing where flipping helps most as the label budget shrinks. The paper runs its own experiments at fixed splits; this study is the student's experiment, not the paper's result.
• [Sparsity-robustness dashboard] An interactive dashboard that plots each dataset's z-value — the ratio of non-zero components in its initial feature vectors, as the paper defines it — against the flipping gain, so a reviewer can see at a glance that sparser graphs gain more. The paper reports the z-values in its Table 1; the dashboard is the student's visualisation of that relationship.
• [Flip-ablation console] A console that runs the three ablations side by side — flip features only, flip hyperplane only, flip both — with a prediction-variance read-out, so the viva can show that both flips together are what updates the full weight matrix. The paper runs its own ablations; this console is the student's illustration of the mechanism.

The pipeline runs as a visible chain, and each stage's output is shown in the demos so a student can explain it in a viva. First, a graph is loaded — a citation graph such as Cora, or the WebKB graphs Cornell, Texas and Wisconsin — with bag-of-words node features and a small labelled set (140 training nodes on Cora, 120 on Citeseer, 60 on Pubmed in the paper's setup). The sparsity of the features is measured with the paper's z-value, the ratio of non-zero components in the initial feature vectors. Then the flipping perturbation is applied: both the initial features and the first-layer hyperplane are flipped, creating a second, shifted training space. The model trains in both spaces, so the gradient updates the entire weight matrix and prediction variance falls. The flipped variants — Flip-MLP, Flip-GCN, Flip-GAT, Flip-GIN and Flip-APPNP — are each trained the same way, which shows the perturbation is orthogonal to the message-passing scheme. A classification head predicts one class per node — 7 classes on Cora, 6 on Citeseer, 3 on Pubmed, 5 on each WebKB graph. The ablation console runs flip-features-only, flip-hyperplane-only and flip-both side by side to show that both flips together are what trains the full matrix. The own features then apply the same Flip-GCN to an Indian academic citation graph and measure accuracy at 5, 10 and 20 labels per class. Evaluation runs the same pipeline on the public benchmarks and records only the figures the student's own runs produce.

1. Load a benchmark graph with bag-of-words node features and a small labelled set (Cora 140, Citeseer 120, Pubmed 60 training nodes in the paper's setup).
2. Measure feature sparsity with the paper's z-value, the ratio of non-zero components in the initial feature vectors.
3. Flip both the initial features and the first-layer hyperplane, creating a second training space.
4. Train in both spaces so the gradient updates the entire weight matrix and prediction variance falls.
5. Apply the same perturbation to five backbones — Flip-MLP, Flip-GCN, Flip-GAT, Flip-GIN and Flip-APPNP — to show it is orthogonal to message passing.
6. Run the flip ablation: features only, hyperplane only, both — and compare the prediction-variance read-outs.
7. Predict one class per node with the classification head (7 classes Cora, 6 Citeseer, 3 Pubmed, 5 per WebKB graph).
8. Report per-class recall separately, so a weak class cannot hide inside a good average.
9. Run the Indian citation-graph extension and the low-label-budget study at 5, 10 and 20 labels per class.
10. Evaluate on the public benchmarks, recording only the figures the student's own runs produce.

Tech stack:

• Python 3 · PyTorch · PyTorch Geometric
• Flip-GNN · feature and hyperplane flipping
• GCN · GAT · GIN · APPNP backbones
• scikit-learn · NumPy · SciPy
• NetworkX · graph datasets
• Matplotlib · evaluation plots
• HTML · CSS · JavaScript demo consoles
• Git · Jupyter Notebook

Dataset & model details

• Dataset (paper and student build): Cora, citation network, 2,708 nodes, 10,558 edges, 1,433 bag-of-words features, 7 classes, 140 labelled training nodes in the paper's setup; Citeseer, citation network, 3,327 nodes, 9,104 edges, 3,703 features, 6 classes, 120 training nodes; Pubmed, citation network, 19,717 nodes, 88,648 edges, 500 features, 3 classes, 60 training nodes; Cornell, WebKB university web-page graph, 183 nodes, 295 edges, 1,703 features, 5 classes; Texas, WebKB graph, 183 nodes, 309 edges, 1,703 features, 5 classes; Wisconsin, WebKB graph, 251 nodes, 499 edges, 1,703 features, 5 classes. The paper's full benchmark set also includes Actor, Chameleon and Squirrel; the student build evaluates on the six graphs above only. All six are public benchmark graphs from the paper's Table 2.
• Dataset (demo consoles): A small illustrated citation graph built for the demo consoles (12 nodes, 5 classes, synthetic bag-of-words features) and a small illustrated Indian academic citation graph (11 nodes, Indian university papers, synthetic features). They are not benchmark graphs, and they are labelled as such wherever they appear. No benchmark node or feature is displayed on this page.
• Dataset (Indian extension): No published Indian citation-graph dataset is claimed. The extension is demonstrated in the console on an illustrated Indian academic citation graph built for the demo, and it is labelled as such wherever it appears.
• Task: Semi-supervised node classification; input = one graph with bag-of-words node features and a small labelled set, output = one class label per node.
• Model: The paper's system — feature-and-hyperplane flipping applied to MLP, GCN, GAT, GIN and APPNP backbones, with dual-space training that updates the entire first-layer weight matrix. No architecture detail beyond the paper's description is claimed for it here. The paper's free preprint is at https://arxiv.org/abs/2211.15081.
• Metrics: Accuracy and per-class recall for node classification, as in the paper, plus the z-value sparsity measure and a prediction-variance read-out in the ablation console; the student build's report records only the figures its own evaluation runs actually produce, and no figure is claimed before those runs.

Flip-GNN delivers seven working capabilities: a feature-and-hyperplane flipping perturbation that trains every weight dimension, five flipped backbone variants, evaluation on six public benchmark graphs with per-class recall, an Indian citation-graph extension, a low-label-budget study, a sparsity-robustness dashboard, and interactive demo consoles a reviewer can operate. The model never changes the message-passing scheme — the fix is entirely on the training side.

• [Feature and hyperplane flipping] Both the sparse initial features and the first-layer hyperplane are flipped during training, creating extra training variability so the gradient reaches every weight dimension instead of only the dimensions the few labelled nodes exercise, exactly as the paper defines it.
• [Flip-MLP, Flip-GCN, Flip-GAT, Flip-GIN and Flip-APPNP] The flipping perturbation applied to five representative backbones, so the method is shown to be orthogonal to the message-passing scheme — the same fix lifts each backbone rather than depending on one architecture.
• [Prediction-variance reduction] Training in both the original and the flipped space reduces the variance of predictions, which is the paper's theoretical mechanism for why the flipped models generalise better to unseen feature dimensions.
• [Public benchmark evaluation] The system is evaluated on the public Cora, Citeseer, Pubmed, Cornell, Texas and Wisconsin graphs with accuracy and per-class recall, and only the figures the student's own runs produce are recorded in the report.
• [Indian citation-graph extension] A student-built extension that applies Flip-GCN to an Indian academic citation graph with an Indian-English vocabulary, demonstrated in the console on an illustrated graph built for the demo.
• [Low-label-budget study] A student-run study at 5, 10 and 20 labelled nodes per class, showing how the flipping gain grows as the label budget shrinks — the regime where sparse-feature overfitting bites hardest.
• [Interactive demo consoles] A pipeline explorer with a visible citation graph and per-node predictions, a sparsity and hyperplane console with flip ablations and variance read-outs, and the Indian citation-graph extension with the label-budget study, so the mechanism is inspectable.

• Complete Flip-GNN source code (feature and hyperplane flipping, Flip-MLP, Flip-GCN, Flip-GAT, Flip-GIN and Flip-APPNP variants, public benchmark evaluation with accuracy and per-class recall)
• Interactive demo consoles (the web demos shown on this page): a pipeline explorer with a visible citation graph and per-node predictions, a sparsity and hyperplane console with flip ablations and variance read-outs, and the Indian citation-graph extension with the low-label-budget study and sparsity dashboard
• Project report PDF (background, base paper, methodology, experiments, limitations)
• PPT presentation for final review
• Viva Q&A preparation document (graph neural networks, sparse features, feature and hyperplane flipping, benchmark evaluation, limitations)
• Starting price: Rs 28,000 (final price confirmed after topic, base paper and compute scope are locked)
• Specific next step: message on WhatsApp for a quotation stating scope (Flip-GNN feature-and-hyperplane perturbation for semi-supervised node classification, Flip-MLP/GCN/GAT/GIN/APPNP variants, evaluated on public Cora, Citeseer, Pubmed, Cornell, Texas and Wisconsin graphs, plus an Indian citation-graph extension with a low-label-budget study), starting price Rs 28,000, and delivery under the 110-hour work plan as a built-to-order project

Work plan & timeline

Total work plan: 110 hours, split across six phases. Phase 1, base-paper study and environment setup: 15 hours — reading the Choi et al. paper, setting up Python, PyTorch and PyTorch Geometric, and preparing the public Cora, Citeseer, Pubmed, Cornell, Texas and Wisconsin data. Phase 2, graph loading and sparsity measurement: 25 hours — the benchmark graph loaders, the z-value sparsity measure, and the baseline MLP, GCN, GAT, GIN and APPNP models. Phase 3, flipping perturbation and dual-space training: 25 hours — feature flipping, hyperplane flipping, the Flip variants, and the ablation console. Phase 4, evaluation on public benchmarks: 15 hours — running the model on the six graphs and recording only the figures the student's own runs produce, with per-class recall reported separately. Phase 5, own features: 15 hours — the Indian academic citation-graph extension, the low-label-budget study, and the sparsity-robustness dashboard. Phase 6, presentation and viva preparation: 15 hours — PPT, demo walkthrough, and the viva Q&A document.

Support

Support covers setup help for the delivered code, a walkthrough of the system and the demo consoles, and fixes for defects in the delivered code. Guidance is also provided for adapting the report and presentation to the student's college format and for answering guide questions about the base paper, graph neural networks, sparse features, feature and hyperplane flipping, benchmark evaluation, and the student's own contribution. Support does not cover re-running experiments on the student's personal machine beyond the setup walkthrough, and it does not invent results for experiments that were not run.