PyG实战:从零构建自定义消息传递层

【PyG】创建消息传递网络-图神经网络 使用PyG实现消息传递层。 阅读详情

1. 为什么你需要亲手打造一个消息传递层?

如果你已经开始用PyTorch Geometric(PyG)玩图神经网络(GNN),那你肯定对MessagePassing这个类不陌生。官方提供的那些卷积层,比如GCNConv、GATConv,用起来确实方便,几行代码就能搭个模型。但不知道你有没有遇到过这种情况:看了一篇顶会论文,里面提出了一种新颖的邻居聚合方式,或者一个酷炫的注意力机制,你摩拳擦掌想复现一下,结果发现PyG里没有现成的层。这时候怎么办?等官方更新?或者去GitHub上大海捞针找别人的实现?最靠谱、最能让你吃透原理的方法,其实就是自己动手,从零构建一个自定义的消息传递层。

我自己在项目里就经常这么干。比如有一次,我们需要处理一种特殊的图数据,节点之间的关系强度不是二元的(存在或不存在),而是有一个连续的权重,并且聚合时需要考虑节点自身历史状态的影响。标准的GCNConv完全没法用,GATConv也只能处理注意力权重,对额外的连续边属性处理起来很别扭。这时候,自定义层就成了唯一的选择。这个过程听起来有点“硬核”,但实际做下来,你会发现PyG的设计非常贴心,它把复杂的消息传播流程封装好了,你只需要像填空一样,实现几个关键的函数。

所以,这篇文章的目的就是当你的“手把手教练”。我不会只给你看最终的代码,而是会从一个具体的任务场景出发,一步步拆解为什么做、怎么做。我们会假设一个任务:在一个学术合作网络(作者为节点,合作为边)上进行节点分类,目标是预测作者的学术领域。但我们发现,简单的均值聚合(mean)效果不佳,因为大牛作者(有很多合作者)的特征会被“稀释”。我们想实现一种加权聚合,根据合作次数(边权重)来调整邻居信息的重要性。这个简单的需求,就是自定义层的最佳切入点。通过实现它,你将彻底掌握MessagePassing的精髓,以后无论看到多复杂的GNN变体,你都有能力自己实现出来。

2. 深入MessagePassing基类:你的工具箱里有什么?

在动手造轮子之前,我们得先搞清楚PyG给我们提供的“工具箱”——torch_geometric.nn.MessagePassing基类——里面到底有哪些好用的工具。理解这个,后续的自定义工作就会事半功倍。

2.1 核心工作流程:消息、聚合、更新

PyG将图上的消息传递抽象成了一个清晰的三步流程,分别对应三个你可以重写的方法:message(), aggregate(), update()。你可以把它想象成一场派对上的信息交流:

  1. 消息(message):每个嘉宾(节点)准备一句想告诉邻居的话。在代码里,就是message()函数,它负责定义从源节点(source node)发送到目标节点(target node)的信息内容。比如,对于边(j -> i),message()函数会计算节点j要发给节点i的“消息”。
  2. 聚合(aggregate):每个嘉宾收集所有邻居对他说的话,并把这些话总结成一条核心信息。在代码里,就是aggregate()函数,它负责将一个目标节点的所有入边传来的消息,聚合成一个单一的信息。常用的聚合方式有求和(sum)、求均值(mean)、取最大值(max)等。
  3. 更新(update):每个嘉宾根据聚合后的核心信息,更新自己的状态。在代码里,就是update()函数,它接收聚合后的信息,并结合节点自身当前的特征,生成节点的新特征。

PyG的巧妙之处在于,它通过一个propagate()函数,自动帮你串联起了这三个步骤。你只需要调用self.propagate(edge_index, ...),引擎就会自动按照message -> aggregate -> update的顺序执行。你的主要工作,就是根据你的算法逻辑,去定制化message和update(aggregate通常使用内置的就行)。

2.2 理解propagate的参数映射魔法

这是自定义层最关键也最容易困惑的地方。我们仔细看看propagate的调用:

def forward(self, x, edge_index, edge_weight=None):
    # ... 一些预处理 ...
    return self.propagate(edge_index, x=x, edge_weight=edge_weight)

我们传入了x(节点特征)和可选的edge_weight(边权重)。那么,在message函数里,我们怎么分别拿到源节点和目标节点的特征呢?PyG使用了一种优雅的命名约定:后缀_i和_j。

在message函数中,你可以定义参数x_i和x_j。PyG会自动进行映射:

  • x_j:对应消息的源节点(source nodes)特征。对于边(j->i),x_j就是节点j的特征。
  • x_i:对应消息的目标节点(target nodes)特征。对于边(j->i),x_i就是节点i的特征。

