消息传递图神经网络

一、引言

在开篇中我们介绍了，为节点生成节点表征（Node Representation）是图计算任务成功的关键，我们要利用神经网络来学习节点表征。消息传递范式是一种聚合邻接节点信息来更新中心节点信息的范式，它将卷积算子推广到了不规则数据领域，实现了图与神经网络的连接。消息传递范式因为简单、强大的特性，于是被人们广泛地使用。遵循消息传递范式的图神经网络被称为消息传递图神经网络。本节中，

  • 首先我们将学习图神经网络生成节点表征的范式–消息传递（Message Passing）范式。
  • 接着我们将初步分析PyG中的MessagePassing基类，通过继承此基类我们可以方便地构造一个图神经网络。
  • 然后我们以继承MessagePassing基类的GCNConv类为例，学习如何通过继承MessagePassing基类来构造图神经网络。
  • 再接着我们将对MessagePassing基类进行剖析。
  • 最后我们将学习在继承MessagePassing基类的子类中覆写message(),aggreate(),message_and_aggreate()和update()，这些方法的规范。

二、 消息传递范式介绍

下方图片展示了基于消息传递范式的聚合邻接节点信息来更新中心节点信息的过程：

  1. 图中黄色方框部分展示的是一次邻接节点信息传递到中心节点的过程：B节点的邻接节点（A,C）的信息经过变换后聚合到B节点，接着B节点信息与邻接节点聚合信息一起经过变换得到B节点的新的节点信息。同时，分别如红色和绿色方框部分所示，遵循同样的过程，C、D节点的信息也被更新。实际上，同样的过程在所有节点上都进行了一遍，所有节点的信息都更新了一遍。
  2. 这样的“邻接节点信息传递到中心节点的过程”会进行多次。如图中蓝色方框部分所示，A节点的邻接节点（B,C,D）的已经发生过一次更新的节点信息，经过变换、聚合、再变换产生了A节点第二次更新的节点信息。多次更新后的节点信息就作为节点表征。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h1dqI2J9-1648002261843)(images/image-20210516110407207.png)]

图片来源于：Graph Neural Network • Introduction to Graph Neural Networks

