第8章-图分类
与之前的节点分类不同，图分类任务需要学习到整张图的标签和类别。为了解决这类问题，一般使用层次化池化（Pooling）的操作。
8.1 基于全局池化的图分类
全局池化的主要思路是设计一个读出（readout）层，对所有节点进行一次性聚合，从而得到图的全局表示，
y
=
R
e
a
d
o
u
t
(
{
h
i
(
k
)
∣
∀
v
i
∈
V
}
)
y=Readout(\{h_i^{(k)}|\forall v_i\in V\})
y=Readout({hi(k)∣∀vi∈V})
读出机制可以取sum，mean或max等函数。
读出机制易于实现，但是丢失了图的结构信息。
8.2 基于层次化池化的图分类
主要有3类方法：
（1）基于图坍缩（Graph Coarsening）的池化机制
（2）基于TopK的池化机制
（3）基于边收缩（Edge Contraction）的池化机制
8.2.1 基于图坍缩的池化机制
主要思路：将图划分成不同的子图，将子图看做超级节点，从而形成一个坍缩的图。
1、图坍缩
定义簇分配矩阵
S
S
S，
S
i
j
=
{
1
,
v
i
∈
τ
(
j
)
0
,
o
t
h
e
r
w
i
s
e
S_{ij}= \begin{cases} 1,& v_i\in \tau^{(j)} \\[2ex] 0,& otherwise \end{cases}
Sij=⎩⎨⎧1,0,vi∈τ(j)otherwise
其中
S
∈
R
N
×
K
S\in R^{N\times K}
S∈RN×K，
N
N
N为节点数，
K
K
K为子图（簇）个数，
τ
(
j
)
\tau^{(j)}
τ(j)为子图
j
j
j中的节点列表。
我们定义，
A
c
o
a
r
=
S
T
A
S
A_{coar}=S^TAS
Acoar=STAS
其中
A
c
o
a
r
A_{coar}
Acoar代表了超级节点之间的连接强度（包括自连接），
(
S
T
A
S
)
i
j
(S^TAS)_{ij}
(STAS)ij代表了第
i
i
i簇与第
j
j
j簇之间的连接强度。
接下来定义采样算子
C
C
C，
C
i
j
(
k
)
=
{
1
,
τ
j
(
k
)
=
v
i
0
,
o
t
h
e
r
w
i
s
e
C_{ij}^{(k)}= \begin{cases} 1,& \tau_{j}^{(k)}=v_i \\[2ex] 0,& otherwise \end{cases}
Cij(k)=⎩⎨⎧1,0,τj(k)=viotherwise
其中
τ
j
(
k
)
\tau_{j}^{(k)}
τj(k)表示
τ
(
k
)
\tau^{(k)}
τ(k)中的第
j
j
j个节点，
C
C
C是一个节点顺序关系的指示矩阵。
我们还可以定义全图信号到子图信号的下采样操作，
x
(
k
)
=
(
C
(
k
)
)
T
x
x^{(k)}=(C^{(k)})^Tx
x(k)=(C(k))Tx
以及子图信号到全图信号的上采样操作，
x
‾
=
C
(
k
)
x
(
k
)
\overline x=C^{(k)}x^{(k)}
x=C(k)x(k)
其中上标
(
k
)
(k)
(k)表示第
k
k
k个子图。
然后，就可以定义子图的邻接矩阵
A
(
k
)
A^{(k)}
A(k)，
A
(
k
)
=
(
C
(
k
)
)
T
A
C
(
k
)
A^{(k)}=(C^{(k)})^TAC^{(k)}
A(k)=(C(k))TAC(k)
A
c
o
a
r
A_{coar}
Acoar和
A
(
k
)
A^{(k)}
A(k)很好的定义了子图间的邻接关系和子图内部的邻接关系。通过不断进行坍缩，我们希望最终整张图成为一个超级节点，这样我们就可以利用其特征向量进行图分类的任务学习了。
2、DiffPOOL
DiffPOOL是首个将图坍缩+GNN的图级任务学习算法。
它提出了一个可学习的簇分配矩阵，使用2个独立的GNN分别对节点特征、节点所属簇的概率分布进行学习。
Z
(
l
)
=
G
N
N
l
,
e
m
b
e
d
(
A
(
l
)
,
H
(
l
)
)
S
(
l
)
=
s
o
f
t
m
a
x
(
G
N
N
l
,
p
o
o
l
(
A
(
l
)
,
H
(
l
)
)
)
Z^{(l)}=GNN_{l,embed}(A^{(l)},H^{(l)}) \\[2ex] S^{(l)}=softmax(GNN_{l,pool}(A^{(l)},H^{(l)}))
Z(l)=GNNl,embed(A(l),H(l))S(l)=softmax(GNNl,pool(A(l),H(l)))
其中，
Z
(
l
)
Z^{(l)}
Z(l)为第
l
l
l层学习到的节点特征，
S
(
l
)
S^{(l)}
S(l)为第
l
l
l层学习到的簇的概率分布，它是一种软分配并且不具备稀疏性。
然后，我们定义DiffPOOL层
(
(
A
(
l
)
,
Z
(
l
)
)
→
(
A
(
l
+
1
)
,
H
(
l
+
1
)
)
)
((A^{(l)},Z^{(l)})\rightarrow (A^{(l+1)},H^{(l+1)}))
((A(l),Z(l))→(A(l+1),H(l+1)))为，
H
(
l
+
1
)
=
(
S
(
l
)
)
T
Z
(
l
)
A
(
l
+
1
)
=
(
S
(
l
)
)
T
A
S
(
l
)
H^{(l+1)}=(S^{(l)})^TZ^{(l)} \\[2ex] A^{(l+1)}=(S^{(l)})^TAS^{(l)}
H(l+1)=(S(l))TZ(l)A(l+1)=(S(l))TAS(l)
计算出每一层的特征向量和邻接矩阵。最后，将整张图探坍缩成一个超级节点，送入后面的
M
L
P
MLP
MLP进行任务学习。
3、EiginPooling
EiginPooling在图分类中没有引入任何任何需要学习的参数！
核心思想是选取作用域和池化操作。选取作用域相当于图坍缩，池化操作是对作用域中的信息进行融合。EiginPooling的池化操作同时考虑了图的结构信息和属性信息，因此效果较好。
（1）图坍缩
EiginPooling是通过图分区算法来实现图坍缩的，比如使用
K
m
e
a
n
s
Kmeans
Kmeans算法。
(
A
,
簇
数
K
)
→
(
节
点
所
属
的
簇
)
(A,簇数K)\rightarrow (节点所属的簇)
(A,簇数K)→(节点所属的簇)
其划分是一种硬分配，并且具有稀疏性，降低了计算复杂度。
（2）池化操作
DiffPOOL在池化操作这一步仅仅是加和，损失了结构信息。
EiginPooling使用图傅里叶变换来进行池化操作，因此可以定义为，
X
l
=
Θ
l
T
X
X_l=\Theta_l^TX
Xl=ΘlTX
其中
Θ
l
=
[
u
‾
l
(
1
)
,
.
.
.
,
u
‾
l
(
k
)
]
\Theta_l=[\overline u_l^{(1)},...,\overline u_l^{(k)}]
Θl=[ul(1),...,ul(k)]表示所有子图的第
l
l
l个特征向量按行方向组织起来。
u
‾
l
(
k
)
\overline u_l^{(k)}
ul(k)表示经过上采样的第
l
l
l个特征向量。
X
l
∈
R
K
×
d
X_l\in R^{K\times d}
Xl∈RK×d是对所有子图的第
l
l
l个特征向量池化的结果。
每一个特征向量都计算完成之后，就可以将它们的结果拼接起来，
X
p
o
o
l
=
[
X
1
,
.
.
.
,
X
N
m
a
x
]
X_{pool}=[X_1,...,X_{N_{max}}]
Xpool=[X1,...,XNmax]
其中
N
m
a
x
N_{max}
Nmax表示所有子图中的最大节点数。也可以只使用前
H
H
H个特征向量的池化结果，
X
c
o
a
r
=
X
p
o
o
l
=
[
X
1
,
.
.
.
,
X
H
]
X_{coar}=X_{pool}=[X_1,...,X_H]
Xcoar=Xpool=[X1,...,XH]
EigenPooling不仅能提高计算效率，并且还能兼顾图的结构和属性信息，显然要比DiffPOOL更加合理。
8.2.2 基于TopK的池化机制
TopK机制主要是一个按照某种规则不断丢弃节点的过程，最终得到全图的一个特征向量，用于后续的任务学习。
我们定义
g
p
o
o
l
gpool
gpool层为，
z
=
X
p
∣
∣
p
∣
∣
i
⃗
=
t
o
p
−
r
a
n
k
(
z
,
k
N
)
X
′
=
(
X
⨀
t
a
n
h
(
z
)
)
i
⃗
,
:
A
′
=
A
i
⃗
,
i
⃗
z=\frac{Xp}{||p||} \\[2ex] \vec i=top-rank(z,kN) \\[2ex] X'=(X\bigodot tanh(z))_{\vec i,:} \\[2ex] A'=A_{\vec i,\vec i}
z=∣∣p∣∣Xpi
=top−rank(z,kN)X′=(X⨀tanh(z))i
,:A′=Ai
,i
其中，
z
z
z为重要度值（节点分数），用于进行降序排序，计算方法是将节点的特征向量在基向量
p
p
p上进行投影。
t
o
p
−
r
a
n
k
top-rank
top−rank函数根据
z
z
z值选出重要度前
k
k
k名的节点的下标。然后依据
i
⃗
\vec i
i
对原先的特征矩阵
X
X
X和邻接矩阵
A
A
A进行切片操作，相当于丢弃一些节点。
但是这种层层丢弃节点的方法，会使得模型缺乏对所有节点进行有效融合的手段。为了实现有效融合，在
g
p
o
o
l
gpool
gpool层后面再加上一个
r
e
a
d
o
u
t
readout
readout层实现一次性聚合。
s
(
l
)
=
(
1
N
∑
i
=
1
N
x
i
(
l
)
)
∣
∣
(
m
a
x
i
=
1
N
x
i
(
l
)
)
s
=
∑
l
=
1
L
s
(
l
)
s^{(l)}=(\frac{1}{N}\sum_{i=1}^{N}x_i^{(l)})||(max_{i=1}^Nx_i^{(l)}) \\[2ex] s=\sum_{l=1}^Ls^{(l)}
s(l)=(N1i=1∑Nxi(l))∣∣(maxi=1Nxi(l))s=l=1∑Ls(l)
其中读出层将平均池化与最大池化拼接起来，最终的全局池化是每一层池化结果的加和。
还有另一种方法SAGPool，在此不进行展开。
8.2.3 基于边收缩的池化机制
EdgePool核心思想是迭代式地将每条边上的节点进行两两归并形成一个新的节点，最终得到全图的特征表示。
每次选择边进行节点归并的依据是边的分数，
r
i
j
=
w
T
[
h
i
∣
∣
h
j
]
+
b
s
i
j
=
s
o
f
t
m
a
x
j
(
r
i
j
)
r_{ij}=w^T[h_i||h_j]+b \\[2ex] s_{ij}=softmax_j(r_{ij})
rij=wT[hi∣∣hj]+bsij=softmaxj(rij)
其中
r
i
j
r_{ij}
rij为每条边的原始分数，
s
i
j
s_{ij}
sij为原始分数沿着邻居节点归一化后的分数。
然后，选择分数最高的且未被选过的两个节点进行归并。合并之后新节点的特征向量
h
i
j
h_{ij}
hij为，
h
i
j
=
m
a
x
{
s
i
j
,
s
j
i
}
⋅
(
h
i
+
h
j
)
h_{ij}=max\{s_{ij},s_{ji}\}\cdot (h_i+h_j)
hij=max{sij,sji}⋅(hi+hj)
EdgePool利用边收缩的原理，仅将邻居节点进行归并，既保留了图的结构信息，有保证了图中连接的稀疏性。
总结
不想总结了，好累。