DeepLearning | 图卷积神经网络(GCN)解析(论文、算法、代码)

本篇博客主要讲述三种图卷积网络（Graph Convolutional Network, GCN）的算法原理及python实现，全文阅读时间约10分钟。

一、图卷积网络原理

图模型早期的研究被称为图信号处理（Graph Signal Processing, GSP）,在12年深度学习爆发以后，学术圈开始研究图模型与神经网络的结合。主要经过三代模型的发展后，相对成熟的图卷积网络开始发展起来，本文主要介绍的也是这三代图卷积模型的原理和变化。

1.0 预备知识

在介绍图卷积之前，需要先普及一些基本的理论知识：

1. 图结构数据
   一张图由节点和边组成，节点代表成员或者对象，而边表示节点间的关系，我们往往使用$A\in {\mathbb{R}}^{n\times n}$表示一张图的结构特性，$A$称为图的邻接矩阵，其中$n$表示节点数量，$a_{i,j}$的数值则表示节点$i$和节点$j$之间的关系。
2. 拉普拉斯图矩阵
   基于图的邻接矩阵，我们可以方便的定义拉普拉斯图矩阵
   $L=D-A$ 上式中$A$是邻接矩阵，$D$称为度矩阵，是一个对角矩阵，$d_{ii}={\sum }_{j=1}^n{a}_{ij}$描述了每一个样本近邻的总和信息。
3. 卷积定理：函数卷积的傅利叶变换是函数傅利叶变换的乘积。
4. 傅立叶变换在图上的推广
   拉普拉斯图矩阵$L$的特征向量$U$可以作为傅立叶变换的基， $L=Udiag({\lambda }_1,...,{\lambda }_n)U^{-1}$ 这里的特征值则可以理解为不同频率分量的系数，越小的特征值表明对应基的分量信息越少。
5. 图卷积的分类
   图卷积主要可以分为基于谱域(谱分解/特征根分解)的卷积以及基于空域的卷积，今天介绍的三代卷积网络都是基于谱域的卷积，但其在空域上也有很好的解释性。关于空域图卷积会在以后的文章中专门介绍

1.1 第一代图卷积网络

第一代图卷积定义为

$y_{output}=\sigma \{Udiag({\theta }_1,...,{\theta }_n)U^{T}x\}$
这里的 $\sigma$表示激活函数, $\theta$表示可训练的网络参数，使用反向传播进行训练， $x$是输入的特征矩阵。
根据预备知识的第4点， 上式可以解释为，$U^T$将$x$变换到频域当中，在频域中与训练得到的 $\theta$加权结合进行特征提取，继而又通过$U$反变换到原来的空域当中。
第一代图卷积模型由LeCun组在14年提出，论文可见 Spectral networks and locally connected networks on graphs. In International Conference on Learning Representations。该模型作为早期的图卷积网络，缺点在于

1. 每一次前向传播都需要计算 $U$, $\theta$, $UT$ 的乘积，计算代价高
2. 在空域内的解释性不好，没法很好利用图的近邻性质
3. 卷积核需要$n$个参数

1.2 第二代图卷积网络

第二代图卷积模型定义为

$y_{output}=\sigma \{Udiag({\sum }_{j=0}^K{\alpha }_j{\lambda }_1^j,...,{\sum }_{j=0}^K{\alpha }_j{\lambda }_n^j)U^{T}x\}$ 上式中， ${\lambda }_i$为 $L$的第 $i$个特征值， $\alpha$是可训练的网络参数，对角矩阵又可以记为 $diag({\sum }_{j=0}^K{\alpha }_j{\lambda }_1^j,...,{\sum }_{j=0}^K{\alpha }_j{\lambda }_n^j)={\sum }_{j=0}^K{\alpha }_j{\Lambda }^j$ 进而可以导出 $U{\sum }_{j=0}^K{\alpha }_j{\Lambda }^j{U}^T={\sum }_{j=0}^K{\alpha }_{j}U{\Lambda }^j{U}^T={\sum }_{j=0}^K{\alpha }_j{L}^j$ 于是有 $y_{output}=\sigma \{{\sum }_{j=0}^K{\alpha }_j{L}^{j}x\}$ 可以看出第二代图卷积网络使用的卷积核其实是 $K$个拉普拉斯图矩阵的加和。那么这里的 $K$是什么含义呢？如何定义的 $K$个拉普拉斯矩阵。其实很简单，第 $k$个图矩阵记录的是经过 $k$跳以后可以找到的近邻，如下图所示

通过定义不同的近邻，来提取更多的信息。
第二代图卷积网络在论文 Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering中被提出，相比与第一代图卷积模型，其优点在于

1. 卷积核只有$K$个参数，一般$K$远小于$N$
2. 不需要做特征根分解，直接用$L$
3. 空间域内的解释性较好

1.3 第三代图卷积网络

第三代图卷积模型，也是当前最流行的版本，由第一代卷积简化推导而来。第一代卷积模型可以表示为

