图神经网络框架DGL教程-第1章：图

最新推荐文章于 2024-08-08 07:37:02 发布

huanghelouzi

最新推荐文章于 2024-08-08 07:37:02 发布

阅读量1.7k

点赞数 5

分类专栏： # DGL 图神经网络文章标签：图神经网络 DGL 图 GNN pytorch

原文链接：https://docs.dgl.ai/guide_cn/graph.html

版权

图神经网络同时被 2 个专栏收录

25 篇文章 20 订阅

订阅专栏

DGL

10 篇文章 14 订阅

订阅专栏

更多图神经网络和深度学习内容请关注：
在这里插入图片描述

第1章：图

图表示实体(节点)和它们的关系(边)，其中节点和边可以是有类型的 (例如，"用户" 和 "物品" 是两种不同类型的节点)。 DGL通过其核心数据结构 DGLGraph 提供了一个以图为中心的编程抽象。 DGLGraph 提供了接口以处理图的结构、节点/边的特征，以及使用这些组件可以执行的计算。

1.1 关于图的基本概念

图是用以表示实体及其关系的结构，记为 $G = (V, E)$ 。图由两个集合组成，一是节点的集合 $V$ ，一个是边的集合 $E$ 。在边集 $E$ 中，一条边 $(u, v)$ 连接一对节点 $u$ 和 $v$ ，表明两节点间存在关系。关系可以是无向的，如描述节点之间的对称关系；也可以是有向的，如描述非对称关系。例如，若用图对社交网络中人们的友谊关系进行建模，因为友谊是相互的，则边是无向的；若用图对Twitter用户的关注行为进行建模，则边是有向的。图可以是 有向的 或 无向的 ，这取决于图中边的方向性。

图可以是 加权的 或 未加权的 。在加权图中，每条边都与一个标量权重值相关联。例如，该权重可以表示长度或连接的强度。

图可以是 同构的 或是 异构的 。在同构图中，所有节点表示同一类型的实体，所有边表示同一类型的关系。例如，社交网络的图由表示同一实体类型的人及其相互之间的社交关系组成。

相对地，在异构图中，节点和边的类型可以是不同的。例如，编码市场的图可以有表示”顾客”、”商家”和”商品”的节点，它们通过“想购买”、“已经购买”、“是顾客”和“正在销售”的边互相连接。二分图是一类特殊的、常用的异构图，其中的边连接两类不同类型的节点。例如，在推荐系统中，可以使用二分图表示”用户”和”物品”之间的关系。想了解更多信息，读者可参考 1.5 异构图。

在多重图中，同一对节点之间可以有多条（有向）边，包括自循环的边。例如，两名作者可以在不同年份共同署名文章，这就带来了具有不同特征的多条边。

1.2 图、节点和边

DGL使用一个唯一的整数来表示一个节点，称为节点ID；并用对应的两个端点ID表示一条边。同时，DGL也会根据边被添加的顺序，给每条边分配一个唯一的整数编号，称为边ID。节点和边的ID都是从0开始构建的。在DGL的图里，所有的边都是有方向的，即边(u,v) 表示它是从节点 u 指向节点 v 的。

对于多个节点，DGL使用一个一维的整型张量（如，PyTorch的Tensor类，TensorFlow的Tensor类或MXNet的ndarray类）来保存图的点ID， DGL称之为”节点张量”。为了指代多条边，DGL使用一个包含2个节点张量的元组 $(U, V)$ ，其中，用 $(U [i], V [i])$ 指代一条 $U [i]$ 到 $V [i]$ 的边。

创建一个 DGLGraph 对象的一种方法是使用 dgl.graph() 函数。它接受一个边的集合作为输入。DGL也支持从其他的数据源来创建图对象。读者可参考 1.4 从外部源创建图。

下面的代码段使用了 dgl.graph() 函数来构建一个 DGLGraph 对象，对应着下图所示的包含4个节点的图。其中一些代码演示了查询图结构的部分API的使用方法。