这个映射是基于propagate调用时传入的x自动完成的。同样,如果你传入了edge_weight,在message函数里你就可以通过edge_weight_j或直接edge_weight来访问每条边上的权重(通常边属性与边对应,不区分_i或_j)。

我刚开始用的时候,经常搞混_i和_j。一个简单的记忆方法是:消息从j流向i,所以x_j是“说话的人”的特征,x_i是“听的人”的特征。flow参数可以改变这个方向,但绝大多数情况我们使用默认的source_to_target(从源到目标),也就是j->i。

2.3 初始化函数中的关键参数

在自定义层的__init__函数里,我们通过super().__init__()来初始化父类,这里可以设置一些重要的行为参数:

  • aggr: 这是聚合方式。如果你需要的聚合逻辑很简单(比如求和、求均值),直接在这里指定就行了,比如super().__init__(aggr='mean'),这样你连aggregate函数都不用写。我们的加权聚合需求,如果权重是固定的,其实也可以用aggr='add',然后在message里把权重乘上去。但为了演示更通用的情况,我们会展示如何自定义。
  • flow: 消息流向。除非你在设计双向传播或特殊的图结构,否则一般不用动。
  • node_dim: 节点特征维度的索引。对于最常见的形状为[num_nodes, num_features]的节点特征矩阵,保持默认值-2即可。

3. 实战第一步:构建一个加权求和的消息传递层

好了,理论铺垫得差不多了,我们开始动手。回到我们的场景:学术合作网络,边上有合作次数作为权重。我们想实现一个WeightedConv层,它在聚合邻居信息时,用边权重对消息进行加权。

3.1 定义层的骨架

首先,我们导入必要的模块,并定义这个层的类。我们将继承MessagePassing。

import torch
from torch_geometric.nn import MessagePassing
from torch_scatter import scatter

class WeightedConv(MessagePassing):
    def __init__(self, in_channels, out_channels):
        # 初始化父类,我们暂时使用‘add’作为基础聚合,因为我们会手动加权。
        # 实际上,我们会完全自定义聚合过程,所以这里的aggr可以先设为‘add’,后续覆盖。
        super().__init__(aggr='add') # 注意:这里用‘add’,但我们会重写aggregate
        # 定义一个线性变换层,用于对节点特征进行变换(类似GCN中的W矩阵)。
        self.lin = torch.nn.Linear(in_channels, out_channels)

    def forward(self, x, edge_index, edge_weight):
        # 第一步:对输入特征进行线性变换。
        x = self.lin(x)

        # 第二步:启动消息传递。
        # 将变换后的特征x和边权重edge_weight传给propagate。
        out = self.propagate(edge_index, x=x, edge_weight=edge_weight)

        return out

在这个骨架里,forward函数做了两件事:特征变换和消息传递。特征变换是很多GNN层的标准操作,将输入维度in_channels映射到输出维度out_channels。核心是self.propagate的调用,我们传入了edge_index, x, edge_weight。

3.2 实现message函数:注入权重信息

接下来,我们要实现message函数。它的任务是为每一条边(j, i)生成一个要传递的消息。在我们的加权求和设计中,消息就是源节点特征x_j乘以对应的边权重edge_weight。

    def message(self, x_j, edge_weight):
        # x_j: 源节点特征,形状为 [num_edges, out_channels]
        # edge_weight: 边权重,形状为 [num_edges, ]
        # 我们需要将edge_weight的形状从[num_edges, ]变为[num_edges, 1],以便与x_j相乘。
        # 这样每个特征通道都会乘以相同的权重。
        return x_j * edge_weight.view(-1, 1)

看,非常简单!x_j是PyG根据我们传入propagate的x自动为我们收集好的所有源节点特征。edge_weight是我们自己传进来的。这里的关键是广播机制,我们将edge_weight从[num_edges]变成[num_edges, 1],这样它就能与x_j [num_edges, out_channels]相乘,结果就是每条边上带权重的消息。

3.3 实现aggregate函数:执行加权求和

默认的aggr='add'会对所有消息进行简单求和。但在我们的场景下,消息已经在message里乘过权重了,所以简单的add其实就是加权求和。等等,那是不是就不用重写aggregate了?是的,对于这个简单的加权求和,用默认的add聚合完全正确!

