GNN图神经网络详述-02

本文作为第2部分，主要根据原始论文介绍几篇基础的工作，主要包括GNN，GCN及变体，DCNN，Tree-LSTM,包括模型的详解和模型训练，以及模型评价。

1. The Graph Neural Network Model

• 论文：2009 -《The Graph Neural Network Model 》

这篇论文是第一个提出Graph Neural Network模型的论文，它将神经网络使用在图结构数据上，并细述了神经网络模型了结构组成、计算方法、优化算法、流程实现等等。论文后面还对模型的复杂度进行了评估，以及在现实任务上进行了实验和比较(比较算法为NL、L、FNN)。该报告暂时主要关注模型设计部分和实验结果部分，忽略复杂性评估部分。

图领域应用

对于图领域问题，假设函数$\tau$是将一个图$G$和图中的一个节点$n$转化为一个实值向量的函数
$$\tau (G,n)\in R^m$$那么监督学习的任务就在于从已知样本中学习得到这样的函数。

图领域的应用主要可以分为两种类型：专注于图的应用(graph-focused)和专注于节点的应用(node-focused)。对于graph-focused的应用，函数$\tau$和具体的节点无关，(即$\tau (G)$)，训练时，在一个图的数据集中进行分类或回归。对于node-focused的应用，$\tau$函数依赖于具体的节点$n$，即$\tau (G,n)$，如下：

• 图 (a) 是一个化学分子结构，能够使用图 $G$ 进行表示，函数$\tau (G)$可能用于估计这种化学分子对人体有害的概率，因此，我们并不关注分子中具体的原子(相当于节点)，所以属于graph-focused应用。
• 图 (b) 是一张城堡的图片，图片中的每一种结构都由节点表示，函数$\tau (G,n)$可能用于预测每一个节点是否属于城堡(图中的黑点)。这种类型属于node-focused应用。

GNN模型详述

GNN模型基于信息传播机制，每一个节点通过相互交换信息来更新自己的节点状态，直到达到某一个稳定值，GNN的输出就是在每个节点处，根据当前节点状态分别计算输出。

有如下定义：

• 一个图$G$表示为一对$(\mathbf{N},\mathbf{E})$，其中，$\mathbf{N}$表示节点集合，$\mathbf{E}$表示边集。

• $ne[n]$表示节点$n$的邻居节点集合

• $co[n]$表示以$n$节点为顶点的所有边集合

• ${\mathbf{l}}_n\in {\mathbb{R}}^{l_N}$表示节点$n$的特征向量

• ${\mathbf{l}}_{\left(n_1,n_2\right)}\in {\mathbb{R}}^{l_E}$表示边$(n_1,n_2)$的特征向量

• $\mathbf{l}$表示所有特征向量叠在一起的向量

注：原论文里面$\mathbf{l}$表示label，但论文中的label指的是features of objects related to nodes and features of the relationships between the objects，也就是相关特征，所以这里一律使用特征向量翻译。

论文将图分为positional graph和nonpositional graph，对于positional graph，对于每一个节点$n$，都会给该节点的邻居节点$u$赋予一个position值${\nu }_n(u)$，该函数称为injective function，${\nu }_n:\mathrm{n}\mathrm{e}[n]\to \{1,\dots |\mathbf{N}|\}$。

假设存在一个图-节点对的集合$\mathcal{D}=\mathcal{G}\times \mathcal{N}$，$\mathcal{G}$表示图的集合，$\mathcal{N}$表示节点集合，图领域问题可以表示成一个有如下数据集的监督学习框架
$$\mathcal{L}=\{\left({\mathbf{G}}_i,n_{i,j},{\mathbf{t}}_{i,j}\right)|{\mathbf{G}}_i=\left({\mathbf{N}}_i,{\mathbf{E}}_i\right)\in \mathcal{G};n_{i,j}\in {\mathbf{N}}_i;{\mathbf{t}}_{i,j}\in {\mathbb{R}}^m,1\le i\le p,1\le j\le q_i\}$$ 其中，$n_{i,j}\in {\mathbf{N}}_i$表示集合${\mathbf{N}}_i\in \mathcal{N}$中的第$j$个节点，${\mathbf{t}}_{i,j}$表示节点$n_{ij}$的期望目标(即标签)。

节点$n$的状态用${\mathbf{x}}_n\in {\mathbb{R}}^s$表示，该节点的输出用${\mathbf{o}}_{\mathbf{n}}$表示，$f_{\mathbf{w}}$为local transition function，$g_{\mathbf{w}}$为local output function，那么${\mathbf{x}}_n$和${\mathbf{o}}_{\mathbf{n}}$的更新方式如下
$$\begin{array}{l}{\mathbf{x}}_n=f_{\mathbf{w}}\left({\mathbf{l}}_n,{\mathbf{l}}_{\mathrm{c}\mathrm{o}[n]},{\mathbf{x}}_{\mathrm{n}\mathrm{e}[n]},{\mathbf{l}}_{\mathrm{n}\mathrm{e}\left[n\right]}\right)\\ {\mathbf{o}}_n=g_{\mathbf{w}}\left({\mathbf{x}}_n,{\mathbf{l}}_n\right)\end{array}$$其中，${\mathbf{l}}_n,{\mathbf{l}}_{\mathrm{co}[n]},{\mathbf{x}}_{\mathrm{n}\mathrm{e}[n]},{\mathbf{l}}_{\mathrm{n}\mathrm{e}[n]}$分别表示节点$n$的特征向量、与节点$n$相连的边的特征向量、节点$n$邻居节点的状态向量、节点$n$邻居节点的特征向量。

假设$\mathbf{x},\mathbf{o},\mathbf{l},{\mathbf{l}}_N$分别为所有的状态、所有的输出、所有的特征向量、所有节点的特征向量的叠加起来的向量，那么上面函数可以写成如下形式
$$\begin{array}{l}\mathbf{x}=F_{\mathbf{w}}(\mathbf{x},\mathbf{l})\\ \mathbf{o}={\mathbf{G}}_{\mathbf{w}}\left(\mathbf{x},{\mathbf{l}}_{\mathbf{N}}\right)\end{array}$$其中，$F_{\mathbf{w}}$为global transition function，$G_{\mathbf{w}}$为global output function，分别是$f_{\mathbf{w}}$和$g_{\mathbf{w}}$的叠加形式。