import torch as th
import dgl

u, v = th.tensor([0, 0, 0, 1]), th.tensor([1, 2, 3, 3])
g = dgl.graph((u, v))
print(g)  # 图中节点的数量(num_nodes=max边ID+1)是DGL通过给定的图的边列表中最大的边ID推断所得出的

Using backend: pytorch


Graph(num_nodes=4, num_edges=4,
      ndata_schemes={}
      edata_schemes={})

print(g.nodes()) #获取节点的点id

tensor([0, 1, 2, 3])

print(g.edges()) #获取边对应的端点

(tensor([0, 0, 0, 1]), tensor([1, 2, 3, 3]))

print(g.edges(form='all')) # 获取边的对应端点和边ID

(tensor([0, 0, 0, 1]), tensor([1, 2, 3, 3]), tensor([0, 1, 2, 3]))

g = dgl.graph((u, v), num_nodes=8) # 如果具有最大ID的节点没有边，在创建图的时候，用户需要明确地指明节点的数量。
print(g.nodes())

tensor([0, 1, 2, 3, 4, 5, 6, 7])

对于无向的图，用户需要为每条边都创建两个方向的边。可以使用 dgl.to_bidirected() 函数来实现这个目的。如下面的代码段所示，这个函数可以把原图转换成一个包含反向边的图(默认创建的是有向图，dgl.to_bidirected()实现有向图转无向图)。

bg = dgl.to_bidirected(g)
bg.edges()

(tensor([0, 0, 0, 1, 1, 2, 3, 3]), tensor([1, 2, 3, 0, 3, 0, 0, 1]))

Note:由于Tensor类内部使用C来存储，且显性定义了数据类型以及存储的设备信息，DGL推荐使用Tensor作为DGL API的输入。不过大部分的DGL API也支持Python的可迭代类型(比如列表)或numpy.ndarray类型作为API的输入，方便用户快速进行开发验证。

DGL支持使用 $32$ 位或 $64$ 位的整数作为节点ID和边ID。节点和边ID的数据类型必须一致。如果使用 $64$ 位整数， DGL可以处理最多 $2^{63}−1$ 个节点或边。不过，如果图里的节点或者边的数量小于 $2^{63}−1$ (我认为这地方有问题，应该是 $2^{31}−1$ )，用户最好使用 $32$ 位整数。这样不仅能提升速度，还能减少内存的使用。DGL提供了进行数据类型转换的方法，如下例所示。

edges = th.tensor([2, 5, 3]), th.tensor([3, 5, 0])  # 边：2->3, 5->5, 3->0
g64 = dgl.graph(edges) # DGL默认使用64位整数
print(g64.idtype)

torch.int64

g32 = dgl.graph(edges, idtype=th.int32)
print(g32.idtype)

torch.int32

g64_2 = g32.long() # 转换成int64
g64_2.idtype

torch.int64

g32_2 = g64.int() # 转换成int32
print(g32_2.idtype)
print(g64.idtype)

torch.int32
torch.int64

1.3 节点和边的特征

DGLGraph 对象的节点和边可具有多个用户定义的、可命名的特征，以储存图的节点和边的属性。通过 ndata 和 edata 接口可访问这些特征。
例如，以下代码创建了2个节点特征（分别在第8、15行命名为 'x' 、 'y' ）和1个边特征（在第9行命名为 'x' ）。

import dgl
import torch as th

g = dgl.graph(([0, 0, 1, 5], [1, 2, 2, 0])) # 建议使用的是Tensor输入而不是Python自带的类型

print(g)

Graph(num_nodes=6, num_edges=4,
      ndata_schemes={}
      edata_schemes={})

num_nodes = g.num_nodes()
num_edges = g.num_edges()

