DGL官方教程--API--dgl.readout

参考：https://docs.dgl.ai/en/latest/api/python/readout.html

PS：新手，很多机翻，建议多看例子

图读出

PS：直接看例子

sum_nodes(graph, feat[, weight])	Sums all the values of node field feat in graph, optionally multiplies the field by a scalar node field weight.
sum_edges(graph, feat[, weight])	Sums all the values of edge field feat in graph, optionally multiplies the field by a scalar edge field weight.
mean_nodes(graph, feat[, weight])	Averages all the values of node field feat in graph, optionally multiplies the field by a scalar node field weight.
mean_edges(graph, feat[, weight])	Averages all the values of edge field feat in graph, optionally multiplies the field by a scalar edge field weight.
max_nodes(graph, feat)	Take elementwise maximum over all the values of node field feat in graph
max_edges(graph, feat)	Take elementwise maximum over all the values of edge field feat in graph
topk_nodes(graph, feat, k[, descending, idx])	Return graph-wise top-k node features of field feat in graph ranked by keys at given index idx.
topk_edges(graph, feat, k[, descending, idx])	Return graph-wise top-k edge features of field feat in graph ranked by keys at given index idx.
softmax_nodes(graph, feat)	Apply batch-wise graph-level softmax over all the values of node field feat in graph.
softmax_edges(graph, feat)	Apply batch-wise graph-level softmax over all the values of edge field feat in graph.
broadcast_nodes(graph, feat_data)	Broadcast feat_data to all nodes in graph, and return a tensor of node features.
broadcast_edges(graph, feat_data)	Broadcast feat_data to all edges in graph, and return a tensor of edge features.

 

dgl.sum_nodes 

dgl.sum_nodes(graph,feat,weight = None)

参数：	graph (DGLGraph.)–图形。 feat (str) –特征字段。 weight(str, optional)–权重字段。如果为None，则不执行加权，否则，使用field字段加权每个节点特征。求和。图中的权重特征应该是形状[graph.number_of_nodes(),1]的张量
返回值：	张量的总和。
返回类型：	张量

笔记

返回具有额外第一维度的堆叠张量，该维度的大小等于输入图的批处理大小。堆叠张量的第i行包含批处理图中第i个图的读取结果。如果图没有节点，则在相应的行处返回形状相同的零张量。PS：建议看例子

例子

>>> import dgl
>>> import torch as th

创建两个DGLGraph对象并初始化其节点特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(2)
>>> g1.ndata['h'] = th.tensor([[1.], [2.]])
>>> g1.ndata['w'] = th.tensor([[3.], [6.]])

 

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(3)
>>> g2.ndata['h'] = th.tensor([[1.], [2.], [3.]])

多点批处理，点特征h进行对应求和，无加权。

>>> bg = dgl.batch([g1, g2], node_attrs='h')
>>> dgl.sum_nodes(bg, 'h')
tensor([[3.],   # 1 + 2
        [6.]])  # 1 + 2 + 3

单图的点进行计算，权重w与点特征h进行加权求和。

>>> dgl.sum_nodes(g1, 'h', 'w')
tensor([[15.]]) # 1 * 3 + 2 * 6

 

 

dgl.sum_edges 

dgl.sum_edges(graph,feat,weight = None)

参数：	graph（DGLGraph）–图形。 feat（str）–特征字段。 weight（str，可选）–权重字段。如果为None，则不执行任何加权，否则，使用field加权每个边缘特征feat。求和。关联的权重特征graph 应该是形状的张量。[graph.number_of_edges(), 1]
返回值：	张量的总和。
返回类型：	张量

笔记

返回具有额外第一维度的堆叠张量，该维度的大小等于输入图的批处理大小。堆叠张量的第i行包含批处理图中第i个图的读取结果。如果图没有边，则在相应的行处返回形状相同的零张量。PS：建议看例子

例子

>>> import dgl
>>> import torch as th

创建两个DGLGraph对象并初始化其边缘特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(2)
>>> g1.add_edges([0, 1], [1, 0])
>>> g1.edata['h'] = th.tensor([[1.], [2.]])
>>> g1.edata['w'] = th.tensor([[3.], [6.]])

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(3)
>>> g2.add_edges([0, 1, 2], [1, 2, 0])
>>> g2.edata['h'] = th.tensor([[1.], [2.], [3.]])

多图批处理，边缘特征h进行对应求和，无加权。