根据Banach的不动点理论，假设$F_{\mathbf{w}}$是一个压缩映射函数，那么式子有唯一不动点解，而且可以通过迭代方式逼近该不动点
$$\mathbf{x}(t+1)=F_{\mathbf{w}}(\mathbf{x}(t),\mathbf{l})$$其中，$\mathbf{x}(t)$表示$\mathbf{x}$在第$t$个迭代时刻的值，对于任意初值，迭代的误差是以指数速度减小的，使用迭代的形式写出状态和输出的更新表达式为
$$\begin{array}{rl}{\mathbf{x}}_n(t+1)& =f_{\mathbf{w}}\left({\mathbf{l}}_n,{\mathbf{l}}_{\mathrm{c}\mathrm{o}[n]},{\mathbf{x}}_{\mathrm{n}\mathrm{e}[n]}(t),{\mathbf{l}}_{\mathrm{n}\mathrm{e}[n]}\right)\\ {\mathbf{o}}_n(t)& =g_{\mathbf{w}}\left({\mathbf{x}}_n(t),{\mathbf{l}}_n\right),n\in \mathbf{N}\end{array}$$GNN的信息传播流图以及等效的网络结构如下图所示

根据上图所示，顶端的图是原始的Graph，中间的图表示状态向量和输出向量的计算流图，最下面的图表示将更新流程迭代$T$次，并展开之后得到等效网络图。

网络的学习算法设计

GNN的学习就是估计参数$\mathbf{w}$，使得函数${\phi }_{\mathbf{w}}$能够近似估计训练集
$$\mathcal{L}=\{\left({\mathbf{G}}_i,n_{i,j},{\mathbf{t}}_{i,j}\right)|{\mathbf{G}}_i=\left({\mathbf{N}}_i,{\mathbf{E}}_i\right)\in \mathcal{G};n_{i,j}\in {\mathbf{N}}_i;{\mathbf{t}}_{i,j}\in {\mathbb{R}}^m,1\le i\le p,1\le j\le q_i\}$$其中，$q_i$表示在图$G_i$中监督学习的节点个数，对于graph-focused的任务，需要增加一个特殊的节点，该节点用来作为目标节点，这样，graph-focused任务和node-focused任务都能统一到节点预测任务上，学习目标可以是最小化如下二次损失函数
$$e_{\mathbf{w}}=\sum _{i=1}^p\sum _{j=1}^{q_i}{\left({\mathbf{t}}_{i,j}-{\phi }_{\mathbf{w}}\left({\mathbf{G}}_i,n_{i,j}\right)\right)}^2$$优化算法基于随机梯度下降的策略，优化步骤按照如下几步进行

• 按照迭代方程迭代$T$次得到$x_n(t)$，此时接近不动点解：$\mathbf{x}(T)\approx \mathbf{x}$
• 计算参数权重的梯度$\partial e_{\mathbf{w}}(T)/\partial \mathbf{w}$
• 使用该梯度来更新权重$\mathbf{w}$

这里假设函数$F_{\mathbf{w}}$是压缩映射函数，保证最终能够收敛到不动点。另外，这里的梯度的计算使用backpropagation-through-time algorithm。

为了表明前面的方法是可行的，论文接着证明了两个结论

---

理论1(可微性)：令$F_{\mathbf{w}}$和$G_{\mathbf{w}}$分别是global transition function和global output function，如果$F_{\mathbf{w}}(\mathbf{x},\mathbf{l})$和$G_{\mathbf{w}}\left(\mathbf{x},{\mathbf{l}}_{\mathbf{N}}\right)$对于$\mathbf{x}$和$\mathbf{w}$是连续可微的，那么${\phi }_{\mathbf{w}}$对$\mathbf{w}$也是连续可微的。

理论2(反向传播)：令$F_{\mathbf{w}}$和$G_{\mathbf{w}}$分别是global transition function和global output function，如果$F_{\mathbf{w}}(\mathbf{x},\mathbf{l})$和$G_{\mathbf{w}}\left(\mathbf{x},{\mathbf{l}}_{\mathbf{N}}\right)$对于$\mathbf{x}$和$\mathbf{w}$是连续可微的。令$\mathbf{z}(t)$定义为
$$z(t)=z(t+1)\cdot \frac{\partial F_w}{\partial x}(x,l)+\frac{\partial e_w}{\partial o}\cdot \frac{\partial G_w}{\partial x}\left(x,l_N\right)$$
那么，序列$\mathbf{z}(T),\mathbf{z}(T-1),\dots$收敛到一个向量，$z={\lim }_{t\to -\infty }z(t)$，并且收敛速度为指数级收敛以及与初值$\mathbf{z}(T)$无关，另外，还存在
$$\frac{\partial e_w}{\partial \mathbf{w}}=\frac{\partial e_{\mathbf{w}}}{\partial \mathbf{o}}\cdot \frac{\partial G_{\mathbf{w}}}{\partial \mathbf{w}}\left(\mathbf{x},{\mathbf{l}}_N\right)+\mathbf{z}\cdot \frac{\partial F_{\mathbf{w}}}{\partial \mathbf{w}}(\mathbf{x},\mathbf{l})$$
其中，$\mathbf{x}$是GNN的稳定状态。

算法流程如下

FORWARD用于迭代计算出收敛点，BACKWARD用于计算梯度。

Transition和Output函数实现

在GNN中，函数$g_{\mathbf{w}}$不需要满足特定的约束，直接使用多层前馈神经网络，对于函数$f_{\mathbf{w}}$，则需要着重考虑，因为$f_{\mathbf{w}}$需要满足压缩映射的条件，而且与不动点计算相关。下面提出两种神经网络和不同的策略来满足这些需求

