├── cora.png ├── pubmed.png ├── citeseer.png ├── requirements-cpu.txt ├── requirements-gpu.txt ├── LICENSE ├── .gitignore ├── gcn ├── utils.py ├── trainer.py └── model.py ├── README.md └── notebooks └── gcn_testing.ipynb /cora.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/andrejmiscic/gcn-pytorch/HEAD/cora.png -------------------------------------------------------------------------------- /pubmed.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/andrejmiscic/gcn-pytorch/HEAD/pubmed.png -------------------------------------------------------------------------------- /citeseer.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/andrejmiscic/gcn-pytorch/HEAD/citeseer.png -------------------------------------------------------------------------------- /requirements-cpu.txt: -------------------------------------------------------------------------------- 1 | dataclasses==0.7 2 | numpy==1.18.5 3 | pandas==1.1.3 4 | plotnine==0.6.0 5 | scipy==1.4.1 6 | scikit-learn==0.22.2.post1 7 | torch==1.6.0+cpu 8 | torch-cluster==1.5.7+cpu 9 | -f https://pytorch-geometric.com/whl/torch-1.6.0.html 10 | torch-scatter==2.0.5+cpu 11 | -f https://pytorch-geometric.com/whl/torch-1.6.0.html 12 | torch-sparse==0.6.7+cpu 13 | -f https://pytorch-geometric.com/whl/torch-1.6.0.html 14 | torch-spline-conv==1.2.0+cpu 15 | -f https://pytorch-geometric.com/whl/torch-1.6.0.html 16 | torch-geometric==1.6.1 17 | tqdm==4.41.1 -------------------------------------------------------------------------------- /requirements-gpu.txt: -------------------------------------------------------------------------------- 1 | dataclasses==0.7 2 | numpy==1.18.5 3 | pandas==1.1.3 4 | plotnine==0.6.0 5 | scipy==1.4.1 6 | scikit-learn==0.22.2.post1 7 | torch==1.6.0+cu101 8 | torch-scatter==latest+cu101 9 | -f https://pytorch-geometric.com/whl/torch-1.6.0.html 10 | torch-sparse==latest+cu101 11 | -f https://pytorch-geometric.com/whl/torch-1.6.0.html 12 | torch-cluster==latest+cu101 13 | -f https://pytorch-geometric.com/whl/torch-1.6.0.html 14 | torch-spline-conv==latest+cu101 15 | -f https://pytorch-geometric.com/whl/torch-1.6.0.html 16 | torch-geometric==1.6.1 17 | tqdm==4.41.1 -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Andrej Miscic 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | pip-wheel-metadata/ 24 | share/python-wheels/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | MANIFEST 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .nox/ 44 | .coverage 45 | .coverage.* 46 | .cache 47 | nosetests.xml 48 | coverage.xml 49 | *.cover 50 | *.py,cover 51 | .hypothesis/ 52 | .pytest_cache/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | target/ 76 | 77 | # Jupyter Notebook 78 | .ipynb_checkpoints 79 | 80 | # IPython 81 | profile_default/ 82 | ipython_config.py 83 | 84 | # pyenv 85 | .python-version 86 | 87 | # pipenv 88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 91 | # install all needed dependencies. 92 | #Pipfile.lock 93 | 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 95 | __pypackages__/ 96 | 97 | # Celery stuff 98 | celerybeat-schedule 99 | celerybeat.pid 100 | 101 | # SageMath parsed files 102 | *.sage.py 103 | 104 | # Environments 105 | .env 106 | .venv 107 | env/ 108 | venv/ 109 | ENV/ 110 | env.bak/ 111 | venv.bak/ 112 | 113 | # Spyder project settings 114 | .spyderproject 115 | .spyproject 116 | 117 | # Rope project settings 118 | .ropeproject 119 | 120 | # mkdocs documentation 121 | /site 122 | 123 | # mypy 124 | .mypy_cache/ 125 | .dmypy.json 126 | dmypy.json 127 | 128 | # Pyre type checker 129 | .pyre/ 130 | -------------------------------------------------------------------------------- /gcn/utils.py: -------------------------------------------------------------------------------- 1 | from enum import Enum 2 | 3 | import numpy as np 4 | import scipy.sparse as sparse 5 | import torch 6 | import torch.nn as nn 7 | from torch_geometric.datasets import Planetoid 8 | from torch_geometric.utils import to_scipy_sparse_matrix 9 | 10 | 11 | class Dataset(Enum): 12 | Cora = 0 13 | CiteSeer = 1 14 | PubMed = 2 15 | 16 | 17 | def load_data(dataset_name: Dataset, load_dir="planetoid"): 18 | dataset = Planetoid(root=load_dir, name=dataset_name.name) 19 | data = dataset[0] # a single graph 20 | 21 | # read & normalize features 22 | features = data.x.clone() 23 | features_sum = features.sum(1).unsqueeze(1) 24 | features_sum[features_sum == 0] = 1. 25 | features = torch.div(features, features_sum) 26 | 27 | # read train, test, valid labels based on public splits of this data 28 | ignore_index = nn.CrossEntropyLoss().ignore_index # = -100, used to ignore not allowed labels in CE loss 29 | num_classes = len(set(data.y.numpy())) 30 | labels = data.y.clone() 31 | train_labels = set_labels(data.y.clone(), data.train_mask, ignore_index) 32 | val_labels = set_labels(data.y.clone(), data.val_mask, ignore_index) 33 | test_labels = set_labels(data.y.clone(), data.test_mask, ignore_index) 34 | 35 | # read & normalize adjacency matrix 36 | adjacency_matrix, adj_csr = get_adjacency_matrix(data.edge_index) 37 | 38 | # compute rescaled laplacian 39 | laplacian_matrix = get_laplacian_matrix(adj_csr) 40 | 41 | return features, labels, train_labels, val_labels, test_labels, adjacency_matrix, laplacian_matrix, num_classes 42 | 43 | 44 | def set_labels(initial_labels, set_mask, ignore_label): 45 | initial_labels[~set_mask] = ignore_label 46 | return initial_labels 47 | 48 | 49 | def get_adjacency_matrix(edge_index): 50 | # working with scipy sparse since current PyTorch version doesn't support sparse x sparse multiplication 51 | adj = to_scipy_sparse_matrix(edge_index) 52 | adj += sparse.eye(adj.shape[0]) # add self loops 53 | degree_for_norm = sparse.diags(np.power(np.array(adj.sum(1)), -0.5).flatten()) # D^(-0.5) 54 | adj_hat_csr = degree_for_norm.dot(adj.dot(degree_for_norm)) # D^(-0.5) * A * D^(-0.5) 55 | adj_hat_coo = adj_hat_csr.tocoo().astype(np.float32) 56 | # to torch sparse matrix 57 | indices = torch.from_numpy(np.vstack((adj_hat_coo.row, adj_hat_coo.col)).astype(np.int64)) 58 | values = torch.from_numpy(adj_hat_coo.data) 59 | adjacency_matrix = torch.sparse_coo_tensor(indices, values, torch.Size(adj_hat_coo.shape)) 60 | 61 | return adjacency_matrix, adj_hat_csr 62 | 63 | 64 | def get_laplacian_matrix(adjacency_matrix_csr: sparse.csr_matrix): 65 | # since adjacency_matrix_csr is already in form D^(-0.5) * A * D^(-0.5), we can simply get normalized laplacian by: 66 | laplacian = sparse.eye(adjacency_matrix_csr.shape[0]) - adjacency_matrix_csr 67 | # rescaling laplacian 68 | max_eigenval = sparse.linalg.eigsh(laplacian, k=1, which='LM', return_eigenvectors=False)[0] 69 | laplacian = 2 * laplacian / max_eigenval - sparse.eye(adjacency_matrix_csr.shape[0]) 70 | # to torch sparse matrix 71 | laplacian = laplacian.tocoo().astype(np.float32) 72 | indices = torch.from_numpy(np.vstack((laplacian.row, laplacian.col)).astype(np.int64)) 73 | values = torch.from_numpy(laplacian.data) 74 | laplacian_matrix = torch.sparse_coo_tensor(indices, values, torch.Size(laplacian.shape)) 75 | return laplacian_matrix 76 | -------------------------------------------------------------------------------- /gcn/trainer.py: -------------------------------------------------------------------------------- 1 | import copy 2 | from dataclasses import dataclass 3 | import os 4 | 5 | import torch 6 | import torch.nn as nn 7 | from torch.optim import Adam, lr_scheduler 8 | from tqdm import tqdm 9 | 10 | 11 | @dataclass 12 | class RunConfig: # default parameters from the paper and official implementation 13 | learning_rate: float = 0.01 14 | num_epochs: int = 200 15 | weight_decay: float = 5e-4 16 | num_warmup_steps: int = 0 17 | save_each_epoch: bool = False 18 | output_dir: str = "." 19 | 20 | 21 | class Trainer: 22 | def __init__(self, model): 23 | self.model = model 24 | 25 | def train(self, features, train_labels, val_labels, additional_matrix, device, run_config, log=True): 26 | self.model = self.model.to(device) 27 | features = features.to(device) 28 | train_labels = train_labels.to(device) 29 | additional_matrix = additional_matrix.to(device) # adjacency or laplacian matrix depending on the model 30 | 31 | optimizer = Adam(self.model.parameters(), lr=run_config.learning_rate, weight_decay=run_config.weight_decay) 32 | 33 | # https://huggingface.co/transformers/_modules/transformers/optimization.html#get_linear_schedule_with_warmup 34 | def lr_lambda(current_step: int): 35 | if current_step < run_config.num_warmup_steps: 36 | return float(current_step) / float(max(1, run_config.num_warmup_steps)) 37 | return max(0.0, float(run_config.num_epochs - current_step) / 38 | float(max(1, run_config.num_epochs - run_config.num_warmup_steps))) 39 | 40 | scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda) 41 | 42 | if log: 43 | print("Training started:") 44 | print(f"\tNum Epochs = {run_config.num_epochs}") 45 | 46 | best_loss, best_model_accuracy = float("inf"), 0 47 | best_model_state_dict = None 48 | train_iterator = tqdm(range(0, int(run_config.num_epochs)), desc="Epoch") 49 | for epoch in train_iterator: 50 | self.model.train() 51 | outputs = self.model(features, additional_matrix, train_labels) 52 | loss = outputs[1] 53 | 54 | self.model.zero_grad() 55 | loss.backward() 56 | optimizer.step() 57 | scheduler.step() 58 | 59 | val_loss, val_accuracy = self.evaluate(features, val_labels, additional_matrix, device) 60 | train_iterator.set_description(f"Training loss = {loss.item():.4f}, " 61 | f"val loss = {val_loss:.4f}, val accuracy = {val_accuracy:.2f}") 62 | 63 | save_best_model = val_loss < best_loss 64 | if save_best_model: 65 | best_loss = val_loss 66 | best_model_accuracy = val_accuracy 67 | best_model_state_dict = copy.deepcopy(self.model.state_dict()) 68 | if save_best_model or run_config.save_each_epoch or epoch + 1 == run_config.num_epochs: 69 | output_dir = os.path.join(run_config.output_dir, f"Epoch_{epoch + 1}") 70 | self.save(output_dir) 71 | if log: 72 | print(f"Best model val CE loss = {best_loss:.4f}, best model val accuracy = {best_model_accuracy:.2f}") 73 | # reloads the best model state dict, bit hacky :P 74 | self.model.load_state_dict(best_model_state_dict) 75 | 76 | def evaluate(self, features, test_labels, additional_matrix, device): 77 | features = features.to(device) 78 | test_labels = test_labels.to(device) 79 | additional_matrix = additional_matrix.to(device) 80 | 81 | self.model.eval() 82 | 83 | outputs = self.model(features, additional_matrix, test_labels) 84 | ce_loss = outputs[1].item() 85 | 86 | ignore_label = nn.CrossEntropyLoss().ignore_index 87 | predicted_label = torch.max(outputs[0], dim=1).indices[test_labels != ignore_label] 88 | true_label = test_labels[test_labels != -100] 89 | accuracy = torch.mean((true_label == predicted_label).type(torch.FloatTensor)).item() 90 | 91 | return ce_loss, accuracy 92 | 93 | def save(self, output_dir): 94 | if not os.path.isdir(output_dir): 95 | os.makedirs(output_dir) 96 | 97 | model_path = os.path.join(output_dir, "model.pth") 98 | torch.save(self.model.state_dict(), model_path) 99 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## Graph Convolutional Networks in PyTorch 2 | 3 | Re-implementation of the work described in [Semi-Supervised Classification with Graph Convolutional Networks](https://arxiv.org/abs/1609.02907). 4 | 5 | The implementation contains two different propagation models, the one from original GCN as described in the above paper and the Chebyshev filter based one from [Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering](https://arxiv.org/abs/1606.09375). 6 | 7 | ## Installation & Usage 8 | 9 | To quickly check: [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/andrejmiscic/gcn-pytorch/blob/main/notebooks/gcn_testing.ipynb) 10 | 11 | ```bash 12 | git clone https://github.com/andrejmiscic/gcn-pytorch.git 13 | cd gcn-pytorch 14 | ``` 15 | 16 | The requirements are dependent on whether you want to use a GPU or not: 17 | 18 | ```bash 19 | pip install -r requirements_gpu.txt 20 | ``` 21 | or 22 | ```bash 23 | pip install -r requirements_cpu.txt 24 | ``` 25 | 26 | A simple evaluation of the model on Cora dataset: 27 | 28 | ```python 29 | import torch 30 | 31 | from gcn.model import TwoLayerGCN 32 | from gcn.trainer import Trainer, RunConfig 33 | from gcn.utils import Dataset, load_data 34 | 35 | features, labels, train_labels, val_labels, test_labels, adjacency_matrix, \ 36 | laplacian_matrix, num_classes = load_data(Dataset.Cora) 37 | 38 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu") 39 | 40 | # training parameters 41 | run_config = RunConfig(learning_rate=0.1, num_epochs=200, weight_decay=5e-4, output_dir="gcn/") 42 | 43 | # constructing a GCN model 44 | model = TwoLayerGCN( 45 | input_size=features.size(1), 46 | hidden_size=16, 47 | output_size=num_classes, 48 | dropout=0.5 49 | ) 50 | 51 | # training 52 | trainer = Trainer(model) 53 | trainer.train(features, train_labels, val_labels, adjacency_matrix, device, run_config, log=False) 54 | 55 | # evaluating 56 | ce_loss, accuracy = trainer.evaluate(features, test_labels, adjacency_matrix, device) 57 | ``` 58 | 59 | You can check out `notebooks/gcn_testing.ipynb` that contains all the code for reproducing the results. 60 | 61 | To run the notebook on Google Colab follow the link 62 | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/andrejmiscic/gcn-pytorch/blob/main/notebooks/gcn_testing.ipynb) 63 | 64 | ## Results 65 | 66 | Test set accuracy for this implementation in comparison to the original paper. All results are based on public splits of analyzed datasets. 67 | In our results we report standard deviation of accuracy based on 100 repetitions. 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 |
Dataset:CoraCiteSeerPubMed
Original paper
GCN81.570.379.0
Cheb (K=2)81.269.673.8
Cheb (K=3)79.569.874.4
This implementation
GCN82.2 ± 0.571.0 ± 0.679.1 ± 0.5
Cheb (K=2)81.3 ± 0.771.1 ± 0.977.9 ± 0.9
Cheb (K=3)82.5 ± 0.771.2 ± 0.879.0 ± 0.7
123 | 124 | Results of experiments with model depth and residual connections are shown below. Same as in the original paper the whole dataset is used and the mean accuracy of 5-fold cross validation is plotted. 125 | 126 |

