Are you sure you want to delete this task? Once this task is deleted, it cannot be recovered.
You can not select more than 25 topics
Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Guangyu Zhou
ec6dd72374
|
10 months ago | |
|---|---|---|
| .circleci | 10 months ago | |
| .github | 2 years ago | |
| docs | 1 year ago | |
| examples | 10 months ago | |
| gammagl | 10 months ago | |
| profiler | 10 months ago | |
| tests | 10 months ago | |
| third_party | 10 months ago | |
| .gitignore | 2 years ago | |
| .gitmodules | 10 months ago | |
| .readthedocs.yaml | 2 years ago | |
| CONTRIBUTING.md | 10 months ago | |
| LICENSE | 2 years ago | |
| MANIFEST.in | 10 months ago | |
| README.md | 10 months ago | |
| requirements.txt | 1 year ago | |
| setup.py | 10 months ago | |
| yunnao_tutotial.md | 1 year ago | |
README.md
Gamma Graph Library(GammaGL)
GammaGL is a multi-backend graph learning library based on TensorLayerX, which supports TensorFlow, PyTorch, PaddlePaddle, MindSpore as the backends.
We give a development tutorial in Chinese on wiki.
Highlighted Features
Multi-backend
GammaGL supports multiple deep learning backends, such as TensorFlow, PyTorch, Paddle and MindSpore. Different from DGL, the GammaGL's examples are implemented with the same code on different backend. It allows users to run the same code on different hardwares like Nvidia-GPU and Huawei-Ascend. Besides, users could use a particular framework API based on preferences for different frameworks.
PyG-Like
Following PyTorch Geometric(PyG), GammaGL utilizes a tensor-centric API. If you are familiar with PyG, it will be friendly and maybe a TensorFlow Geometric, Paddle Geometric, or MindSpore Geometric to you.
News
2023-04-01 paper accepted
Our paper GammaGL: A Multi-Backend Library for Graph Neural Networks is accpeted at SIGIR 2023 resource paper track.
2023-02-21 中国电子学会科技进步一等奖
算法库支撑了北邮牵头，蚂蚁、中移动、海致科技等参与的“大规模复杂异质图数据智能分析技术与规模化应用”项目。该项目获得了2022年电子学会科技进步一等奖。
2023-01-17 release v0.2
We release the latest version v0.2.
- 40 GNN models
- 20 datasets
- Efficient message passing operators and fused operator
- GPU sampling and heterogeneous graphs samplers.
2022-06-20 release v0.1
We release the latest version v0.1.
- Framework-agnostic design
- PyG-like
- Graph data structures, message passing module and sampling module
- 20+ GNN models
Quick Tour for New Users
In this quick tour, we highlight the ease of creating and training a GNN model with only a few lines of code.
Train your own GNN model
In the first glimpse of GammaGL, we implement the training of a GNN for classifying papers in a citation graph.
For this, we load the Cora dataset, and create a simple 2-layer GCN model using the pre-defined GCNConv:
import tensorlayerx as tlx
from gammagl.layers.conv import GCNConv
from gammagl.datasets import Planetoid
dataset = Planetoid(root='.', name='Cora')
class GCN(tlx.nn.Module):
def __init__(self, in_channels, hidden_channels, out_channels):
super().__init__()
self.conv1 = GCNConv(in_channels, hidden_channels)
self.conv2 = GCNConv(hidden_channels, out_channels)
self.relu = tlx.ReLU()
def forward(self, x, edge_index):
# x: Node feature matrix of shape [num_nodes, in_channels]
# edge_index: Graph connectivity matrix of shape [2, num_edges]
x = self.conv1(x, edge_index)
x = self.relu(x)
x = self.conv2(x, edge_index)
return x
model = GCN(dataset.num_features, 16, dataset.num_classes)
We can now optimize the model in a training loop, similar to the standard TensorLayerX training procedure.
import tensorlayerx as tlx
data = dataset[0]
loss_fn = tlx.losses.softmax_cross_entropy_with_logits
optimizer = tlx.optimizers.Adam(learning_rate=1e-3)
net_with_loss = tlx.model.WithLoss(model, loss_fn)
train_one_step = tlx.model.TrainOneStep(net_with_loss, optimizer, train_weights)
for epoch in range(200):
loss = train_one_step(data.x, data.y)
We can now optimize the model in a training loop, similar to the standard PyTorch training procedure.
import torch.nn.functional as F
data = dataset[0]
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
for epoch in range(200):
pred = model(data.x, data.edge_index)
loss = F.cross_entropy(pred[data.train_mask], data.y[data.train_mask])
# Backpropagation
optimizer.zero_grad()
loss.backward()
optimizer.step()
We can now optimize the model in a training loop, similar to the standard TensorFlow training procedure.
import tensorflow as tf
optimizer = tf.keras.optimizers.Adam()
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
for epoch in range(200):
with tf.GradientTape() as tape:
predictions = model(images, training=True)
loss = loss_fn(labels, predictions)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
We can now optimize the model in a training loop, similar to the standard PaddlePaddle training procedure.
import paddle
data = dataset[0]
optim = paddle.optimizer.Adam(parameters=model.parameters())
loss_fn = paddle.nn.CrossEntropyLoss()
model.train()
for epoch in range(200):
predicts = model(data.x, data.edge_index)
loss = loss_fn(predicts, y_data)
# Backpropagation
loss.backward()
optim.step()
optim.clear_grad()
We can now optimize the model in a training loop, similar to the standard MindSpore training procedure.
# 1. Generate training dataset
train_dataset = create_dataset(num_data=160, batch_size=16)
# 2.Build a model and define the loss function
net = LinearNet()
loss = nn.MSELoss()
# 3.Connect the network with loss function, and define the optimizer
net_with_loss = nn.WithLossCell(net, loss)
opt = nn.Momentum(net.trainable_params(), learning_rate=0.005, momentum=0.9)
# 4.Define the training network
train_net = nn.TrainOneStepCell(net_with_loss, opt)
# 5.Set the model as training mode
train_net.set_train()
# 6.Training procedure
for epoch in range(200):
for d in train_dataset.create_dict_iterator():
result = train_net(d['data'], d['label'])
print(f"Epoch: [{epoch} / {epochs}], "
f"step: [{step} / {steps}], "
f"loss: {result}")
step = step + 1
More information about evaluating final model performance can be found in the corresponding example.
Create your own GNN layer
In addition to the easy application of existing GNNs, GammaGL makes it simple to implement custom Graph Neural Networks (see here for the accompanying tutorial).
For example, this is all it takes to implement the edge convolutional layer from Wang et al.:
$$x_i^{\prime} ~ = ~ \max_{j \in \mathcal{N}(i)} ~ \textrm{MLP}_{\theta} \left( [ ~ x_i, ~ x_j - x_i ~ ] \right)$$
import tensorlayerx as tlx
from tensorlayerx.nn import Sequential as Seq, Linear, ReLU
from gammagl.layers import MessagePassing
class EdgeConv(MessagePassing):
def __init__(self, in_channels, out_channels):
super().__init__()
self.mlp = Seq(Linear(2 * in_channels, out_channels),
ReLU(),
Linear(out_channels, out_channels))
def forward(self, x, edge_index):
# x has shape [N, in_channels]
# edge_index has shape [2, E]
return self.propagate(x=x, edge_index,aggr_type='max')
def message(self, x_i, x_j):
# x_i has shape [E, in_channels]
# x_j has shape [E, in_channels]
tmp = tlx.concat([x_i, x_j - x_i], axis=1) # tmp has shape [E, 2 * in_channels]
return self.mlp(tmp)
Get Started
-
Python environment (Optional): We recommend using Conda package manager
conda create -n ggl python=3.7 source activate ggl -
Install Backend
# For tensorflow pip install tensorflow-gpu # GPU version pip install tensorflow # CPU version # For torch, version 1.10 # https://pytorch.org/get-started/locally/ pip3 install torch==1.10.2 # For paddle, any latest stable version # https://www.paddlepaddle.org.cn/ python -m pip install paddlepaddle-gpu # For mindspore, GammaGL only supports version 1.8.1, GPU-CUDA 11.1 # https://www.mindspore.cn/install pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/1.8.1/MindSpore/gpu/x86_64/cuda-11.1/mindspore_gpu-1.8.1-cp37-cp37m-linux_x86_64.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simpleFor other backend with specific version, please check whether TLX supports.
pip install git+https://github.com/tensorlayer/tensorlayerx.git大陆用户如果遇到网络问题，推荐从启智社区安装
Try to git clone from OpenI
pip install git+https://git.openi.org.cn/OpenI/TensorLayerX.git -
Download GammaGL
git clone --recursive https://github.com/BUPT-GAMMA/GammaGL.git python setup.py install大陆用户如果遇到网络问题，推荐从启智社区安装
Try to git clone from OpenI
git clone --recursive https://git.openi.org.cn/GAMMALab/GammaGL.git"--recursive" is required, if you forgot, you can run command below in Gammagl root dir:
git submodule update --init
How to Run
Take GCN as an example:
# cd ./examples/gcn
# set parameters if necessary
python gcn_trainer.py --dataset cora --lr 0.01
If you want to use specific backend or GPU, just set environment variable like:
CUDA_VISIBLE_DEVICES="1" TL_BACKEND="paddle" python gcn_trainer.py
Note
The DEFAULT backend is
tensorflowand GPU is0. The backend TensorFlow will take up all GPU left memory by default.The CANDIDATE backends are
tensorflow,paddle,torchandmindspore.Set
CUDA_VISIBLE_DEVICES=" "if you want to run it in CPU.
Supported Models
| Contrastive Learning | TensorFlow | PyTorch | Paddle | MindSpore |
|---|---|---|---|---|
| DGI [ICLR 2019] | ✔️ | ✔️ | ✔️ | |
| GRACE [ICML 2020 Workshop] | ✔️ | ✔️ | ✔️ | |
| MVGRL [ICML 2020] | ✔️ | ✔️ | ✔️ | |
| InfoGraph [ICLR 2020] | ✔️ | ✔️ | ✔️ | |
| MERIT [IJCAI 2021] | ✔️ | ✔️ |
| Heterogeneous Graph Learning | TensorFlow | PyTorch | Paddle | MindSpore |
|---|---|---|---|---|
| RGCN [ESWC 2018] | ✔️ | ✔️ | ✔️ | |
| HAN [WWW 2019] | ✔️ | ✔️ | ✔️ | ✔️ |
| HGT [WWW 2020] | ✔️ | ✔️ | ✔️ | |
| SimpleHGN [KDD 2021] | ✔️ | |||
| CompGCN [ICLR 2020] | ✔️ | ✔️ | ||
| HPN [TKDE 2021] | ✔️ | ✔️ | ✔️ | ✔️ |
| ieHGCN [TKDE 2021] | ✔️ | ✔️ | ✔️ | |
| MetaPath2Vec [KDD 2017] | ✔️ | ✔️ | ✔️ | |
| HERec [TKDE 2018] | ✔️ | ✔️ | ✔️ |
Note
The models can be run in mindspore backend. Howerver, the results of experiments are not satisfying due to training component issue,
which will be fixed in future.
Contributors
GammaGL Team[GAMMA LAB] and Peng Cheng Laboratory.
See more in CONTRIBUTING.
Contribution is always welcomed. Please feel free to open an issue or email to yaoqiliu@bupt.edu.cn.
Cite GammaGL
If you use GammaGL in a scientific publication, we would appreciate citations to the following paper:
@inproceedings{Liu2023gammagl,
title={GammaGL: A Multi-Backend Library for Graph Neural Networks},
author={Yaoqi Liu, Cheng Yang, Tianyu Zhao, Hui Han, Siyuan Zhang, Jing Wu, Guangyu Zhou, Hai Huang, Hui Wang, Chuan Shi},
booktitle={SIGIR},
year={2023}
}
No Description
Python C++ Cuda Markdown Text
Contributors (25+)
34649403+Theheavens@users.noreply.github.com
48177103+zsy0828@users.noreply.github.com
948283368@qq.com
1340175409@qq.com
1416320489@qq.com
78466115+The3yx@users.noreply.github.com
77875480+gyzhou2000@users.noreply.github.com
61597185+LuoXC-Wu@users.noreply.github.com
1048435989@qq.com
75086617+dddg617@users.noreply.github.com
77875480+HeuTab@users.noreply.github.com
61610568+jymmmmm@users.noreply.github.com
65502815+yang71@users.noreply.github.com
github 710697495@qq.com
45054549+YijianLiu@users.noreply.github.com
50618951+Zhanghyi@users.noreply.github.com
59616556+1957787636@users.noreply.github.com
49893870+0fvlllx@users.noreply.github.com
81277810+Eliaukyh@users.noreply.github.com
73645437+Enthalpyyy@users.noreply.github.com