1. Linear(nonpositional) GNN：

   对于节点$n$状态的计算，将$f_{\mathbf{w}}$改成如下形式
   $${\mathbf{x}}_n=\sum _{u\in \text{ ne }|n]}{h}_{\mathbf{w}}\left({\mathbf{l}}_n,{\mathbf{l}}_{(n,u)},{\mathbf{x}}_u,{\mathbf{l}}_u\right),n\in \mathbf{N}$$ 相当于是对节点$n$的每一个邻居节点使用$h_{\mathbf{w}}$，并将得到的值求和来作为节点$n$的状态。

   由此，对上式中的函数$h_{\mathbf{w}}$按照如下方式实现
   $$h_{\mathbf{w}}\left({\mathbf{l}}_n,{\mathbf{l}}_{(n,\mathfrak{a})},{\mathbf{x}}_u,{\mathbf{l}}_u\right)={\mathbf{A}}_{n,u}{\mathbf{x}}_u+{\mathbf{b}}_n$$ 其中，向量${\mathbf{b}}_n\in {\mathbb{R}}^s$，矩阵${\mathbf{A}}_{n,u}\in {\mathbb{R}}^{s\times s}$定义为两个前向神经网络的输出。更确切地说，令产生矩阵${\mathbf{A}}_{n,u}$的网络为transition network，产生向量${\mathbf{b}}_n$的网络为forcing network

   transition network表示为${\varphi }_{\mathbf{w}}$
   $${\varphi }_{\mathbf{w}}:{\mathbb{R}}^{2l_N+l_E}\to {\mathbb{R}}^{s^2}$$
   forcing network表示为${\rho }_{\mathbf{w}}$
   $${\rho }_{\mathbf{w}}:{\mathbb{R}}^{l_N}\to {\mathbb{R}}^s$$ 由此，可以定义${\mathbf{A}}_{n,u}$和${\mathbf{b}}_n$
   $$\begin{array}{rl}{\mathbf{A}}_{\mathbf{n},\mathbf{u}}& =\frac{\mu }{s|\mathrm{ne}[u]|}\cdot \mathbf{\Xi }\\ {\mathbf{b}}_{\mathbf{w}}& ={\rho }_{\mathbf{w}}\left({\mathbf{l}}_n\right)\end{array}$$ 其中，$\mu \in (0,1)$，$\Xi =\mathrm{resize}\left({\varphi }_{\mathbf{w}}\left({\mathbf{l}}_n,{\mathbf{l}}_{(n,u)},{\mathbf{l}}_u\right)\right)$，$\text{resize}(\cdot )$表示将$s^2$维的向量整理(reshape)成$s\times s$的矩阵，也就是说，将transition network的输出整理成方形矩阵，然后乘以一个系数就得到${\mathbf{A}}_{n,u}$。${\mathbf{b}}_n$就是forcing network的输出。

   在这里，假定${\Vert {\varphi }_{\mathbf{w}}\left({\mathbf{l}}_n,{\mathbf{l}}_{(\mathbf{n},\mathbf{u})},{\mathbf{l}}_u\right)\Vert }_1\le \mathbf{s}$，这个可以通过设定transition function的激活函数来满足，比如设定激活函数为$tanh()$。在这种情况下，$F_{\mathbf{w}}(\mathbf{x},\mathbf{l})=\mathbf{A}\mathbf{x}+\mathbf{b}$，$\mathbf{A}$和$\mathbf{b}$分别是${\mathbf{A}}_{n,u}$的块矩阵形式和${\mathbf{b}}_n$的堆叠形式，通过简单的代数运算可得
   $$\begin{array}{rl}{\Vert \frac{\partial F_{\mathbf{w}}}{\partial \mathbf{x}}\Vert }_1& =\Vert \mathbf{A}{\Vert }_1\le \underset{u\in \mathbf{N}}{\max }\left(\sum _{n\in \mathrm{ne}[u]}{\Vert {\mathbf{A}}_{n,u}\Vert }_1\right)\\ & \le \underset{u\in N}{\max }\left(\frac{\mu }{s|\mathrm{ne}[u]|}\cdot \sum _{n\in \mathrm{n}\mathrm{e}[u]}\Vert \mathbf{\Xi }{\Vert }_1\right)\le \mu \end{array}$$
   该式表示$F_{\mathbf{w}}$对于任意的参数$\mathbf{w}$是一个压缩映射。

   矩阵$M$的1-norm定义为
   $$\Vert M{\Vert }_1=\underset{j}{\max }\sum _i\left|m_{i,j}\right|$$

2. Nonelinear(nonpositional) GNN：在这个结构中，$h_{\mathbf{w}}$通过多层前馈网络实现，但是，并不是所有的参数$\mathbf{w}$都会被使用，因为同样需要保证$F_{\mathbf{w}}$是一个压缩映射函数，这个可以通过惩罚项来实现
   $$e_{\mathbf{w}}=\sum _{i=1}^p\sum _{j=1}^{q_i}{\left({\mathbf{t}}_{i,j}-{\phi }_{\mathbf{w}}\left({\mathbf{G}}_i,n_{i,j}\right)\right)}^2+\beta L\left(\Vert \frac{\partial F_{\mathbf{w}}}{\partial \mathbf{x}}\Vert \right)$$ 其中，惩罚项$L(y)$在$y>\mu$时为$(y-\mu {)}^2$，在$y\le \mu$时为0，参数$\mu \in (0,1)$定义为希望的$F_{\mathbf{w}}$的压缩系数。

实验结果

论文将GNN模型在三个任务上进行了实验：子图匹配(subgraph matching)任务，诱变(mutagenesis)任务和网页排序(web page ranking)任务。在这些任务上使用linear和nonlinear的模型测试，其中nonlinear模型中的激活函数使用sigmoid函数。

子图匹配任务为在一个大图$G$上找到给定的子图$S$(标记出属于子图的节点)，也就是说，函数$\tau$必须学习到，如果$n_{i,j}$属于子图$G$，那么$\tau (G_i,n_{i,j})=1$，否则，$\tau (G_i,n_{i,j})=-1$。实验结果中，nonlinear模型的效果要好于linear模型的效果，两个模型都要比FNN模型效果更好。

诱变问题任务是对化学分子进行分类，识别出诱变化合物，采用二分类方法。实验结果是nonlinear效果较好，但不是最好。

网页排序任务是学会网页排序。实验表明虽然训练集只包含50个网页，但是仍然没有产生过拟合的现象。

模型实现

在模拟的节点分类任务上实现该论文的GNN模型。

• 任务要求为输入一个graph，该graph的所有节点都有标签，然后对部分节点进行训练，在验证阶段使用另外一部分节点进行验证。输入的数据图如下图：

其中，该graph总共有18个节点，分别是$\{n1,n2,...,n18\}$，不同颜色的节点表示不同的节点类别。模拟的问题中节点类别有三类，分别用$\{0,1,2\}$表示，在训练阶段，使用节点$\{n1,n2,n3,n7,n8,n9,n13,n14,n15\}$进行训练，相当于每一类取出三个节点训练，其余的节点用于在验证阶段进行验证。

输入的数据为(node,label)列表和(node1, node2)边列表，表示如下

