banner

TensorFlow or PyTorch, both!

GraphGallery

GraphGallery is a gallery for benchmarking Graph Neural Networks (GNNs) and Graph Adversarial Learning with TensorFlow 2.x and PyTorch backend. Besides, Pytorch Geometric (PyG) backend and Deep Graph Library (DGL) backend now are available in GraphGallery.

💨 NEWS

We have removed the TensorFlow dependency and use PyTorch as the default backend for GraphGallery.

🚀 Installation

Please make sure you have installed PyTorch. Also, TensorFlow, Pytorch Geometric (PyG) and Deep Graph Library (DGL) are alternative choices.

# Maybe outdated
pip install -U graphgallery

# Recommended
git clone https://github.com/EdisonLeeeee/GraphGallery.git && cd GraphGallery
pip install -e . --verbose

where -e means “editable” mode so you don’t have to reinstall every time you make changes.

🤖 Implementations

In detail, the following methods are currently implemented:

Node Classification

Method	Author	Paper
ChebyNet	Michaël Defferrard et al	Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering (NeurIPS’16)
GCN	Thomas N. Kipf et al	Semi-Supervised Classification with Graph Convolutional Networks (ICLR’17)
GraphSAGE	William L. Hamilton et al	Inductive Representation Learning on Large Graphs (NeurIPS’17)
FastGCN	Jie Chen et al	FastGCN: Fast Learning with Graph Convolutional Networks via Importance Sampling (ICLR’18)
LGCN	Hongyang Gao et al	Large-Scale Learnable Graph Convolutional Networks (KDD’18)
GAT	Petar Veličković et al	Graph Attention Networks (ICLR’18)
SGC	Felix Wu et al	Simplifying Graph Convolutional Networks (ICLR’19)
GWNN	Bingbing Xu et al	Graph Wavelet Neural Network (ICLR’19)
GMNN	Meng Qu et al	Graph Attention Networks (ICLR’19)
ClusterGCN	Wei-Lin Chiang et al	Cluster-GCN: An Efficient Algorithm for Training Deep and Large Graph Convolutional Networks (KDD’19)
DAGNN	Meng Liu et al	Towards Deeper Graph Neural Networks (KDD’20)
GDC	Johannes Klicpera et al	Diffusion Improves Graph Learning (NeurIPS’19)
TAGCN	Jian Du et al	Topology Adaptive Graph Convolutional Networks (arxiv’17)
APPNP, PPNP	Johannes Klicpera et al	Predict then Propagate: Graph Neural Networks meet Personalized PageRank (ICLR’19)
PDN	Benedek Rozemberczki et al	Pathfinder Discovery Networks for Neural Message Passing (ICLR’21)
SSGC	Zhu et al	Simple Spectral Graph Convolution (ICLR’21)
AGNN	Zhu et al	Attention-based Graph Neural Network for semi-supervised learning (ICLR’18 openreview)
ARMA	Bianchi et al	Graph Neural Networks with convolutional ARMA filters (Arxiv’19)
GraphMLP	Yang Hu et al	Graph-MLP: Node Classification without Message Passing in Graph (Arxiv’21)
LGC, EGC, hLGC	Luca Pasa et al	Simple Graph Convolutional Networks (Arxiv’21)
GRAND	Wenzheng Feng et al	Graph Random Neural Network for Semi-Supervised Learning on Graphs (NeurIPS’20)
AlaGCN, AlaGAT	Yiqing Xie et al	When Do GNNs Work: Understanding and Improving Neighborhood Aggregation (IJCAI’20)
JKNet	Keyulu Xu et al	Representation Learning on Graphs with Jumping Knowledge Networks (ICML’18)
MixHop	Sami Abu-El-Haija et al	MixHop: Higher-Order Graph Convolutional Architecturesvia Sparsified Neighborhood Mixing (ICML’19)
DropEdge	Yu Rong et al	DropEdge: Towards Deep Graph Convolutional Networks on Node Classification (ICML’20)
Node2Grids	Dalong Yang et al	Node2Grids: A Cost-Efficient Uncoupled Training Framework for Large-Scale Graph Learning (CIKM’21)

Defense models (for Graph Adversarial Learning)

Robust Optimization

Method	Author	Paper
RobustGCN	Petar Veličković et al	Robust Graph Convolutional Networks Against Adversarial Attacks (KDD’19)
SBVAT, OBVAT	Zhijie Deng et al	Batch Virtual Adversarial Training for Graph Convolutional Networks (ICML’19)
SimPGCN	Wei Jin et al	Node Similarity Preserving Graph Convolutional Networks (WSDM’21)
GCN-VAT, GraphVAT	Fuli Feng et al	Graph Adversarial Training: Dynamically Regularizing Based on Graph Structure (TKDE’19)
LATGCN	Hongwei Jin et al	Latent Adversarial Training of Graph Convolution Networks (ICML@LRGSD’19)
DGAT	Weibo Hu et al	Robust graph convolutional networks with directional graph adversarial training (Applied Intelligence’19)
MedianGCN , TrimmedGCN	Liang Chen et al	Understanding Structural Vulnerability in Graph Convolutional Networks