但是,为了教学目的,我们假设一个更复杂的需求:我们想先对加权后的消息求和,然后除以一个归一化因子(比如目标节点的度,或者所有权重的和)。这就必须自定义aggregate了。让我们来实现这个“加权和除以权重和”的版本,这有时能增加数值稳定性。

    def aggregate(self, inputs, index, ptr=None, dim_size=None):
        # inputs: message函数的输出,形状 [num_edges, out_channels]
        # index: 目标节点的索引,形状 [num_edges]。对于边(j->i),index中存储的就是i。
        # 这个参数由propagate自动生成,指示每条消息应该聚合到哪个目标节点。

        # 我们需要计算两件事:
        # 1. 加权消息的和:sum(x_j * edge_weight)
        # 2. 权重的和:sum(edge_weight) (用于归一化)

        # 但是,inputs里已经包含了权重信息。为了计算权重和,我们需要原始的edge_weight。
        # 我们在message里用了edge_weight,但aggregate接收不到它。
        # 怎么办?方法一:在message里返回一个元组,包含加权消息和权重本身。
        # 方法二(更简洁):我们修改一下设计,在forward里计算好归一化权重,然后传入propagate。

        # 让我们采用方法二,稍微调整一下思路。
        # 假设我们在forward里已经计算了“归一化权重”,比如 weight_norm = edge_weight / scatter_add(edge_weight, index)。
        # 然后message里直接返回 x_j * weight_norm。
        # 这样aggregate只需要做简单的求和(add)即可。

        # 但为了展示aggregate的用法,我们假设inputs就是加权消息,并且我们额外传入了一个`weight_sum`给aggregate。
        # 这需要修改propagate的调用,传递更多参数。这有点绕。

        # 更直接的例子:实现一个稳定的mean聚合,防止除零。
        # 我们可以使用PyG内置的scatter函数,它功能强大。
        # 实际上,PyG默认的聚合就是基于scatter实现的。

        # 这里,我们展示如何使用scatter手动实现一个‘mean’聚合,但用我们自己的逻辑。
        # 假设我们想要聚合的是 inputs,并且我们想用 index 来分组。
        # 我们计算每个目标节点接收到的消息之和。
        aggregated = scatter(inputs, index, dim=0, dim_size=dim_size, reduce='sum')
        # 注意:这其实就是默认‘add’聚合的行为。自定义aggregate给了我们极大的灵活性,
        # 比如可以实现注意力机制中的加权求和(权重在message中计算并相乘),或者更复杂的操作。

        # 对于“加权和除以权重和”,更正确的做法是在message阶段准备好(消息=权重*特征),
        # 并额外传递权重向量,在aggregate里分别对加权特征和权重求和,然后在update里做除法。
        # 这涉及到在多个函数间传递数据,我们将在下一个更复杂的例子(仿GAT)中详细展开。

        return aggregated

上面的代码注释比代码本身还长,因为它揭示了自定义aggregate时的关键点:数据流的设计。message和aggregate之间的数据传递需要仔细规划。对于简单的加权求和,让message返回加权消息,然后用默认的aggr='add'是最干净的。对于需要归一化的复杂聚合,通常有两种模式:1)在message中完成所有计算,返回可直接聚合的结果;2)在message中返回原始数据和权重,在aggregate中完成加权与求和,在update中完成归一化。GAT采用的是第一种模式,我们在下一节会看到。

3.4 完成update函数与测试

update函数接收aggregate的输出,并返回最终更新的节点特征。对于很多简单的层,更新可能只是加上一个偏置项,或者应用一个非线性激活函数。如果我们不需要额外的操作,可以不用重写update,它会直接返回聚合的结果。

让我们完成这个简单的WeightedConv层,并测试它:

class SimpleWeightedConv(MessagePassing):
    def __init__(self, in_channels, out_channels):
        super().__init__(aggr='add') # 使用内置的求和聚合
        self.lin = torch.nn.Linear(in_channels, out_channels)

    def forward(self, x, edge_index, edge_weight):
        x = self.lin(x)
        return self.propagate(edge_index, x=x, edge_weight=edge_weight)

    def message(self, x_j, edge_weight):
        # 消息 = 源节点特征 * 边权重
        return x_j * edge_weight.view(-1, 1)

# 测试
if __name__ == "__main__":
    # 模拟数据:4个节点,每个节点3维特征
    x = torch.randn(4, 3)
    # 边索引:4条边 (0->1, 1->2, 2->3, 0->3)
    edge_index = torch.tensor([[0, 1, 2, 0],
                               [1, 2, 3, 3]], dtype=torch.long)
    # 边权重:合作次数
    edge_weight = torch.tensor([2.0, 1.0, 1.5, 0.5])

    conv = SimpleWeightedConv(in_channels=3, out_channels=5)
    out = conv(x, edge_index, edge_weight)
    print("输入特征形状:", x.shape)
    print("输出特征形状:", out.shape) # 应该是 [4, 5]
    print("输出:\n", out)

