图神经网络（二）：消息传递范式

1.消息范式的中心节点更新

基于消息传递范式的聚合邻接节点信息来更新中心节点信息生成节点表征（节点嵌入）

以红色框为例，C的邻居节点（A,B,E,F)经过变换后聚合到节点C，C节点自己的信息与聚合来的邻居节点的信息更新得到新的C节点信息，B,D节点同理。每个节点都经历一次如此的节点更新过程
A节点的邻接节点（B,C,D）的已经发生过一次更新的节点信息，经过变换、聚合、再变换产生了A节点第二次更新的节点信息。多次更新后的节点信息就作为节点表征。

（1）：神经网络的生成节点表征的操作称为节点嵌入（Node Embedding），节点表征也可以称为节点嵌入。为了统一此次组队学习中的表述，我们规定节点嵌入只代指神经网络生成节点表征的操作。

（2）：未经过训练的图神经网络生成的节点表征还不是好的节点表征，好的节点表征可用于衡量节点之间的相似性。

MessagePassing基类初步分析

Pytorch Geometric(PyG)提供了MessagePassing基类，它封装了“消息传递”的运行流程。通过继承MessagePassing基类，可以方便地构造消息传递图神经网络。

构造一个最简单的消息传递图神经网络类，我们只需定义message()方法（ϕ）、update()方法（γ），以及使用的消息聚合方案（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：定义沿着哪个维度传播，默认值为-2，也就是节点表征张量（Tensor）的哪一个维度是节点维度。节点表征张量x形状为[num_nodes, num_features]，其第0维度（也是第-2维度）是节点维度，其第1维度（也是第-1维度）是节点表征维度，所以我们可以设置node_dim=-2。
注：MessagePassing(……)等同于MessagePassing.init(……)

MessagePassing.propagate(edge_index, size=None, kwargs)：

开始传递消息的起始调用，在此方法中message、update等方法被调用。
它以edge_index（边的端点的索引）和flow（消息的流向）以及一些额外的数据为参数。
MessagePassing.message(…)：
首先确定要给节点i传递消息的边的集合：
如果flow=“source_to_target”，则是(j,i)∈E的边的集合；
如果flow=“target_to_source”，则是(i,j)∈E的边的集合。
接着为各条边创建要传递给节点i的消息，即实现ϕ函数。
MessagePassing.message(…)方法可以接收传递给MessagePassing.propagate(edge_index, size=None, **kwargs)方法的所有参数，我们在message()方法的参数列表里定义要接收的参数，例如我们要接收x,y,z参数，则我们应定义message(x,y,z)方法。
传递给propagate()方法的参数，如果是节点的属性的话，可以被拆分成属于中心节点的部分和属于邻接节点的部分，只需在变量名后面加上_i或_j。例如，我们自己定义的meassage方法包含参数x_i，那么首先propagate()方法将节点表征拆分成中心节点表征和邻接节点表征，接着propagate()方法调用message方法并传递中心节点表征给参数x_i。而如果我们自己定义的meassage方法包含参数x_j，那么propagate()方法会传递邻接节点表征给参数x_j。
我们用i表示“消息传递”中的中心节点，用j表示“消息传递”中的邻接节点。

MessagePassing.aggregate(…)：
将从源节点传递过来的消息聚合在目标节点上，一般可选的聚合方式有sum, mean和max。
MessagePassing.message_and_aggregate(…)：
在一些场景里，邻接节点信息变换和邻接节点信息聚合这两项操作可以融合在一起，那么我们可以在此方法里定义这两项操作，从而让程序运行更加高效。
MessagePassing.update(aggr_out, …):
为每个节点i∈V更新节点表征，即实现γ函数。此方法以aggregate方法的输出为第一个参数，并接收所有传递给propagate()方法的参数。

MessagePassing子类实例

实现GCN

