Description
GraphSAINT is a general and flexible framework designed for training Graph Neural Networks (GNNs) on large-scale graphs. It distinguishes itself through a novel minibatch training methodology that employs graph sampling, a departure from conventional layer sampling approaches. This graph sampling technique allows for the construction of complete GNN layers on small sampled subgraphs, rather than sampling within layers. This fundamental shift in perspective leads to several key advantages.
Read More
Accuracy is enhanced through simple yet effective normalization techniques that mitigate bias introduced by graph sampling. Furthermore, GraphSAINT proposes lightweight graph samplers that preserve crucial neighbors based on topological characteristics, addressing information loss inherent in any sampling process. This can also be viewed as a form of data augmentation or training regularization.
Efficiency is significantly improved by resolving the 'neighbor explosion' problem, a common challenge in layer sampling methods. By constructing complete, unsampled GNN layers on subgraphs, the number of neighbors remains constant regardless of network depth, reducing computation cost per minibatch from exponential to linear with respect to GNN depth. This also dramatically reduces communication overhead in distributed settings.
Flexibility is a core tenet of GraphSAINT. Layer propagation on a minibatch subgraph closely mirrors that on the full graph, enabling seamless training of most GNN architectures designed for full graphs. This contrasts with some layer sampling algorithms that support only limited GNN architectures. Scalability is achieved across graph size, model size, and parallel resources. Subgraph sizes do not need to grow proportionally with graph size, allowing large graphs to fit in GPU memory. Training costs scale linearly with GNN width and depth, and graph sampling is highly parallelizable.
The repository provides Python implementations in both TensorFlow and PyTorch, along with a C++ implementation for parallel training techniques. It supports various GNN architectures like GraphSAGE, GAT, and JK-Net, and multiple graph samplers including Node, Edge, RW, and MRW. The framework is designed for researchers and practitioners working with large graph datasets who need efficient and accurate GNN training.
- CategoryMachine Learning Platforms
- Pricing ModelOpen source
- DeploymentCloud, Self-hosted
- PlatformsLinux, Windows
GraphSAINT's Core Features
Minibatch training for deep GNNs on large graphs
Graph sampling-based inductive learning method
Novel minibatch training approach using graph sampling
Eliminates bias introduced by graph sampling via normalization
Light-weight graph samplers to preserve important neighbors
Resolves 'neighbor explosion' problem for efficiency
Scalable with respect to graph size, model size, and parallel resources
Supports multiple GNN architectures (GraphSAGE, GAT, JK-Net, GaAN, MixHop)
Supports various graph samplers (Node, Edge, RW, MRW, Full graph)
Available in TensorFlow and PyTorch implementations
Includes C++ implementation for parallel training techniques
Facilitates customization for own datasets and samplers
Getting Started with GraphSAINT
Access model: Clone the GitHub repository.
Set up environment: Install dependencies including Python, TensorFlow/PyTorch, Cython, and g++.
Compile samplers: Run `python graphsaint/setup.py build_ext --inplace`.
Prepare dataset: Format your graph data into `adj_full.npz`, `adj_train.npz`, `role.json`, `class_map.json`, and `feats.npy`.
Configure training: Set hyperparameters using YAML configuration files in `./train_config/`.
Run training: Execute training scripts using `python -m graphsaint.<tensorflow/pytorch>_version.train` with appropriate flags for data, config, and GPU usage.
GraphSAINT's Use Cases
- Large-scale graph training
- Inductive learning on graphs
- Graph representation learning
- Node classification
- Link prediction
- Graph-level prediction
- Custom GNN development
