图卷积神经网络（GCN）论文笔记与Geometric源码解释

【参考文献】：1. SEMI-SUPERVISED CLASSIFICATION WITH GRAPH CONVOLUTIONAL NETWORKS

---

引言

主要解决问题 图半监督分类问题，如引用网络。

一般解决方案及缺点 图半监督学习问题，使用基于图的显示正则化平滑标签信息，如在损失函数中使用图拉普拉斯正则项：
$$\mathcal{L}={\mathcal{L}}_0+\lambda {\mathcal{L}}_{\text{reg }},\text{ with }{\mathcal{L}}_{\text{reg }}=\sum _{i,j}{A}_{ij}{\Vert f\left(X_i\right)-f\left(X_j\right)\Vert }^2=f(X{)}^{\top }\Delta f(X),\text{\hspace{1em}(1)}$$

式中，${\mathcal{L}}_0$为仅考虑标注节点的监督损失；$f(\cdot )$为可微函数，如神经网络；$\lambda$为权重因子；$\mathbf{X}$为节点特征向量矩阵；$\Delta =D-A$为无向图未标准化的拉普拉斯矩阵；$A$为邻接矩阵；$D$为节点度矩阵，$D_{ii}={\sum }_j{A}_{ij}$。

公式1依赖于 “图中相连接的节点可能具有相同标签” 的假设，然而这一假设限制了模型容量，虽然不需要在边中编码节点相似性信息，但边仍可能包含额外的信息。

本文解决方案 使用神经网络模型$f(X,A)$直接编码图结构，在监督目标${\mathcal{L}}_0$上训练所有带标签的节点，避免在损失函数中引入显式的基于图的正则化。在图邻接矩阵上调整$f(\cdot )$，使模型能够从${\mathcal{L}}_0$中分发梯度信息，从而同时学习标注节点和未标注节点的表示。

本文主要贡献

• 第一，提出一种可将神经网络直接应用于图的简单且良好的逐层传播规则，并基于谱图卷积的一阶近似给出推导过程；
• 第二，展示如何以快速、可扩展的方式，将这种形式的图神经网络模型应用于图节点半监督分类；

理论推导

先给出结论，多层图卷积网络（GCN）的逐层传播规则是：
$$H^{(l+1)}=\sigma \left({\tilde{D}}^{-1/2}\tilde{A}{\tilde{D}}^{-1/2}{H}^{(l)}{W}^{(l)}\right),\text{\hspace{1em}(2)}$$

式中，

• $\tilde{A}=A+I_N$：加入自连接的无向图的邻接矩阵
• $I_N$：单位矩阵
• ${\tilde{D}}_{ii}={\sum }_j{\tilde{A}}_{ij}$
• $W^{(l)}$：第$l$层参数矩阵
• $\sigma (\cdot )$：激活函数，如ReLU
• $H^{(l)}\in {\mathbb{R}}^{N\times D}$：第$l$层的激活矩阵（特征矩阵），$H^{(0)}=X$

这种形式的传播规则可通过图上局部谱滤波器的一阶近似激发。

通俗理解GCN

如果每一层的输入都是邻接矩阵$A$和特征$H$，我们直接做内积（聚合邻接点特征），再乘一个参数矩阵$W$，经激活函数，构建这种简单神经网络是否可以？
$$f(H^{(l)},A)=\sigma (A{H}^{(l)}{W}^{(l)})$$

实验证明，这种简单神经网络已经足够强大，但具有局限性；

• $A$对角线元素为0，信息聚合时会丢失自身信息，因此需要加入自连接，即用$A+I$替代$A$；
• $A$没有经过归一化，信息聚合后，分布会发生变化，因此需要做标准化处理让$A$的行元素之和为1，即可以用$D^{-1/2}A{D}^{-1/2}$替代$A$；

经以上替换，我们得到层新的传播方式，即公式2。

谱图卷积的一阶近似——GCN

普通形式的拉普拉斯矩阵$L=D-A$，标准化的拉普拉斯矩阵为
$$L^{sys}=D^{-1/2}L{D}^{-1/2}=I-D^{-1/2}A{D}^{-1/2}=U\Lambda U^{\top }$$