# (node, label)集
N = [("n{}".format(i), 0) for i in range(1,7)] + \
    [("n{}".format(i), 1) for i in range(7,13)] + \
    [("n{}".format(i), 2) for i in range(13,19)]
# 边集
E = [("n1","n2"), ("n1","n3"), ("n1","n5"),
     ("n2","n4"),
     ("n3","n6"), ("n3","n9"),
     ("n4","n5"), ("n4","n6"), ("n4","n8"),
     ("n5","n14"),
     ("n7","n8"), ("n7","n9"), ("n7","n11"),
     ("n8","n10"), ("n8","n11"), ("n8", "n12"),
     ("n9","n10"), ("n9","n14"),
     ("n10","n12"),
     ("n11","n18"),
     ("n13","n15"), ("n13","n16"), ("n13","n18"),
     ("n14","n16"), ("n14","n18"),
     ("n15","n16"), ("n15","n18"),
     ("n17","n18")]

$N$为节点集合，$E$为边集合。

• 模型部分使用论文的linear函数来设计$f_w$和$g_w$，而且，这两个函数在graph所有的节点上进行共享。模型部分实现了$\Xi$，$\rho$函数，以及完整的forward传播部分，如下简化代码：

  # 实现Xi函数，输入一个batch的相邻节点特征向量对ln，返回是s*s的A矩阵
  # ln是特征向量维度，s为状态向量维度
  # Input : (N, 2*ln)
  # Output : (N, S, S)
  class Xi(nn.Module):
      def __init__(self, ln, s):
          ...
      def forward(self, X):
          ...
  
  # 实现Rou函数
  # Input : (N, ln)
  # Output : (N, S)
  class Rou(nn.Module):
      def __init__(self, ln, s):
          ...
      def forward(self, X):
          ...
  
  # 实现Hw函数
  # Input : (N, 2 * ln) 
  #         每一行都是一个节点特征向量和该节点的某一个邻接向量concat
  #         得到的向量
  # Input : (N, s)
  #         对应中心节点的状态向量
  # Input : (N, )
  #         对应中心节点的度的向量
  # Output : (N, s)
  class Hw(nn.Module):
      def __init__(self, ln, s, mu=0.9):
          ...
      def forward(self, X, H, dg_list):
          ...
  
  class AggrSum(nn.Module):
      def __init__(self, node_num):
          ...
      
      def forward(self, H, X_node):
          ...
  
  # 实现GNN模型
  class OriLinearGNN(nn.Module):
      def __init__(self, node_num, feat_dim, stat_dim, T):
          ...
      # Input : 
      #    X_Node : (N, )
      #    X_Neis : (N, )
      #    H      : (N, s)
      #    dg_list: (N, )
      def forward(self, X_Node, X_Neis, dg_list):
          ...
          for t in range(self.T):
              # (V, s) -> (N, s)
              H = torch.index_select(self.node_states, 0, X_Node)
              # (N, s) -> (N, s)
              H = self.Hw(X, H, dg_list)
              # (N, s) -> (V, s)
              self.node_states = self.Aggr(H, X_Node)
  #             print(H[1])
          ...
  

  可以看出，在模型训练阶段，每次forward，都会直接循环计算T次$f_w$函数计算不动点，然后再计算output。

• 模型训练部分按照常规的分类模型进行训练，采用Adam优化器，学习率保持为0.01，权重衰减为0.01，使用交叉熵作为损失函数，模型训练部分代码如下

  # 用于计算accuracy
  def CalAccuracy(output, label):
      ...
  
  # 开始训练模型
  def train(node_list, edge_list, label_list, T, ndict_path="./node_dict.json"):
      # 生成node-index字典
      ...
  
      # 现在需要生成两个向量
      # 第一个向量类似于
      #   [0, 0, 0, 1, 1, ..., 18, 18]
      # 其中的值表示节点的索引，连续相同索引的个数为该节点的度
      # 第二个向量类似于
      #   [1, 2, 4, 1, 4, ..., 11, 13]
      # 与第一个向量一一对应，表示第一个向量节点的邻居节点
  
      # 首先统计得到节点的度
      ...
      
      # 然后生成两个向量
      ...
      # 生成度向量
      ...
      # 准备训练集和测试集
      train_node_list = [0,1,2,6,7,8,12,13,14]
      train_node_label = [0,0,0,1,1,1,2,2,2]
      test_node_list = [3,4,5,9,10,11,15,16,17]
      test_node_label = [0,0,0,1,1,1,2,2,2]
      
      # 开始训练
      model = OriLinearGNN(node_num=len(node_list),
                           feat_dim=2,
                           stat_dim=2,
                           T=T)
      optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=0.01)
      criterion = nn.CrossEntropyLoss(size_average=True)
      
      min_loss = float('inf')
      node_inds_tensor = Variable(torch.Tensor(node_inds).long())
      node_neis_tensor = Variable(torch.Tensor(node_neis).long())
      train_label = Variable(torch.Tensor(train_node_label).long())
      for ep in range(500):
          # 运行模型得到结果
          res = model(node_inds_tensor, node_neis_tensor, dg_list) # (V, 3)
          train_res = torch.index_select(res, 0, torch.Tensor(train_node_list).long())
          test_res = torch.index_select(res, 0, torch.Tensor(test_node_list).long())
          loss = criterion(input=train_res,
                           target=train_label)
          loss_val = loss.item()
          train_acc = CalAccuracy(train_res.cpu().detach().numpy(), np.array(train_node_label))
          test_acc = CalAccuracy(test_res.cpu().detach().numpy(), np.array(test_node_label))
          # 更新梯度
          optimizer.zero_grad()
          loss.backward(retain_graph=True)
          optimizer.step()
  
          if loss_val < min_loss:
              min_loss = loss_val
          print("==> [Epoch {}] : loss {:.4f}, min_loss {:.4f}, train_acc {:.3f}, test_acc {:.3f}".format(ep, loss_val, min_loss, train_acc, test_acc))
  

• 模型的训练和评估结果如下图:
  
  第一条曲线为训练loss曲线，第二条曲线为训练的acc曲线，第三条曲线为评估的acc曲线，可以看出，训练的loss很快达到了最低0.56左右，而准确率达到了1.0，基本已经过拟合，而验证集的准确率一直很低，最高在第500个epoch处上升到0.667，约为$\frac{2}{3}$左右。

2. Graph Convolutional Networks

• 论文：《Semi-Supervised Classification with Graph Convolutional Networks》