运行这段代码,你会得到一个形状为[4, 5]的输出张量。节点0因为没有入边(edge_index中目标节点没有0),所以它的输出特征可能是全零(取决于scatter的实现),而节点1、2、3都聚合了来自邻居的加权信息。这就成功实现了我们最基本的加权聚合层!

4. 进阶实战:实现一个简化版的图注意力层

现在我们来挑战一个更复杂、也更常见的例子:实现一个类似GAT的注意力层。这能充分展示自定义message、aggregate和update的协作。为了简化,我们实现一个固定注意力机制的层,而不是学习型的,但流程是完整的。

假设我们想让注意力权重由源节点和目标节点特征的余弦相似度决定。消息传递公式为: h_i' = σ( Σ_{j∈N(i)} α_{ij} * W * h_j ),其中 α_{ij} = cosine_similarity(W*h_i, W*h_j)。

4.1 设计层结构与forward

首先,我们定义层的结构。我们需要一个线性变换W,和一个激活函数σ(如ReLU)。

import torch.nn.functional as F
from torch_geometric.utils import softmax

class SimpleAttnConv(MessagePassing):
    def __init__(self, in_channels, out_channels):
        super().__init__(aggr='add') # 聚合方式为求和
        self.lin = torch.nn.Linear(in_channels, out_channels, bias=False)
        # 注意:我们没有可学习的注意力向量a,而是使用固定的余弦相似度。

    def forward(self, x, edge_index):
        # 线性变换
        x_transformed = self.lin(x) # 形状 [num_nodes, out_channels]

        # 启动消息传播。我们需要将变换后的特征传给propagate,
        # 因为注意力计算和消息构建都需要它。
        out = self.propagate(edge_index, x=x_transformed)

        # 应用非线性激活函数 (在update中做也可以)
        return F.relu(out)

4.2 实现message函数:计算注意力权重与加权消息

这是核心。在message函数里,我们需要计算每对节点(j, i)的注意力权重α_ij,然后返回加权后的消息α_ij * W * h_j。注意,W*h_j就是x_j(因为我们在forward里已经做了线性变换并传入了propagate)。

    def message(self, x_i, x_j, edge_index_i):
        # x_i: 目标节点变换后的特征 [num_edges, out_channels]
        # x_j: 源节点变换后的特征 [num_edges, out_channels]
        # edge_index_i: 目标节点索引 [num_edges]

        # 1. 计算余弦相似度作为注意力分数
        # 余弦相似度 = (x_i · x_j) / (||x_i|| * ||x_j||)
        # 为了防止除零,我们给分母加一个很小的数eps。
        eps = 1e-12
        cosine_sim = (x_i * x_j).sum(dim=-1, keepdim=True) # [num_edges, 1]
        norm_i = x_i.norm(dim=-1, keepdim=True) + eps # [num_edges, 1]
        norm_j = x_j.norm(dim=-1, keepdim=True) + eps # [num_edges, 1]
        attention = cosine_sim / (norm_i * norm_j) # [num_edges, 1]
        # attention现在在[-1, 1]之间。我们可以用softmax使其归一化,但余弦相似度可能为负。
        # 更常见的做法是使用LeakyReLU(相似度)后再softmax。这里为了简化,我们取绝对值并加个偏置确保为正。
        attention = torch.abs(attention) + 0.1
        # 2. 对每个目标节点的所有入边注意力进行softmax归一化
        # edge_index_i指定了每条边对应的目标节点。我们需要按目标节点分组做softmax。
        attention = softmax(attention, edge_index_i) # [num_edges, 1]
        # 3. 构建加权消息:注意力权重 * 源节点特征
        return attention * x_j

这里有几个关键点:

  1. 计算相似度:我们使用了余弦相似度。在实际的GAT中,使用的是学习得到的a向量和LeakyReLU。
  2. 归一化:使用torch_geometric.utils.softmax函数。这个函数非常关键,它能根据edge_index_i(目标节点索引)对注意力分数进行分组softmax,确保每个目标节点所有入边的注意力权重之和为1。这是实现注意力机制的核心步骤。
  3. 返回消息:最终返回的是归一化后的注意力权重与源节点特征x_j的乘积。

4.3 聚合与更新