无向图邻接阵$A$为对称阵，可正交/谱分解，$\Lambda$为特征值对角阵，$U$为特征向量矩阵。拉普拉斯矩阵的性质：

• 半正定，最小特征值非负；
• 普通形式$L=D-A$，行和为0，最小特征值是0，且对应的特征向量值全为1；

给定信号$x\in {\mathbb{R}}^N$，滤波器$g_{\theta }=diag(\theta )$（由傅里叶空间$\theta \in {\mathbb{R}}^N$参数化），谱图卷积定义为
$$g_{\theta }\star x=U{g}_{\theta }{U}^{\top }x,\text{\hspace{1em}(3)}$$

其中，$U^{\top }x$为$x$的图傅里叶变换.

谱图卷积由来 给定输入$\mathbf{x}$和卷积核$\mathbf{g}$，则
$$\mathbf{x}\ast \mathbf{g}={\mathcal{F}}^{-1}(\mathcal{F}(\mathbf{x})\odot \mathcal{F}(\mathbf{g}))=\mathbf{U}({\mathbf{U}}^{\top }\mathbf{x}\odot {\mathbf{U}}^{\top }\mathbf{g})$$
令$g_{\theta }=U^{T}g=diag(U^{T}g)$作为可学习的卷积核，即可推出公式3。

公式4的局限性：

• $\Lambda$与$U$相乘的时间复杂度是$O(N^2)$
• 大型图邻接矩特征分解复杂，计算代价很高
• 基于全局特征学习滤波器，不能应用于不同结构的图

Hammond et al. (2011) 利用特征值对角矩阵的切比雪夫多项式，以$K$阶近似滤波器$g_{\theta }$：
$$g_{{\theta }^{\prime }}(\Lambda )\approx \sum _{k=0}^K{\theta }_k^{\prime }{T}_k(\tilde{\Lambda }),\text{\hspace{1em}(4)}$$

式中，各参数意义为

• $\tilde{\Lambda }$为重新调整后的特征值对角矩阵，$\tilde{\Lambda }=2\Lambda /{\lambda }_{\max }-I_N$，${\lambda }_{\max }$为$L$的最大特征值
• ${\theta }^{\prime }\in {\mathbb{R}}^K$为切比雪夫系数向量

切比雪夫多项式递归形式为：$T_k(x)=2x{T}_{k-1}(x)-T_{k-2}(x),T_0(x)=1,T_1(x)=x$，此时，谱图卷积变为
$$g_{{\theta }^{\prime }}\star x\approx \sum _{k=0}^{K}U{\theta }_k^{\prime }{T}_k(\tilde{\Lambda })U^{\top }x=\sum _{k=0}^K{\theta }_k^{\prime }{T}_k(U\tilde{\Lambda }{U}^{\top })x=\sum _{k=0}^K{\theta }_k^{\prime }{T}_k(\tilde{L})x,\text{\hspace{1em}(5)}$$

上式是拉普拉斯中的$K$阶多项式，相当于它仅依赖于离中心点最大$K$步的节点。公式5的时间复杂度与边数量成线性关系。

逐层线性模型

通过堆叠多个公式5形式的卷积层可构造图卷积神经网络。

我们希望模型能够在广度分布节点的图上尽可能减轻局部领域结构的过拟合问题，例如社交网络，引用网络，以及许多真实世界的图数据集。对于固定的计算预算，逐层线性表达允许我们创建更深的模型，这可在许多领域增加模型容量。

我们令$K=1$，$\theta ={\theta }_0^{\prime }=-{\theta }_1^{\prime }$，且近似${\lambda }_{\max }\approx 2$，则公式5简化为
$$g_{{\theta }^{\prime }}\star x\approx {\theta }_0^{\prime }x+{\theta }_1^{\prime }\left(L-I_N\right)x={\theta }_0^{\prime }x-{\theta }_1^{\prime }{D}^{-1/2}A{D}^{-1/2}x⟹g_{\theta }\star x\approx \theta \left(I_N+D^{-1/2}A{D}^{-1/2}\right)x,\text{\hspace{1em}(7)}$$