图卷积的演变

按照图傅里叶变换的性质，可以得到如下图卷积的定义
$$(\mathbf{f}\ast \mathbf{h}{)}_{\mathcal{G}}=\mathbf{\Phi }\mathrm{diag}\left[\hat{h}\left({\lambda }_1\right),\dots ,\hat{h}\left({\lambda }_n\right)\right]{\mathbf{\Phi }}^T\mathbf{f}$$其中

• 对于图$ \boldsymbol{f}$的傅里叶变换为$\boldsymbol{\hat{f}}=\mathbf{\Phi}^{T} \boldsymbol{f}$

• 对于卷积核的图傅里叶变换：$\hat{h}=\left({\hat{h}}_1,\dots ,{\hat{h}}_n\right)$，其中
  $${\hat{h}}_k=⟨h,{\varphi }_k⟩,k=1,2\dots ,n$$ 按照矩阵形式就是$\hat{\mathbf{h}}={\mathbf{\Phi }}^T\mathbf{h}$

• 对两者的傅里叶变换向量$\hat{f}\in {\mathbb{R}}^{N\times 1}$和$\hat{h}\in {\mathbb{R}}^{N\times 1}$求element-wise乘积，等价于将$\mathbf{h}$组织成对角矩阵，即$\mathrm{diag}\left[\hat{h}\left({\lambda }_k\right)\right]\in {\mathbb{R}}^{N\times N}$，然后再求$\mathrm{diag}\left[\hat{h}\left({\lambda }_k\right)\right]$和$\mathbf{f}$矩阵乘法。

• 求上述结果的傅里叶逆变换，即左乘$\mathbf{\Phi }$。

深度学习中的卷积就是要设计trainable的卷积核，从上式可以看出，就是要设计$\mathrm{diag}\left[\hat{h}\left({\lambda }_1\right),\dots ,\hat{h}\left({\lambda }_n\right)\right]$，由此，可以直接将其变为卷积核$\mathrm{diag}\left[{\theta }_1,\dots ,{\theta }_n\right]$，而不需要再将卷积核进行傅里叶变换，由此，相当于直接将变换后的参量进行学习。

第一代GCN

第一代GCN为
$${\mathbf{y}}_{\text{output}}=\sigma \left(\mathbf{\Phi }{\mathbf{g}}_{\theta }{\mathbf{\Phi }}^T\mathbf{x}\right)=\sigma \left(\mathbf{\Phi }\mathrm{diag}\left[{\theta }_1,\dots ,{\theta }_n\right]{\mathbf{\Phi }}^T\mathbf{x}\right)$$
其中，$\mathbf{x}$就是graph上对应每个节点的feature构成的向量，$x=\left(x_1,x_2,\dots ,x_n\right)$，这里暂时对每个节点都使用标量，然后经过激活之后，得到输出${\mathbf{y}}_{\text{output}}$，之后传入下一层。

一些缺点：

• 需要对拉普拉斯矩阵进行谱分解来求$\mathbf{\Phi }$，在graph很大的时候复杂度很高。另外，还需要计算矩阵乘积，复杂度为$O(n^2)$。
• 卷积核参数为$n$，当graph很大的时候，$n$会很大。
• 卷积核的spatial localization不好。

第二代GCN

图傅里叶变换是关于特征值(相当于普通傅里叶变换的频率)的函数，也就是$F\left({\lambda }_1\right),\dots ,F\left({\lambda }_n\right)$，即$F(\mathbf{\Lambda })$，因此，将卷积核${\mathbf{g}}_{\theta }$写成${\mathbf{g}}_{\theta }(\Lambda )$，然后，将${\mathbf{g}}_{\theta }(\Lambda )$定义为如下k阶多项式
$$g_{{\theta }^{\prime }}(\mathbf{\Lambda })\approx \sum _{k=0}^K{\theta }_k^{\prime }{\mathbf{\Lambda }}^k$$将卷积公式带入，可以得到
$$\begin{array}{rl}{g}_{{\theta }^{\prime }}\ast x& \approx \Phi \sum _{k=0}^K{\theta }_k^{\prime }{\mathbf{\Lambda }}^k{\mathbf{\Phi }}^T\mathbf{x}\\ & =\sum _{k=0}^K{\theta }_k^{\prime }\left(\mathbf{\Phi }{\mathbf{\Lambda }}^k{\mathbf{\Phi }}^T\right)x\\ & =\sum _{k=0}^K{\theta }_k^{\prime }{\left(\mathbf{\Phi }\mathbf{\Lambda }{\mathbf{\Phi }}^T\right)}^{k}x\\ & =\sum _{k=0}^K{\theta }_k^{\prime }{\mathbf{L}}^{k}x\end{array}$$
可以看出，这一代的GCN不需要做特征分解了，可以直接对Laplacian矩阵做变换，通过事先将Laplacian矩阵求出来，以及${\mathbf{L}}^k$求出来，前向传播的时候，就可以直接使用，复杂度为$O(K{n}^2)$。

对于每一次Laplacian矩阵$\mathbf{L}$和$\mathbf{x}$相乘，对于节点$n$，相当于从邻居节点$ne[n]$传递一次信息给节点$n$，由于连续乘以了$k$次Laplacian矩阵，那么相当于n节点的k-hop之内的节点能够传递信息给$n$，因此，实际上只利用了节点的K-Localized信息。

另外，可以使用切比雪夫展开式来近似${\mathbf{L}}^k$，任何k次多项式都可以使用切比雪夫展开式来近似，由此，引入切比雪夫多项式的$K$阶截断获得${\mathbf{L}}^k$近似，从而获得对$g_{\theta }(\mathbf{\Lambda })$的近似
$$g_{{\theta }^{\prime }}(\mathbf{\Lambda })\approx \sum _{k=0}^K{\theta }_k^{\prime }{T}_k(\tilde{\mathbf{\Lambda }})$$
其中，$\tilde{\mathbf{\Lambda }}=\frac{2}{{\lambda }_{\max }}\mathbf{\Lambda }-{\mathbf{I}}_n$，${\mathbf{\theta }}^{\prime }\in {\mathbb{R}}^K$为切比雪夫向量，${\theta }_k^{\prime }$为第$k$个分量，切比雪夫多项式$T_k(x)$使用递归的方式进行定义：$T_k(x)=2x{T}_{k-1}(x)-T_{k-2}(x)$，其中，$T_0(x)=1,T_1(x)=x$。

