神经网络框架DGL（图、节点、边及其特征赋值）

101（入门）以后就是开始具体逐项学习图神经网络的各个细节。下面介绍：
1.如何构建图
2.将特征赋给节点或者边，及查询方法
这算是图神经网络最基础最基础的部分了。

一、如何构建图

DGL中创建的图的方法有：
1. 通过（u, v），u和v分别为起始节点和终止节点的列表，可以是numpy矩阵也可以是tensor
2. scipy中的稀疏矩阵，该稀疏矩阵储存这图的邻接矩阵
3. networkx图对象转化
4. 逐步添加节点与边

先导入所有可能需要的模块

import networkx as nx
import dgl
import torch as th
import numpy as np
import scipy.sparse as spp

1. 通过起始节点u和终止节点v的列表构建图

u = th.tensor([0,0,0,0,0]) #起始节点
v = th.tensor([1,2,3,4,5]) #终止节点
star1 = dgl.DGLGraph((u,v))
nx.draw(star1.to_networkx(), with_labels=True) #可视化
# plt.show()

结果如下图：

如果u、v之一是标量，那么DGL会自动使用boadscat机制，适应数组的长度

plt.clf()
u = th.tensor(0)
v = th.tensor([1,2,3,4,5])
star2= dgl.DGLGraph((u,v))
nx.draw(star2.to_networkx(), with_labels=True)

结果与上图类似

2. scipy中的稀疏矩阵，该稀疏矩阵储存这图的邻接矩

稀疏矩阵是图的邻接矩阵

u = th.tensor([0,0,0,0,0])
v = th.tensor([1,2,3,4,5])
adj = spp.coo_matrix((np.ones(len(u)), (u.numpy(), v.numpy()))) #稀疏矩阵
star3 = dgl.DGLGraph(adj)
nx.draw(star3.to_networkx(), with_labels=True)
plt.show()

结果如上图

3.networkx图对象转化

DGL中的图与networkx中的图是可以相互转化的

g_nx = nx.petersen_graph() #networkx内置的彼得森图
g_dgl = dgl.DGLGraph(g_nx) #生成dgl的图

import matplotlib.pyplot as plt
plt.subplot(121)
nx.draw(g_nx, with_labels=True)
plt.title('Networkx')
plt.subplot(122)
nx.draw(g_dgl.to_networkx(), with_labels=True)
plt.title('DGL')
plt.show()

结果如下图，可以看出二者等价。

4. 逐步添加节点与边

plt.clf()
g = dgl.DGLGraph()
g.add_nodes(10)
for i in range(0,5):
    g.add_edge(i, 0) #逐个添加边
src = list(range(5,8))
dst = th.tensor([0]*3)
g.add_edges(src, dst) #根据边起点，终点，一次性添加多条边
src = th.tensor([8,9])
dst = th.tensor([0,0])
g.add_edges(src, dst)
nx.draw(g.to_networkx(), with_labels=True)
plt.show()

结果如下：

二、将特征赋给节点或者边，及查询方法

先构建一个图

g = dgl.DGLGraph()
g.add_nodes(10)
for i in range(0,10):
    g.add_edge(i, 0) #逐个添加边

将特征分配到节点或者边，使用字典的格式存储 {名字：特征张量}，称之为fields。
ndata是访问图中节点数据的语法，类似于数组，通过切片访问
edata是访问图中边数据的语法，类似于数组，通过切片访问

1. 特征赋给节点或者边，及查询方法

x = th.randn(10, 3)
print(x)
g.ndata['x'] = x
print('第0个节点：', g.ndata['x'][0])
print('第1, 2个节点：', g.ndata['x'][[1, 2]])
print('第1, 2个节点：', g.ndata['x'][th.tensor([1, 2])])

print('图中边的数量：', len(g.edata)) #没有赋值之前是空的
g.edata['w'] = th.randn(10, 2)
print(g.edata['w'])
print('第0个边：', g.ndata['x'][0])
print('第1, 2个边：', g.ndata['x'][[1, 2]])
print('第1, 2个边：', g.ndata['x'][th.tensor([1, 2])])
#通过边的起始节点和终止节点的ID进行访问
print('起始节点为1，终止节点为0的边：', g.edata['w'][g.edge_id(1, 0)])
print('起始节点分别为1，2，3，终止节点均为0的边：', g.edata['w'][g.edge_ids([1,2,3,], 0)])
print('起始节点分别为1，2，3，终止节点均为0的边：', g.edata['w'][g.edge_ids([1,2,3,], [0,0,0])])

g.ndata['feats'] = th.zeros((10, 4))
print(g.node_attr_schemes()) #输出图中每一个特征shape等信息

#删除节点或者边的数据
g.ndata.pop('feats')
print(g.node_attr_schemes()) #输出图中每一个特征shape等信息

2.存在重复的边的情况

有的图可能存在两条重合的边，例如：1->0

lt.clf()
g_mutil = dgl.DGLGraph()
g_mutil.add_nodes(10)
g_mutil.ndata['x'] = th.randn(10, 2)
g_mutil.add_edges(list(range(1,10)),0) #图中只有9条边
g_mutil.add_edge(1,0) #再次添加一条1->0的边，此时有两条边了, 分别为第一条边和最后一条边
# 此时图*计10条边
g_mutil.edata['w'] = th.randn(10, 2)
print('第一条边数据：', g_mutil.edges[0].data['w'])
print('最后一条边数据', g_mutil.edges[9].data['w'])

g_mutil.edges[0].data['w'] = th.zeros(1, 2) #修改第一条边的数据
print('第一条边数据：', g_mutil.edges[0].data['w'])
print('第一条边数据：', g_mutil.edges[0].data)

一些节点和边的调用方法：

#所有的边
print(g_mutil.edges())

#所有的边
print(g_mutil.nodes())

#根据节点找边
eid_10 = g_mutil.edge_id(1, 0, return_array=True)
print(eid_10)
g_mutil.edges[eid_10].data['w'] = th.ones(len(eid_10), 2)
print(g_mutil.edata['w'])

nx.draw(g_mutil.to_networkx(), with_labels=True)
plt.show()

本文地址：https://blog.csdn.net/wufeil7/article/details/107106299