Merge pull request #208 from gyzhou2000/gnnlfhf

[Model & dataset] add model gnnlfhf and dataset yelp

Author: gyzhou2000

examples/gnnlfhf/gnnlfhf_trainer.py

@@ -0,0 +1,146 @@
+import os
+# os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+# os.environ['TL_BACKEND'] = 'torch'
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+import sys
+import argparse
+sys.path.insert(0, os.path.abspath('./'))
+import tensorlayerx as tlx
+from gammagl.datasets import Planetoid
+from gammagl.utils import mask_to_index
+from gammagl.models import GNNLFHFModel
+from tensorlayerx.model import TrainOneStep, WithLoss
+
+
+class SemiSpvzLoss(WithLoss):
+    def __init__(self, net, loss_fn):
+        super(SemiSpvzLoss, self).__init__(backbone=net, loss_fn=loss_fn)
+
+    def forward(self, data, y):
+        logits = self.backbone_network(data['x'])
+        train_logits = tlx.gather(logits, data['train_idx'])
+        train_y = tlx.gather(data['y'], data['train_idx'])
+        loss = self._loss_fn(train_logits, train_y)
+
+        l2_reg = sum((tlx.reduce_sum(param ** 2) for param in self.backbone_network.reg_params))
+        loss = loss + data["reg_lambda"] / 2 * l2_reg
+
+        return loss
+
+
+def calculate_acc(logits, y, metrics):
+    """
+    Args:
+        logits: node logits
+        y: node labels
+        metrics: tensorlayerx.metrics
+    Returns:
+        rst
+    """
+
+    metrics.update(logits, y)
+    rst = metrics.result()
+    metrics.reset()
+    return rst
+
+
+def main(args):
+    # load datasets
+    if str.lower(args.dataset) not in ['cora','pubmed','citeseer']:
+        raise ValueError('Unknown dataset: {}'.format(args.dataset))
+    dataset = Planetoid(args.dataset_path, args.dataset)
+    graph = dataset[0]
+
+    # for mindspore, it should be passed into node indices
+    train_idx = mask_to_index(graph.train_mask)
+    test_idx = mask_to_index(graph.test_mask)
+    val_idx = mask_to_index(graph.val_mask)
+
+    net = GNNLFHFModel(in_channels = graph.num_features,
+                       out_channels = dataset.num_classes,
+                       hidden_dim = args.hidden_dim,
+                       model_type = args.model_type,
+                       model_form = args.model_form,
+                       edge_index = graph.edge_index,
+                       x = graph.x,
+                       alpha = args.alpha,
+                       mu = args.mu,
+                       beta = args.beta,
+                       niter = args.niter,
+                       drop_rate = args.drop_rate,
+                       num_layers = args.num_layers,
+                       name = "GNNLFHF")
+
+    optimizer = tlx.optimizers.Adam(lr=args.lr)
+    metrics = tlx.metrics.Accuracy()
+    train_weights = net.trainable_weights
+
+    loss_func = SemiSpvzLoss(net, tlx.losses.softmax_cross_entropy_with_logits)
+    train_one_step = TrainOneStep(loss_func, optimizer, train_weights)
+
+    data = {
+        "x": graph.x,
+        "y": graph.y,
+        "edge_index": graph.edge_index,
+        "train_idx": train_idx,
+        "test_idx": test_idx,
+        "val_idx": val_idx,
+        "num_nodes": graph.num_nodes,
+        "reg_lambda": args.reg_lambda
+    }
+
+    best_val_acc = 0
+    for epoch in range(args.n_epoch):
+        net.set_train()
+        train_loss = train_one_step(data, data['y'])
+        net.set_eval()
+        logits = net(data['x'])
+        val_logits = tlx.gather(logits, data['val_idx'])
+        val_y = tlx.gather(data['y'], data['val_idx'])
+        val_acc = calculate_acc(val_logits, val_y, metrics)
+
+        print("Epoch [{:0>3d}] ".format(epoch+1)\
+              + "  train loss: {:.4f}".format(train_loss.item())\
+              + "  val acc: {:.4f}".format(val_acc))
+
+        # save best model on evaluation set
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            net.save_weights(args.best_model_path+net.name+".npz", format='npz_dict')
+
+    net.load_weights(args.best_model_path+net.name+".npz", format='npz_dict')
+    net.set_eval()
+    logits = net(data['x'])
+    test_logits = tlx.gather(logits, data['test_idx'])
+    test_y = tlx.gather(data['y'], data['test_idx'])
+    test_acc = calculate_acc(test_logits, test_y, metrics)
+    print("Test acc:  {:.4f}".format(test_acc))
+
+
+if __name__ == '__main__':
+    # parameters setting
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--lr", type=float, default=0.01, help="learnin rate")
+    parser.add_argument("--n_epoch", type=int, default=200, help="number of epoch")
+    parser.add_argument("--hidden_dim", type=int, default=64, help="dimention of hidden layers")
+    parser.add_argument("--drop_rate", type=float, default=0.8, help="drop_rate")
+    parser.add_argument("--num_layers", type=int, default=2, help="number of layers")
+    parser.add_argument("--reg_lambda", type=float, default=5e-3, help="reg_lambda")
+    parser.add_argument('--dataset', type=str, default='cora', help='dataset')
+    parser.add_argument("--model_type", type=str, default=r'GNN-LF', help="GNN-LF or GNN-HF")
+    parser.add_argument("--model_form", type=str, default=r'closed', help="closed or iterative")
+    parser.add_argument("--dataset_path", type=str, default=r'./', help="path to save dataset")
+    parser.add_argument("--best_model_path", type=str, default=r'./', help="path to save best model")
+    parser.add_argument("--alpha", type=float, default=0.3, help="the value of alpha")
+    parser.add_argument("--mu", type=float, default=0.1, help="the value of mu")
+    parser.add_argument("--beta", type=float, default=0.1, help="the value of beta")
+    parser.add_argument("--niter", type=int, default=20, help="the value of niter")
+    parser.add_argument("--gpu", type=int, default=0)
+    
+    args = parser.parse_args()
+    if args.gpu >= 0:
+        tlx.set_device("GPU", args.gpu)
+    else:
+        tlx.set_device("CPU")
+
+    main(args)