1.将自循环添加到邻接矩阵。
2.线性变换节点特征矩阵。
3.计算归一化系数。
4.规范化节点特征 .
5.将相邻节点表征相加（"求和 "聚合）。

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')
        self.lin=torch.nn.Linear(in_channels,out_channels)
    def forward(self,x,edge_index):
        #1.添加自循环边到邻接矩阵
        edge_index,_=add_self_loops(edge_index,num_nodes=x.size(0))
        #2.对节点表征做线性转换，x=(num_node,num_feature)
        x=self.lin(x)
        #3.计算归一化系数
        source,target=edge_index
        #print(row)
        deg=degree(target,x.size(0),dtype=x.dtype)#计算各个节点的度
        print(deg)#（num_node,1)
        print(deg.shape)
        deg_inv_sqrt=deg.pow(-0.5)
        print(deg_inv_sqrt[source])
        print(deg_inv_sqrt[target])
        norm=deg_inv_sqrt[source]*deg_inv_sqrt[target]#归一化系数
        print(norm)
        print(norm.shape)
        print(norm.view(-1,1).shape)
        #4，5.开始消息传递
        return self.propagate(edge_index,x=x,norm=norm)
    
    def message(self,x_j,norm):
        #4.归一化邻接结点的节点表征
        #print(x_j.shape)
        #print((norm.view(-1,1)*x_j).shape)
        return `norm.view(-1,1)*x_j
        

代码解析

 edge_index,_=add_self_loops(edge_index,num_nodes=x.size(0))

这里为边添加自循环，即到自己的索引，原来边条数为10556，添加后为（10556+2708）=13264，2708为节点数量

 source,target=edge_index

edge_index维度为（2，13264），这里相当于把第一行赋值给source,第二行给target，当flow=source_to_target时，第一行是源节点，第二行是目标节点。

 deg=degree(target,x.size(0),dtype=x.dtype)#计算各个节点的度

这里计算每一个节点的度，degree内写source,或者target都可以

norm=deg_inv_sqrt[source]*deg_inv_sqrt[target]#归一化系数

这里计算的norm是一个13264的列表，归一化系数是由每个节点的节点度得出的，它被转换为每条边的节点度。

norm.view(-1,1)*x_j

这里将norm打平成（13264，1）的矩阵，x_j是邻接节点的节点表征，用norm相乘得到邻接节点归一化后的节点表征。

return self.propagate(edge_index,x=x,norm=norm)

propagate()方法也在forward方法中被调用，propagate()方法被调用后节点间的信息传递开始执行。
propagate() 方法首先检查edge_index是否为SparseTensor类型以及是否子类实现了message_and_aggregate() 方法，如是就执行子类的message_and_aggregate方法；否则依次执行子类的**message(),aggregate(),update()**三个方法。

初始化和调用我们构造的一层图神经网络

from torch_geometric.datasets import Planetoid

dataset = Planetoid(root='dataset', name='Cora')
data = dataset[0]

net = GCNConv(data.num_features, 64)
h_nodes = net(data.x, data.edge_index)
print(h_nodes.shape)

message方法的覆写

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, deg=deg.view((-1, 1)))

    def message(self, x_j, norm, deg_i):
        # x_j has shape [E, out_channels]
        # deg_i has shape [E, 1]
        # Step 4: Normalize node features.
        return norm.view(-1, 1) * x_j * deg_i


from torch_geometric.datasets import Planetoid

dataset = Planetoid(root='dataset', name='Cora')
data = dataset[0]

net = GCNConv(data.num_features, 64)
h_nodes = net(data.x, data.edge_index)
print(h_nodes.shape)

return self.propagate(edge_index, x=x, norm=norm, deg=deg.view((-1, 1)))

若一个数据可以被拆分成属于中心节点的部分和属于邻接节点的部分，其形状必须是[num_nodes, *]，执行了deg.view((-1, 1))操作，使得数据形状为[num_nodes, 1]，然后才将数据传给propagate()方法

 def message(self, x_j, norm, deg_i):
        # x_j has shape [E, out_channels]
        # deg_i has shape [E, 1]
        # Step 4: Normalize node features.
        return norm.view(-1, 1) * x_j * deg_i

这一部分其实是我们构造自己图神经网络的核心，通过修改message方法，我们可以修改特征参数的计算方法，加入更多的特征。

aggregate方法的覆写

def aggregate(self, inputs, index, ptr, dim_size):
        print('self.aggr:', self.aggr)
        print("`aggregate` is called")
        return super().aggregate(inputs, index, ptr=ptr, dim_size=dim_size)

可以看到，这里调用了我们自己的aggregate方法

update方法的覆写

    def update(self, inputs, deg):
        print(deg)
        return inputs

接受聚合的输出作为输入，这里我们可以对聚合输出的结果做一个修正

总结

message函数中，我们可以通过聚合邻接节点的节点表征来获取更新中心节点的节点表征， 邻居节点的信息究竟怎么得到，可以在这里面进行适当的修改，比如加度的特征或者边联系等。
propagate函数中，将获取的节点表征转换成向量 ，可以sum,avg和max等，获取中心节点的embedding
update函数，接收上面的embedding即接受输入特征，可以对特征在进行处理