消息传递图神经网络遵循上述的“聚合邻接节点信息来更新中心节点信息的过程”，来生成节点表征。用xi(k−1)∈RF\mathbf{x}^{(k-1)}_i\in\mathbb{R}^Fxi(k−1)​∈RF表示(k−1)(k-1)(k−1)层中节点iii的节点表征，ej,i∈RD\mathbf{e}_{j,i} \in \mathbb{R}^Dej,i​∈RD 表示从节点jjj到节点iii的边的属性，消息传递图神经网络可以描述为
xi(k)=γ(k)(xi(k−1),□j∈N(i)ϕ(k)(xi(k−1),xj(k−1),ej,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□表示可微分的、具有排列不变性（函数输出结果与输入参数的排列无关）的函数。具有排列不变性的函数有，sum()函数、mean()函数和max()函数。γ\gammaγ和ϕ\phiϕ表示可微分的函数，如MLPs（多层感知器）。此处内容来源于CREATING MESSAGE PASSING NETWORKS。

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

注（2）：未经过训练的图神经网络生成的节点表征还不是好的节点表征，好的节点表征可用于衡量节点之间的相似性。通过监督学习对图神经网络做很好的训练，图神经网络才可以生成好的节点表征。我们将在第5节介绍此部分内容。

注（3），节点表征与节点属性的区分：遵循被广泛使用的约定，此次组队学习我们也约定，节点属性data.x是节点的第0层节点表征，第hhh层的节点表征经过一次的节点间信息传递产生第h+1h+1h+1层的节点表征。不过，节点属性不单指data.x，广义上它就指节点的属性，如节点的度等。

三、MessagePassing基类初步分析

Pytorch Geometric(PyG)提供了MessagePassing基类，它封装了“消息传递”的运行流程。通过继承MessagePassing基类，可以方便地构造消息传递图神经网络。构造一个最简单的消息传递图神经网络类，我们只需定义**message()方法（ϕ\phiϕ）、update()方法（γ\gammaγ），以及使用的消息聚合方案**（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（消息的流向）以及一些额外的数据为参数。
    • 请注意，propagate()不局限于基于形状为[N, N]的对称邻接矩阵进行“消息传递过程”。基于非对称的邻接矩阵进行消息传递（当图为二部图时），需要传递参数size=(N, M)。
    • 如果设置size=None，则认为邻接矩阵是对称的。
  • MessagePassing.message(...)：
    • 首先确定要给节点iii传递消息的边的集合：

      • 如果flow="source_to_target"，则是(j,i)∈E(j,i) \in \mathcal{E}(j,i)∈E的边的集合；
      • 如果flow="target_to_source"，则是(i,j)∈E(i,j) \in \mathcal{E}(i,j)∈E的边的集合。
    • 接着为各条边创建要传递给节点iii的消息，即实现ϕ\phiϕ函数。
    • 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。
    • 我们用iii表示“消息传递”中的中心节点，用jjj表示“消息传递”中的邻接节点。
  • MessagePassing.aggregate(...)：
    • 将从源节点传递过来的消息聚合在目标节点上，一般可选的聚合方式有sum, mean和max。
  • MessagePassing.message_and_aggregate(...)：
    • 在一些场景里，邻接节点信息变换和邻接节点信息聚合这两项操作可以融合在一起，那么我们可以在此方法里定义这两项操作，从而让程序运行更加高效。
  • MessagePassing.update(aggr_out, ...):
    • 为每个节点i∈Vi \in \mathcal{V}i∈V更新节点表征，即实现γ\gammaγ函数。此方法以aggregate方法的输出为第一个参数，并接收所有传递给propagate()方法的参数。

以上内容来源于The “MessagePassing” Base Class。

四、MessagePassing子类实例

我们以继承MessagePassing基类的GCNConv类为例，学习如何通过继承MessagePassing基类来实现一个简单的图神经网络。

GCNConv的数学定义为
xi(k)=∑j∈N(i)∪{i}1deg⁡(i)⋅deg⁡(j)⋅(Θ⋅xj(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)∪{i}∑​deg(i)

​⋅deg(j)

​1​⋅(Θ⋅xj(k−1)​),
其中，邻接节点的表征xj(k−1)\mathbf{x}_j^{(k-1)}xj(k−1)​首先通过与权重矩阵Θ\mathbf{\Theta}Θ相乘进行变换，然后按端点的度deg⁡(i),deg⁡(j)\deg(i), \deg(j)deg(i),deg(j)进行归一化处理，最后进行求和。这个公式可以分为以下几个步骤：

  1. 向邻接矩阵添加自环边。
  2. 对节点表征做线性转换。
  3. 计算归一化系数。
  4. 归一化邻接节点的节点表征。
  5. 将相邻节点表征相加（"求和 "聚合）。

步骤1-3通常是在消息传递发生之前计算的。步骤4-5可以使用MessagePassing基类轻松处理。该层的全部实现如下所示。

import torch
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import add_self_loops, degreeclass 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_indexdeg = 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）。propagate()方法也在forward方法中被调用，propagate()方法被调用后节点间的信息传递开始执行。

归一化系数是由每个节点的节点度得出的，它被转换为每条边的节点度。结果被保存在形状为[num_edges,]的变量norm中（步骤3）。

在message()方法中，我们需要通过norm对邻接节点表征x_j进行归一化处理。

通过以上内容的学习，我们便掌握了创建一个仅包含一次“消息传递过程”的图神经网络的方法。如下方代码所示，我们可以很方便地初始化和调用它：

from torch_geometric.datasets import Planetoiddataset = 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)

通过串联多个这样的简单图神经网络，我们就可以构造复杂的图神经网络模型。我们将在第5节介绍复杂图神经网络模型的构建。

以上主要内容来源于Implementing the GCN Layer。

五、MessagePassing基类剖析

在__init__()方法中，我们看到程序会检查子类是否实现了message_and_aggregate()方法，并将检查结果赋值给fuse属性。

class MessagePassing(torch.nn.Module):def __init__(self, aggr: Optional[str] = "add", flow: str = "source_to_target", node_dim: int = -2):super(MessagePassing, self).__init__()# 此处省略n行代码# Support for "fused" message passing.self.fuse = self.inspector.implements('message_and_aggregate')# 此处省略n行代码

“消息传递过程”是从propagate方法被调用开始执行的。

class MessagePassing(torch.nn.Module):# 此处省略n行代码def propagate(self, edge_index: Adj, size: Size = None, **kwargs):# 此处省略n行代码# Run "fused" message and aggregation (if applicable).if (isinstance(edge_index, SparseTensor) and self.fuse and not self.__explain__):coll_dict = self.__collect__(self.__fused_user_args__, edge_index, size, kwargs)msg_aggr_kwargs = self.inspector.distribute('message_and_aggregate', coll_dict)out = self.message_and_aggregate(edge_index, **msg_aggr_kwargs)update_kwargs = self.inspector.distribute('update', coll_dict)return self.update(out, **update_kwargs)# Otherwise, run both functions in separation.elif isinstance(edge_index, Tensor) or not self.fuse:coll_dict = self.__collect__(self.__user_args__, edge_index, size, kwargs)msg_kwargs = self.inspector.distribute('message', coll_dict)out = self.message(**msg_kwargs)# 此处省略n行代码aggr_kwargs = self.inspector.distribute('aggregate', coll_dict)out = self.aggregate(out, **aggr_kwargs)update_kwargs = self.inspector.distribute('update', coll_dict)return self.update(out, **update_kwargs)

参数简介：

  • edge_index: 边端点索引，它可以是Tensor类型或SparseTensor类型。

    • 当flow="source_to_target"时，节点edge_index[0]的信息将被传递到节点edge_index[1]，
    • 当flow="target_to_source"时，节点edge_index[1]的信息将被传递到节点edge_index[0]
  • size: 邻接节点的数量与中心节点的数量。
    • 对于普通图，邻接节点的数量与中心节点的数量都是N，我们可以不给size传参数，即让size取值为默认值None。
    • 对于二部图，邻接节点的数量与中心节点的数量分别记为M, N，于是我们需要给size参数传一个元组(M, N)。
  • kwargs: 图其他属性或额外的数据。

propagate()方法首先检查edge_index是否为SparseTensor类型以及是否子类实现了message_and_aggregate()方法，如是就执行子类的message_and_aggregate方法；否则依次执行子类的message(),aggregate(),update()三个方法。

六、message方法的覆写

前面我们介绍了，传递给propagate()方法的参数，如果是节点的属性的话，可以被拆分成属于中心节点的部分和属于邻接节点的部分，只需在变量名后面加上_i或_j。现在我们有一个额外的节点属性，节点的度deg，我们希望meassge方法还能接收中心节点的度，我们对前面GCNConv的message方法进行改造得到新的GCNConv类：

import torch
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import add_self_loops, degreeclass 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_indexdeg = 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_ifrom torch_geometric.datasets import Planetoiddataset = 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)

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

七、aggregate方法的覆写

在前面的例子的基础上，我们增加如下的aggregate方法。通过观察运行结果我们可以看到，我们覆写的aggregate方法被调用，同时在super(GCNConv, self).__init__(aggr='add')中传递给aggr参数的值被存储到了self.aggr属性中。

import torch
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import add_self_loops, degreeclass 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_indexdeg = 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_idef 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)from torch_geometric.datasets import Planetoiddataset = 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_and_aggregate方法的覆写