examples/gnnlfhf/readme.md

@@ -0,0 +1,50 @@
+# Interpreting and Unifying Graph Neural Networks with An Optimization Framework（GNNLFHF）
+
+- Paper link: [https://arxiv.org/pdf/2101.11859](https://arxiv.org/pdf/2101.11859)
+- Author's code repo: [https://github.com/zhumeiqiBUPT/GNN-LF-HF/tree/main](https://github.com/zhumeiqiBUPT/GNN-LF-HF/tree/main). Note that the original code is implemented with PyTorch for the paper. 
+
+# Dataset Statics
+
+| Dataset  | # Nodes | # Edges | # Classes |
+|----------|---------|---------|-----------|
+| Cora     | 2,708   | 10,556  | 7         |
+| Citeseer | 3,327   | 9,228   | 6         |
+| Pubmed   | 19,717  | 88,651  | 3         |
+
+Refer to [Planetoid](https://gammagl.readthedocs.io/en/latest/api/gammagl.datasets.html#gammagl.datasets.Planetoid).
+
+Results
+-------
+
+```bash
+# available dataset: "cora", "citeseer", "pubmed"
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset cora --model_type GNN-LF --model_form closed --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset cora --model_type GNN-LF --model_form iterative --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset cora --model_type GNN-HF --model_form closed --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset cora --model_type GNN-HF --model_form iterative --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset citeseer --model_type GNN-LF --model_form closed --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset citeseer --model_type GNN-LF --model_form iterative --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset citeseer --model_type GNN-HF --model_form closed --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset citeseer --model_type GNN-HF --model_form iterative --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset pubmed --model_type GNN-LF --model_form closed --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset pubmed --model_type GNN-LF --model_form iterative --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset pubmed --model_type GNN-HF --model_form closed --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+TL_BACKEND="torch" python gnnlfhf_trainer.py --dataset pubmed --model_type GNN-HF --model_form iterative --alpha 0.3 --mu 0.1 --beta 0.1 --niter 20 --lr 0.01 --hidden_dim 64 --drop_rate 0.8 --reg_lambda 5e-3
+```
+
+| Dataset  | Model         | Paper      | Our(th)    |
+| -------- | ------------- | ---------- | ---------- |
+| cora     | GNN-LF-closed | 83.70±0.14 | 82.05±0.98 |
+| cora     | GNN-LF-iter   | 83.53±0.24 | 81.81±0.65 |
+| cora     | GNN-HF-closed | 83.96±0.22 | 82.48±1.18 |
+| cora     | GNN-HF-iter   | 83.79±0.29 | 81.28±0.69 |
+| citeseer | GNN-LF-closed | 71.98±0.33 | 70.51±1.08 |
+| citeseer | GNN-LF-iter   | 71.92±0.24 | 71.11±1.38 |
+| citeseer | GNN-HF-closed | 72.30±0.28 | 70.24±1.01 |
+| citeseer | GNN-HF-iter   | 72.03±0.36 | 70.14±1.52 |
+| pubmed   | GNN-LF-closed | 80.34±0.18 | 75.14±0.89 |
+| pubmed   | GNN-LF-iter   | 80.33±0.20 | 76.68±0.58 |
+| pubmed   | GNN-HF-closed | 80.41±0.25 | 76.36±0.71 |
+| pubmed   | GNN-HF-iter   | 80.54±0.25 | 78.02±0.28 |

gammagl/data/__init__.py

@@ -2,7 +2,7 @@
 from .heterograph import HeteroGraph
 from .dataset import Dataset
 from .batch import BatchGraph
-from .download import download_url
+from .download import download_url, download_google_url
 from .in_memory_dataset import InMemoryDataset
 from .extract import extract_zip, extract_tar
 from .utils import global_config_init
@@ -14,6 +14,7 @@
     'HeteroGraph',
     'Dataset',
     'download_url',
+    'download_google_url',
     'InMemoryDataset',
     'extract_zip',
     'extract_tar',

gammagl/data/download.py

@@ -67,3 +67,10 @@ def download_url(url: str, folder: str, log: bool = True,
                 pbar.update(chunk_size)
 
     return path
+
+
+def download_google_url(id: str, folder: str,
+                        filename: str, log: bool = True):
+    r"""Downloads the content of a Google Drive ID to a specific folder."""
+    url = f'https://drive.usercontent.google.com/download?id={id}&confirm=t'
+    return download_url(url, folder, log, filename)

gammagl/datasets/__init__.py

@@ -19,6 +19,7 @@
 from .wikics import WikiCS
 from .blogcatalog import BlogCatalog
 from .molecule_net import MoleculeNet
+from .yelp import Yelp
 
 __all__ = [
     'Amazon',
@@ -40,7 +41,8 @@
     'AMiner',
     'PolBlogs',
     'WikiCS',
-    'MoleculeNet'
+    'MoleculeNet',
+    'Yelp'
 ]
 
 classes = __all__

gammagl/datasets/yelp.py

@@ -0,0 +1,115 @@
+import json
+import os.path as osp
+from typing import Callable, List, Optional
+
+import numpy as np
+import scipy.sparse as sp
+import tensorlayerx as tlx
+
+from gammagl.data import Graph, InMemoryDataset, download_google_url
+
+
+class Yelp(InMemoryDataset):
+    r"""The Yelp dataset from the `"GraphSAINT: Graph Sampling Based
+    Inductive Learning Method" <https://arxiv.org/abs/1907.04931>`_ paper,
+    containing customer reviewers and their friendship.
+    
+    Parameters
+    ----------
+    root: str, optional
+        Root directory where the dataset should be saved.
+    transform: callable, optional
+        A function/transform that takes in an
+        :obj:`gammagl.data.Graph` object and returns a transformed
+        version. The data object will be transformed before every access.
+        (default: :obj:`None`)
+    pre_transform: callable, optional
+        A function/transform that takes in
+        an :obj:`gammagl.data.Graph` object and returns a
+        transformed version. The data object will be transformed before
+        being saved to disk. (default: :obj:`None`)
+    force_reload (bool, optional): Whether to re-process the dataset.
+        (default: :obj:`False`)
+
+    Tip
+    ---
+        .. list-table::
+            :widths: 10 10 10 10 10
+            :header-rows: 1
+            
+            * - #nodes
+              - #edges
+              - #features
+              - #tasks
+            * - 716,847
+              - 13,954,819
+              - 300
+              - 100
+    """
+
+    adj_full_id = '1Juwx8HtDwSzmVIJ31ooVa1WljI4U5JnA'
+    feats_id = '1Zy6BZH_zLEjKlEFSduKE5tV9qqA_8VtM'
+    class_map_id = '1VUcBGr0T0-klqerjAjxRmAqFuld_SMWU'
+    role_id = '1NI5pa5Chpd-52eSmLW60OnB3WS5ikxq_'
+
+    def __init__(
+        self,
+        root: str = None,
+        transform: Optional[Callable] = None,
+        pre_transform: Optional[Callable] = None,
+        force_reload: bool = False,
+    ) -> None:
+        super().__init__(root, transform, pre_transform,
+                         force_reload=force_reload)
+        self.data, self.slices = self.load_data(self.processed_paths[0])
+
+    @property
+    def raw_file_names(self) -> List[str]:
+        return ['adj_full.npz', 'feats.npy', 'class_map.json', 'role.json']
+
+    @property
+    def processed_file_names(self) -> str:
+        return 'data.pt'
+
+    def download(self) -> None:
+        download_google_url(self.adj_full_id, self.raw_dir, 'adj_full.npz')
+        download_google_url(self.feats_id, self.raw_dir, 'feats.npy')
+        download_google_url(self.class_map_id, self.raw_dir, 'class_map.json')
+        download_google_url(self.role_id, self.raw_dir, 'role.json')
+
+    def process(self) -> None:
+        f = np.load(osp.join(self.raw_dir, 'adj_full.npz'))
+        adj = sp.csr_matrix((f['data'], f['indices'], f['indptr']), f['shape'])
+        adj = adj.tocoo()
+        row = tlx.convert_to_tensor(adj.row, dtype=tlx.int64)
+        col = tlx.convert_to_tensor(adj.col, dtype=tlx.int64)
+        edge_index = tlx.stack([row, col], axis=0)
+
+        x = np.load(osp.join(self.raw_dir, 'feats.npy'))
+        x = tlx.convert_to_tensor(x, dtype=tlx.float32)
+
+        ys = [-1] * x.size(0)
+        with open(osp.join(self.raw_dir, 'class_map.json')) as f:
+            class_map = json.load(f)
+            for key, item in class_map.items():
+                ys[int(key)] = item
+        y = tlx.convert_to_tensor(ys)
+
+        with open(osp.join(self.raw_dir, 'role.json')) as f:
+            role = json.load(f)
+
+        train_mask = tlx.zeros((x.shape[0],), dtype=tlx.bool)
+        train_mask[tlx.convert_to_tensor(role['tr'])] = True
+
+        val_mask = tlx.zeros((x.shape[0],), dtype=tlx.bool)
+        val_mask[tlx.convert_to_tensor(role['va'])] = True
+
+        test_mask = tlx.zeros((x.shape[0],), dtype=tlx.bool)
+        test_mask[tlx.convert_to_tensor(role['te'])] = True
+
+        data = Graph(x=x, edge_index=edge_index, y=y, train_mask=train_mask,
+                    val_mask=val_mask, test_mask=test_mask)
+
+        data = data if self.pre_transform is None else self.pre_transform(data)
+
+        self.save_data(self.collate([data]), self.processed_paths[0])

gammagl/models/__init__.py

@@ -54,6 +54,8 @@
 from .graphormer import Graphormer
 from .fusedgat import FusedGATModel
 from .hid_net import Hid_net
+from .gnnlfhf import GNNLFHFModel
+
 __all__ = [
     'GCNModel',
     'GATModel',
@@ -110,7 +112,8 @@
     'SFGCNModel',
     'Graphormer',
     'FusedGATModel',
-    'hid_net'
+    'hid_net',
+    'GNNLFHFModel'
 ]
 
 classes = __all__