>>> bg = dgl.batch([g1, g2], edge_attrs='h')
>>> dgl.sum_edges(bg, 'h')
tensor([[3.],   # 1 + 2
        [6.]])  # 1 + 2 + 3

单图的边进行计算，权重w与边缘特征h进行加权求和。

>>> dgl.sum_edges(g1, 'h', 'w')
tensor([[15.]]) # 1 * 3 + 2 * 6

 

 

dgl.mean_nodes 

dgl.mean_nodes(graph,feat,weight = None)

参数：	graph（DGLGraph）–图形。 feat（str）–特征字段。 weight（str，可选）–重量字段。如果为None，则不执行加权，否则，使用field加权每个节点特征feat。用于计算平均值。关联的权重特征graph 应该是形状的张量。[graph.number_of_nodes(), 1]
返回值：	平均张量。
返回类型：	张量

笔记

返回具有额外第一维度的堆叠张量，该维度的大小等于输入图的批处理大小。堆叠张量的第i行包含批处理中第i个图的读取结果。如果图没有节点，则在相应的行处返回形状相同的零张量。PS：建议看例子

例子

>>> import dgl
>>> import torch as th

创建两个DGLGraph对象并初始化其节点特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(2)
>>> g1.ndata['h'] = th.tensor([[1.], [2.]])
>>> g1.ndata['w'] = th.tensor([[3.], [6.]])

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(3)
>>> g2.ndata['h'] = th.tensor([[1.], [2.], [3.]])

多图批处理，点特征h进行对应求和再取平均，无加权。

>>> bg = dgl.batch([g1, g2], node_attrs='h')
>>> dgl.mean_nodes(bg, 'h')
tensor([[1.5000],    # (1 + 2) / 2
        [2.0000]])   # (1 + 2 + 3) / 3

单图的点进行计算，权重w与点特征h，进行如下公式进行计算。

>>> dgl.mean_nodes(g1, 'h', 'w') # h1 * (w1 / (w1 + w2)) + h2 * (w2 / (w1 + w2))
tensor([[1.6667]])               # 1 * (3 / (3 + 6)) + 2 * (6 / (3 + 6))

 

 

dgl.mean_edges 

dgl.mean_edges(graph,feat,weight = None)

平均值所有边缘字段的值feat中graph，任选地乘以所述场由标量边缘场weight。

参数：	graph（DGLGraph）–图形。 feat（str）–特征字段。 weight（可选，str）–重量字段。如果为None，则不执行任何加权，否则，使用field加权每个边缘特征feat。用于计算平均值。关联的权重特征graph 应该是形状的张量。[graph.number_of_edges(), 1]
返回值：	平均张量。
返回类型：	张量

笔记

返回具有额外第一维度的堆叠张量，该维度的大小等于输入图的批处理大小。堆叠张量的第i行包含批处理图中第i个图的读取结果。如果图没有边，则在相应的行处返回形状相同的零张量。

例子

>>> import dgl
>>> import torch as th

创建两个DGLGraph对象并初始化其边缘特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(2)
>>> g1.add_edges([0, 1], [1, 0])
>>> g1.edata['h'] = th.tensor([[1.], [2.]])
>>> g1.edata['w'] = th.tensor([[3.], [6.]])

 

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(3)
>>> g2.add_edges([0, 1, 2], [1, 2, 0])
>>> g2.edata['h'] = th.tensor([[1.], [2.], [3.]])

多图批处理，边特征h进行对应求和再取平均，无加权。

>>> bg = dgl.batch([g1, g2], edge_attrs='h')
>>> dgl.mean_edges(bg, 'h')
tensor([[1.5000],    # (1 + 2) / 2
        [2.0000]])   # (1 + 2 + 3) / 3

单图的边进行计算，权重w与边缘特征h，进行如下公式进行计算。

>>> dgl.mean_edges(g1, 'h', 'w') # h1 * (w1 / (w1 + w2)) + h2 * (w2 / (w1 + w2))
tensor([[1.6667]])               # 1 * (3 / (3 + 6)) + 2 * (6 / (3 + 6))

 

 

dgl.max_nodes 

dgl.max_nodes(graph,feat)

采取的elementwise最大在所有节点字段的值 feat在graph

参数：	graph（DGLGraph）–图形。 feat（str）–特征字段。
返回值：	获得张量。
返回类型：	张量

例子

>>> import dgl
>>> import torch as th

创建两个DGLGraph对象并初始化其节点特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(2)
>>> g1.ndata['h'] = th.tensor([[1.], [2.]])

 

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(3)
>>> g2.ndata['h'] = th.tensor([[1.], [2.], [3.]])

