零、引言
先：复习MPNN
首先回顾一波上次学习的GNN的通用框架——消息传递神经网络（Message Passing Neural Network，MPNN）：
1.消息传递阶段（学习图中节点的特征）
假设我们要计算k kk时刻红色节点的表示，从消息传递的角度来看，会经历以下步骤：
1）首先从邻居获取信息（即消息传递阶段的消息函数A g g r e g a t i o n AggregationAggregation F u n c t i o n FunctionFunction）：计算红色节点周围的四个邻居节点的消息总和。
消息函数作用：聚合邻居节点的特征，形成一个消息向量，准备传递给中心节点。
2）对获得的信息加以利用（即消息传递阶段的节点更新函数C o m b i n a t i o n CombinationCombination F u n c t i o n FunctionFunction）：将获得的消息与( k − 1 ) (k-1)(k−1)时刻红色节点本身的表示组合起来，计算得到k kk时刻的红色节点表示。
节点更新函数：更新当前时刻的节点表示，结合当前时刻结点的表示以及从A g g r e g a t i o n AggregationAggregation F u n c t i o n FunctionFunction中获得的消息。
（上图源自李宏毅课件）基于空域的GNN还有一个readout过程：
2.读出阶段（得到整个图的特征）
对于图级别的任务（如图分类）不能只获得节点级别的表示，还要通过读出函数（R e a d o u t ReadoutReadout F u n c t i o n FunctionFunction）聚合节点级别的表示，计算获得图级别的表示。
后：本次任务
在图节点预测或边预测任务中，首先需要生成节点表征（Node Representation），也即我们上面说的第一大块步骤。
我们使用图神经网络来生成节点表征，并通过基于监督学习的对图神经网络的训练，使得图神经网络学会产生高质量的节点表征（高质量的节点表征能够用于衡量节点的相似性，同时高质量的节点表征也是准确分类节点的前提。）。
学习实现多层图神经网络的方法
并以节点分类任务为例，学习训练图神经网络的一般过程。
我们将以Cora数据集为例子进行说明，Cora是一个论文引用网络，节点代表论文，如果两篇论文存在引用关系，则对应的两个节点之间存在边，各节点的属性都是一个1433维的词包特征向量.
（1）预测各篇论文的类别（共7类）。
（2）对MLP和GCN, GAT（两个知名度很高的图神经网络）三类神经网络在节点分类任务中的表现进行比较分析，以此来展现图神经网络的强大和论证图神经网络强于普通深度神经网络的原因。
任务
首先，我们要做一些准备工作，即获取并分析数据集、构建一个方法用于分析节点表征的分布。
然后，我们考察MLP神经网络用于节点分类的表现，并观察基于MLP神经网络学习到的节点表征的分布。
接着，我们逐一介绍GCN, GAT这两个图神经网络的理论、对比它们在节点分类任务中的表现以及它们学习到的节点表征的质量。
最后，我们比较三者在节点表征学习能力上的差异。
一、准备工作
1.获取并分析数据集
from torch_geometric.datasets import Planetoid from torch_geometric.transforms import NormalizeFeatures dataset = Planetoid(root='dataset', 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()}')
输出的结果为：
Dataset: Cora(): ====================== Number of graphs: 1 Number of features: 1433 Number of classes: 7 Data(edge_index=[2, 10556], test_mask=[2708], train_mask=[2708], val_mask=[2708], x=[2708, 1433], y=[2708]) ====================== Number of nodes: 2708 Number of edges: 10556 Average node degree: 3.90 Number of training nodes: 140 Training node label rate: 0.05 Contains isolated nodes: False Contains self-loops: False Is undirected: True
我们可以看到，Cora图拥有2,708个节点和10,556条边，平均节点度为3.9，训练集仅使用了140个节点，占整体的5%。我们还可以看到，这个图是无向图（undirected），不存在孤立的节点。
数据转换（transform）在将数据输入到神经网络之前修改数据，这一功能可用于实现数据规范化或数据增强。在此例子中，我们使用NormalizeFeatures进行节点特征归一化，使各节点特征总和为1。其他的数据转换方法请参阅torch-geometric-transforms。
2.可视化节点表征分布的方法
import matplotlib.pyplot as plt from sklearn.manifold import TSNE def visualize(h, color): z = TSNE(n_components=2).fit_transform(h.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()
我们先利用TSNE方法将高维的节点表征映射到二维平面空间，然后在二维平面画出节点，这样我们就实现了节点表征分布的可视化。
二、使用MLP神经网络进行节点分类
多层感知机M L P MLPMLP神经网络，在学术上也被称为A N N ANNANN（A r t i f i c i a l ArtificialArtificial N e u r a l NeuralNeural N e t w o r k s NetworksNetworks，A N N ANNANN），其输入层、隐藏层和输出层，MLP神经网络不同层之间是全连接的。
理论上，我们应该能够仅根据文章的内容，即它的词包特征表征（bag-of-words feature representation）来推断文章的类别，而无需考虑文章之间的任何关系信息。接下来，让我们通过构建一个简单的MLP神经网络来验证这一点。
MLP神经网络只对输入节点的表征做变换，它在所有节点之间共享权重。
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)
输出结果为：
model = MLP(hidden_channels=16) criterion = torch.nn.CrossEntropyLoss() # 定义损失标准 optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) # 定义Adam优化器 def train(): model.train() optimizer.zero_grad() # 清除梯度 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( (lin1): Linear(in_features=1433, out_features=16, bias=True) (lin2): Linear(in_features=16, out_features=7, bias=True) )
我们的MLP由两个线性层、一个ReLU非线性层和一个dropout操作组成。第一个线性层将1433维的节点表征嵌入（embedding）到低维空间中（hidden_channels=16），第二个线性层将节点表征嵌入到类别空间中（num_classes=7）。
MLP神经网络的训练
常见的损失函数有【平方损失函数】——常用于回归类问题、【交叉熵损失】——常用于分类问题，交叉熵衡量的是数据标签的真实分布与分类模型预测的概率分布之间的差异程度。
我们利用交叉熵损失和Adam优化器来训练这个简单的MLP神经网络。
model = MLP(hidden_channels=16) criterion = torch.nn.CrossEntropyLoss() # 定义损失标准 optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) # 定义Adam优化器 def train(): model.train() optimizer.zero_grad() # 清除梯度 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}')
（截取部分）：
Epoch: 001, Loss: 1.9615 Epoch: 002, Loss: 1.9557 Epoch: 003, Loss: 1.9505 Epoch: 004, Loss: 1.9423 Epoch: 005, Loss: 1.9327 Epoch: 006, Loss: 1.9279 Epoch: 007, Loss: 1.9144 Epoch: 008, Loss: 1.9087 Epoch: 009, Loss: 1.9023 Epoch: 010, Loss: 1.8893 Epoch: 011, Loss: 1.8776 Epoch: 012, Loss: 1.8594 Epoch: 013, Loss: 1.8457 Epoch: 014, Loss: 1.8365 Epoch: 015, Loss: 1.8280 Epoch: 016, Loss: 1.7965 。。。。。。。。 Epoch: 191, Loss: 0.3824 Epoch: 192, Loss: 0.3479 Epoch: 193, Loss: 0.3798 Epoch: 194, Loss: 0.3799 Epoch: 195, Loss: 0.4015 Epoch: 196, Loss: 0.3615 Epoch: 197, Loss: 0.3985 Epoch: 198, Loss: 0.4664 Epoch: 199, Loss: 0.3714 Epoch: 200, Loss: 0.3810
上面也可以将Loss的变化用曲线图展示出来，
import pandas as pd df = pd.DataFrame(columns = ["Loss"]) df.index.name = "Epoch" for epoch in range(1, 201): loss =train() df.loc[epoch] = loss.item() df.plot() # 或者： # 绘制损失函数曲线 losslist = [] for epoch in range(1, 201): loss = train() losslist.append(float(loss)) print(f'Epoch: {epoch:03d}, Loss: {loss:.4f}') x = range(len(losslist)) plt.plot(x,losslist) plt.legend(["loss"]) plt.title('loss curve')
MLP神经网络的测试
训练完模型后，我们可以通过测试来检验这个简单的MLP神经网络在测试集上的表现。
# 模型测试 def test(): model.eval() out = model(data.x) 使用概率最大的作为类别标签 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}') # 可视化训练过的MLP模型输出的节点表征 model.eval() out = model(data.x) visualize(out, color = data.y)
输出的结果为：
Test Accuracy: 0.5900
正如我们所看到的，我们的MLP表现相当糟糕，只有大约59%的测试准确性。
另外，如果使用GPU训练则需要在train函数开头加上：
model.train().to(torch.device('cuda'))