127 | 128 | 129 | 130 |

131 | 132 | ### References & Citations 133 | 134 | * [Official GCN Tensorflow implementation](https://github.com/tkipf/gcn) 135 | * [Spectral graph Convnets (ChebNets) implementation](https://github.com/xbresson/spectral_graph_convnets) 136 | 137 | ```bibtex 138 | @article{kipf2016semi, 139 | title={Semi-supervised classification with graph convolutional networks}, 140 | author={Kipf, Thomas N and Welling, Max}, 141 | journal={arXiv preprint arXiv:1609.02907}, 142 | year={2016} 143 | } 144 | ``` 145 | 146 | ```bibtex 147 | @inproceedings{defferrard2016convolutional, 148 | title={Convolutional neural networks on graphs with fast localized spectral filtering}, 149 | author={Defferrard, Micha{\"e}l and Bresson, Xavier and Vandergheynst, Pierre}, 150 | booktitle={Advances in neural information processing systems}, 151 | pages={3844--3852}, 152 | year={2016} 153 | } 154 | ``` 155 | -------------------------------------------------------------------------------- /gcn/model.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | 5 | 6 | """ 7 | LAYERS: GCNConv and ChebNetConv 8 | """ 9 | 10 | 11 | class GCNConv(nn.Module): 12 | def __init__(self, in_features, out_features): 13 | super(GCNConv, self).__init__() 14 | self.linear = nn.Linear(in_features, out_features, bias=False) 15 | 16 | def forward(self, x: torch.Tensor, adjacency_hat: torch.sparse_coo_tensor): 17 | x = self.linear(x) 18 | x = torch.sparse.mm(adjacency_hat, x) 19 | return x 20 | 21 | 22 | class ChebNetConv(nn.Module): 23 | def __init__(self, in_features, out_features, k): 24 | super(ChebNetConv, self).__init__() 25 | 26 | self.K = k 27 | self.linear = nn.Linear(in_features * k, out_features) 28 | 29 | def forward(self, x: torch.Tensor, laplacian: torch.sparse_coo_tensor): 30 | x = self.__transform_to_chebyshev(x, laplacian) 31 | x = self.linear(x) 32 | return x 33 | 34 | def __transform_to_chebyshev(self, x, laplacian): 35 | cheb_x = x.unsqueeze(2) 36 | x0 = x 37 | 38 | if self.K > 1: 39 | x1 = torch.sparse.mm(laplacian, x0) 40 | cheb_x = torch.cat((cheb_x, x1.unsqueeze(2)), 2) 41 | for _ in range(2, self.K): 42 | x2 = 2 * torch.sparse.mm(laplacian, x1) - x0 43 | cheb_x = torch.cat((cheb_x, x2.unsqueeze(2)), 2) 44 | x0, x1 = x1, x2 45 | 46 | cheb_x = cheb_x.reshape([x.shape[0], -1]) 47 | return cheb_x 48 | 49 | 50 | """ 51 | MODELS 52 | """ 53 | 54 | 55 | class TwoLayerGCN(nn.Module): 56 | def __init__(self, input_size, hidden_size, output_size, dropout=0.1): 57 | super(TwoLayerGCN, self).__init__() 58 | 59 | self.conv1 = GCNConv(input_size, hidden_size) 60 | self.conv2 = GCNConv(hidden_size, output_size) 61 | self.relu = nn.ReLU() 62 | self.dropout = nn.Dropout(dropout) 63 | 64 | def forward(self, x: torch.Tensor, adjacency_hat: torch.sparse_coo_tensor, labels: torch.Tensor = None): 65 | x = self.dropout(x) 66 | x = self.conv1(x, adjacency_hat) 67 | x = self.relu(x) 68 | x = self.dropout(x) 69 | x = self.conv2(x, adjacency_hat) 70 | 71 | if labels is None: 72 | return x 73 | 74 | loss = nn.CrossEntropyLoss()(x, labels) 75 | return x, loss 76 | 77 | 78 | class GCN(nn.Module): 79 | def __init__(self, input_size, hidden_size, output_size, num_hidden_layers=0, dropout=0.1, residual=False): 80 | super(GCN, self).__init__() 81 | 82 | self.dropout = dropout 83 | self.residual = residual 84 | 85 | self.input_conv = GCNConv(input_size, hidden_size) 86 | self.hidden_convs = nn.ModuleList([GCNConv(hidden_size, hidden_size) for _ in range(num_hidden_layers)]) 87 | self.output_conv = GCNConv(hidden_size, output_size) 88 | 89 | def forward(self, x: torch.Tensor, adjacency_hat: torch.sparse_coo_tensor, labels: torch.Tensor = None): 90 | x = F.dropout(x, p=self.dropout, training=self.training) 91 | x = F.relu(self.input_conv(x, adjacency_hat)) 92 | for conv in self.hidden_convs: 93 | if self.residual: 94 | x = F.relu(conv(x, adjacency_hat)) + x 95 | else: 96 | x = F.relu(conv(x, adjacency_hat)) 97 | x = F.dropout(x, p=self.dropout, training=self.training) 98 | x = self.output_conv(x, adjacency_hat) 99 | 100 | if labels is None: 101 | return x 102 | 103 | loss = nn.CrossEntropyLoss()(x, labels) 104 | return x, loss 105 | 106 | 107 | class TwoLayerChebNet(nn.Module): 108 | def __init__(self, input_size, hidden_size, output_size, dropout=0.1, k=2): 109 | super(TwoLayerChebNet, self).__init__() 110 | 111 | self.conv1 = ChebNetConv(input_size, hidden_size, k) 112 | self.conv2 = ChebNetConv(hidden_size, output_size, k) 113 | self.relu = nn.ReLU() 114 | self.dropout = nn.Dropout(dropout) 115 | 116 | def forward(self, x: torch.Tensor, laplacian: torch.sparse_coo_tensor, labels: torch.Tensor = None): 117 | x = self.dropout(x) 118 | x = self.conv1(x, laplacian) 119 | x = self.relu(x) 120 | x = self.dropout(x) 121 | x = self.conv2(x, laplacian) 122 | 123 | if labels is None: 124 | return x 125 | 126 | loss = nn.CrossEntropyLoss()(x, labels) 127 | return x, loss 128 | 129 | 130 | class ChebNetGCN(nn.Module): 131 | def __init__(self, input_size, hidden_size, output_size, num_hidden_layers=0, dropout=0.1, residual=False, k=2): 132 | super(ChebNetGCN, self).__init__() 133 | 134 | self.dropout = dropout 135 | self.residual = residual 136 | 137 | self.input_conv = ChebNetConv(input_size, hidden_size, k) 138 | self.hidden_convs = nn.ModuleList([ChebNetConv(hidden_size, hidden_size, k) for _ in range(num_hidden_layers)]) 139 | self.output_conv = ChebNetConv(hidden_size, output_size, k) 140 | 141 | def forward(self, x: torch.Tensor, laplacian: torch.sparse_coo_tensor, labels: torch.Tensor = None): 142 | x = F.dropout(x, p=self.dropout, training=self.training) 143 | x = F.relu(self.input_conv(x, laplacian)) 144 | for conv in self.hidden_convs: 145 | if self.residual: 146 | x = F.relu(conv(x, laplacian)) + x 147 | else: 148 | x = F.relu(conv(x, laplacian)) 149 | x = F.dropout(x, p=self.dropout, training=self.training) 150 | x = self.output_conv(x, laplacian) 151 | 152 | if labels is None: 153 | return x 154 | 155 | loss = nn.CrossEntropyLoss()(x, labels) 156 | return x, loss 157 | -------------------------------------------------------------------------------- /notebooks/gcn_testing.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "gcn_testing.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "toc_visible": true 10 | }, 11 | "kernelspec": { 12 | "name": "python3", 13 | "display_name": "Python 3" 14 | }, 15 | "accelerator": "GPU" 16 | }, 17 | "cells": [ 18 | { 19 | "cell_type": "markdown", 20 | "metadata": { 21 | "id": "dvqCZrwkP2wC" 22 | }, 23 | "source": [ 24 | "## Graph Convolutional Networks\n", 25 | "\n", 26 | "Reproducing some of the experiments from the [original paper](https://arxiv.org/abs/1609.02907)." 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "metadata": { 32 | "id": "R9gXGQC2bie7", 33 | "outputId": "df4cecc2-28d9-48c9-90d0-736e1d727794", 34 | "colab": { 35 | "base_uri": "https://localhost:8080/" 36 | } 37 | }, 38 | "source": [ 39 | "!git clone https://github.com/andrejmiscic/gcn-pytorch.git\n", 40 | "!cp -R /content/gcn-pytorch/gcn /content/gcn/" 41 | ], 42 | "execution_count": 1, 43 | "outputs": [ 44 | { 45 | "output_type": "stream", 46 | "text": [ 47 | "Cloning into 'gcn-pytorch'...\n", 48 | "remote: Enumerating objects: 19, done.\u001b[K\n", 49 | "remote: Counting objects: 100% (19/19), done.\u001b[K\n", 50 | "remote: Compressing objects: 100% (16/16), done.\u001b[K\n", 51 | "remote: Total 19 (delta 4), reused 13 (delta 2), pack-reused 0\u001b[K\n", 52 | "Unpacking objects: 100% (19/19), done.\n" 53 | ], 54 | "name": "stdout" 55 | } 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": { 61 | "id": "eADBSdRJC6a2" 62 | }, 63 | "source": [ 64 | "The models are implemented in pure PyTorch, but we require PyTorch Geometric for loading the data (it's the easiest this way). The following two cells install Pytorch Geometric library." 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "metadata": { 70 | "id": "nBXZ7lP9v0Ok" 71 | }, 72 | "source": [ 73 | "import torch\n", 74 | "\n", 75 | "TORCH_version = torch.__version__\n", 76 | "TORCH = TORCH_version.split('+')[0]\n", 77 | "CUDA_version = torch.version.cuda\n", 78 | "CUDA = \"cu\" + CUDA_version.replace('.', '')" 79 | ], 80 | "execution_count": 2, 81 | "outputs": [] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "metadata": { 86 | "id": "i8Iv4ozAvvcr" 87 | }, 88 | "source": [ 89 | "%%capture\n", 90 | "!pip install torch-scatter==latest+{CUDA} -f https://pytorch-geometric.com/whl/torch-{TORCH}.html\n", 91 | "!pip install torch-sparse==latest+{CUDA} -f https://pytorch-geometric.com/whl/torch-{TORCH}.html\n", 92 | "!pip install torch-cluster==latest+{CUDA} -f https://pytorch-geometric.com/whl/torch-{TORCH}.html\n", 93 | "!pip install torch-spline-conv==latest+{CUDA} -f https://pytorch-geometric.com/whl/torch-{TORCH}.html\n", 94 | "!pip install torch-geometric" 95 | ], 96 | "execution_count": 3, 97 | "outputs": [] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "metadata": { 102 | "id": "9fQki12CYnA_" 103 | }, 104 | "source": [ 105 | "import numpy as np\n", 106 | "import pandas as pd\n", 107 | "from plotnine import ggplot, geom_line, aes, xlab, theme, element_blank, ggtitle\n", 108 | "import scipy.sparse as sparse\n", 109 | "from sklearn.model_selection import KFold\n", 110 | "import torch\n", 111 | "import torch.nn as nn\n", 112 | "\n", 113 | "from gcn.model import TwoLayerGCN, GCN, TwoLayerChebNet\n", 114 | "from gcn.trainer import Trainer, RunConfig\n", 115 | "from gcn.utils import Dataset, load_data, set_labels" 116 | ], 117 | "execution_count": 4, 118 | "outputs": [] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "metadata": { 123 | "id": "yL4Vsp-XZFtd" 124 | }, 125 | "source": [ 126 | "# important for reproducibility!\n", 127 | "def set_seed(seed=1):\n", 128 | " np.random.seed(seed)\n", 129 | " torch.manual_seed(seed)\n", 130 | " if torch.cuda.is_available():\n", 131 | " torch.cuda.manual_seed(seed)" 132 | ], 133 | "execution_count": 5, 134 | "outputs": [] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "metadata": { 139 | "id": "ft-KIwU3ZiZB" 140 | }, 141 | "source": [ 142 | "# training parameters, there is no batch size as we use the whole set in each iteration\n", 143 | "run_config = RunConfig(\n", 144 | " learning_rate=0.1,\n", 145 | " num_epochs=200,\n", 146 | " weight_decay=5e-4,\n", 147 | " output_dir=\"/content/gcn-training/\"\n", 148 | ")" 149 | ], 150 | "execution_count": 6, 151 | "outputs": [] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "metadata": { 156 | "id": "xjhGd9Sr0hzK" 157 | }, 158 | "source": [ 159 | "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" 160 | ], 161 | "execution_count": 7, 162 | "outputs": [] 163 | }, 164 | { 165 | "cell_type": "markdown", 166 | "metadata": { 167 | "id": "XmBZ_tv4Vwbz" 168 | }, 169 | "source": [ 170 | "### Evaluation on Cora, CiteSeer and PubMed datasets\n", 171 | "\n", 172 | "We compare two different propagation models: the graph convolutional layer as introduced by [Kipf and Welling](https://arxiv.org/abs/1609.02907) and the Chebyshev convolutional layer as introduced by [Defferrard, Bresson and Vandergheynst](https://arxiv.org/abs/1606.09375). For the latter we set the order of expansion *k* to 2 and 3." 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "metadata": { 178 | "id": "fBPzQJYNZgq-" 179 | }, 180 | "source": [ 181 | "def evaluate_gcn_on_dataset(dataset: Dataset, iter = 1):\n", 182 | " set_seed()\n", 183 | " features, labels, train_labels, val_labels, test_labels, adjacency_matrix, \\\n", 184 | " laplacian_matrix, num_classes = load_data(dataset)\n", 185 | " accuracies = []\n", 186 | "\n", 187 | " for i in range(iter):\n", 188 | " model = TwoLayerGCN(\n", 189 | " input_size=features.size(1),\n", 190 | " hidden_size=16,\n", 191 | " output_size=num_classes,\n", 192 | " dropout=0.5\n", 193 | " )\n", 194 | " trainer = Trainer(model)\n", 195 | " trainer.train(features, train_labels, val_labels, adjacency_matrix, device, run_config, log=False)\n", 196 | "\n", 197 | " _, accuracy = trainer.evaluate(features, test_labels, adjacency_matrix, device)\n", 198 | " accuracies.append(accuracy)\n", 199 | " print(f\"\\nPerformance on {dataset.name}:\\n- test accuracy = {np.mean(accuracies):.3f} +- {np.std(accuracies):.3f}\\n\")\n", 200 | "\n", 201 | "def evaluate_chebnet_on_dataset(dataset: Dataset, k = 2, iter = 1):\n", 202 | " set_seed()\n", 203 | " features, labels, train_labels, val_labels, test_labels, adjacency_matrix, \\\n", 204 | " laplacian_matrix, num_classes = load_data(dataset)\n", 205 | " accuracies = []\n", 206 | "\n", 207 | " for i in range(iter):\n", 208 | " model = TwoLayerChebNet(\n", 209 | " input_size=features.size(1),\n", 210 | " hidden_size=16,\n", 211 | " output_size=num_classes,\n", 212 | " dropout=0.5,\n", 213 | " k=k\n", 214 | " )\n", 215 | "\n", 216 | " trainer = Trainer(model)\n", 217 | " trainer.train(features, train_labels, val_labels, laplacian_matrix, device, run_config, log=False)\n", 218 | "\n", 219 | " _ , accuracy = trainer.evaluate(features, test_labels, laplacian_matrix, device)\n", 220 | " accuracies.append(accuracy)\n", 221 | " print(f\"\\nPerformance on {dataset.name}:\\n- test accuracy = {np.mean(accuracies):.3f} +- {np.std(accuracies):.3f}\\n\")" 222 | ], 223 | "execution_count": 8, 224 | "outputs": [] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "metadata": { 229 | "id": "UABHmdg_1AFU", 230 | "outputId": "8c49bbe3-cf64-451a-940c-2b20e9c88444", 231 | "colab": { 232 | "base_uri": "https://localhost:8080/" 233 | } 234 | }, 235 | "source": [ 236 | "evaluate_gcn_on_dataset(Dataset.Cora) # iter=100 to get uncertainty reported\n", 237 | "evaluate_gcn_on_dataset(Dataset.CiteSeer)\n", 238 | "evaluate_gcn_on_dataset(Dataset.PubMed)" 239 | ], 240 | "execution_count": 10, 241 | "outputs": [ 242 | { 243 | "output_type": "stream", 244 | "text": [ 245 | "Training loss = 0.3118, val loss = 0.7106, val accuracy = 0.80: 100%|██████████| 200/200 [00:01<00:00, 106.37it/s]\n", 246 | "Training loss = 1.6862, val loss = 1.7310, val accuracy = 0.35: 0%| | 0/200 [00:00" 584 | ] 585 | }, 586 | "metadata": { 587 | "tags": [] 588 | } 589 | }, 590 | { 591 | "output_type": "stream", 592 | "text": [ 593 | "\n" 594 | ], 595 | "name": "stdout" 596 | } 597 | ] 598 | }, 599 | { 600 | "cell_type": "code", 601 | "metadata": { 602 | "id": "YBWIeG8pqPCi" 603 | }, 604 | "source": [ 605 | "%%capture\n", 606 | "df_citeseer = compute_residual_effect_df(Dataset.CiteSeer)" 607 | ], 608 | "execution_count": 18, 609 | "outputs": [] 610 | }, 611 | { 612 | "cell_type": "code", 613 | "metadata": { 614 | "id": "EjEC1ogiqQpN", 615 | "outputId": "dc55d36c-2aa3-4d98-a63a-f612e3b2f95c", 616 | "colab": { 617 | "base_uri": "https://localhost:8080/", 618 | "height": 548 619 | } 620 | }, 621 | "source": [ 622 | "plot_residual_effect(df_citeseer, Dataset.CiteSeer)" 623 | ], 624 | "execution_count": 19, 625 | "outputs": [ 626 | { 627 | "output_type": "stream", 628 | "text": [ 629 | "/usr/local/lib/python3.6/dist-packages/plotnine/utils.py:1246: FutureWarning: is_categorical is deprecated and will be removed in a future version. Use is_categorical_dtype instead\n", 630 | " if pdtypes.is_categorical(arr):\n" 631 | ], 632 | "name": "stderr" 633 | }, 634 | { 635 | "output_type": "display_data", 636 | "data": { 637 | "image/png": "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\n", 638 | "text/plain": [ 639 | "
" 640 | ] 641 | }, 642 | "metadata": { 643 | "tags": [] 644 | } 645 | }, 646 | { 647 | "output_type": "stream", 648 | "text": [ 649 | "\n" 650 | ], 651 | "name": "stdout" 652 | } 653 | ] 654 | }, 655 | { 656 | "cell_type": "code", 657 | "metadata": { 658 | "id": "rZJ1YeKqqjMZ" 659 | }, 660 | "source": [ 661 | "%%capture\n", 662 | "df_pubmed = compute_residual_effect_df(Dataset.PubMed)" 663 | ], 664 | "execution_count": 20, 665 | "outputs": [] 666 | }, 667 | { 668 | "cell_type": "code", 669 | "metadata": { 670 | "id": "2RYzDN90qnWp", 671 | "outputId": "40d8b8d5-33b3-4169-b4ab-2e72136eaf31", 672 | "colab": { 673 | "base_uri": "https://localhost:8080/", 674 | "height": 548 675 | } 676 | }, 677 | "source": [ 678 | "plot_residual_effect(df_pubmed, Dataset.PubMed)" 679 | ], 680 | "execution_count": null, 681 | "outputs": [ 682 | { 683 | "output_type": "stream", 684 | "text": [ 685 | "/usr/local/lib/python3.6/dist-packages/plotnine/utils.py:1246: FutureWarning: is_categorical is deprecated and will be removed in a future version. Use is_categorical_dtype instead\n", 686 | " if pdtypes.is_categorical(arr):\n" 687 | ], 688 | "name": "stderr" 689 | }, 690 | { 691 | "output_type": "display_data", 692 | "data": { 693 | "image/png": "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\n", 694 | "text/plain": [ 695 | "
" 696 | ] 697 | }, 698 | "metadata": { 699 | "tags": [] 700 | } 701 | }, 702 | { 703 | "output_type": "stream", 704 | "text": [ 705 | "\n" 706 | ], 707 | "name": "stdout" 708 | } 709 | ] 710 | } 711 | ] 712 | } --------------------------------------------------------------------------------