在一些案例中，“消息传递”与“消息聚合”可以融合在一起。对于这种情况，我们可以覆写message_and_aggregate方法，在message_and_aggregate方法中一块实现“消息传递”与“消息聚合”，这样能使程序的运行更加高效。

import torch
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import add_self_loops, degree
from torch_sparse import SparseTensorclass 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_indexdeg = 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.adjmat = SparseTensor(row=edge_index[0], col=edge_index[1], value=torch.ones(edge_index.shape[1]))# 此处传的不再是edge_idex，而是SparseTensor类型的Adjancency Matrixreturn self.propagate(adjmat, 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_idef 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)def message_and_aggregate(self, adj_t, x, norm):print('`message_and_aggregate` is called')# 没有实现真实的消息传递与消息聚合的操作from torch_geometric.datasets import Planetoiddataset = 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方法和aggregate方法，然而只有message_and_aggregate方法被执行。

九、update方法的覆写

from torch_geometric.datasets import Planetoid
import torch
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import add_self_loops, degree
from torch_sparse import SparseTensorclass 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_indexdeg = 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.adjmat = SparseTensor(row=edge_index[0], col=edge_index[1], value=torch.ones(edge_index.shape[1]))# 此处传的不再是edge_idex，而是SparseTensor类型的Adjancency Matrixreturn self.propagate(adjmat, 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_idef 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)def message_and_aggregate(self, adj_t, x, norm):print('`message_and_aggregate` is called')# 没有实现真实的消息传递与消息聚合的操作def update(self, inputs, deg):print(deg)return inputsdataset = 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)

