代码可以在github上fork,本文主要是加了一些注释,并且搭配本人所作笔记【GCN代码笔记】
layers.py
import math
import torch
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
class GraphConvolution(Module):
"""
Simple GCN layer, similar to https://arxiv.org/abs/1609.02907
"""
def __init__(self, in_features, out_features, bias=True):
super(GraphConvolution, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.weight = Parameter(torch.FloatTensor(in_features, out_features))
if bias:
self.bias = Parameter(torch.FloatTensor(out_features))
else:
self.register_parameter('bias', None)
#Parameter()与register_parameter()都是将一个不可训练的类型Tensor转换成可以训练的类型parameter,并将这个parameter绑定到这个module里面,相当于变成了模型的一部分,成为了模型中可以根据训练进行变化的参数。
self.reset_parameters()
#构建好特征之后对特征进行随机初始化的过程
def reset_parameters(self):
stdv = 1. / math.sqrt(self.weight.size(1))
self.weight.data.uniform_(-stdv, stdv)
if self.bias is not None:
self.bias.data.uniform_(-stdv, stdv)
def forward(self, input, adj):
support = torch.mm(input, self.weight)#将input函数和weight函数做了一个乘积;torch.mm(a, b)是矩阵a和b矩阵相乘
output = torch.spmm(adj, support)#稀疏矩阵的相乘,是之前归一化之后的结果和上一步相乘
if self.bias is not None:
return output + self.bias
else:
return output
def __repr__(self):
return self.__class__.__name__ + ' (' \
+ str(self.in_features) + ' -> ' \
+ str(self.out_features) + ')'
models.py
import torch.nn as nn
import torch.nn.functional as F
from pygcn.layers import GraphConvolution
class GCN(nn.Module):
def __init__(self, nfeat, nhid, nclass, dropout):
super(GCN, self).__init__()
#构建第一层GCN,第一个参数是初始特征,第二个参数是隐藏层特征
self.gc1 = GraphConvolution(nfeat, nhid)
#构建第二层GCN,传入的nhid维度是16维,输出的nclass与最后要判定的类别数是一致的,是7个类别
self.gc2 = GraphConvolution(nhid, nclass)
self.dropout = dropout
def forward(self, x, adj):
x = F.relu(self.gc1(x, adj))
x = F.dropout(x, self.dropout, training=self.training)
#完成第一层GCN训练之后,x.shape是2708*16维的。16是hidden layer的维度,16是传参传进去的
x = self.gc2(x, adj)
return F.log_softmax(x, dim=1)
train.py
from __future__ import division
from __future__ import print_function
import time
import argparse
import numpy as np
import torch
import torch.nn.functional as F
import torch.optim as optim
from pygcn.utils import load_data, accuracy
from pygcn.models import GCN
# Training settings添加train set的一些参数
parser = argparse.ArgumentParser()
parser.add_argument('--no-cuda', action='store_true', default=False,
help='Disables CUDA training.')
parser.add_argument('--fastmode', action='store_true', default=False,
help='Validate during training pass.')
parser.add_argument('--seed', type=int, default=42, help='Random seed.')
parser.add_argument('--epochs', type=int, default=200,
help='Number of epochs to train.')
parser.add_argument('--lr', type=float, default=0.01,
help='Initial learning rate.')
parser.add_argument('--weight_decay', type=float, default=5e-4,
help='Weight decay (L2 loss on parameters).')
parser.add_argument('--hidden', type=int, default=16,
help='Number of hidden units.')
parser.add_argument('--dropout', type=float, default=0.5,
help='Dropout rate (1 - keep probability).')
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
# Load data
adj, features, labels, idx_train, idx_val, idx_test = load_data()
# Model and optimizer 构建GCN模型,初始化参数。两层GCN
model = GCN(nfeat=features.shape[1],
nhid=args.hidden,
nclass=labels.max().item() + 1,
dropout=args.dropout)
optimizer = optim.Adam(model.parameters(),
lr=args.lr, weight_decay=args.weight_decay)
if args.cuda:
model.cuda()
features = features.cuda()
adj = adj.cuda()
labels = labels.cuda()
idx_train = idx_train.cuda()
idx_val = idx_val.cuda()
idx_test = idx_test.cuda()
#定义训练的一个函数
def train(epoch):
t = time.time()
# 如果模型中有BN层(Batch Normalization)和Dropout,需要在训练时添加model.train()。
# model.train()是保证BN层能够用到每一批数据的均值和方差。对于Dropout,model.train()是随机取一部分网络连接来训练更新参数。
model.train()
optimizer.zero_grad()#把模型中参数的梯度设为0
output = model(features, adj)#运行模型,输入参数(features,adj)即特征和邻接矩阵
#output输出结果是2708*7的维度,值代表每一位可能输出的概率
loss_train = F.nll_loss(output[idx_train], labels[idx_train])#等同于cross_entropy
acc_train = accuracy(output[idx_train], labels[idx_train])
loss_train.backward()
optimizer.step()
if not args.fastmode:
# Evaluate validation set performance separately,
# deactivates dropout during validation run.
model.eval()
output = model(features, adj)
loss_val = F.nll_loss(output[idx_val], labels[idx_val])
acc_val = accuracy(output[idx_val], labels[idx_val])
print('Epoch: {:04d}'.format(epoch+1),
'loss_train: {:.4f}'.format(loss_train.item()),
'acc_train: {:.4f}'.format(acc_train.item()),
'loss_val: {:.4f}'.format(loss_val.item()),
'acc_val: {:.4f}'.format(acc_val.item()),
'time: {:.4f}s'.format(time.time() - t))
#定义测试的一个函数
def test():
# 如果模型中有BN层(BatchNormalization)和Dropout,在测试时添加model.eval()。
# model.eval()是保证BN层能够用全部训练数据的均值和方差,即测试过程中要保证BN层的均值和方差不变。
# 对于Dropout,model.eval()是利用到了所有网络连接,即不进行随机舍弃神经元。
# 训练完train样本后,生成的模型model要用来测试样本。
# 在model(test)之前,需要加上model.eval(),否则的话,有输入数据,即使不训练,它也会改变权值。这是model中含有BN层和Dropout所带来的的性质。
model.eval()
output = model(features, adj)
loss_test = F.nll_loss(output[idx_test], labels[idx_test])
acc_test = accuracy(output[idx_test], labels[idx_test])
print("Test set results:",
"loss= {:.4f}".format(loss_test.item()),
"accuracy= {:.4f}".format(acc_test.item()))
# Train model
t_total = time.time()
#定义了训练多少回合
for epoch in range(args.epochs):
train(epoch)
print("Optimization Finished!")
print("Total time elapsed: {:.4f}s".format(time.time() - t_total))
# Testing
test()
utils.py
import numpy as np
import scipy.sparse as sp
import torch
def encode_onehot(labels):
classes = set(labels)
classes_dict = {c: np.identity(len(classes))[i, :] for i, c in
enumerate(classes)}
labels_onehot = np.array(list(map(classes_dict.get, labels)),
dtype=np.int32)
return labels_onehot
def load_data(path="../data/cora/", dataset="cora"):
"""Load citation network dataset (cora only for now)"""
print('Loading {} dataset...'.format(dataset))
#得到cora.content中的数据
idx_features_labels = np.genfromtxt("{}{}.content".format(path, dataset),
dtype=np.dtype(str))
#取特征,从第一个到倒数第二个
#sp.csr_matrix就是按照列来压缩
features = sp.csr_matrix(idx_features_labels[:, 1:-1], dtype=np.float32)
#labels即最后一列 文章分类
labels = encode_onehot(idx_features_labels[:, -1])
# build graph
#取索引,取的是cora.content中的第0列的数据
idx = np.array(idx_features_labels[:, 0], dtype=np.int32)
#构建节点的索引字典,就是转换为从0到索引长度-1的编号,例如将第一个元素31336转换为0,{31336:0,等等}
idx_map = {j: i for i, j in enumerate(idx)}
#导入边的一个数据 cora.cites文件中是边之间的联系
edges_unordered = np.genfromtxt("{}{}.cites".format(path, dataset),
dtype=np.int32)
#将之前的转换成字典编号后的边,即假设23:9,23与31336之间有联系,现在转化为9与0之间有联系。
edges = np.array(list(map(idx_map.get, edges_unordered.flatten())),
dtype=np.int32).reshape(edges_unordered.shape)
#构建边的邻接矩阵(sp.coo_matrix构建的是稀疏矩阵)
adj = sp.coo_matrix((np.ones(edges.shape[0]), (edges[:, 0], edges[:, 1])),
shape=(labels.shape[0], labels.shape[0]),
dtype=np.float32) #2708*2708 因为有2708个节点
# build symmetric adjacency matrix,计算转置矩阵,将有向图转化为无向图
adj = adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)
features = normalize(features) #对特征做了归一化的操作,但不是一个必要的操作
adj = normalize(adj + sp.eye(adj.shape[0])) #对(邻接矩阵+单位矩阵)做归一化的操作,这是必要的一个操作,这一步完成之后就是完成公式中的D的负1次*A
#划分训练,验证,测试的样本
idx_train = range(140)
idx_val = range(200, 500)
idx_test = range(500, 1500)
#将numpy的数据转换成torch格式
features = torch.FloatTensor(np.array(features.todense()))
labels = torch.LongTensor(np.where(labels)[1])
adj = sparse_mx_to_torch_sparse_tensor(adj)
idx_train = torch.LongTensor(idx_train)
idx_val = torch.LongTensor(idx_val)
idx_test = torch.LongTensor(idx_test)
#返回经过归一化后的邻接矩阵,特征,标签,训练集、验证集、测试集所对应到的索引
return adj, features, labels, idx_train, idx_val, idx_test
#对节点做归一化
def normalize(mx):
"""Row-normalize sparse matrix"""
rowsum = np.array(mx.sum(1))#矩阵按行求和
r_inv = np.power(rowsum, -1).flatten() #求倒数,有的可能是0 然后求倒数之后出现无穷大,,此时是2708维
r_inv[np.isinf(r_inv)] = 0. #如果是inf(无穷大),转换成0
r_mat_inv = sp.diags(r_inv) #构建对角矩阵 ,转换成2708*2708维的矩阵
#用转换之后的矩阵乘以之前的特征,即将特征按行做了归一化的一个操作。
mx = r_mat_inv.dot(mx)
return mx
def accuracy(output, labels):
preds = output.max(1)[1].type_as(labels)#求output矩阵每一行的最大值,最大值即要输出的label
correct = preds.eq(labels).double()
correct = correct.sum()
return correct / len(labels)
def sparse_mx_to_torch_sparse_tensor(sparse_mx):
"""Convert a scipy sparse matrix to a torch sparse tensor."""
sparse_mx = sparse_mx.tocoo().astype(np.float32)
indices = torch.from_numpy(
np.vstack((sparse_mx.row, sparse_mx.col)).astype(np.int64))
values = torch.from_numpy(sparse_mx.data)
shape = torch.Size(sparse_mx.shape)
return torch.sparse.FloatTensor(indices, values, shape)