文章目录
1 – cora数据集
2 – 源码含义记录
首先我们来整体看一下代码的组成
截图中的这一大坨为命令行传递参数，含义参考命令行传递参数 argparse.ArgumentParser解析简单点说，就是想在不改动代码的情况下，使用命令行去改参数。
; 2.1 加载数据集
在代码中，加载数据集通过这个函数实现
adj, features, labels, idx_train, idx_val, idx_test = load_data()
可以看看 load_data中的内容：
def load_data(path="../data/cora/", dataset="cora"):
"""Load citation network dataset (cora only for now)"""
print('Loading {} dataset...'.format(dataset))
idx_features_labels = np.genfromtxt("{}{}.content".format(path, dataset),
dtype=np.dtype(str))
features = sp.csr_matrix(idx_features_labels[:, 1:-1], dtype=np.float32)
labels = encode_onehot(idx_features_labels[:, -1])
idx = np.array(idx_features_labels[:, 0], dtype=np.int32)
idx_map = {j: i for i, j in enumerate(idx)}
edges_unordered = np.genfromtxt("{}{}.cites".format(path, dataset),
dtype=np.int32)
edges = np.array(list(map(idx_map.get, edges_unordered.flatten())),
dtype=np.int32).reshape(edges_unordered.shape)
adj = sp.coo_matrix((np.ones(edges.shape[0]), (edges[:, 0], edges[:, 1])),
shape=(labels.shape[0], labels.shape[0]),
dtype=np.float32)
adj = adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)
features = normalize(features)
adj = normalize(adj + sp.eye(adj.shape[0]))
idx_train = range(140)
idx_val = range(200, 500)
idx_test = range(500, 1500)
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
np.genfromtxt函数为numpy加载数据集，当然还有其它几种加载数据集的方式，例如pandas等等，详情见Python加载数据的5种不同方式(收藏)。
2.1.1 加载节点数据
首先是加载节点的数据，即.content。
通过断点+命令行调试，可以看到输出的 idx_features_labels的结果
因此我们想把
中间节点的特征给取出来，即这一句
features = sp.csr_matrix(idx_features_labels[:, 1:-1], dtype=np.float32)
中间 [1：-1]是从 第二列到倒数第二列（因为python为 左闭右开）
然后再取 label，使用
labels = encode_onehot(idx_features_labels[:, -1])
只取最后一列，并且采用 one-hot编码。
解释一下特征的含义
最后开始取 节点的索引(index)，即第一列，并且 构建节点的索引字典。
idx = np.array(idx_features_labels[:, 0], dtype=np.int32)
idx_map = {j: i for i, j in enumerate(idx)}
看看输出，字典就构建好啦
2.1.2 加载边的数据
节点的数据导入完了，我们再来导入边的数据
edges_unordered = np.genfromtxt("{}{}.cites".format(path, dataset), dtype=np.int32)
将之前的转换成 字典编号后的边
2.1.3 构造邻接矩阵
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)
由于Cora数据集是一个 有向图，而GCN本身使用的为 无向图，其邻接矩阵是对称的，因此我们需要构造一个 对称矩阵，如下：
adj = adj + adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)
其中 adj.T > adj的含义为，如果转置后为1，而原矩阵为0，则该位置为1
Python将非对称邻接矩阵转变为对称邻接矩阵(有向图转无向图)
2.1.4 归一化
features = normalize(features)
adj = normalize(adj + sp.eye(adj.shape[0]))
我们可以看一下 normalize函数
def normalize(mx):
"""Row-normalize sparse matrix"""
rowsum = np.array(mx.sum(1))
r_inv = np.power(rowsum, -1).flatten()
r_inv[np.isinf(r_inv)] = 0.
r_mat_inv = sp.diags(r_inv)
mx = r_mat_inv.dot(mx)
return mx
分别看看 rowsum和 r_inv的输出
然后我们在把r_inv中的无穷值变为0后， 构造对角矩阵，可以看到结果
特征矩阵归一化（非必须）
可以发现特征每一行加起来都是1，已经被归一化好了。
邻接矩阵归一化（必须）
再对 邻接矩阵+单位阵进行归一化（必须操作）
首先看起来 邻接矩阵+单位阵的值：
然后再进行归一化，这里用的是 简便方法，和上面一样啦~
; 2.1.5 加载数据集/数据格式转换
idx_train = range(140)
idx_val = range(200, 500)
idx_test = range(500, 1500)
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)
最后返回的格式
return adj, features, labels, idx_train, idx_val, idx_test
2.2 构造模型
我们构造一个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)
当然想看看GCN长什么样啦~
class GCN(nn.Module):
def __init__(self, nfeat, nhid, nclass, dropout):
super(GCN, self).__init__()
self.gc1 = GraphConvolution(nfeat, nhid)
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)
x = self.gc2(x, adj)
return F.log_softmax(x, dim=1)
在初始化里，看到了 GraphConvolution函数，自然想看看它是什么样子的
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)
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)
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) + ')'
这里的 forward函数就是矩阵的相乘
2.3 使用GPU
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()
2.4 定义训练和测试函数
def train(epoch):
t = time.time()
model.train()
optimizer.zero_grad()
output = model(features, adj)
loss_train = F.nll_loss(output[idx_train], labels[idx_train])
acc_train = accuracy(output[idx_train], labels[idx_train])
loss_train.backward()
optimizer.step()
if not args.fastmode:
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():
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()))
2.5 模型训练和测试
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))
test()
首先我们看一下模型第一层输出的size
经过一个dropout，再经过第二层gcn，此时的input已经是
第二层要学习的权重，维度为
学完之后，x变为
最后经过一个log_softmax，得到output
训练完之后计算loss，然后计算准确度（不是很重要）
def accuracy(output, labels):
preds = output.max(1)[1].type_as(labels)
correct = preds.eq(labels).double()
correct = correct.sum()
return correct / len(labels)
训练完了再测试，就大功告成啦
Original: https://blog.csdn.net/FelicityXu/article/details/123490299
Author: Lucy@IshtarXu
Title: 【GCN】图卷积神经网络 – 简单的源码记录
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/709949/
转载文章受原作者版权保护。转载请注明原作者出处！