由于我们在message中已经完成了加权(attention * x_j),并且初始化时指定了aggr='add',所以aggregate函数会自动对这些加权消息按目标节点进行求和。这正是我们需要的:h_i' = Σ α_ij * W * h_j。

update函数接收这个求和后的结果。在我们的forward中,我们在propagate之后才应用了F.relu。我们也可以选择在update里应用激活函数:

    def update(self, aggr_out):
        # aggr_out: aggregate函数的输出,形状 [num_nodes, out_channels]
        # 在这里应用非线性激活
        return F.relu(aggr_out)

然后修改forward,去掉最后的F.relu(out),直接返回propagate的结果。两种方式都是可以的,取决于你的设计习惯。

4.4 完整代码与测试

将以上部分组合起来,并添加测试:

import torch
from torch_geometric.nn import MessagePassing
from torch_geometric.utils import softmax
import torch.nn.functional as F

class SimpleAttnConv(MessagePassing):
    def __init__(self, in_channels, out_channels):
        super().__init__(aggr='add')
        self.lin = torch.nn.Linear(in_channels, out_channels, bias=False)

    def forward(self, x, edge_index):
        x = self.lin(x)
        return self.propagate(edge_index, x=x)

    def message(self, x_i, x_j, edge_index_i):
        # 计算余弦相似度注意力
        eps = 1e-12
        cosine_sim = (x_i * x_j).sum(dim=-1, keepdim=True)
        norm_i = x_i.norm(dim=-1, keepdim=True) + eps
        norm_j = x_j.norm(dim=-1, keepdim=True) + eps
        attention = cosine_sim / (norm_i * norm_j)
        attention = torch.abs(attention) + 0.1 # 简单处理为正值
        # 按目标节点进行softmax归一化
        attention = softmax(attention, edge_index_i)
        # 返回加权消息
        return attention * x_j

    def update(self, aggr_out):
        return F.relu(aggr_out)

# 测试
if __name__ == "__main__":
    conv = SimpleAttnConv(in_channels=16, out_channels=8)
    x = torch.randn(5, 16) # 5个节点,16维特征
    edge_index = torch.tensor([[0, 0, 1, 1, 2, 2, 3, 4],
                               [1, 2, 0, 2, 0, 1, 4, 3]], dtype=torch.long) # 8条边
    out = conv(x, edge_index)
    print("输出形状:", out.shape) # [5, 8]
    print("前两个节点的输出:\n", out[:2])

运行这个代码,你就得到了一个具有注意力机制的消息传递层!虽然这个注意力机制比较简单,但它完整走通了自定义层的所有步骤:在message中计算动态权重并生成消息,利用内置的add聚合,在update中应用激活函数。

5. 集成到完整模型与调试技巧

自定义层写好了,怎么把它用起来呢?和PyG中其他层一样,把它放到你的torch.nn.Module模型里就行了。

5.1 构建一个简单的两层GNN模型

假设我们用上面实现的SimpleAttnConv层来构建一个节点分类模型:

class SimpleAttnGNN(torch.nn.Module):
    def __init__(self, num_features, hidden_dim, num_classes):
        super().__init__()
        self.conv1 = SimpleAttnConv(num_features, hidden_dim)
        self.conv2 = SimpleAttnConv(hidden_dim, num_classes)
        # 可以添加dropout、批归一化等

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = F.relu(self.conv1(x, edge_index))
        x = F.dropout(x, training=self.training, p=0.5)
        x = self.conv2(x, edge_index) # 最后一层通常不加激活函数,用于logits
        return F.log_softmax(x, dim=1)

看,和用GCNConv没什么区别!你可以像训练任何PyTorch模型一样训练它。

5.2 调试与验证:确保你的层行为正确

自定义层最容易出错的地方是张量形状和对齐。这里分享几个我常用的调试技巧:

  1. 从小数据开始:用3-5个节点,手工计算一遍预期的输出,然后用你的层跑一遍,对比结果。就像我们上面测试代码做的那样。
  2. 打印中间形状:在message、aggregate、update函数的开头打印关键张量的形状。确保x_i、x_j、你计算的注意力权重、返回的消息等形状都符合预期。
    def message(self, x_i, x_j, edge_index_i):
        print(f"x_i shape: {x_i.shape}") # 应为 [num_edges, out_channels]
        print(f"x_j shape: {x_j.shape}")
        # ... 其余计算
    
  3. 检查梯度:确保你的层是可微的,能够进行反向传播。用一个简单的输入和输出创建损失,调用.backward(),检查模型参数的.grad属性是否不为None。
  4. 利用PyG工具函数:torch_geometric.utils模块有很多好用的函数,比如我们用的softmax,还有scatter、degree等。熟悉它们能大大简化你的代码。
  5. 理解edge_index的方向:始终清楚你的flow设置是source_to_target还是target_to_source。这决定了_i和_j的映射关系。画一个小图,标出几条边,手动验证一下。