此时，$I_N+D^{-1/2}A{D}^{-1/2}$的特征值位于区间$[0,2]$。在深度网络中反复应用该算子回造成梯度消失/爆炸，因此引入renormalization trick，令$\tilde{A}=A+I_N$，则
$$I_N+D^{-1/2}A{D}^{-1/2}={\tilde{D}}^{-1/2}\tilde{A}{\tilde{D}}^{-1/2}$$

更一般地，对于含有$C$个通道的输入信号，使用$F$个过滤器，有：
$$Z={\tilde{D}}^{-1/2}\tilde{A}{\tilde{D}}^{-1/2}X\Theta ,Z\in {\mathbb{R}}^{N\times F},X\in {\mathbb{R}}^{N\times C},\Theta \in {\mathbb{R}}^{C\times F},\text{\hspace{1em}(8)}$$

半监督节点分类

使用公式8构造两层图卷积网络：
$$Z=f(X,A)=\text{softmax}(\hat{A}\text{ReLU}(\hat{A}X{W}^{(0)})W^{(1)}),\hat{A}={\tilde{D}}^{-1/2}\tilde{A}{\tilde{D}}^{-1/2},\text{\hspace{1em}(9)}$$

无监督多分类任务，在所有有标签的节点上评估损失：
$$\mathcal{L}=-\sum _{l\in {\mathcal{Y}}_L}\sum _{f=1}^F{Y}_{lf}\ln Z_{lf},\text{\hspace{1em}(10)}$$

4 Geometric GCNConv源码

Geometric基于向量形式实现（与加入边权重、去除激活函数的公式2等价）：
$${x\text{x}x}_i^{(k)}=\sum _{j\in \mathcal{N}(i)\cup i}\underset{1}{\underbrace{\frac{w_{i,j}}{\sqrt{\text{deg}(i)}\cdot \sqrt{\text{deg}(j)}}}}\cdot \underset{2}{\underbrace{\left({\Theta }^{(k)}\cdot {x\text{x}x}_j^{(k-1)}\right)}},\text{\hspace{1em}(11)}$$
式中，各参数意义

• $\text{deg}(i)$：节点$i$的度
• $w_{i,j}$：边$i\to j$的权重
• ${\Theta }^{(k)}$：第$k$层卷积层参数
• ${x\text{x}x}_j^{(k-1)}$：第$k-1$层输出

部分源码：