g.ndata['x'] = th.ones(num_nodes, 3) # 长度为3的节点特征
g.edata['x'] = th.ones(num_edges, dtype=th.int32) # 标量32位整型特征

g

Graph(num_nodes=6, num_edges=4,
      ndata_schemes={'x': Scheme(shape=(3,), dtype=torch.float32)}
      edata_schemes={'x': Scheme(shape=(), dtype=torch.int32)})

# 不同名称的特征可以具有不同形状
g.ndata['y'] = th.randn(g.num_nodes(), 5)
g

Graph(num_nodes=6, num_edges=4,
      ndata_schemes={'x': Scheme(shape=(3,), dtype=torch.float32), 'y': Scheme(shape=(5,), dtype=torch.float32)}
      edata_schemes={'x': Scheme(shape=(), dtype=torch.int32)})

print(g.ndata['x'])
print(g.ndata['y'])
print(g.ndata['y'][1])# 获取节点1的特征

tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]])
tensor([[-0.5030, -0.4713, -1.0465,  0.4455, -1.1428],
        [ 0.7956, -1.4748,  1.1465,  2.4539, -0.5905],
        [-0.2892, -0.2399,  0.5773, -0.0539, -1.0164],
        [ 0.6143,  0.1210, -0.3048,  1.7286,  0.8323],
        [ 0.2687,  2.4086, -0.0522,  0.3603,  0.0708],
        [ 1.8455, -0.3802,  1.0930, -0.3971,  1.3446]])
tensor([ 0.7956, -1.4748,  1.1465,  2.4539, -0.5905])

# 获取边0和3的特征
print(g.edata['x'][[0,3]])
print(g.edata['x'][th.tensor([0, 3])])

tensor([1, 1], dtype=torch.int32)
tensor([1, 1], dtype=torch.int32)

关于 ndata 和 edata 接口的重要说明：

仅允许使用数值类型（如单精度浮点型、双精度浮点型和整型）的特征。这些特征可以是标量、向量或多维张量。
每个节点特征具有唯一名称，每个边特征也具有唯一名称。节点和边的特征可以具有相同的名称（如上述示例代码中的 ‘x’ ）。
通过张量分配创建特征时，DGL会将特征赋给图中的每个节点和每条边。该张量的第一维必须与图中节点或边的数量一致。不能将特征赋给图中节点或边的子集。
相同名称的特征必须具有相同的维度和数据类型(如上述代码中的edata[‘x’]、ndata[‘x’])。
特征张量使用”行优先”的原则，即每个行切片储存1个节点或1条边的特征（参考上述示例代码最后几行）。

对于加权图，用户可以将权重储存为一个边特征，如下。

# 边 0->1, 0->2, 0->3, 1->3
edges = th.tensor([0, 0, 0, 1]), th.tensor([1, 2, 3, 3])
weights = th.tensor([0.1, 0.6, 0.9, 0.7])  # 每条边的权重
g = dgl.graph(edges)# 将权重命名为 'w'
g.edata['w'] = weights
g

Graph(num_nodes=4, num_edges=4,
      ndata_schemes={}
      edata_schemes={'w': Scheme(shape=(), dtype=torch.float32)})

1.4 从外部源创建图

可以从外部来源构造一个 DGLGraph 对象，包括：

从用于图和稀疏矩阵的外部Python库（NetworkX 和 SciPy）创建而来。
从磁盘加载图数据。

本节不涉及通过转换其他图来生成图的函数，相关概述请阅读API参考手册。

从外部库创建图

以下代码片段为从SciPy稀疏矩阵和NetworkX图创建DGL图的示例。

import dgl
import torch as th
import scipy.sparse as sp
spmat = sp.rand(100, 100, density=0.05) # 5%的非零项
g = dgl.from_scipy(spmat) #从SciPy稀疏矩阵导入图（的边）
print(g)

Graph(num_nodes=100, num_edges=500,
      ndata_schemes={}
      edata_schemes={})