多图批处理，各个图中点特征h进行取最大值操作

>>> bg = dgl.batch([g1, g2], node_attrs='h')
>>> dgl.max_nodes(bg, 'h')
tensor([[2.],    # max(1, 2)
        [3.]])   # max(1, 2, 3)

单图处理，单个图中点特征h进行取最大值操作

>>> dgl.max_nodes(g1, 'h')
tensor([[2.]])

 

 

 

dgl.max_edges 

dgl.max_edges(graph,feat)

采取的elementwise最大在所有边缘字段的值 feat在graph

参数：	graph（DGLGraph）–图形。 feat（str）–特征字段。
返回值：	获得张量。
返回类型：	张量

例子

>>> import dgl
>>> import torch as th

创建两个DGLGraph对象并初始化其边缘特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(2)
>>> g1.add_edges([0, 1], [1, 0])
>>> g1.edata['h'] = th.tensor([[1.], [2.]])

 

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(3)
>>> g2.add_edges([0, 1, 2], [1, 2, 0])
>>> g2.edata['h'] = th.tensor([[1.], [2.], [3.]])

多图批处理，各个图中边特征h进行取最大值操作

>>> bg = dgl.batch([g1, g2], edge_attrs='h')
>>> dgl.max_edges(bg, 'h')
tensor([[2.],    # max(1, 2)
        [3.]])   # max(1, 2, 3)

单图处理，单个图中边特征h进行取最大值操作

>>> dgl.max_edges(g1, 'h')
tensor([[2.]])

 

 

 

dgl.topk_nodes 

dgl.topk_nodes(graph,feat,k,Descending = True,idx = None)

返回按给定索引的键对字段feat进行 graph排序的图形方式的top-k节点特征idx。如果attr: descending设置为False，则返回k个最小的元素。

如果idx设置为None，该函数将返回所有索引的top-k值，这等效于调用torch.topk(graph.ndata[feat],dim=0) 输入图的每个示例。