踩过几次坑之后,我最大的体会是:耐心和分解问题。不要试图一口气实现一个复杂的层。先实现最基础的版本(比如只做线性变换和求和),确保能跑通。然后一步一步添加功能,比如加入边权重、加入注意力计算。每加一步都进行测试。这样,当出现错误时,你就能很快定位到是新增的哪部分代码出了问题。

自定义消息传递层是深入理解GNN和进行模型创新的关键一步。它打破了“黑箱”,让你能自由地实验各种新颖的图学习思想。希望这篇从需求出发,一步步推导实现的过程,能帮你扫清障碍,自信地打造属于你自己的GNN层。当你第一次看到自己设计的层在任务上取得不错的效果时,那种成就感是非常棒的。

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

相关推荐

PyG 2.x 消息传递机制实战:从 GCN 到 EdgeConv 的 3 种自定义层实现

本文深入解析PyG 2.x中的消息传递机制,通过实战代码演示如何从零实现GCN、GraphSAGE和EdgeConv三种经典图神经网络层。内容涵盖PyG核心设计理念、消息传递范式数学原理,以及不同图神经网络层的实现细节与适用场景对比,为开发者提供自定义GNN层的完整技术指南。

weixin_27372101的博客 354

PyG教程(6):自定义消息传递网络

在上篇文章中主要介绍了GNN的消息传递机制,在PyG中提供了一个消息传递基类,它实现了消息传递的自动处理,继承该类就可以简单方便的构建自己的消息传播GNN。本文的主要内容包括:类剖析、继承实现GAT。...

LW的技术小筑 5274

06.消息传递网络

本文摘要: PyTorch Geometric中的MessagePassing基类简化了图神经网络(GNN)的实现,用户只需定义消息函数(message)、更新函数(update)和聚合方案(aggr)。文章以GCN和EdgeConv为例,展示了如何使用该基类实现消息传递机制。GCN层通过添加自环、线性变换、归一化和聚合来更新节点特征;EdgeConv则利用节点间特征差异和MLP计算边信息,采用max聚合。两种实现都继承MessagePassing类,分别使用add和max聚合方式,并通过propagate

kaiaaaa的博客 1401

PyG实战:从零构建消息传递层,打造专属GNN模型

本文深入解析PyG中MessagePassing基类的工作原理,通过拆解消息构造、聚合与更新三大步骤,指导读者从零构建自定义图神经网络层。针对异构图、带边特征等复杂场景,提供了HeteroRGCNConv和EdgeGatedGATConv等实战案例,帮助开发者打造专属的GNN模型,提升处理非标准图数据的能力。

play7的博客 429

图神经网络实战:利用DGL/PyG构建分子性质预测模型

分子可表示为图GVEG = (V, E)GVE节点集VVV:原子(每个节点包含原子类型、电荷等特征)边集EEE:化学键(键类型、键长等特征)邻接矩阵AAA:描述原子间连接关系。

datacanvas2426的博客 1390

pyg-创建消息传递网络