import networkx as nx
nx_g = nx.path_graph(5)# 一条链路0-1-2-3-4
g = dgl.from_networkx(nx_g)
print(g)

Graph(num_nodes=5, num_edges=8,
      ndata_schemes={}
      edata_schemes={})

注意，当使用 nx.path_graph(5) 进行创建时， DGLGraph 对象有8条边，而非4条。这是由于 nx.path_graph(5) 构建了一个无向的NetworkX图 networkx.Graph ，而 DGLGraph 的边总是有向的。所以当将无向的NetworkX图转换为 DGLGraph 对象时，DGL会在内部将1条无向边转换为2条有向边。使用有向的NetworkX图 networkx.DiGraph 可避免该行为。

nxg = nx.DiGraph([(2, 1), (1, 2), (2, 3), (0, 0)])
dgl.from_networkx(nxg)

Graph(num_nodes=4, num_edges=4,
      ndata_schemes={}
      edata_schemes={})

Note:DGL在内部将SciPy矩阵和NetworkX图转换为张量来创建图。因此，这些构建方法并不适用于重视性能的场景。

相关API： dgl.from_scipy()、 dgl.from_networkx()。

从磁盘加载图

有多种文件格式可储存图，所以这里难以枚举所有选项。本节仅给出一些常见格式的一般情况。

逗号分隔值（CSV）

CSV是一种常见的格式，以表格格式储存节点、边及其特征：

nodes.csv

age, title
43, 1
23, 3
…

edges.csv

src, dst, weight
0, 1, 0.4
0, 3, 0.9
…

许多知名Python库(如Pandas)可以将该类型数据加载到python对象(如 numpy.ndarray)中，进而使用这些对象来构建DGLGraph对象。如果后端框架也提供了从磁盘中保存或加载张量的工具(如 torch.save(), torch.load() )，可以遵循相同的原理来构建图。

另见：从成对的边 CSV 文件中加载 Karate Club Network 的教程

JSON/GML 格式

如果对速度不太关注的话，读者可以使用NetworkX提供的工具来解析各种数据格式， DGL可以间接地从这些来源创建图。

DGL 二进制格式

DGL提供了API以从磁盘中加载或向磁盘里保存二进制格式的图。除了图结构，API也能处理特征数据和图级别的标签数据。 DGL也支持直接从S3/HDFS中加载或向S3/HDFS保存图。参考手册提供了该用法的更多细节。

相关API : dgl.save_graphs()、 dgl.load_graphs()

1.5 异构图

相比同构图，异构图里可以有不同类型的节点和边。这些不同类型的节点和边具有独立的ID空间和特征。例如在下图中，”用户”和”游戏”节点的ID都是从0开始的，而且两种节点具有不同的特征。
在这里插入图片描述
一个异构图示例。该图具有两种类型的节点(“用户”和”游戏”)和两种类型的边(“关注”和”玩”)。

创建异构图

在DGL中，一个异构图由一系列子图构成，一个子图对应一种关系。每个关系由一个字符串三元组定义 (源节点类型, 边类型, 目标节点类型) 。由于这里的关系定义消除了边类型的歧义，DGL称它们为规范边类型。

下面的代码是一个在DGL中创建异构图的示例。

import dgl
import torch as th

# 创建一个具有2种节点类型和2种边类型的异构图

graph_data = {
    ("User", "follows", "User"): (th.tensor([0]), th.tensor([1])),
    ("User", "plays", "Game"): (th.tensor([0, 0, 1, 1]), th.tensor([0, 1, 1, 2]))
}
g = dgl.heterograph(graph_data)
print(g.ntypes) # 节点类型

['Game', 'User']

print(g.etypes) # 边类型

['follows', 'plays']

print(g.canonical_etypes) #规范边类型

[('User', 'follows', 'User'), ('User', 'plays', 'Game')]

