首先感谢datawhale 的课程内容：引用
GNN/Markdown版本/5-基于图神经网络的节点表征学习.md · Datawhale/team-learning-nlp - 码云 - 开源中国 (gitee.com)
这个实验做的很顺利。
在节点预测任务中，我们拥有一个图，图上有很多节点，部分节点的预测标签已知，部分节点的预测标签未知。我们的任务是根据节点的属性(可以是类别型、也可以是数值型)、边的信息、边的属性（如果有的话）、已知的节点预测标签，对未知标签的节点做预测。
我们将以Cora 数据集为例子进行说明，Cora 是一个论文引用网络，节点代表论文，如果两篇论文存在引用关系，那么认为对应的两个节点之间存在边，每个节点由一个1433维的词包特征向量描述。我们的任务是推断每个文档的类别（共7类）。
为了展现图神经网络的强大，我们通过节点分类任务来比较MLP和GCN, GAT（两个知名度很高的图神经网络）三者的节点表征学习能力。此节内容安排为：
首先，我们要做一些准备工作，即获取并分析数据集、构建一个方法用于分析节点表征的分布。
然后，我们考察MLP用于节点分类的表现，并分析基于MLP学习到的节点表征的分布。
接着，我们逐一介绍GCN, GAT这两个图神经网络的理论、他们在节点分类任务中的表现以及它们学习到的节点表征的分布。
最后，我们比较三者在节点表征学习能力上的差异。
下载数据集
from torch_geometric.datasets import Planetoid
from torch_geometric.transforms import NormalizeFeatures
dataset = Planetoid(root='./tmp/cora', name='Cora', transform=NormalizeFeatures())
print()
print(f'Dataset: {dataset}:')
print('======================')
看一下数据的情况：
print(f'Number of graphs: {len(dataset)}')
print(f'Number of features: {dataset.num_features}')
print(f'Number of classes: {dataset.num_classes}')
data = dataset[0] # Get the first graph object.
print()
print(data)
print('======================')
# Gather some statistics about the graph.
print(f'Number of nodes: {data.num_nodes}')
print(f'Number of edges: {data.num_edges}')
print(f'Average node degree: {data.num_edges / data.num_nodes:.2f}')
print(f'Number of training nodes: {data.train_mask.sum()}')
print(f'Training node label rate: {int(data.train_mask.sum()) / data.num_nodes:.2f}')
print(f'Contains isolated nodes: {data.contains_isolated_nodes()}')
print(f'Contains self-loops: {data.contains_self_loops()}')
print(f'Is undirected: {data.is_undirected()}')
可视化代码：
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
def visualize(h, color):
z = TSNE(n_components=2).fit_transform(out.detach().cpu().numpy())
plt.figure(figsize=(10,10))
plt.xticks([])
plt.yticks([])
plt.scatter(z[:, 0], z[:, 1], s=70, c=color, cmap="Set2")
plt.show()
构建MLP模型：
import torch
from torch.nn import Linear
import torch.nn.functional as F
class MLP(torch.nn.Module):
def __init__(self, hidden_channels):
super(MLP, self).__init__()
torch.manual_seed(12345)
self.lin1 = Linear(dataset.num_features, hidden_channels)
self.lin2 = Linear(hidden_channels, dataset.num_classes)
def forward(self, x):
x = self.lin1(x)
x = x.relu()
x = F.dropout(x, p=0.5, training=self.training)
x = self.lin2(x)
return x
model = MLP(hidden_channels=16)
print(model)
MLP 模型 训练情况：
model = MLP(hidden_channels=16)
criterion = torch.nn.CrossEntropyLoss() # Define loss criterion.
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) # Define optimizer.
def train():
model.train()
optimizer.zero_grad() # Clear gradients.
out = model(data.x) # Perform a single forward pass.
loss = criterion(out[data.train_mask], data.y[data.train_mask]) # Compute the loss solely based on the training nodes.
loss.backward() # Derive gradients.
optimizer.step() # Update parameters based on gradients.
return loss
for epoch in range(1, 201):
loss = train()
print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}')
MLP结果：
做了两次实验，小的数据量，和大的数据量，越大的数量两，精度越低，说明该模型不适合再大数据集上跑。
# GCN图节点分类神经网络
from torch_geometric.nn import GCNConv
class GCN(torch.nn.Module):
def __init__(self, hidden_channels):
super(GCN, self).__init__()
torch.manual_seed(12345)
self.conv1 = GCNConv(dataset.num_features, hidden_channels)
self.conv2 = GCNConv(hidden_channels, dataset.num_classes)
def forward(self, x, edge_index):
x = self.conv1(x, edge_index)
x = x.relu()
x = F.dropout(x, p=0.5, training=self.training)
x = self.conv2(x, edge_index)
return x
model = GCN(hidden_channels=16)
print(model)
# 可视化未训练过的模型输出的节点表征
model = GCN(hidden_channels=16)
model.eval()
out = model(data.x, data.edge_index)
visualize(out, color=data.y)
# 训练GCN图节点分类器model = GCN(hidden_channels=16)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
criterion = torch.nn.CrossEntropyLoss()deftrain(): model.train()
optimizer.zero_grad() # Clear gradients. out = model(data.x, data.edge_index) # Perform a single forward pass. loss = criterion(out[data.train_mask], data.y[data.train_mask]) # Compute the loss solely based on the training nodes. loss.backward() # Derive gradients. optimizer.step() # Update parameters based on gradients. return lossfor epoch in range(1, 201):
loss = train()
print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}')
# 测试GCN图节点分类器deftest(): model.eval()
out = model(data.x, data.edge_index)
pred = out.argmax(dim=1) # Use the class with highest probability. test_correct = pred[data.test_mask] == data.y[data.test_mask] # Check against ground-truth labels. test_acc = int(test_correct.sum()) / int(data.test_mask.sum()) # Derive ratio of correct predictions. return test_acc
test_acc = test()
print(f'Test Accuracy: {test_acc:.4f}')
# 可视化训练过的GCN模型输出的节点表征
# 可视化训练过的GCN模型输出的节点表征
model.eval()
out = model(data.x,data.edge_index)
visualize(out, color=data.y)
因为数据没有下载全，所有，节点有限，呵呵
训练前的
训练后：
测试精度：
GAT
# 构造GAT节点分类神经网络
import torch
from torch.nn import Linear
import torch.nn.functional as F
from torch_geometric.nn import GATConv
class GAT(torch.nn.Module):
def __init__(self, hidden_channels):
super(GAT, self).__init__()
torch.manual_seed(12345)
self.conv1 = GATConv(dataset.num_features, hidden_channels)
self.conv2 = GATConv(hidden_channels, dataset.num_classes)
def forward(self, x, edge_index):
x = self.conv1(x, edge_index)
x = x.relu()
x = F.dropout(x, p=0.5, training=self.training)
x = self.conv2(x, edge_index)
return x
# 可视化未训练过的GAT模型输出的节点表征
model.eval()
out = model(data.x,data.edge_index)
visualize(out, color=data.y)
# 训练GAT图节点分类器
model = GAT(hidden_channels=16)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
criterion = torch.nn.CrossEntropyLoss()
deftrain():
model.train()
optimizer.zero_grad() # Clear gradients.
out = model(data.x, data.edge_index) # Perform a single forward pass.
loss = criterion(out[data.train_mask], data.y[data.train_mask]) # Compute the loss solely based on the training nodes.
loss.backward() # Derive gradients.
optimizer.step() # Update parameters based on gradients.
return lossfor epoch in range(1, 201):
loss = train()
print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}')
可以看出GAT的效果相比GCN差一些。
结论：
在节点表征的学习中，MLP节点分类器只考虑了节点自身属性，忽略了节
点之间的连接关系，它的结果是最差的；而GCN与GAT节点分类器，同时
考虑了节点自身属性与周围邻居节点的属性，它们的结果优于MLP节点分
类器。从中可以看出邻居节点的信息对于节点分类任务的重要性。
基于图神经网络的节点表征的学习遵循消息传递范式：
在邻居节点信息变换阶段，GCN与GAT都对邻居节点做归一化和线性变
换（两个操作不分前后）；
在邻居节点信息聚合阶段都将变换后的邻居节点信息做求和聚合；
在中心节点信息变换阶段只是简单返回邻居节点信息聚合阶段的聚合结
果。
GCN与GAT的区别在于邻居节点信息聚合过程中的归一化方法不同：
前者根据中心节点与邻居节点的度计算归一化系数，后者根据中心节点
与邻居节点的相似度计算归一化系数。
前者的归一化方式依赖于图的拓扑结构，不同节点其自身的度不同、其
邻居的度也不同，在一些应用中可能会影响泛化能力。
后者的归一化方式依赖于中心节点与邻居节点的相似度，相似度是训练
得到的，因此不受图的拓扑结构的影响，在不同的任务中都会有较好的
泛化表现。