EGATConv

class dgl.nn.pytorch.conv.EGATConv(in_node_feats, in_edge_feats, out_node_feats, out_edge_feats, num_heads, bias=True)[source]

Bases: Module

处理来自Rossmann-Toolbox的边缘特征的图注意力层（见补充数据）

区别在于如何获得未归一化的注意力分数 \(e_{ij}\)：

\[ \begin{align}\begin{aligned}e_{ij} &= \vec{F} (f_{ij}^{\prime})\\f_{ij}^{\prime} &= \mathrm{LeakyReLU}\left(A [ h_{i} \| f_{ij} \| h_{j}]\right)\end{aligned}\end{align} \]

其中 \(f_{ij}^{\prime}\) 是边特征，\(\mathrm{A}\) 是权重矩阵， \(\vec{F}\) 是权重向量。之后，生成的节点特征 \(h_{i}^{\prime}\) 会以与常规 GAT 相同的方式更新。

Parameters:

in_node_feats (int, 或 pair 的 ints) – 输入特征大小；即，\(h_{i}\) 的维度数。 EGATConv 可以应用于同构图和单向二分图。如果该层要应用于单向二分图，in_feats 指定源节点和目标节点的输入特征大小。如果给定一个标量，源节点和目标节点的特征大小将取相同的值。
in_edge_feats (int) – 输入边的特征大小 \(f_{ij}\)。
out_node_feats (int) – 输出节点特征大小。
out_edge_feats (int) – 输出边的特征大小 \(f_{ij}^{\prime}\).
num_heads (int) – 注意力头的数量。
偏差 (bool, 可选) – 如果为True，则向\(f_{ij}^{\prime}\)添加偏差项。默认值：True。

示例

>>> import dgl
>>> import torch as th
>>> from dgl.nn import EGATConv

>>> # Case 1: Homogeneous graph
>>> num_nodes, num_edges = 8, 30
>>> # generate a graph
>>> graph = dgl.rand_graph(num_nodes,num_edges)
>>> node_feats = th.rand((num_nodes, 20))
>>> edge_feats = th.rand((num_edges, 12))
>>> egat = EGATConv(in_node_feats=20,
...                 in_edge_feats=12,
...                 out_node_feats=15,
...                 out_edge_feats=10,
...                 num_heads=3)
>>> #forward pass
>>> new_node_feats, new_edge_feats = egat(graph, node_feats, edge_feats)
>>> new_node_feats.shape, new_edge_feats.shape
torch.Size([8, 3, 15]) torch.Size([30, 3, 10])

>>> # Case 2: Unidirectional bipartite graph
>>> u = [0, 1, 0, 0, 1]
>>> v = [0, 1, 2, 3, 2]
>>> g = dgl.heterograph({('A', 'r', 'B'): (u, v)})
>>> u_feat = th.tensor(np.random.rand(2, 25).astype(np.float32))
>>> v_feat = th.tensor(np.random.rand(4, 30).astype(np.float32))
>>> nfeats = (u_feat,v_feat)
>>> efeats = th.tensor(np.random.rand(5, 15).astype(np.float32))
>>> in_node_feats = (25,30)
>>> in_edge_feats = 15
>>> out_node_feats = 10
>>> out_edge_feats = 5
>>> num_heads = 3
>>> egat_model =  EGATConv(in_node_feats,
...                        in_edge_feats,
...                        out_node_feats,
...                        out_edge_feats,
...                        num_heads,
...                        bias=True)
>>> #forward pass
>>> new_node_feats,
>>> new_edge_feats,
>>> attentions = egat_model(g, nfeats, efeats, get_attention=True)
>>> new_node_feats.shape, new_edge_feats.shape, attentions.shape
(torch.Size([4, 3, 10]), torch.Size([5, 3, 5]), torch.Size([5, 3, 1]))

forward(graph, nfeats, efeats, edge_weight=None, get_attention=False)[source]

计算新的节点和边特征。

Parameters:

graph (DGLGraph) – The graph.
nfeat (torch.Tensor 或 pair 的 torch.Tensor) –
如果给定一个 torch.Tensor，则输入特征的形状为 \((N, D_{in})\) 其中：

\(D_{in}\) 是输入节点特征的大小， \(N\) 是节点的数量。

如果给定一对 torch.Tensor，则该对必须包含两个形状为
\((N_{in}, D_{in_{src}})\) 和 \((N_{out}, D_{in_{dst}})\) 的张量。
efeats (torch.Tensor) –
输入的边特征，形状为 \((E, F_{in})\) 其中：

\(F_{in}\) 是输入节点特征的大小， \(E\) 是边的数量。
edge_weight (torch.Tensor, optional) – 一个1D张量的边权重值。形状：\((|E|,)\)。
get_attention (bool, optional) – 是否返回注意力值。默认为 False。

Returns:

一对 torch.Tensor – 节点输出特征后跟边输出特征。节点输出特征的形状为 \((N, H, D_{out})\) 边输出特征的形状为 \((F, H, F_{out})\) 其中：

\(H\) 是头数， \(D_{out}\) 是输出节点特征的大小， \(F_{out}\) 是输出边特征的大小。
torch.Tensor, 可选 – 形状为 \((E, H, 1)\) 的注意力值。仅在 get_attention 为 True 时返回。

reset_parameters()[source]: 重新初始化可学习的参数。