注意，同构图和二分图只是一种特殊的异构图，它们只包括一种关系，同构图包含一种节点类型，二分图包含两种节点类型。

# 一个同构图
g = dgl.heterograph({
    ("node_type", "edge_type", "node_type"): (th.tensor([0, 0, 1]),th.tensor([1, 2, 0])),
})

# 一个二分图
u, v = th.tensor([0, 1, 2, 1]), th.tensor([1,2,3,4])
dgl.heterograph({('source_type', 'edge_type', 'destination_type'): (u, v)})

Graph(num_nodes={'destination_type': 5, 'source_type': 3},
      num_edges={('source_type', 'edge_type', 'destination_type'): 4},
      metagraph=[('source_type', 'destination_type', 'edge_type')])

与异构图相关联的 metagraph 就是图的模式。它指定节点集和节点之间的边的类型约束。 metagraph 中的一个节点 u 对应于相关异构图中的一个节点类型。 metagraph 中的边 (u,v) 表示在相关异构图中存在从 u 型节点到 v 型节点的边

graph_data = {
    ("User", "follows", "User"): (th.tensor([0]), th.tensor([1])),
    ("User", "plays", "Game"): (th.tensor([0, 0, 1, 1]), th.tensor([0, 1, 1, 2]))
}
g = dgl.heterograph(graph_data)
g

Graph(num_nodes={'Game': 3, 'User': 2},
      num_edges={('User', 'follows', 'User'): 1, ('User', 'plays', 'Game'): 4},
      metagraph=[('User', 'User', 'follows'), ('User', 'Game', 'plays')])

g.metagraph().edges()

OutMultiEdgeDataView([('User', 'User'), ('User', 'Game')])

g.metagraph().nodes()

NodeView(('User', 'Game'))

使用多种类型

当引入多种节点和边类型后，用户在调用DGLGraph API以获取特定类型的信息时，需要指定具体的节点和边类型。此外，不同类型的节点和边具有单独的ID。

g.num_nodes() # 获取图中所有节点的数量

g.num_nodes("Game")# 获取Game节点的数量

g.nodes()# 不同类型的节点有单独的ID。因此，没有指定节点类型就没有明确的返回值。

---------------------------------------------------------------------------

DGLError                                  Traceback (most recent call last)

<ipython-input-30-066353790f8a> in <module>
----> 1 g.nodes()# 不同类型的节点有单独的ID。因此，没有指定节点类型就没有明确的返回值。


C:\ProgramData\Anaconda3\lib\site-packages\dgl\view.py in __call__(self, ntype)
     40     def __call__(self, ntype=None):
     41         """Return the nodes."""
---> 42         ntid = self._typeid_getter(ntype)
     43         ret = F.arange(0, self._graph._graph.number_of_nodes(ntid),
     44                        dtype=self._graph.idtype, ctx=self._graph.device)


C:\ProgramData\Anaconda3\lib\site-packages\dgl\heterograph.py in get_ntype_id(self, ntype)
   1102         if ntype is None:
   1103             if self.is_unibipartite or len(self._srctypes_invmap) != 1:
-> 1104                 raise DGLError('Node type name must be specified if there are more than one '
   1105                                'node types.')
   1106             return 0


DGLError: Node type name must be specified if there are more than one node types.

g.nodes("User")

tensor([0, 1])

为了设置/获取特定节点和边类型的特征，DGL提供了两种新类型的语法：
g.nodes[‘node_type’].data[‘feat_name’] 和 g.edges[‘edge_type’].data[‘feat_name’] 。

g.nodes["User"].data['hw'] = th.ones(2, 1)
g.nodes["User"].data["hw"]

tensor([[1.],
        [1.]])

g.edges["plays"].data["ew"] = th.zeros(4, 1)
g.edges["plays"].data["ew"]

tensor([[0.],
        [0.],
        [0.],
        [0.]])

如果图里只有一种节点或边类型，则不需要指定节点或边的类型。

