消息传递图神经网络
图计算任务的关键: 为节点生成节点特征。
本节任务:
1、基于神经网络的生成节点表征的范式–消息传递范式。是一种聚合邻接节点信息来更新中心节点信息的范式。包含三个步骤:
- 邻接节点信息交换
- 邻接节点信息聚合导中心节点
- 据合信息变换
2、基于消息传递范式构建图神经网络
一、消息传递范式介绍
用 x ( k − 1 ) i ∈ R F \mathbf{x}^{(k-1)}i\in\mathbb{R}^F x(k−1)i∈RF表示(k-1)层中节点i的节点特征, e j , i ∈ R D \mathbf{e}{j,i} \in \mathbb{R}^D ej,i∈RD表示从节点j到节点i的边的特征,消息传递图神经网络可以描述为
x i ( k ) = γ ( k ) ( x i ( k − 1 ) , □ j ∈ N ( i ) , ϕ ( k ) ( x i ( k − 1 ) , x j ( k − 1 ) , e j , i ) ) \mathbf{x}_i^{(k)} = \gamma^{(k)} \left( \mathbf{x}i^{(k-1)}, \square{j \in \mathcal{N}(i)} , \phi^{(k)}\left(\mathbf{x}_i^{(k-1)}, \mathbf{x}j^{(k-1)},\mathbf{e}{j,i}\right) \right) xi(k)=γ(k)(xi(k−1),□j∈N(i),ϕ(k)(xi(k−1),xj(k−1),ej,i)),
其中 □ \square □ 表示可微分的、具有排列不变性(函数输出结果与输入参数的排列无关)的函数。具有排列不变性的函数有,和函数、均值函数和最大值函数。 γ \gamma γ和 ϕ \phi ϕ表示可微分的函数,如MLPs(多层感知器)。
节点嵌入(Node Embedding)指 1) 生成节点表征的操作 ;2)节点表征。在本次学习中,特指神经网络生成节点表征的操作。
基于消息传递范式的生成节点表征的过程:
- 在图的最右侧,B节点的邻接节点(A,C)的信息传递给了B,经过信息变换得到了B的嵌入,C、D节点同。
- 在图的中右侧,A节点的邻接节点(B,C,D)的之前得到的节点嵌入传递给了节点A;在图的中左侧,聚合得到的信息经过信息变换得到了A节点新的嵌入。
- 重复多次,我们可以得到每一个节点的经过多次信息变换的嵌入。这样的经过多次信息聚合与变换的节点嵌入就可以作为节点的表征,可以用于节点的分类。
二、Pytorch Geometric中的MessagePassing基类
MessagePassing 基类实现了消息传播的自动处理,继承该类我们可以方便的构造消息传递图神经网络。我们只需要定义:
- 函数 ϕ \phi ϕ : message()函数
- 函数 γ \gamma γ: update()函数
- 消息聚合方案:eg:aggr=“add”、aggr="mean"或aggr=“max”
MessagePassing(aggr=“add”, flow=“source_to_target”, node_dim=-2)
- aggr:定义要使用的聚合方案(“add”、"mean "或 “max”);
- flow:定义消息传递的流向("source_to_target "或 “target_to_source”);
- node_dim:定义沿着哪个轴线传播。
MessagePassing.propagate(edge_index, size=None, **kwargs)
- 开始传播消息的起始调用。它以edge_index(边的端点的索引)和flow(消息的流向)以及一些额外的数据为参数。
- 请注意,propagate()不仅限于在形状为[N, N]的对称邻接矩阵中交换消息,还可以通过传递size=(N, M)作为额外参数。例如,在二部图的形状为[N, M]的一般稀疏分配矩阵中交换消息。
- 如果设置size=None,则假定邻接矩阵是对称的。
- 对于有两个独立的节点集合和索引集合的二部图,并且每个集合都持有自己的信息,我们可以传递一个元组参数,即x=(x_N, x_M),来标记信息的区分。
MessagePassing.message(…):
- 首先确定要给节点 i i i传递消息的边的集合,如果flow=“source_to_target”,则是 ( j , i ) ∈ E (j,i)∈E (j,i)∈E 的边的集合。
- 如果flow=“target_to_source”,则是 ( i , j ) ∈ E (i,j)∈E (i,j)∈E的边的集合。
- 接着为各条边创建要传递给节点 i i i的消息,即实现 ϕ ϕ ϕ函数。
- MessagePassing.message(…)函数接受最初传递给MessagePassing.propagate(edge_index, size=None, **kwargs)函数的所有参数。
- 此外,传递给propagate()的张量可以被映射到各自的节点 i i i和 j j j上,只需在变量名后面加上 _ i \_i _i或 _ j \_j _j。我们把i称为消息传递的目标中心节点,把 j j j称为邻接节点。
MessagePassing.aggregate(…):
- 将从源节点传递过来的消息聚合在目标节点上,一般可选的聚合方式有sum, mean和max
MessagePassing.message_and_aggregate(…):
- 在一些场景里,邻接节点信息变换和邻接节点信息聚合这两项操作可以融合在一起,那么我们可以在此函数里定义这两项操作,从而让程序运行更加高效。
MessagePassing.update(aggr_out, …):
- 为每个节点 i ∈ V i∈V i∈V更新节点表征,即实现γ函数。该函数以聚合函数的输出为第一个参数,并接收所有传递给propagate()函数的参数
三、继承MessagePassing类的GCNConv
GCNConv的数学定义为 x i ( k ) = ∑ j ∈ N ( i ) ∪ i 1 deg ( i ) ⋅ deg ( j ) ⋅ ( Θ ⋅ x j ( k − 1 ) ) \mathbf{x}i^{(k)} = \sum{j \in \mathcal{N}(i) \cup { i }} \frac{1}{\sqrt{\deg(i)} \cdot \sqrt{\deg(j)}} \cdot \left( \mathbf{\Theta} \cdot \mathbf{x}_j^{(k-1)} \right) xi(k)=∑j∈N(i)∪ideg(i)⋅deg(j)1⋅(Θ⋅xj(k−1)) 其中,相邻节点的特征首先通过权重矩阵 Θ \mathbf{\Theta} Θ进行转换,然后按端点的度进行归一化处理,最后进行加总。这个公式可以分为以下几个步骤:
- 向邻接矩阵添加自环边。 (这一步就是把邻接矩阵的对角线全部变成1,因为没有自环边也就是邻接矩阵对角线为0的图没有考虑到节点自身特征 消息传播只聚合邻居)
- 线性转换节点特征矩阵。
- 计算归一化系数。
- 归一化 j j j 中的节点特征。
- 将相邻节点特征相加("求和 "聚合)。
补充几个概念:
1)自环边和平行边
自环边(self-loop):一个顶点到这个顶点自身的边
平行边(parallel-edges):两个顶点之间存在多条边相连接。
2)张量
一个量, 在不同的参考系下按照某种特定的法则进行变换, 就是张量.
步骤1-3通常是在消息传递发生之前计算的。步骤4-5可以使用MessagePassing基类轻松处理。该层的全部实现如下所示:
import torch
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import add_self_loops, degree
class GCNConv(MessagePassing):
def __init__(self, in_channels, out_channels):
super(GCNConv, self).__init__(aggr='add', flow='source_to_target')
# "Add" aggregation (Step 5).
# flow='source_to_target' 表示消息从源节点传播到目标节点
self.lin = torch.nn.Linear(in_channels, out_channels)
def forward(self, x, edge_index):
# x has shape [N, in_channels]
# edge_index has shape [2, E]
# Step 1: Add self-loops to the adjacency matrix.
edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))
# Step 2: Linearly transform node feature matrix.
x = self.lin(x)
# Step 3: Compute normalization.
row, col = edge_index
deg = degree(col, x.size(0), dtype=x.dtype)
deg_inv_sqrt = deg.pow(-0.5)
norm = deg_inv_sqrt[row] * deg_inv_sqrt[col]
# Step 4-5: Start propagating messages.
return self.propagate(edge_index, x=x, norm=norm)
def message(self, x_j, norm):
# x_j has shape [E, out_channels]
# Step 4: Normalize node features.
return norm.view(-1, 1) * x_j
GCNConv继承了MessagePassing并以"求和"作为领域节点信息聚合方式。该层的所有逻辑都发生在其forward()方法中。
- 首先使用torch_geometric.utils.add_self_loops()函数向我们的边索引添加自循环边(步骤1)
- 通过调用torch.nn.Linear实例对节点特征进行线性变换(步骤2)
- 归一化系数是由每个节点的节点度得出的,它被转换为每个边的节点度
- 结果被保存在形状[num_edges,]的张量norm中(步骤3)
- 在message()函数中,我们需要通过norm对相邻节点特征x_j进行归一化处理。这里,x_j包含每条边的源节点特征,即每个中心节点的邻接。
这就是创建一个简单的x传递层的全部内容。我们可以把这个层作为深度架构的构建块。我们可以很方便地初始化和调用它:
conv = GCNConv(16, 32)
x = conv(x, edge_index)
四、propagate函数
def propagate(self, edge_index: Adj, size: Size = None, **kwargs):
r"""开始消息传播的初始调用。
Args:
edge_index (Tensor or SparseTensor): 定义了消息传播流。
当flow="source_to_target"时,节点`edge_index[0]`的信息将被发送到节点`edge_index[1]`,
反之当flow="target_to_source"时,节点`edge_index[1]`的信息将被发送到节点`edge_index[0]`
kwargs: 图其他属性或额外的数据。
"""
edge_index是propagate函数必须的参数。在我们的message函数中希望接受到哪些数据(或图的属性或额外的数据),就要在propagate函数的调用中传递哪些参数。
五、覆写message函数
在第三部分例子中,我们覆写的message函数接收两个参数x_j和norm,而propagate函数被传递三个参数edge_index, x=x, norm=norm。由于x是Data类的属性,且message函数接收x_j参数而不是x参数,所以在propagate函数被调用,message函数被执行之前,一项额外的操作被执行,该项操作根据edge_index参数从x中分离出x_j。事实上,在message函数里,当参数是Data类的属性时,我们可以在参数名后面拼接_i或_j来指定要接收源节点的属性或是目标节点的属性。类似的,如果我们希望在message函数中额外再接受源节点的度,那么我们做如下的修改(假设节点的度为deg,它是Data对象的属性):
class GCNConv(MessagePassing):
def forward(self, x, edge_index):
# ....
return self.propagate(edge_index, x=x, norm=norm, d=d)
def message(self, x_j, norm, d_i):
# x_j has shape [E, out_channels]
return norm.view(-1, 1) * x_j * d_i # 这里不管正确性
六、覆写aggregate函数
我们在前面的例子中增加如下的aggregate函数,通过观察运行结果我们发现,我们覆写的aggregate函数被调用,同时在super(GCNConv, self).init(aggr=‘add’)中传递给aggr参数的值被存储到了self.aggr属性中。
class GCNConv(MessagePassing):
def __init__(self, in_channels, out_channels):
super(GCNConv, self).__init__(aggr='add', flow='source_to_target')
def forward(self, x, edge_index):
# ....
return self.propagate(edge_index, x=x, norm=norm, d=d)
def aggregate(self, inputs, index, ptr, dim_size):
print(self.aggr)
print("`aggregate` is called")
return super().aggregate(inputs, index, ptr=ptr, dim_size=dim_size)
七、覆写message_and_aggregate函数
在一些例子中,消息传递与消息聚合可以融合在一起,这种情况我们通过覆写message_and_aggregate函数来实现:
from torch_sparse import SparseTensor
class GCNConv(MessagePassing):
def __init__(self, in_channels, out_channels):
super(GCNConv, self).__init__(aggr='add', flow='source_to_target')
def forward(self, x, edge_index):
# ....
adjmat = SparseTensor(row=edge_index[0], col=edge_index[1], value=torch.ones(edge_index.shape[1]))
# 此处传的不再是edge_idex,而是SparseTensor类型的Adjancency Matrix
return self.propagate(adjmat, x=x, norm=norm, d=d)
def message(self, x_j, norm, d_i):
# x_j has shape [E, out_channels]
return norm.view(-1, 1) * x_j * d_i # 这里不管正确性
def aggregate(self, inputs, index, ptr, dim_size):
print(self.aggr)
print("`aggregate` is called")
return super().aggregate(inputs, index, ptr=ptr, dim_size=dim_size)
def message_and_aggregate(self, adj_t, x, norm):
print('`message_and_aggregate` is called')
虽然我们同时覆写了message函数和aggregate函数,然而只有message_and_aggregate函数被执行。
八、覆写update函数
class GCNConv(MessagePassing):
def __init__(self, in_channels, out_channels):
super(GCNConv, self).__init__(aggr='add', flow='source_to_target')
def update(self, inputs: Tensor) -> Tensor:
return inputs
update函数接收聚合的输出作为第一个参数,并接收传递给propagate的任何参数。
总结:
消息传递范式遵循**“消息传播->消息聚合->消息更新”**这一过程,实现将邻接节点的信息聚合到中心节点上。在PyG中,MessagePassing是所有基于消息传递范式的图神经网络的基类。MessagePassing类大大方便了我们图神经网络的构建,但由于其高度封装性,它也向我们隐藏了很多的细节。
这节看下来有点懵懵的,很多地方不知道到底在做什么,我觉得需要带数据,带范例的走一遍程序会理解的更好。
作业前几个知识点:
1) PyTorch之Squeeze()和Unsqueeze()
- unsqueeze():用来增加维度。在PyTorch中维度是从0开始的。
import torch
a = torch.arange(0, 9)
print(a)
## tensor([0, 1, 2, 3, 4, 5, 6, 7, 8])
# 利用view()改变tensor的形状。
# 值得注意的是view不会修改自身的数据,
# 返回的新tensor与源tensor共享内存;同时必须保证前后元素总数一致。
a = a.view(3, 3)
print(f"a:{a} \n shape:{a.shape}")
### a:tensor([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
shape:torch.Size([3, 3])
在第一个维度(即维度序号为0)前增加一个维度。
a = a.unsqueeze(0)
print(f"a:{a}\nshape:{a.shape}")
### a:tensor([[[0, 1, 2],
[3, 4, 5],
[6, 7, 8]]])
shape:torch.Size([1, 3, 3])
- squeeze():该函数用来减少某个维度。
print(f"1. a:{a}\nshape:{a.shape}")
a = a.unsqueeze(0)
a = a.unsqueeze(2)
print(f"2. a:{a}\nshape:{a.shape}")
a = a.squeeze(2)
print(f"3. a:{a}\nshape:{a.shape}")
### 1. a:tensor([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
shape:torch.Size([3, 3])
2. a:tensor([[[[0, 1, 2]],
[[3, 4, 5]],
[[6, 7, 8]]]])
shape:torch.Size([1, 3, 1, 3])
3. a:tensor([[[0, 1, 2],
[3, 4, 5],
[6, 7, 8]]])
shape:torch.Size([1, 3, 3])
作业:
1.请总结MessagePassing类的运行流程以及继承MessagePassing类的规范。
运行流程:先执行forward函数完成1)向邻接矩阵添加自环边 2)线性转换节点特征矩阵 3)计算归一化系数 这三步,然后进入propagate函数进行消息传递,propagate在执行的过程中会调用message和update。先调用message函数,对相邻节点特征x_j进行归一化处理,接着调用aggregate函数,对消息进行聚合,最后调用update函数进行消息更新。如果有 message_and_aggregate函数,则不会执行message和aggregate函数,而是直接执行message_and_aggregate函数。
继承规范:要继承这个类,需要复写三个函数:
2.请继承MessagePassing类来自定义以下的图神经网络类,并进行测试:
第一个类,覆写message函数,要求该函数接收消息传递源节点属性x、目标节点度d。
第二个类,在第一个类的基础上,再覆写aggregate函数,要求不能调用super类的aggregate函数,并且不能直接复制super类的aggregate函数内容。
第三个类,在第二个类的基础上,再覆写update函数,要求对节点信息做一层线性变换。
第四个类,在第三个类的基础上,再覆写message_and_aggregate函数,要求在这一个函数中实现前面message函数和aggregate函数的功能。
propagate(edge_index, size=None)
message() #消息传递分两种方式,默认的是source_to_target
update()
class GCNConv(MessagePassing):
def __init__(self, in_channels, out_channels):
super().__init__(aggr='add', flow='source_to_target')
self.lin = torch.nn.Linear(in_channels, out_channels)
self.lin1 = torch.nn.Linear(out_channels, in_channels)
def forward(self, x, edge_index):
# x has shape [N, in_channels]
# edge_index has shape [2, E]
# Step 1: Add self-loops to the adjacency matrix.
edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))
# Step 2: Linearly transform node feature matrix.
x = self.lin(x)
print("x*******")
print(x.dim())
# Step 3: Compute normalization.
row, col = edge_index
print("row:" )
print(row)
print("col:" )
print(col)
deg = degree(col, x.size(0), dtype=x.dtype)
print("deg:" )
print(deg.dim())
deg_inv_sqrt = deg.pow(-0.5)
print("deg_inv_sqrt:" )
print(deg_inv_sqrt.dim())
norm = deg_inv_sqrt[row] * deg_inv_sqrt[col]
# Step 4-5: Start propagating messages.
print("begin propagate")
return self.propagate(edge_index, x=x, norm=norm, d=deg.unsqueeze(1))
# 接收消息传递源节点属性x、目标节点度d
def message(self, x_i, norm, d_j):
# d 为节点的度 d_i 源节点的度,d_j 目标节点的度
# x_i 源节点属性,x_j目标节点属性
print("begin message")
print(x_i.dim(), norm.dim(), d_j.dim())
return norm.view(-1, 1) * x_i * d_j
def aggregate(self, inputs, index, ptr, dim_size):
print("`aggregate` is called")
print("inputs*****")
print(inputs)
print("index*****")
print(index)
print("ptr*****")
print(ptr)
if ptr is not None:
for _ in range(self.node_dim + inputs.dim() if self.node_dim < 0 else self.node_dim):
ptr = ptr.unsqueeze(0)
return segment_csr(inputs, ptr, reduce=self.aggr)
else:
return scatter(inputs, index, dim=self.node_dim, dim_size=dim_size,
reduce=self.aggr)
def update(self, inputs):
print("`update` is called")
# print("inputs*****")
print(inputs.size())
return self.lin1(inputs)