$g_{\theta }\star x=U{g}_{\theta }{U}^{T}x$ ，其中卷积核 $g_{\theta }=diag(\theta )$ 是待训练的参数，特征向量 $U$由标准化的拉普拉斯矩阵特征根分解得到 $L=I-D^{-0.5}A{D}^{-0.5}=U\Lambda U^T$ ，这里的卷积核 $g_{\theta }$可以理解为特征值 $\Lambda$的函数，记为 $g_{\theta }(\Lambda )$.
使用切比雪夫多项式 $K$阶近似 $g_{\theta }(\Lambda )$, $g_{{\theta }^{\prime }}(\Lambda )\approx {\sum }_{k=0}^K{\theta }_k^{\prime }{T}_k(\tilde{\Lambda })$ ，其中 $\tilde{\Lambda }=\frac{2}{{\lambda }_{max}}\Lambda -I$， ${\theta }^{\prime }$是需要学习的系数， $T_k$的定义是递归的 $T_k(x)=ax{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{\theta }_k^{\prime }{T}_k(\tilde{L})x$ ，其中 $\tilde{L}=\frac{2}{{\lambda }_{max}}L-I$。
进一步近似，约束 ${\lambda }_{max}=2$, 取 $K=1$， 则有 $g_{\theta }^{\prime }\star x\approx {\theta }_0^{\prime }x-{\theta }_1^{\prime }{D}^{-0.5}A{D}^{-0.5}x$ ，因为 ${\theta }^{\prime }$是需要学习的系数，可以将其约束为 $\theta ={\theta }_0^{\prime }=-{\theta }_1^{\prime }$, 则有 $g_{\theta }^{\prime }\star x\approx \theta (I+D^{-0.5}A{D}^{-0.5})x$ ，再使用重参数化技巧 $I+D^{-0.5}A{D}^{-0.5}\to {\tilde{D}}^{-0.5}\tilde{A}{\tilde{D}}^{-0.5}$ ，其中 $\tilde{A}=A+I$ 和 $\widetilde{d_{ii}}={\sum }_{j=1}^n{\tilde{a}}_{ij}$。
据上，第三代图卷积模型为定义为 $y_{output}={\tilde{D}}^{-0.5}\tilde{A}{\tilde{D}}^{-0.5}X\theta$ 。其模型可以被理解为是对一代模型做了一阶的切比雪夫近似，为每一个节点提取一阶近邻的信息。
第三代图卷积模型在论文 Semi-Supervised Classification with Graph Convolutional Networks中被提出，由于其较好空域解释性和精简的模型结构，受到广泛应用。

1.4 图卷积网络的优缺点

特点：

1. 训练的输入为$X$和$A$，以整张数据图为输入，而不是以batch训练
2. 训练阶段会用到无标签的测试数据，因而是直推式半监督学习

优点：

1. 显式的利用节点间的关系进行特征的提取
2. 实现相对简单、计算并不复杂

缺点：

1. 图卷积网络一般只有1-4层，无法深层堆叠，会出现梯度消失的问题
2. . 一般的图卷积网络以整张图作为输入，所以在普通机器上无法训练大规模的图数据

二、图卷积网络python实现

下面是图卷积网络的核心代码

#卷积层代码
import  torch
from    torch import nn
from    torch.nn import functional as F
from    utils import sparse_dropout, dot

class GraphConvolution(nn.Module):
    def __init__(self, input_dim, output_dim, num_features_nonzero,
                 dropout=0.,
                 is_sparse_inputs=False,
                 bias=False,
                 activation = F.relu,
                 featureless=False):
        super(GraphConvolution, self).__init__()


        self.dropout = dropout
        self.bias = bias
        self.activation = activation
        self.is_sparse_inputs = is_sparse_inputs
        self.featureless = featureless
        self.num_features_nonzero = num_features_nonzero

        self.weight = nn.Parameter(torch.randn(input_dim, output_dim))
        self.bias = None
        if bias:
            self.bias = nn.Parameter(torch.zeros(output_dim))


    def forward(self, inputs):
        # print('inputs:', inputs)
        x, support = inputs

        if self.training and self.is_sparse_inputs:
            x = sparse_dropout(x, self.dropout, self.num_features_nonzero)
        elif self.training:
            x = F.dropout(x, self.dropout)

        # convolve
        if not self.featureless: # if it has features x
            if self.is_sparse_inputs:
                xw = torch.sparse.mm(x, self.weight)
            else:
                xw = torch.mm(x, self.weight)
        else:
            xw = self.weight

        out = torch.sparse.mm(support, xw)

        if self.bias is not None:
            out += self.bias

        return self.activation(out), support

#模型代码
import  torch
from    torch import nn
from    torch.nn import functional as F
from    layer import GraphConvolution

from    config import args

class GCN(nn.Module):
    def __init__(self, input_dim, output_dim, num_features_nonzero):
        super(GCN, self).__init__()

        self.input_dim = input_dim # 1433
        self.output_dim = output_dim

        print('input dim:', input_dim)
        print('output dim:', output_dim)
        print('num_features_nonzero:', num_features_nonzero)


        self.layers = nn.Sequential(GraphConvolution(self.input_dim, args.hidden, num_features_nonzero,
                                                     activation=F.relu,
                                                     dropout=args.dropout,
                                                     is_sparse_inputs=True),

                                    GraphConvolution(args.hidden, output_dim, num_features_nonzero,
                                                     activation=F.relu,
                                                     dropout=args.dropout,
                                                     is_sparse_inputs=False),

                                    )

    def forward(self, inputs):
        x, support = inputs

        x = self.layers((x, support))

        return x

    def l2_loss(self):

        layer = self.layers.children()
        layer = next(iter(layer))

        loss = None

        for p in layer.parameters():
            if loss is None:
                loss = p.pow(2).sum()
            else:
                loss += p.pow(2).sum()

        return loss

三、图卷积网络论文、代码、数据集资源下载!

有问题可以私信博主，点赞关注的一般都会回复，一起努力，谢谢支持。
微信搜索“老和山算法指南”获取下载链接与技术交流群