g = dgl.heterograph({
   ('drug', 'interacts', 'drug'): (th.tensor([0, 1]), th.tensor([1, 2])),
   ('drug', 'is similar', 'drug'): (th.tensor([0, 1]), th.tensor([2, 3]))
})
g.nodes()

tensor([0, 1, 2, 3])

# 设置/获取单一类型的节点或边特征，不必使用新的语法
g.ndata["vw"] = th.ones(4, 1)
g.ndata["vw"]

tensor([[1.],
        [1.],
        [1.],
        [1.]])

当边类型唯一地确定了源节点和目标节点的类型时，用户可以只使用一个字符串而不是字符串三元组来指定边类型。例如，对于具有两个关系 ('user', 'plays', 'game') 和 ('user', 'likes', 'game') 的异构图，只使用 ‘plays’ 或 ‘like’ 来指代这两个关系是可以的。

从磁盘加载异构图

逗号分隔值（CSV）

一种存储异构图的常见方法是在不同的CSV文件中存储不同类型的节点和边。下面是一个例子。

data/
|-- drug.csv        # drug节点
|-- gene.csv        # gene节点
|-- disease.csv     # disease节点
|-- drug-interact-drug.csv  # drug-drug相互作用边
|-- drug-interact-gene.csv  # drug-gene相互作用边
|-- drug-treat-disease.csv  # drug-disease治疗边

与同构图的情况类似，用户可以使用像Pandas这样的包先将CSV文件解析为numpy数组或框架张量，再构建一个关系字典，并用它构造一个异构图。这种方法也适用于其他流行的文件格式，比如GML或JSON。

DGL二进制格式

DGL提供了 dgl.save_graphs() 和 dgl.load_graphs() 函数，分别用于以二进制格式保存异构图和加载它们。

边类型子图

用户可以通过指定要保留的关系来创建异构图的子图，相关的特征也会被拷贝。

g = dgl.heterograph({
   ('drug', 'interacts', 'drug'): (th.tensor([0, 1]), th.tensor([1, 2])),
   ('drug', 'interacts', 'gene'): (th.tensor([0, 1]), th.tensor([2, 3])),
   ('drug', 'treats', 'disease'): (th.tensor([1]), th.tensor([2]))
})
g.nodes["drug"].data['hv'] = th.ones(3, 1)
# 保留关系 ('drug', 'interacts', 'drug') 和 ('drug', 'treats', 'disease') 。
# 'drug' 和 'disease' 类型的节点也会被保留
eg = dgl.edge_type_subgraph(g, [('drug', 'interacts', 'drug'),
                                ('drug', 'treats', 'disease')])
eg

Graph(num_nodes={'disease': 3, 'drug': 3},
      num_edges={('drug', 'interacts', 'drug'): 2, ('drug', 'treats', 'disease'): 1},
      metagraph=[('drug', 'drug', 'interacts'), ('drug', 'disease', 'treats')])

# 相关的特征也会被拷贝
eg.nodes["drug"].data["hv"]

tensor([[1.],
        [1.],
        [1.]])

将异构图转化为同构图

异构图为管理不同类型的节点和边及其相关特征提供了一个清晰的接口。这在以下情况下尤其有用:

不同类型的节点和边的特征具有不同的数据类型或大小。
用户希望对不同类型的节点和边应用不同的操作。

如果上述情况不适用，并且用户不希望在建模中区分节点和边的类型，则DGL允许使用 dgl.DGLGraph.to_homogeneous() API将异构图转换为同构图。具体行为如下:

用从0开始的连续整数重新标记所有类型的节点和边。
对所有的节点和边合并用户指定的特征。

g = dgl.heterograph({
   ('drug', 'interacts', 'drug'): (th.tensor([0, 1]), th.tensor([1, 2])),
   ('drug', 'treats', 'disease'): (th.tensor([1]), th.tensor([2]))})