此时，带入到卷积公式
$$\begin{array}{rl}{\mathbf{g}}_{{\mathbf{\theta }}^{\prime }}\ast \mathbf{x}& \approx \mathbf{\Phi }\sum _{k=0}^K{\theta }_k^{\prime }{T}_k(\tilde{\mathbf{\Lambda }}){\mathbf{\Phi }}^T\mathbf{x}\\ & \approx \sum _{k=0}^K{\theta }_k^{\prime }\left(\mathbf{\Phi }{T}_k(\tilde{\mathbf{\Lambda }}){\mathbf{\Phi }}^T\right)x\\ & =\sum _{k=0}^K{\theta }_k^{\prime }{T}_k(\tilde{\mathbf{L}})\mathbf{x}\end{array}$$其中，$\tilde{\mathbf{L}}=\frac{2}{{\lambda }_{\max }}\mathbf{L}-{\mathbf{I}}_n$。

因此，可以得到输出为
$${\mathbf{y}}_{\text{output}}=\sigma \left(\sum _{k=0}^K{\theta }_k^{\prime }{T}_k(\tilde{\mathbf{L}})\mathbf{x}\right)$$

第三代GCN

这一代GCN直接取切比雪夫多项式中$K=1$，此时模型是1阶近似

将$K=1$，${\lambda }_{\max }=2$带入可以得到
$$\begin{array}{rl}{\mathbf{g}}_{{\mathbf{\theta }}^{\prime }}\ast \mathbf{x}& \approx {\mathbf{\theta }}_0^{\prime }\mathbf{x}+{\theta }_1^{\prime }\left(\mathbf{L}-{\mathbf{I}}_n\right)\mathbf{x}\\ & ={\mathbf{\theta }}_0^{\prime }\mathbf{x}+{\theta }_1^{\prime }\left(\mathbf{L}-{\mathbf{I}}_n\right)\mathbf{x}\\ & ={\theta }_0^{\prime }\mathbf{x}-{\theta }_1^{\prime }\left({\mathbf{D}}^{-1/2}\mathbf{W}{\mathbf{D}}^{-1/2}\right)\mathbf{x}\end{array}$$
其中，归一化拉普拉斯矩阵$\mathbf{L}={\mathbf{D}}^{-1/2}(\mathbf{D}-\mathbf{W}){\mathbf{D}}^{-1/2}={\mathbf{I}}_n-{\mathbf{D}}^{-1/2}\mathbf{W}{\mathbf{D}}^{-1/2}$。为了进一步简化，令${\theta }_0^{\prime }=-{\theta }_1^{\prime }$，此时只含有一个参数$\theta$
$$g_{{\theta }^{\prime }}\ast x=\theta \left(I_n+D^{-1/2}W{D}^{-1/2}\right)x$$
由于${\mathbf{I}}_n+{\mathbf{D}}^{-1/2}\mathbf{W}{\mathbf{D}}^{-1/2}$的谱半径$[0,2]$太大，使用归一化的trick
$${\mathbf{I}}_n+{\mathbf{D}}^{-1/2}\mathbf{W}{\mathbf{D}}^{-1/2}\to {\tilde{\mathbf{D}}}^{-1/2}\tilde{\mathbf{W}}{\tilde{\mathbf{D}}}^{-1/2}$$
其中，$\tilde{\mathbf{W}}=\mathbf{W}+{\mathbf{I}}_n$，${\tilde{D}}_{ij}={\Sigma }_j{\tilde{W}}_{ij}$。

由此，带入卷积公式
$$\underset{{\mathbb{R}}^{n\times 1}}{g_{{\theta }^{\prime }}\ast x}=\theta \left(\underset{{\mathbb{R}}^{n\times n}}{{\tilde{D}}^{-1/2}\tilde{W}{\tilde{D}}^{-1/2}}\right)\underset{{\mathbb{R}}^{n\times 1}}{x}$$
如果推广到多通道，相当于每一个节点的信息是向量
$$x\in {\mathbb{R}}^{N\times 1}\to X\in {\mathbb{R}}^{N\times C}$$
其中，$N$是节点数量，$C$是通道数，或者称作表示节点的信息维度数。$\mathbf{X}$是节点的特征矩阵。

相应的卷积核参数变化
$$\theta \in \mathbb{R}\to \Theta \in {\mathbb{R}}^{C\times F}$$
其中，$F$为卷积核数量。

那么卷积结果写成矩阵形式为
$$\underset{{\mathbb{R}}^{N\times F}}{Z}=\underset{{\mathbb{R}}^{N\times N}}{{\tilde{D}}^{-1/2}\tilde{W}{\tilde{D}}^{-1/2}}\underset{{\mathbb{R}}^{N\times C}}{X}\underset{{\mathbb{R}}^{C\times F}}{\mathbf{\Theta }}$$
上述操作可以叠加多层，对上述输出激活一下，就可以作为下一层节点的特征矩阵。

这一代GCN特点：

• 取$K=1$，相当于直接取邻域信息，类似于$3\times 3$的卷积核。
• 由于卷积核宽度减小，可以通过增加卷积层数来扩大感受野，从而增强网络的表达能力。
• 增加了参数约束，比如${\lambda }_{\max }\approx 2$，引入归一化操作。

论文模型

论文采用两层的GCN，用来在graph上进行半监督的节点分类任务，邻接矩阵为$A$，首先计算出$\hat{A}={\tilde{D}}^{-\frac{1}{2}}\tilde{A}{\tilde{D}}^{-\frac{1}{2}}$，由此，前向网络模型形式如下
$$Z=f(X,A)=\mathrm{softmax}\left(\hat{A}\mathrm{ReLU}\left(\hat{A}X{W}^{(0)}\right)W^{(1)}\right)$$
其中，$W^{(0)}\in {\mathbb{R}}^{C\times H}$为输入层到隐藏层的权重矩阵，隐藏层的特征维度为$H$，$W^{(1)}\in {\mathbb{R}}^{H\times F}$为隐藏层到输出层的权重矩阵，softmax激活函数定义为$\mathrm{softmax}\left(x_i\right)=\frac{1}{\mathcal{Z}}\exp \left(x_i\right)$，$\mathcal{Z}={\sum }_i\exp \left(x_i\right)$，相当于对每一列做softmax，由此，得到交叉熵损失函数为
$$\mathcal{L}=-\sum _{l\in {\mathcal{Y}}_L}\sum _{f=1}^F{Y}_{lf}\ln Z_{lf}$$
其中，${\mathcal{Y}}_L$为带有标签的节点集合。