class GCNConv(MessagePassing)：
    def __init__(self, in_channels: int, out_channels: int, improved: bool = False, cached: bool = False,
                 add_self_loops: bool = True, normalize: bool = True, bias: bool = True, **kwargs):
	   	"""
	   	add_self_loops: 是否加入自循环，默认True
	   	normalize：是否加入自循环以及应用对称标准化，默认True
	   	"""
   	    pass
                 
	def forward(self, x: Tensor, edge_index: Adj, edge_weight: OptTensor = None) -> Tensor:
		"""
		x: shape=[num_nodes, num_node_features]
		edge_index: shape=[2, num_edhes]
		"""
		if self.normalize:
			if isinstance(edge_index, Tensor):
				cache = self._cached_edge_index
				if cache is None:
					# 对应于公式11的第1部分
					edge_index, edge_weight = gcn_norm(  # yapf: disable
						edge_index, edge_weight, x.size(self.node_dim),
						self.improved, self.add_self_loops, dtype=x.dtype)
					if self.cached:
						self._cached_edge_index = (edge_index, edge_weight)
				else:
					edge_index, edge_weight = cache[0], cache[1]
	
			elif isinstance(edge_index, SparseTensor):
				cache = self._cached_adj_t
				if cache is None:
					edge_index = gcn_norm(  # yapf: disable
						edge_index, edge_weight, x.size(self.node_dim),
						self.improved, self.add_self_loops, dtype=x.dtype)
					if self.cached:
						self._cached_adj_t = edge_index
				else:
					edge_index = cache
					
		# 对应于公式11的第2部分
		x = torch.matmul(x, self.weight)
		
		# 对应于公式11中1、2部分相乘，并求和
		# propagate_type: (x: Tensor, edge_weight: OptTensor)
		out = self.propagate(edge_index, x=x, edge_weight=edge_weight,size=None)
	
		if self.bias is not None:
			out += self.bias
	
		return out    
	
	def propagate(self, edge_index: Adj, size: Size = None, **kwargs):
		"""The initial call to start propagating messages."""
		size = self.__check_input__(edge_index, size)
	
		# Run "fused" message and aggregation (if applicable).
		if (isinstance(edge_index, SparseTensor) and self.fuse and not self.__explain__):
			coll_dict = self.__collect__(self.__fused_user_args__, edge_index, size, kwargs)
			msg_aggr_kwargs = self.inspector.distribute(
				'message_and_aggregate', coll_dict)
			out = self.message_and_aggregate(edge_index, **msg_aggr_kwargs)
	        
			update_kwargs = self.inspector.distribute('update', coll_dict)
			return self.update(out, **update_kwargs)
			
		# Otherwise, run both functions in separation.
		elif isinstance(edge_index, Tensor) or not self.fuse:
	        # x_j = x.index_select(-2, edge_index[0]), “源节点”features
			coll_dict = self.__collect__(self.__user_args__, edge_index, size, kwargs)
			msg_kwargs = self.inspector.distribute('message', coll_dict)
			# 公式11中1、2部分相乘
			out = self.message(**msg_kwargs)
	
			# For `GNNExplainer`, we require a separate message and aggregate
			# procedure since this allows us to inject the `edge_mask` into the
			# message passing computation scheme.
			if self.__explain__:
				edge_mask = self.__edge_mask__.sigmoid()
				# Some ops add self-loops to `edge_index`. We need to do the
				# same for `edge_mask` (but do not train those).
				if out.size(self.node_dim) != edge_mask.size(0):
					loop = edge_mask.new_ones(size[0])
					edge_mask = torch.cat([edge_mask, loop], dim=0)
				assert out.size(self.node_dim) == edge_mask.size(0)
				out = out * edge_mask.view([-1] + [1] * (out.dim() - 1))
	            
			aggr_kwargs = self.inspector.distribute('aggregate', coll_dict)
	        # 聚合指向相同“目标节点”的特征，对应于公式11求和
			out = self.aggregate(out, **aggr_kwargs)
			
			update_kwargs = self.inspector.distribute('update', coll_dict)
			return self.update(out, **update_kwargs)
			
	def message(self, x_j: Tensor, edge_weight: OptTensor) -> Tensor:
		if edge_weight is None:
			return x_j
		else:
			return edge_weight.view(-1, 1) * x_j
	    
def gcn_norm(edge_index, edge_weight=None, num_nodes=None, improved=False, add_self_loops=True, dtype=None):
    fill_value = 2. if improved else 1.

    if isinstance(edge_index, SparseTensor):
        adj_t = edge_index
        if not adj_t.has_value():
            adj_t = adj_t.fill_value(1., dtype=dtype)
        if add_self_loops:
            adj_t = fill_diag(adj_t, fill_value)
        deg = sum(adj_t, dim=1)
        deg_inv_sqrt = deg.pow_(-0.5)
        deg_inv_sqrt.masked_fill_(deg_inv_sqrt == float('inf'), 0.)
        adj_t = mul(adj_t, deg_inv_sqrt.view(-1, 1))
        adj_t = mul(adj_t, deg_inv_sqrt.view(1, -1))
        return adj_t

    else:
        num_nodes = maybe_num_nodes(edge_index, num_nodes)

        if edge_weight is None:
            edge_weight = torch.ones(
                (edge_index.size(1), ), dtype=dtype, device=edge_index.device)

        if add_self_loops:
            # 向没有自循环的节点加入自循环，新添加的自循环权重为fill_value
            edge_index, tmp_edge_weight = add_remaining_self_loops(
                edge_index, edge_weight, fill_value, num_nodes)
            assert tmp_edge_weight is not None
            edge_weight = tmp_edge_weight

        row, col = edge_index[0], edge_index[1]
        # 计算目标节点（被指向节点）的度，无向图源节点和目标节点的度相同
        deg = scatter_add(edge_weight, col, dim=0, dim_size=num_nodes)
        deg_inv_sqrt = deg.pow_(-0.5)
        deg_inv_sqrt.masked_fill_(deg_inv_sqrt == float('inf'), 0)
        
        # output shape = [num_edges], [num_edges]
        return edge_index, deg_inv_sqrt[row] * edge_weight * deg_inv_sqrt[col]