update方法接收聚合的输出作为第一个参数，此外还可以接收传递给propagate方法的任何参数。在上方的代码中，我们覆写的update方法接收了聚合的输出作为第一个参数，此外接收了传递给propagate的deg参数。

十、结语

消息传递范式是一种聚合邻接节点信息来更新中心节点信息的范式，它将卷积算子推广到了不规则数据领域，实现了图与神经网络的连接。该范式包含这样三个步骤：(1)邻接节点信息变换、(2)邻接节点信息聚合到中心节点、(3)聚合信息变换。因为简单且强大的特性，消息传递范式现被人们广泛地使用。基于此范式，我们可以定义聚合邻接节点信息来生成中心节点表征的图神经网络。在PyG中，MessagePassing基类是所有基于消息传递范式的图神经网络的基类，它大大地方便了我们对图神经网络的构建。

在此节内容中，我们打开了MessagePassing基类的黑箱子。通过此节内容的学习，我们可以了解MessagePassing基类实现“消息传递”的运行流程，可以掌握继承MessagePassing基类来构造自己的图神经网络类的规范。

再次强调，要掌握基于MessagePassing基类构建自己的图神经网络类的方法，我们不能仅停留于理论理解层面，还需要通过逐行代码调试，观察代码运行流程，最终掌握对MessagePassing基类的实际应用。

作业

  1. 请总结MessagePassing基类的运行流程。
  2. 请复现一个一层的图神经网络的构造，总结通过继承MessagePassing基类来构造自己的图神经网络类的规范。

参考资料

  • CREATING MESSAGE PASSING NETWORKS
  • torch_geometric.nn.conv.message_passing.MessagePassing
  • The “MessagePassing” Base Class
  • Implementing the GCN Layer