g.nodes['drug'].data['hv'] = th.zeros(3, 1)
g.nodes['disease'].data['hv'] = th.ones(3, 1)
g.edges['interacts'].data['he'] = th.zeros(2, 1)
g.edges['treats'].data['he'] = th.zeros(1, 2)
# 默认情况下不进行特征合并
hg = dgl.to_homogeneous(g)
print(hg.ndata)
'hv' in hg.ndata

{'_ID': tensor([0, 1, 2, 0, 1, 2]), '_TYPE': tensor([0, 0, 0, 1, 1, 1])}





False

# 拷贝边的特征
# 对于要拷贝的特征，DGL假定不同类型的节点或边的需要合并的特征具有相同的大小和数据类型
hg = dgl.to_homogeneous(g, edata=['he'])

---------------------------------------------------------------------------

DGLError                                  Traceback (most recent call last)

<ipython-input-39-dfe9b08b04de> in <module>
      1 # 拷贝边的特征
      2 # 对于要拷贝的特征，DGL假定不同类型的节点或边的需要合并的特征具有相同的大小和数据类型
----> 3 hg = dgl.to_homogeneous(g, edata=['he'])


C:\ProgramData\Anaconda3\lib\site-packages\dgl\convert.py in to_homogeneous(G, ndata, edata, store_type, return_count)
    935         edata = []
    936     comb_nf = combine_frames(G._node_frames, range(len(G.ntypes)), col_names=ndata)
--> 937     comb_ef = combine_frames(G._edge_frames, range(len(G.etypes)), col_names=edata)
    938     if comb_nf is not None:
    939         retg.ndata.update(comb_nf)


C:\ProgramData\Anaconda3\lib\site-packages\dgl\heterograph.py in combine_frames(frames, ids, col_names)
   5966             if key in frame.schemes:
   5967                 if frame.schemes[key] != scheme:
-> 5968                     raise DGLError('Cannot concatenate column %s with shape %s and shape %s' %
   5969                                    (key, frame.schemes[key], scheme))
   5970             else:


DGLError: Cannot concatenate column he with shape Scheme(shape=(2,), dtype=torch.float32) and shape Scheme(shape=(1,), dtype=torch.float32)

# 拷贝节点特征
hg = dgl.to_homogeneous(g, ndata=['hv'])
hg.ndata['hv']

tensor([[1.],
        [1.],
        [1.],
        [0.],
        [0.],
        [0.]])

原始的节点或边的类型和对应的ID被存储在 ndata 和 edata 中。

# 异构图中节点类型的顺序
g.ntypes

['disease', 'drug']

# 原始节点类型
hg.ndata[dgl.NTYPE]

tensor([0, 0, 0, 1, 1, 1])

# 原始的特定类型节点ID
hg.ndata[dgl.NID]

tensor([0, 1, 2, 0, 1, 2])

# 异构图中边类型的顺序
g.etypes

['interacts', 'treats']

# 原始边类型
hg.edata[dgl.ETYPE]

tensor([0, 0, 1])

# 原始的特定类型边ID
hg.edata[dgl.EID]

tensor([0, 1, 0])

出于建模的目的，用户可能需要将一些关系合并，并对它们应用相同的操作。为了实现这一目的，可以先抽取异构图的边类型子图，然后将该子图转换为同构图。

g = dgl.heterograph({
   ('drug', 'interacts', 'drug'): (th.tensor([0, 1]), th.tensor([1, 2])),
   ('drug', 'interacts', 'gene'): (th.tensor([0, 1]), th.tensor([2, 3])),
   ('drug', 'treats', 'disease'): (th.tensor([1]), th.tensor([2]))
})
sub_g = dgl.edge_type_subgraph(g, [('drug', 'interacts', 'drug'),
                                   ('drug', 'interacts', 'gene')])
h_sub_g = dgl.to_homogeneous(sub_g)
h_sub_g

