A multi-backend graph learning library.
Alternatives To Gammagl
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Dgl12,21815526 hours ago446September 20, 2022430apache-2.0Python
Python package built to ease deep learning on graph, on top of existing DL frameworks.
Tflearn9,595481821 days ago6November 11, 2020575otherPython
Deep learning library featuring a higher-level API for TensorFlow.
6 months ago644gpl-3.0Python
Translate darknet to tensorflow. Load trained weights, retrain/fine-tune using tensorflow, export constant graph def to mobile devices
Smile5,79312134a month ago33June 14, 202317otherJava
Statistical Machine Intelligence & Learning Engine
Graph_nets5,188719 months ago7January 29, 20205apache-2.0Python
Build Graph Nets in Tensorflow
Graph Based Deep Learning Literature4,294
a month ago1mitJupyter Notebook
links to conference publications in graph-based deep learning
3 months ago2April 10, 2019218apache-2.0C++
A distributed graph deep learning framework.
Stellargraph2,7682612 days ago24September 14, 2018318apache-2.0Python
StellarGraph - Machine Learning on Graphs
Yolov3 Tf22,501
a day ago167mitJupyter Notebook
YoloV3 Implemented in Tensorflow 2.0
3 years ago4mit
A comprehensive collection of recent papers on graph deep learning
Alternatives To Gammagl
Select To Compare

Alternative Project Comparisons

Gamma Graph Library(GammaGL)

GitHub release (latest by date) Documentation Status GitHub visitors GitHub all releases Total lines

Documentation |

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


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.


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.


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-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):
        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
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()

for epoch in range(200):
    predicts = model(data.x, data.edge_index)
    loss = loss_fn(predicts, y_data)

    # Backpropagation
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

# 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):
        self.mlp = Seq(Linear(2 * in_channels, out_channels),
                       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

  1. Python environment (Optional): We recommend using Conda package manager

    $ conda create -n ggl python=3.8
    $ source activate ggl
  2. Install Backend

    # For tensorflow
    $ pip install tensorflow-gpu # GPU version
    $ pip install tensorflow # CPU version
    # For torch, version 1.10
    $ pip install torch==1.10.1+cu111 torchvision==0.11.2+cu111 torchaudio==0.10.1 -f
    # For paddle, any latest stable version
    $ python -m pip install paddlepaddle-gpu
    # For mindspore, GammaGL only supports version 1.8.1, GPU-CUDA 11.1
    $ pip install --trusted-host -i

    For other backend with specific version, please check whether TLX supports.

    Install TensorLayerX

    pip install git+ 

    Try to git clone from OpenI

    pip install git+


    • TensorFlow is necessary when installing TensorLayerX.
    • The version of protobuf should be 3.19.6, remember to re-install it after you install TensorLayerX.
  3. Download GammaGL

    $ git clone --recursive
    $ pip install pybind11 pyparsing
    $ python install

    Try to git clone from OpenI

    git clone --recursive


    "--recursive" is necessary, 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 --dataset cora --lr 0.01

If you want to use specific backend or GPU, just set environment variable like:



The DEFAULT backend is tensorflow and GPU is 0. The backend TensorFlow will take up all GPU left memory by default.

The CANDIDATE backends are tensorflow, paddle, torch and mindspore.

Set CUDA_VISIBLE_DEVICES=" " if you want to run it in CPU.

Supported Models

TensorFlow PyTorch Paddle MindSpore
GCN [ICLR 2017] ✔️ ✔️ ✔️ ✔️
GAT [ICLR 2018] ✔️ ✔️ ✔️ ✔️
GraphSAGE [NeurIPS 2017] ✔️ ✔️ ✔️ ✔️
ChebNet [NeurIPS 2016] ✔️ ✔️ ✔️
GCNII [ICLR 2017] ✔️ ✔️ ✔️
JKNet [ICML 2018] ✔️ ✔️ ✔️
DiffPool [NeurIPS 2018]
SGC [ICML 2019] ✔️ ✔️ ✔️ ✔️
GIN [ICLR 2019] ✔️ ✔️ ✔️
APPNP [ICLR 2019] ✔️ ✔️ ✔️ ✔️
AGNN [arxiv] ✔️ ✔️ ✔️ ✔️
SIGN [ICML 2020 Workshop] ✔️ ✔️ ✔️
DropEdge [ICLR 2020] ✔️ ✔️ ✔️ ✔️
GPRGNN [ICLR 2021] ✔️
GNN-FiLM [ICML 2020] ✔️ ✔️ ✔️
GraphGAN [AAAI 2018] ✔️ ✔️ ✔️
HardGAT [KDD 2019] ✔️ ✔️ ✔️
MixHop [ICML 2019] ✔️ ✔️ ✔️ ✔️
PNA [NeurIPS 2020] ✔️ ✔️ ✔️
FAGCN [AAAI 2021] ✔️ ✔️ ✔️
GATv2 [ICLR 2021] ✔️ ✔️ ✔️
GEN [WWW 2021] ✔️ ✔️
GAE [NeurIPS 2016] ✔️ ✔️ ✔️
VGAE [NeurIPS 2016] ✔️ ✔️ ✔️
HCHA [PR 2021] ✔️ ✔️ ✔️
Node2Vec [KDD 2016] ✔️ ✔️ ✔️
DeepWalk [KDD 2014] ✔️ ✔️ ✔️
DGCNN [ACM T GRAPHIC 2019] ✔️ ✔️
GaAN [UAI 2018] ✔️ ✔️ ✔️
GRADE [NeurIPS 2022] ✔️ ✔️ ✔️
GMM [CVPR 2017] ✔️ ✔️ ✔️ ✔️
TADW [IJCAI 2015] ✔️ ✔️ ✔️ ✔️
MGNNI [NeurIPS 2022] ✔️ ✔️ ✔️
MAGCL [AAAI 2023] ✔️ ✔️ ✔️
CAGCN [NeurIPS 2021] ✔️ ✔️ ✔️
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] ✔️ ✔️ ✔️


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.


GammaGL Team[GAMMA LAB] and Peng Cheng Laboratory.


Contribution is always welcomed. Please feel free to open an issue or email to [email protected].

Cite GammaGL

If you use GammaGL in a scientific publication, we would appreciate citations to the following paper:

  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},
Popular Graph Projects
Popular Deep Learning Projects
Popular Computer Science Categories

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
Deep Learning
Framework Agnostic