Graph Purification

The graph purification methods are universal for all models, just specify:

graph_transform="purification_method"

so, here we only give the examples of GCN with purification methods, other models should work.

Method	Author	Paper	PyTorch	TensorFlow	PyG	DGL
GCN-Jaccard	Huijun Wu et al	Adversarial Examples on Graph Data: Deep Insights into Attack and Defense (IJCAI’19)
GCN-SVD	Negin Entezari et al	All You Need Is Low (Rank): Defending Against Adversarial Attacks on Graphs (WSDM’20)

LinkPrediction

Method	Author	Paper	PyTorch	TensorFlow	PyG	DGL
GAE, VGAE	Thomas N. Kipf et al	Variational Graph Auto-Encoders (NeuIPS’16)

Node Embedding

The following methods are framework-agnostic.

Method	Author	Paper
Deepwalk	Bryan Perozzi et al	DeepWalk: Online Learning of Social Representations (KDD’14)
Node2vec	Aditya Grover and Jure Leskovec	node2vec: Scalable Feature Learning for Networks (KDD’16)
Node2vec+	Renming Liu et al	Accurately Modeling Biased Random Walks on Weighted Graphs Using Node2vec+
BANE	Hong Yang et al	Binarized attributed network embedding (ICDM’18)

⚡ Quick Start on GNNs

Datasets

more details please refer to GraphData.

Example of GCN (Node Classification Task)

It takes just a few lines of code.

from graphgallery.gallery.nodeclas import GCN
trainer = GCN()
trainer.setup_graph(graph)
trainer.build()
history = trainer.fit(train_nodes, val_nodes)
results = trainer.evaluate(test_nodes)
print(f'Test loss {results.loss:.5}, Test accuracy {results.accuracy:.2%}')

Other models in the gallery are the same.

If you have any troubles, you can simply run trainer.help() for more messages.

Other Backends

>>> import graphgallery
# Default: PyTorch backend
>>> graphgallery.backend()
PyTorch 1.9.0+cu111 Backend
# Switch to TensorFlow backend
>>> graphgallery.set_backend("tf")
# Switch to PyTorch backend
>>> graphgallery.set_backend("th")
# Switch to PyTorch Geometric backend
>>> graphgallery.set_backend("pyg")
# Switch to DGL PyTorch backend
>>> graphgallery.set_backend("dgl")

But your codes don’t even need to change.

❓ How to add your datasets

This is motivated by gnn-benchmark

from graphgallery.data import Graph

# Load the adjacency matrix A, attribute matrix X and labels vector y
# A - scipy.sparse.csr_matrix of shape [num_nodes, num_nodes]
# X - scipy.sparse.csr_matrix or np.ndarray of shape [num_nodes, num_attrs]
# y - np.ndarray of shape [num_nodes]

mydataset = Graph(adj_matrix=A, node_attr=X, node_label=y)
# save dataset
mydataset.to_npz('path/to/mydataset.npz')
# load dataset
mydataset = Graph.from_npz('path/to/mydataset.npz')

⭐ Road Map

Add PyTorch trainers support
Add other frameworks (PyG and DGL) support
set tensorflow as optional dependency when using graphgallery
Add more GNN trainers (TF and Torch backend)
Support for more tasks, e.g., graph Classification and link prediction
Support for more types of graphs, e.g., Heterogeneous graph
Add Docstrings and Documentation (Building)
Comprehensive tutorials

❓ FAQ

Please fell free to contact me if you have any troubles.

😘 Acknowledgement

This project is motivated by Pytorch Geometric, Tensorflow Geometric, Stellargraph and DGL, etc., and the original implementations of the authors, thanks for their excellent works!

Cite

Please cite our paper (and the respective papers of the methods used) if you use this code in your own work:

@inproceedings{li2021graphgallery,
author = {Jintang Li and Kun Xu and Liang Chen and Zibin Zheng and Xiao Liu},
booktitle = {2021 IEEE/ACM 43rd International Conference on Software Engineering: Companion Proceedings (ICSE-Companion)},
title = {GraphGallery: A Platform for Fast Benchmarking and Easy Development of Graph Neural Networks Based Intelligent Software},
year = {2021},
pages = {13-16},
publisher = {IEEE Computer Society},
address = {Los Alamitos, CA, USA},
}