PyG 中Message Passing机制详解相关推荐

  1. OSPF中DR选举机制详解

    OSPF中DR选举机制详解--对于这方面不太清楚的可以看看附件 转载于:https://blog.51cto.com/gauyanm/226882

  2. gnu radio学习（三）Message Passing消息传递详解

    Message Passing Introduction(介绍) Message Passing API(消息传递端口) Message Handler Functions(消息处理函数) Conne ...

  3. JAVA基础－－JAVA中的反射机制详解

    JAVA反射机制     JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法:这种动态获取的信息以及动态调用对象的方法的功能 ...

  4. Qt中事件循环机制详解

    问题1:Qt中常见的事件有哪些? 答:鼠标事件(QMouseEvent).键盘事件(QKeyEvent).绘制事件(QPaintEvent).窗口尺寸改变(QResizeEvent).滚动事件(QSc ...

  5. Android中Binder通讯机制详解

    Android深入浅出之Binder机制 本文是转载文章,在此感谢原作者精彩的讲解!! 原文地址:http://www.cnblogs.com/innost/archive/2011/01/09/19 ...

  6. php中的session详解,PHP中的session机制详解

    Session是什么? 首先,我们大概知道session是浏览器与服务器之间的一次交互会话. 那么会话又是什么呢?顾名思义就是浏览器与服务器之间的对话,浏览器一关闭,会话就结束了. 说session不 ...

  7. java gil,Python中的GIL机制详解

    大家应该都知道,python有一个GIL(全局解释器锁),用于控制多线程的并发行为. 注:GIL不是必须的,可以通过对每个资源单独加锁的方式去掉GIL,也就是将GIL换成更细粒度的锁. GIL锁的实现 ...

  8. 【CSDN软件工程师能力认证学习精选】Vue 中的事件处理机制详解

    CSDN软件工程师能力认证(以下简称C系列认证)是由中国软件开发者网CSDN制定并推出的一个能力认证标准.C系列认证历经近一年的实际线下调研.考察.迭代.测试,并梳理出软件工程师开发过程中所需的各项技 ...

  9. Session机制详解及分布式中Session共享解决方案

    Session机制详解及分布式中Session共享解决方案 参考文章: (1)Session机制详解及分布式中Session共享解决方案 (2)https://www.cnblogs.com/jing ...

  10. Hadoop中RPC机制详解之Server端

    2019独角兽企业重金招聘Python工程师标准>>> Hadoop 中 RPC 机制详解之 Client 端 1. Server.Listener RPC Client 端的 RP ...

最新文章

  1. 第四章 python的turtle库的运用
  2. 2017年50道Java线程面试题
  3. 【实习】今日头条【抖音火山】后台开发实习生
  4. 在linux下，如何在C语言中使用正则表达式
  5. mysql按照日期先去重在分组_【巨杉数据库Sequoiadb】【咨询】【数据操作】【聚集查询】在执行聚集查询时，字符类型的字段能否按照实际内容进行分组去重...
  6. Java基础学习总结（65）——Java中的String,StringBuilder和StringBuffer比较
  7. android 自动打包工具,AutopackingAndroid
  8. python零基础能学吗-Python真的零基础可以学会吗?
  9. 软件测试nextdata函数决策表,软件测试NextDate函数决策表测试法实验报告
  10. win10安装、卸载、升级tensorflow命令
  11. ES6、7学习笔记（尚硅谷）-5-箭头函数
  12. 读书笔记《Redis入门指南》
  13. 社交网络用户行为分析,各类社交软件用户分析
  14. 五大车载操作（VOS）系统优劣对比
  15. Exp3 免杀原理与实践 20164302 王一帆
  16. Factorials
  17. [转]日语快速学习原则和方法！
  18. 作业要求20190919-2 功能测试
  19. [SWPUCTF 2021 新生赛]PseudoProtocols
  20. Android去除EditText的聚焦Focuse

热门文章

  1. java.lang.null_java.lang.nullpointerexception 怎么解决
  2. 社会工程学利用的人性_社会互程学利用的人性“弱点”
  3. 论我是如何被自己搭建的聊天机器人气死的（自己的搞笑经历）
  4. Crystal Reports（水晶报表）安装及拉（PULL）模式/推（PUSH）模式的使用
  5. 文件系统 转载至百度百科
  6. Python面向对象编程-类和实例
  7. STM32 Bootloader开发记录 3 固件签名校验
  8. 个人笔记-如何学习(上)
  9. 每日一篇_启动又报错了The POM for com.xxxx:qgg-core:jar:0.0.1-SNAPSHOT is missing
  10. 《WebRTC 1.0: Real-Time Communication Between Browsers》学习