参数：	graph（DGLGraph）–图形。 feat（str）–特征字段。 k（int）–“前k个”中的k descending（bool）–控制是否返回最大或最小元素。 idx（int或None，默认为None）–我们feat在其上排名的键的索引，如果设置为None，则对整个键进行排序feat。
返回值：	第一个张量返回输入图的每个单个图的top-k节点特征：具有形状的张量 (B,K,D)(B,K,D) 将返回，在那里 BB是输入图的批量大小。第二张量返回输入图的每个图的前k个节点索引：具有形状的张量(B,K)‘(:math:‘(B,K,D)(B,K)‘(:math:‘(B,K,D) 如果idx设置为None），则返回 BB 是输入图的批量大小。
返回类型：	张量元组

例子

>>> import dgl
>>> import torch as th

创建两个DGLGraph对象并初始化其节点特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(4)
>>> g1.ndata['h'] = th.rand(4, 5)
>>> g1.ndata['h']
tensor([[0.9403, 0.8546, 0.6056, 0.6419, 0.3814],
        [0.4957, 0.6841, 0.8564, 0.9122, 0.2969],
        [0.0328, 0.8874, 0.7872, 0.7092, 0.7816],
        [0.4205, 0.5675, 0.4066, 0.7049, 0.7705]])

 

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(5)
>>> g2.ndata['h'] = th.rand(5, 5)
>>> g2.ndata['h']
tensor([[0.6124, 0.9622, 0.3908, 0.1628, 0.8566],
        [0.8544, 0.6563, 0.2615, 0.2268, 0.7685],
        [0.3503, 0.8374, 0.1224, 0.5029, 0.0683],
        [0.0431, 0.0781, 0.8805, 0.7368, 0.7176],
        [0.0936, 0.0409, 0.2409, 0.9652, 0.7706]])

批处理图中点的top-k属性。

>>> bg=dgl.batch([g1,g2],node_attrs='h')
>>> dgl.topk_nodes(bg,'h',3)
tensor([[[0.9403, 0.8874, 0.8564, 0.9122, 0.7816],
          [0.4957, 0.8546, 0.7872, 0.7092, 0.7705],
          [0.4205, 0.6841, 0.6056, 0.7049, 0.3814]],
 
         [[0.8544, 0.9622, 0.8805, 0.9652, 0.8566],
          [0.6124, 0.8374, 0.3908, 0.7368, 0.7706],
          [0.3503, 0.6563, 0.2615, 0.5029, 0.7685]]]),
 tensor([[[0, 2, 1, 1, 2],
          [1, 0, 2, 2, 3],
          [3, 1, 0, 3, 0]],
 
         [[1, 0, 3, 4, 0],
          [0, 2, 0, 3, 4],
          [2, 1, 1, 2, 1]]])

批处理图中索引-1上点的top-k 属性。（用于SortPooling）

>>> dgl.topk_nodes(bg, 'h', 3, idx=-1)
(tensor([[[0.0328, 0.8874, 0.7872, 0.7092, 0.7816],
          [0.4205, 0.5675, 0.4066, 0.7049, 0.7705],
          [0.9403, 0.8546, 0.6056, 0.6419, 0.3814]],
 
         [[0.6124, 0.9622, 0.3908, 0.1628, 0.8566],
          [0.0936, 0.0409, 0.2409, 0.9652, 0.7706],
          [0.8544, 0.6563, 0.2615, 0.2268, 0.7685]]]), 
tensor([[2, 3, 0],
         [0, 4, 1]]))

单个图中点的top-k 属性。

>>> dgl.topk_nodes(g1, 'h', 3)
(tensor([[[0.5901, 0.8307, 0.9280, 0.8954, 0.7997],
         [0.5171, 0.6515, 0.9140, 0.7507, 0.5297],
         [0.0880, 0.6379, 0.4451, 0.6893, 0.5197]]]), 
tensor([[[1, 0, 1, 3, 1],
         [3, 2, 0, 2, 2],
         [2, 3, 2, 1, 3]]]))

 

 

 

dgl.topk_edges 

dgl.topk_edges（graph，feat，k，Descending = True，idx = None ）

场的返回图形明智的top-k边缘设有feat在 graph通过以给定的索引关键字排名idx。如果 descending设置为False，则返回k个最小的元素。

如果idx设置为None，该函数将返回所有索引的top-k值，这等效于调用 输入图的每个示例。torch.topk(graph.edata[feat], dim=0)

参数：	graph（DGLGraph）–图形。 feat（str）–特征字段。 k（int）–“ top-k”中的k。 降序（bool）–控制是否返回最大或最小元素。 idx（int或None，默认为None）–我们对键索引进行排序feat，如果设置为None，则对整个键进行排序feat。
返回值：	第一个张量返回输入图的每个图的top-k边缘特征：具有形状的张量 (B,K,D)(B,K,D) 将返回，在那里 BB是输入图的批量大小。第二张量返回输入图的每个图的top-k边索引：具有形状的张量(B,K)‘(:math:‘(B,K,D)(B,K)‘(:math:‘(B,K,D) 如果idx设置为None），则返回 BB 是输入图的批量大小。
返回类型：	张量元组

例子

>>> import dgl
>>> import torch as th

创建两个DGLGraph对象并初始化其边缘特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(4)
>>> g1.add_edges([0, 1, 2, 3], [1, 2, 3, 0])
>>> g1.edata['h'] = th.rand(4, 5)
>>> g1.edata['h']
tensor([[0.0297, 0.8307, 0.9140, 0.6702, 0.3346],
        [0.5901, 0.3030, 0.9280, 0.6893, 0.7997],
        [0.0880, 0.6515, 0.4451, 0.7507, 0.5297],
        [0.5171, 0.6379, 0.2695, 0.8954, 0.5197]])

 

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(5)
>>> g2.add_edges([0, 1, 2, 3, 4], [1, 2, 3, 4, 0])
>>> g2.edata['h'] = th.rand(5, 5)
>>> g2.edata['h']
tensor([[0.3168, 0.3174, 0.5303, 0.0804, 0.3808],
        [0.1323, 0.2766, 0.4318, 0.6114, 0.1458],
        [0.1752, 0.9105, 0.5692, 0.8489, 0.0539],
        [0.1931, 0.4954, 0.3455, 0.3934, 0.0857],
        [0.5065, 0.5182, 0.5418, 0.1520, 0.3872]])

h批处理图中的top-k over edge属性。

>>> bg = dgl.batch([g1, g2], edge_attrs='h')
>>> dgl.topk_edges(bg, 'h', 3)
(tensor([[[0.5901, 0.8307, 0.9280, 0.8954, 0.7997],
         [0.5171, 0.6515, 0.9140, 0.7507, 0.5297],
         [0.0880, 0.6379, 0.4451, 0.6893, 0.5197]],

 

[[0.5065，0.9105，0.5692，0.8489，0.3872]，

[0.3168，0.5182，0.5418，0.6114，0.3808]，[0.1931，0.4954，0.5303，0.3934，0.1458]]]）张量（[[[1，0，1，3，1]，[3，2，0， 2，2]，[2，3，2，1，3]]，

[[4，2，2，2，4]，

[0，4，4，1，0]，[3，3，0，3，1]]]））

h批处理图中沿索引-1的top-k over edge属性。（用于SortPooling）

>>> dgl.topk_edges(bg, 'h', 3, idx=-1)
(tensor([[[0.5901, 0.3030, 0.9280, 0.6893, 0.7997],
         [0.0880, 0.6515, 0.4451, 0.7507, 0.5297],
         [0.5171, 0.6379, 0.2695, 0.8954, 0.5197]],

 

[[0.5065，0.5182，0.5418，0.1520，0.3872]，

[0.3168，0.3174，0.5303，0.0804，0.3808]，[0.1323，0.2766，0.4318，0.6114，0.1458]]]，张量（[[1,2,3]，

[4，0，1]]）

h单个图形中的top-k over edge属性。

>>> dgl.topk_edges(g1, 'h', 3)
(tensor([[[0.5901, 0.8307, 0.9280, 0.8954, 0.7997],
         [0.5171, 0.6515, 0.9140, 0.7507, 0.5297],
         [0.0880, 0.6379, 0.4451, 0.6893, 0.5197]]]), tensor([[[1, 0, 1, 3, 1],
         [3, 2, 0, 2, 2],
         [2, 3, 2, 1, 3]]]))

 

 

 

dgl.softmax_nodes 

dgl.softmax_nodes(graph,feat)

应用分批图级别上添加Softmax节点场的所有值 feat在graph。

参数：	graph（DGLGraph）–图形。 feat（str）–特征字段。
返回值：	获得张量。
返回类型：	张量

例子

>>> import dgl
>>> import torch as th

创建两个DGLGraph对象并初始化其节点特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(2)
>>> g1.ndata['h'] = th.tensor([[1., 0.], [2., 0.]])

 

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(3)
>>> g2.ndata['h'] = th.tensor([[1., 0.], [2., 0.], [3., 0.]])

h批处理图中的节点上的Softmax属性。

>>> bg = dgl.batch([g1, g2], node_attrs='h')
>>> dgl.softmax_nodes(bg, 'h')
tensor([[0.2689, 0.5000], # [0.2689, 0.7311] = softmax([1., 2.])
        [0.7311, 0.5000], # [0.5000, 0.5000] = softmax([0., 0.])
        [0.0900, 0.3333], # [0.0900, 0.2447, 0.6652] = softmax([1., 2., 3.])
        [0.2447, 0.3333], # [0.3333, 0.3333, 0.3333] = softmax([0., 0., 0.])
        [0.6652, 0.3333]])

单个图中的节点上的Softmax属性。

>>> dgl.softmax_nodes(g1, 'h')
tensor([[0.2689, 0.5000],   # [0.2689, 0.7311] = softmax([1., 2.])
        [0.7311, 0.5000]]), # [0.5000, 0.5000] = softmax([0., 0.])

 

笔记

如果输入图的批处理大小大于一个，则将softmax应用于批处理图中的每个单个图。

 

dgl.softmax_edges 

dgl.softmax_edges（graph，feat ）[源代码]

应用分批图表级SOFTMAX超过边缘场的所有值 feat在graph。

参数：	graph（DGLGraph）–图形。 feat（str）–特征字段。
返回值：	获得张量。
返回类型：	张量

例子

>>> import dgl
>>> import torch as th

 

创建两个DGLGraph对象并初始化其边缘特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(2)
>>> g1.add_edges([0, 1], [1, 0])
>>> g1.edata['h'] = th.tensor([[1., 0.], [2., 0.]])

 

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(3)
>>> g2.add_edges([0, 1, 2], [1, 2, 0])
>>> g2.edata['h'] = th.tensor([[1., 0.], [2., 0.], [3., 0.]])

 

h批处理图中的Softmax over edge属性。

>>> bg = dgl.batch([g1, g2], edge_attrs='h')
>>> dgl.softmax_edges(bg, 'h')
tensor([[0.2689, 0.5000], # [0.2689, 0.7311] = softmax([1., 2.])
        [0.7311, 0.5000], # [0.5000, 0.5000] = softmax([0., 0.])
        [0.0900, 0.3333], # [0.0900, 0.2447, 0.6652] = softmax([1., 2., 3.])
        [0.2447, 0.3333], # [0.3333, 0.3333, 0.3333] = softmax([0., 0., 0.])
        [0.6652, 0.3333]])

 

h单个图形中的softmax over edge属性。

>>> dgl.softmax_edges(g1, 'h')
tensor([[0.2689, 0.5000],   # [0.2689, 0.7311] = softmax([1., 2.])
        [0.7311, 0.5000]]), # [0.5000, 0.5000] = softmax([0., 0.])

 

笔记

如果输入图的批处理大小大于1，则将softmax应用于批处理中的每个示例。

 

 

dgl.broadcast_nodes 

dgl.broadcast_nodes（graph，feat_data ）[源代码]

广播feat_data到中的所有节点graph，并返回节点特征的张量。

参数：	graph（DGLGraph）–图形。 feat_data（tensor）–要广播的功能。张量形状是(∗)(∗) 对于单个图形，以及 (B,∗)(B,∗) 用于批处理图。
返回值：	节点具有形状的张量 (N,∗)(N,∗)。
返回类型：	张量

例子

>>> import dgl
>>> import torch as th

 

创建两个DGLGraph对象并初始化其节点特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(2)

 

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(3)

 

>>> bg = dgl.batch([g1, g2])
>>> feat = th.rand(2, 5)
>>> feat
tensor([[0.4325, 0.7710, 0.5541, 0.0544, 0.9368],
        [0.2721, 0.4629, 0.7269, 0.0724, 0.1014]])

 

向批处理图中的所有节点广播功能，feat [i]被广播到该批处理的第i个示例中的节点。

>>> dgl.broadcast_nodes(bg, feat)
tensor([[0.4325, 0.7710, 0.5541, 0.0544, 0.9368],
        [0.4325, 0.7710, 0.5541, 0.0544, 0.9368],
        [0.2721, 0.4629, 0.7269, 0.0724, 0.1014],
        [0.2721, 0.4629, 0.7269, 0.0724, 0.1014],
        [0.2721, 0.4629, 0.7269, 0.0724, 0.1014]])

 

向批处理图中的所有节点广播功能。

>>> dgl.broadcast_nodes(g1, feat[0])
tensor([[0.4325, 0.7710, 0.5541, 0.0544, 0.9368],
        [0.4325, 0.7710, 0.5541, 0.0544, 0.9368]])

 

笔记

feat [i]被广播到批处理图中的第i个图中的节点。

 

dgl.broadcast_edges 

dgl.broadcast_edges（graph，feat_data ）[源代码]

广播feat_data到中的所有边缘graph，并返回边缘特征的张量。

参数：	graph（DGLGraph）–图形。 feat_data（tensor）–要广播的功能。张量形状是(∗)(∗) 对于单个图形，以及 (B,∗)(B,∗) 用于批处理图。
返回值：	边缘特征张量与形状 (E,∗)(E,∗)
返回类型：	张量

例子

>>> import dgl
>>> import torch as th

 

创建两个DGLGraph对象并初始化其边缘特征。

>>> g1 = dgl.DGLGraph()                           # Graph 1
>>> g1.add_nodes(2)
>>> g1.add_edges([0, 1], [1, 0])

 

>>> g2 = dgl.DGLGraph()                           # Graph 2
>>> g2.add_nodes(3)
>>> g2.add_edges([0, 1, 2], [1, 2, 0])

 

>>> bg = dgl.batch([g1, g2])
>>> feat = th.rand(2, 5)
>>> feat
tensor([[0.4325, 0.7710, 0.5541, 0.0544, 0.9368],
        [0.2721, 0.4629, 0.7269, 0.0724, 0.1014]])

 

将特征广播到批处理图中的所有边，feat [i]被广播到批处理中第i个示例的边。

>>> dgl.broadcast_edges(bg, feat)
tensor([[0.4325, 0.7710, 0.5541, 0.0544, 0.9368],
        [0.4325, 0.7710, 0.5541, 0.0544, 0.9368],
        [0.2721, 0.4629, 0.7269, 0.0724, 0.1014],
        [0.2721, 0.4629, 0.7269, 0.0724, 0.1014],
        [0.2721, 0.4629, 0.7269, 0.0724, 0.1014]])

 

向批处理图中的所有边广播功能。

>>> dgl.broadcast_edges(g1, feat[0])
tensor([[0.4325, 0.7710, 0.5541, 0.0544, 0.9368],
        [0.4325, 0.7710, 0.5541, 0.0544, 0.9368]])