比如:edge = [[1 2 3], pos :[[0 0] , [1 1] [ 2 2 ]]首先forward输入的是x 可以当作是点云数据,edage_index表示边数据[2 ,下标]def message(self, x_i, x_j): x_i, x_j是什么呢?通过[x_i, x_j - x_i]->[ [ [ 0 0 ], [-1 -1]首先看形状 E 是边个数 in_channels是维度 我猜应该是点的坐标。message就是这一个公式的实现。

zpc17875305019的博客 978

PYG图卷积中的消息传递

图卷积网络中的消息传递,在PyG中实现。

m0_52647764的博客 1002

Pytorch实现GCN(基于Message Passing消息传递机制实现)

本专栏整理了《图神经网络代码实战》,内包含了不同图神经网络的相关代码实现(PyG以及自实现),理论与实践相结合,如GCN、GAT、GraphSAGE等经典图网络,每一个代码实例都附带有完整的代码。

优快云 精品推荐 6033

【PyG 教程】PyG 自定义构造 GNN

文章作者:梦家 个人站点:dreamhomes.top 原文地址:https://dreamhomes.github.io/posts/202005191115.html 公众号ID:DreamHub 基于 PyG 构造消息传递网络 图上的卷积操作主要包含两部分:节点消息传递与消息聚集。假设 xi(k−1)∈RF\mathbf{x}_i^{(k-1)} \in \mathbb{R}^{F}xi(k−1)​∈RF 表示k−1k-1k−1层节点的特征,ej,i∈RD\mathbf{e}_{j, i} \in.

梦家の博客 1887

DSP28335做FFT傅里叶变换

1. 看了一下例程,居然没有FFT的例程,难道这个DSP28335不能做FFT吗?对了C2000系列是有C2000 ware这个库的。方便很多,不过目前不确定在C5000上运行的FFT能直接迁移到DSP28335上行不?测试了一下,是可以的,因为都是用的math.h,下面的一些正弦函数基本一样的 2. 硬件简介,其中DSP28335和TLV320AIC23B之间使用I2C接口进行寄存器配置,...

weixin_30390075的博客 3333

rk3588 Android HDMI IN热插拔解决

1、公司在使用 别的厂商的板卡遇到一个问题,开机我们的app自启就会闪退,后来定位发现是camera 的open出错了,这个问题的出现是因为没有插HDMI IN输入的问题导致的,所以需要对HDMI IN的热插拔进行检测,后面我把这个问题也顺利解决了。下面是我的尝试和使用的解决办法。3、话不多说,我用的是读取系统文件实现的,但是这个方法,需要有status文件的系统读权限,可以修改设备下的/vendor/etc/init/hw/init.rk3588.rc文件修改的权限,这个问题交给自己或者厂家协商解决。

qq_54089476的博客 1922

消息传递神经网络(pyG实现GCN层)

消息传递神经网络一、引言二、消息传递范式介绍三、消息传递的实现(pyG)1、MessagePassing基类2、继承MessagePassing实现GCNConv 一、引言 为节点生成节点表征是图计算任务成功的关键,神经网络的生成节点表征的操作叫做节点嵌入(node embeddi ng) 二、消息传递范式介绍 基于消息传递范式的生成节点表征的过程: 我们从左往右来看此图。图的左边是我们输入的整张图(INPUT GRAPH),由ABCDEFG六个节点组成,现在目标是得到更新之后A节点(target no

qq_42766639的博客 1933

Zynq远程更新程序实战:从emmc到flash的完整方案解析

本文详细解析了Zynq远程更新程序的完整方案,重点探讨了从emmc到flash的实战操作。通过硬件连接限制破解、emmc配置技巧、flash擦写策略优化等关键技术点,提供了可靠的远程更新解决方案,特别适合需要频繁更新boot.bin的应用场景。

weixin_29163797的博客 180

PyG实战:用自定义MessagePassing为异构图构建一个简单的推荐系统消息传递层

本文详细介绍了如何使用PyTorch Geometric(PyG)的MessagePassing机制为异构推荐系统构建自定义消息传递层。通过分析用户-商品二分图的特性,展示了如何设计方向控制、类型感知和边过滤的消息传递机制,并提供了完整的代码实现和优化技巧,帮助开发者高效处理推荐系统中的异构关系。

weixin_33686714的博客 352

基于ROS2 Humble与Livox Mid-360的双雷达点云融合实战解析

本文详细解析了基于ROS2 Humble与Livox Mid-360的双雷达点云融合实战方案。从环境搭建、驱动安装、双雷达配置、外参标定、时间同步到点云融合核心实现,全面介绍了技术要点与避坑指南,并提供了工程化部署与性能优化建议,助力开发者高效实现高精度点云合成应用。

ss78901的博客 1095

MATLAB机械臂轨迹规划:在关节空间中生成多项式轨迹以及 jtraj函数(内容超详细讲解)

matlab机器人仿真,关节空间多项式轨迹生成

qq_40969179的博客 1万+

【GNN】第三章 消息传递范式与PyG的MessagePassing基类

1 消息传递范式 消息传递范式是一种聚合邻接节点信息来更新中心节点信息的范式,它将卷积算子推广到了不规则数据领域,实现了图与神经网络的连接 消息传递神经网络(MPNN)是一种框架,其前向传递有两个阶段:消息传递阶段(Message Passing)、读出阶段(Readout),这里先介绍消息传递阶段 1.1 消息传递的三个函数 三个函数分为: 各边要传递的消息的创建 ϕ\phiϕ、消息聚合 □\square□ 、节点表征的更新 γ\gammaγ 三个步骤 对三个函数的要求: 要求上述三个函数均可微

m0_59247846的博客 1645

AD9361 Fast Lock实战:Python脚本自动生成Profile寄存器配置(附完整代码)

本文详细介绍了利用Python脚本实现AD9361 Fast Lock Profile寄存器自动化配置的实战方案。通过解析频率合成公式、VCO约束及查表机制,脚本能根据目标频率一键生成完整的16进制寄存器序列,大幅提升射频系统开发中多频点切换的效率和准确性,并支持CSV、JSON、C头文件等多种输出格式,便于与FPGA/嵌入式系统集成。

weixin_29194693的博客 475

PyG教程:MessagePassing基类

理解PyG中的基类MessagePassing对于MPNN的实现原理,这对于我们利用PyG实现自己的GNN至关重要。

???? 1446

Windows Pychram部署Unet++过程

windows系统 在pycharm平台上配置并跑通Unet网络 这里我用的是B站课程里的资源《唐宇迪Unet图像分割语义分割实战》

ArcGis_Niu的博客 803

SAP Gateway 中事务码 /IWFND/MAINT_SERVICE 的用法介绍

本文系统梳理了SAP Gateway中/IWFND/MAINT_SERVICE事务码的核心功能与运维实践。作为OData服务管理中樞,它支持服务注册激活、ICF节点配置、系统别名绑定、批量处理等关键操作。文章详解了服务目录、ICF节点、系统别名的配置要点,提供了批量激活、缓存清理、性能监控等实用技巧,并针对常见陷阱(如传输配置、删除残留)给出解决方案。通过制造业批量激活、零售业OAuth集成等案例,展示了事务码在企业级应用中的实际价值,为SAP Gateway运维提供了一套完整的治理清单。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 314

PyG的MessagePassing基类中self.propagate函数的消息传递机制

前面提到,message函数对应着邻居信息的变换,这里假设对邻居信息的变换具体指对邻居的信号乘以2,则直接返回2*x_j即可,即。,其分别对应着1 2 0 0 0 1 2号结点(edge_index中的第2行),即所有尾结点的图信号。,其分别对应着0 0 1 2 0 1 2号结点(edge_index中的第1行),即所有头结点的图信号。,对其余所有结点进行相同的操作,就完成了aggregate函数的任务:邻居信息的聚合。,找到1号结点所有的邻居结点,即x_j的第3行和第6行,然后加和,结果为。

m0_52438642的博客 1936

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

昇腾AI4S图机器学习:DGL消息传递接口的PyG替换

DGL (Deep Graph Learning) 和 PyG (Pytorch Geometric) 是两个主流的图神经网络库,它们在API设计和底层实现上有一定差异,在不同场景下,研究人员会使用不同的依赖库,昇腾NPU对PyG图机器学习库的支持亲和度更高,因此有些时候需要做DGL接口的PyG替换。SE3Transformer在RFdiffusion蛋白质设计模型中()作为核心组件,负责处理蛋白质结构的几何信息。其架构基于图神经网络,通过SE(3)等变性实现对三维旋转和平移的不变性特征提取。

Splendid2025的博客 886

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

比较DGL和PyG中的消息传递机制

回到刚刚的这张图,我们可以看到,节点1接收到来自节点0,2,3的消息,使用加法聚合,最后得到的结果应该为8,节点3收到了来自节点0的消息,结果应该为1,同理,节点0,2聚合后的结果应该为0。定义如何聚合收到的消息。为了方便大家进一步理解,这里画了一个简单的图,我们用数字0,1,2,3去编号每个节点,X0~X5分别代表每个节点的特征。在化学上的一些应用,根据原子的性质和分子结构,预测了13种物质的化学性质。构造函数,用于初始化消息传递的聚合方式,例如 add(加和)、mean(平均)、max(最大值)等。

qq_49456814的博客 3044

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

PyG图神经网络核心:消息传递机制与实战模型构建

图神经网络(GNN)是处理社交网络、推荐系统等图结构数据的核心技术,其核心原理在于通过消息传递机制聚合邻居信息来更新节点表示。这一范式将图这种非欧几里得数据的高效计算抽象为消息生成、聚合与更新三个步骤,极大地简化了开发流程并提升了计算性能。PyTorch Geometric(PyG)作为主流框架,其价值正是通过高度优化的消息传递接口,让开发者能专注于模型设计与业务逻辑,而非底层张量操作。在工程实践中,基于消息传递可构建从节点分类到图分类的各类模型,并需结合残差连接、归一化及池化等技术应对过平滑、大规模图处理

weixin_33892359的博客 404
上一篇: MOSFET参数实战指南:从数据手册到设计选型
下一篇: 通过Termius实现iOS设备远程管理Windows 11的SSH实战指南
bread
博客等级 码龄26年 60粉丝 1210原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值