上图中左图为GCN图示，输入为$C$个通道，输出为$F$个通道，$Y_1$和$Y_2$为节点标签。右图为在一数据集上进行训练得到的隐藏层激活值经过t-SNE降维可视化后的结果，可以看出聚类效果较好。

实验结果

论文在如下几个任务中进行实验

• 在citation network中进行半监督的document classification。
• 在从knowledge graph中提取的bipartite graph中进行半监督的entity classification

实验数据说明如下

前三个Dataset是citation network数据集，节点表示文档，边表示引用的连接，label rate表示用来有监督训练的节点数量占总节点数量比例，第四个Dataset是bipartite graph数据集。

结果如下：

可以看出，在比较的几种算法中，论文GCN的在准确率和时间上都最好。

3. DCNN

• 论文：《Diffusion-Convolutional Neural Networks》

该模型对每一个节点(或边、或图)采用H个hop的矩阵进行表示，每一个hop都表示该邻近范围的邻近信息，由此，对于局部信息的获取效果比较好，得到的节点的representation的表示能力很强。

DCNN模型详述

假设有如下定义

• 一个graph数据集$\mathcal{G}=\left\{G_t|t\in 1\dots T\right\}$
• graph定义为$G_t=\left(V_t,E_t\right)$，其中，$V_t$为节点集合，$E_t$为边集合
• 所有节点的特征矩阵定义为$X_t$，大小为$N_t\times F$，其中，$N_t$为图$G_t$的节点个数，$F$为节点特征维度
• 边信息$E_t$定义为$N_t\times N_t$的邻接矩阵$A_t$，由此可以计算出节点度(degree)归一化的转移概率矩阵$P_t$，表示从$i$节点转移到$j$节点的概率。

对于graph来说没有任何限制，graph可以是带权重的或不带权重的，有向的或无向的。

模型的目标为预测$Y$，也就是预测每一个图的节点标签，或者边的标签，或者每一个图的标签，在每一种情况中，模型输入部分带有标签的数据集合，然后预测剩下的数据的标签。

DCNN模型输入图$\mathcal{G}$，返回硬分类预测值$Y$或者条件分布概率$\mathbb{P}(Y|X)$。该模型将每一个预测的目标对象(节点、边或图)转化为一个diffusion-convolutional representation，大小为$H\times F$，$H$表示扩散的hops。因此，对于节点分类任务，图$t$的confusion-convolutional representation为大小为$N_t\times H\times F$的张量，表示为$Z_t$，对于图分类任务，张量$Z_t$为大小为$H\times F$的矩阵，对于边分类任务，张量$Z_t$为大小为$M_t\times H\times F$的矩阵。示意图如下

对于节点分类任务，假设$P_t^{\ast }$为$P_t$的power series，大小为$N_t\times H\times N_t$，那么对于图$t$的节点$i$，第$j$个hop，第$k$维特征值$Z_{tijk}$计算公式为
$$Z_{tijk}=f\left(W_{jk}^c\cdot \sum _{l=1}^{N_t}{P}_{tijl}^{\ast }{X}_{tlk}\right)$$
使用矩阵表示为
$$Z_t=f\left(W^c\odot P_t^{\ast }{X}_t\right)$$
其中$\odot$表示element-wise multiplication，由于模型只考虑$H$跳的参数，即参数量为$O(H\times F)$，使得diffusion-convolutional representation不受输入大小的限制。

在计算出$Z$之后，过一层全连接得到输出$Y$，使用$\hat{Y}$表示硬分类预测结果，使用$\mathbb{P}(Y|X)$表示预测概率，计算方式如下
$$\hat{Y}=\arg \max \left(f\left(W^d\odot Z\right)\right)$$

$$\mathbb{P}(Y|X)=\mathrm{softmax}\left(f\left(W^d\odot Z\right)\right)$$

对于图分类任务，直接采用所有节点表示的均值作为graph的representation
$$Z_t=f\left(W^c\odot 1_{N_t}^T{P}_t^{\ast }{X}_t/N_t\right)$$
其中，$1_{N_t}$是全为1的$N_t\times 1$的向量。

对于边分类任务，通过将每一条边转化为一个节点来进行训练和预测，这个节点与原来的边对应的首尾节点相连，转化后的图的邻接矩阵$A_t^{\prime }$可以直接从原来的邻接矩阵$A_t$增加一个incidence matrix得到
$$A_t^{\prime }=\left(\begin{array}{cc}{A}_t& B_t^T\\ B_t& 0\end{array}\right)$$
之后，使用$A_t^{\prime }$来计算$P_t^{\prime }$，并用来替换$P_t$来进行分类。

对于模型训练，使用梯度下降法，并采用early-stop方式得到最终模型。

实验结果

节点分类任务的实验数据集使用Cora和Pubmed数据集，包含scientific papers(相当于node)、citations(相当于edge)和subjects(相当于label)。实验评估标准使用分类准确率以及F1值。

节点分类的实验结果如下

可以看出使用各种评估标准，DCNN效果都是最好的。

图分类任务的实验结果如下

可以看出，在不同数据集上，DCNN在图分类任务上并没有明显表现出很好的效果。

优缺点

优点：

• 节点分类准确率很高
• 灵活性
• 快速

缺点：

• 内存占用大：DCNN建立在密集的张量计算上，需要存储大量的张量，需要$O(N_t^{2}H)$的空间复杂度。
• 长距离信息传播不足：模型对于局部的信息获取较好，但是远距离的信息传播不足。

4. Tree-LSTM

• 论文：《Improved Semantic Representations From Tree-Structured Long Short-Term Memory Networks》

将序列型的LSTM模型扩展到树型的LSTM模型，简称Tree-LSTM，并根据孩子节点是否有序，论文提出了两个模型变体，Child-Sum Tree-LSTM模型和N-ary Tree-LSTM模型。和序列型的LSTM模型的主要不同点在于，序列型的LSTM从前一时刻获取隐藏状态$h_t$，而树型的LSTM从其所有的孩子节点获取隐藏状态。

模型详解

Tree-LSTM模型对于每一个孩子节点都会产生一个“遗忘门”$f_{jk}$，这个使得模型能够从所有的孩子节点选择性地获取信息和结合信息。

Child-Sum Tree-LSTMs