Graph(num_nodes=7, num_edges=4,
      ndata_schemes={'_ID': Scheme(shape=(), dtype=torch.int64), '_TYPE': Scheme(shape=(), dtype=torch.int64)}
      edata_schemes={'_ID': Scheme(shape=(), dtype=torch.int64), '_TYPE': Scheme(shape=(), dtype=torch.int64)})

1.6 在GPU上使用DGLGraph

用户可以通过在构造过程中传入两个GPU张量来创建GPU上的 DGLGraph 。另一种方法是使用 to() API将 DGLGraph 复制到GPU，这会将图结构和特征数据都拷贝到指定的设备。

import dgl
import torch as th

u, v = th.tensor([0, 1, 2]), th.tensor([2,3,4])
g = dgl.graph((u, v))
g.ndata["x"] = th.randn(5, 3)
g.device

device(type='cpu')

cuda_g = g.to('cuda:0')         # 接受来自后端框架的任何设备对象
cuda_g.device

cuda配置正确时：

device(type='cuda', index=0)

cuda没有配置正确时：

---------------------------------------------------------------------------

OSError                                   Traceback (most recent call last)

<ipython-input-84-3791c64e38bc> in <module>
----> 1 cuda_g = g.to('cuda:0')         # 接受来自后端框架的任何设备对象
      2 cuda_g.device


C:\ProgramData\Anaconda3\lib\site-packages\dgl\heterograph.py in to(self, device, **kwargs)
   5190 
   5191         # 1. Copy graph structure
-> 5192         ret._graph = self._graph.copy_to(utils.to_dgl_context(device))
   5193 
   5194         # 2. Copy features


C:\ProgramData\Anaconda3\lib\site-packages\dgl\heterograph_index.py in copy_to(self, ctx)
    232             The graph index on the given device context.
    233         """
--> 234         return _CAPI_DGLHeteroCopyTo(self, ctx.device_type, ctx.device_id)
    235 
    236     def shared_memory(self, name, ntypes=None, etypes=None, formats=('coo', 'csr', 'csc')):


C:\ProgramData\Anaconda3\lib\site-packages\dgl\_ffi\_ctypes\function.py in __call__(self, *args)
    186         ret_val = DGLValue()
    187         ret_tcode = ctypes.c_int()
--> 188         check_call(_LIB.DGLFuncCall(
    189             self.handle, values, tcodes, ctypes.c_int(num_args),
    190             ctypes.byref(ret_val), ctypes.byref(ret_tcode)))


OSError: [WinError -529697949] Windows Error 0xe06d7363

cuda_g.ndata['x'].device        # 特征数据也拷贝到了GPU上

device(type='cuda', index=0)

# 由GPU张量构造的图也在GPU上
u, v = u.to('cuda:0'), v.to('cuda:0')
g = dgl.graph((u, v))
g.device

device(type='cuda', index=0)

任何涉及GPU图的操作都是在GPU上运行的。因此，这要求所有张量参数都已经放在GPU上，其结果(图或张量)也将在GPU上。此外，GPU图只接受GPU上的特征数据。

cuda_g.in_degrees()
# output: tensor([0, 0, 1, 1, 1], device='cuda:0')

cuda_g.in_edges([2, 3, 4])                          # 可以接受非张量类型的参数
# output: (tensor([0, 1, 2], device='cuda:0'), tensor([2, 3, 4], device='cuda:0'))

cuda_g.in_edges(th.tensor([2, 3, 4]).to('cuda:0'))  # 张量类型的参数必须在GPU上
# output: (tensor([0, 1, 2], device='cuda:0'), tensor([2, 3, 4], device='cuda:0'))

cuda_g.ndata['h'] = th.randn(5, 4)                  # ERROR! 特征也必须在GPU上！
#output: DGLError: Cannot assign node feature "h" on device cpu to a graph on device 
# cuda:0. Call DGLGraph.to() to copy the graph to the same device.