该模型的更新方程如下
$$\begin{array}{rl}{\tilde{h}}_j& =\sum _{k\in C(j)}{h}_k\\ i_j& =\sigma \left(W^{(i)}{x}_j+U^{(i)}{\tilde{h}}_j+b^{(i)}\right)\\ f_{jk}& =\sigma \left(W^{(f)}{x}_j+U^{(f)}{h}_k+b^{(f)}\right)\\ o_j& =\sigma \left(W^{(o)}{x}_j+U^{(o)}{\tilde{h}}_j+b^{(o)}\right)\\ u_j& =\tanh \left(W^{(u)}{x}_j+U^{(u)}{\tilde{h}}_j+b^{(u)}\right)\\ c_j& =i_j\odot u_j+\sum _{k\in C(j)}{f}_{jk}\odot c_k\\ h_j& =o_j\odot \tanh \left(c_j\right)\end{array}$$其中，$C(j)$表示$j$节点的邻居节点的个数，$h_k$表示节点$k$的隐藏状态，$i_j$表示节点$j$的”输入门“，$f_{jk}$表示节点$j$的邻居节点$k$的“遗忘门“，$o_j$表示节点$j$的”输出门“。

这里的关键点在于第三个公式的$f_{jk}$，这个模型对节点$j$的每个邻居节点$k$都计算了对应的”遗忘门“向量，然后在第六行中计算$c_j$时对邻居节点的信息进行”遗忘“和组合。

由于该模型是对所有的孩子节点求和，所以这个模型对于节点顺序不敏感的，适合于孩子节点无序的情况。

N-ary Tree-LSTMs

假如一个树的最大分支数为$N$(即孩子节点最多为$N$个)，而且孩子节点是有序的，对于节点$j$，对于该节点的第$k$个孩子节点的隐藏状态和记忆单元分别用$h_{jk}$和$c_{jk}$表示。模型的方程如下
$$\begin{array}{rl}{i}_j& =\sigma \left(W^{(i)}{x}_j+\sum _{\ell =1}^N{U}_{\ell }^{(i)}{h}_{j\ell }+b^{(i)}\right)\\ f_{jk}& =\sigma \left(W^{(f)}{x}_j+\sum _{\ell =1}^N{U}_{k\ell }^{(f)}{h}_{j\ell }+b^{(f)}\right)\\ o_j& =\sigma \left(W^{(o)}{x}_j+\sum _{\ell =1}^N{U}_{\ell }^{(o)}{h}_{j\ell }+b^{(o)}\right)\\ u_j& =\tanh \left(W^{(u)}{x}_j+\sum _{\ell =1}^N{U}_{\ell }^{(a)}{h}_{j\ell }+b^{(a)}\right)\\ c_j& =i_j\odot u_j+\sum _{\ell =1}^N{f}_{j\ell }\odot c_{j\ell }\\ h_j& =o_j\odot \tanh \left(c_j\right)\end{array}$$值得注意的是该模型为每个孩子节点都单独地设置了参数$U_l$。

模型训练

分类任务

分类任务定义为在类别集$\mathcal{Y}$中预测出正确的标签$\hat{y}$，对于每一个节点$j$，使用一个softmax分类器来预测节点标签${\hat{y}}_j$，分类器取每个节点的隐藏状态$h_j$作为输入
$$\begin{array}{rl}{\hat{p}}_{\theta }\left(y|\{x{\}}_j\right)& =\mathrm{softmax}\left(W^{(s)}{h}_j+b^{(s)}\right)\\ {\hat{y}}_j& =\arg \underset{y}{\max }{\hat{p}}_{\theta }\left(y|\{x{\}}_j\right)\end{array}$$损失函数使用negative log-likelihood
$$J(\theta )=-\frac{1}{m}\sum _{k=1}^m\log {\hat{p}}_{\theta }\left(y^{(k)}|\{x{\}}^{(k)}\right)+\frac{\lambda }{2}\Vert \theta {\Vert }_2^2$$其中，$m$是带有标签的节点数量，$\lambda$是$L2$是正则化超参。

语义相关性任务

该任务给定一个句子对(sentence pair)，模型需要预测出一个范围在$[1,K]$之间的实数值，这个值越高，表示相似度越高。

论文首先对每一个句子产生一个representation，两个句子的表示分别用$h_L$和$h_R$表示，得到这两个representation之后，从distance和angle两个方面考虑，使用神经网络来得到$(h_L,h_R)$相似度：
$$\begin{array}{rl}{h}_{\times }& =h_L\odot h_R\\ h_{+}& =\left|h_L-h_R\right|\\ h_s& =\sigma \left(W^{(\times )}{h}_{\times }+W^{(+)}{h}_{+}+b^{(h)}\right)\\ {\hat{p}}_{\theta }& =\mathrm{softmax}\left(W^{(p)}{h}_s+b^{(p)}\right)\\ \hat{y}& =r^T{\hat{p}}_{\theta }\end{array}$$其中，$r^T=\left[\begin{array}{llll}1& 2& \dots & K\end{array}\right]$。模型期望根据训练得到的参数$\theta$得到的结果：$\hat{y}=r^T{\hat{p}}_{\theta }\approx y$。由此，定义一个目标分布$p$
$$p_i=\{\begin{array}{ll}y-\lfloor y\rfloor ,& i=\lfloor y\rfloor +1\\ \lfloor y\rfloor -y+1,& i=\lfloor y\rfloor \\ 0& \text{ otherwise }\end{array}$$其中，$1\le i\le K$，损失函数为$p$和${\hat{p}}_{\theta }$之间的KL散度：
$$J(\theta )=\frac{1}{m}\sum _{k=1}^m\mathrm{K}\mathrm{L}\left(p^{(k)}\Vert {\hat{p}}_{\theta }^{(k)}\right)+\frac{\lambda }{2}\Vert \theta {\Vert }_2^2$$

实验结果

对于分类任务，实验数据使用Stanford Sentiment Treebank，分为五类：very negative, negative, neural, positive和very positive。在该数据集上的测试集上的准确度结果如下：

对于语义相似度度量，模型的任务是预测出两个句子语义的相似度分数。在SICK的语义相似度子任务上的测试结果如下

对于模型的实现部分目前可以直接使用DGL或者PyG等库帮助快速实现，接下来会整理如何使用这些库进行简单的图网络的实验。图神经网络在工业界的挑战主要是非结构化的图结构计算需要消耗巨大的计算资源和存储资源。