简介
首先说一下这个东西,全名是PyTorch-Geometric,是一个PyTorch基础上的一个库,专门用于图形式的数据,可以加速图学习算法的计算过程,比如稀疏化的图等。在学习PyG的各个大的分支之前,先看一下官方文档给出的学习例子。参考链接:
https://pytorch-geometric.readthedocs.io/en/latest/notes/introduction.html
此处直接进行使用的说明,安装过程文档中给出了方式,个人感觉Ubuntu安装会简单一点,但是没有安装过,本人在Windows10安装的,一些依赖库通过VS2019编译,至于为什么不用编译好的wheel文件安装,是因为电脑安装的是Python3.7,大部分编译好的文件都是py36的,所以只能自己编译了。提示一下,windows10编译库的时候过程不是很顺序,出现了很多VS编译的问题。
样例
根据PyG的一些功能函数给出了自带的五个例子,分别为:
(1)图数据处理–Data Handling of Graphs
(2)通用的数据集–Common Benchmark Datasets
(3)小批次–Mini-batches
(4)数据转换–Data Transforms
(5)图上的学习方法–Learning Methods on Graphs
1.Data Handling of Graphs
图(Graph)往往用来表示节点之间成对的关系(也就是边),一个图在PyG中会被定义为torch_geometric.data.Data
类的一个实例,常见的类属性如下:
data.x
节点的特征矩阵,大小为[num_nodes, num_node_features]
。data.edge_index
图中的边的信息,采用COO格式记录,大小为[2, num_edges]
,类型为torch.long
。COO格式也就是Coordinate Format
,采用三元组进行存储,三元组内元素分别为行坐标、列坐标和元素值,此处没有元素值,所以只有2
行,num_edges
列,每一列表示一个元素。data.edge_attr
边的特征矩阵,大小为[num_edges, num_edge_features]
data.y
训练目标,允许任意形状,比如节点级别的为[num_nodes, *]
,图级别的为[1, *]
data.pos
节点的位置矩阵,大小为[num_node, num_dimensions]
以上属性都不是必须的,而且可以进行属性拓展,上述的属性用于二维图中,如果对于三维网格数据,可以增加属性data.face
,大小为[3, num_faces]
,同样为COO格式。
举一个简单的例子,边上没有权重,无向图(定义边的时候需要两对索引),如下:
import torch
from torch_geometric.data import Data
# 节点不一定从0开始
edge_index = torch.tensor([
[3, 1, 1, 2],
[1, 3, 2, 1]],dtype=torch.long)
# 注意x是二维的,不是一维的,每一行代表一个节点的特征向量,此处特征维度为1
x = torch.tensor([[-1],
[0],
[1]], dtype=torch.float)
data = Data(x=x, edge_index=edge_index)
print(data)
输出为
Data(edge_index=[2, 4], x=[3, 1])
这里表示的都是维度。如果边数据不是通过COO方式给出的,而是通过节点对方式给出的,需要先转置t()
再利用函数contiguous()
:
# 通过节点对的方式给出
edge_index = torch.tensor([
[0, 1], [1, 0], [1, 2], [2, 1]
], dtype=torch.long)
data = Data(x=x, edge_index=edge_index.t().contiguous())
print(data)
两次输出data一致。除此之外,还提供了一部分实用的函数接口:
# 输出data的属性关键字,只有传递参数的才会被输出
print(data.keys)
# ['x', 'edge_index']
# 按照关键字进行输出,注意是字符串
print(data['x'])
# tensor([[-1.],
# [ 0.],
# [ 1.]])
print(data['edge_index'])
# tensor([[0, 1, 1, 2],
# [1, 0, 2, 1]])
print('edge_attr: ', data['edge_attr'])
# edge_attr: None
# 遍历所有关键字及其对应的数值
for key, item in data:
print(key, '---', item)
# 可以直接检索key,也可以检索data内函数
if 'edge_attr' not in data.keys:
print('Not in')
# Not in
if 'x' in data:
print('In')
# In
# print(type(data.keys))
# <class 'list'>
print(data.num_nodes)
# 3
# 这里的边数为4
print(data.num_edges)
# 4
print(data.num_edge_features)
# 0
print(data.num_node_features)
# 1
print(data.contains_isolated_nodes())
# False
print(data.contains_self_loops())
# False
print(data.is_undirected())
# True
上面有个地方需要注意:
在输出keys
的时候是没有edge_attr
的,但是可以直接访问data['edge_attr']
并且得到返回值为None
。于是分析一下Data
类的源码:
def __init__(self, x=None, edge_index=None, edge_attr=None, y=None,
pos=None, norm=None, face=None, **kwargs):
self.x = x
self.edge_index = edge_index
self.edge_attr = edge_attr
self.y = y
self.pos = pos
self.norm = norm
self.face = face
首先上面的代码块,可以看到一开始所有的属性都被初始化参数值,而参数的默认值为None
。
def __getitem__(self, key):
r"""Gets the data of the attribute :obj:`key`."""
return getattr(self, key, None)
通过重载上面的函数,使得类的对象变为可迭代对象,此时,可以通过data['XXX']
访问。此时就明白了为什么可以通过对象访问到edge_attr
并且为None
。但是为什么从keys中无法获得呢?
@property
def keys(self):
r"""Returns all names of graph attributes."""
keys = [key for key in self.__dict__.keys() if self[key] is not None]
keys = [key for key in keys if key[:2] != '__' and key[-2:] != '__']
return keys
此处进行一个if self[key] is not None
判断。并且需要注意的是Data
类的很多函数都被@property
修饰。此时,对Data
类的使用方式有了一个大致了解,但是此时出现一个疑惑,data
中的x
的顺序和节点大小顺序是对应的么?是不是x的第一个特征向量就是对应最小编号节点的特征向量呢?这个问题暂时还不能解决,等后面再说。
2.Common Benchmark Datasets
这个库中包含了很多数据集,比如Cora
、Citeseer
、Pubmed
以及图分类数据集等等(详情见文档)。直接对数据集进行初始化,初始化的时候就会自动下载其原始文件并转换为Data
格式,以数据集ENZYMES
为例,其中包含600个图分为6类:
from torch_geometric.datasets import TUDataset
dataset = TUDataset(root='data/', name='ENZYMES')
print(dataset)
# ENZYMES(600)
第一次下载需要一点时间,第二次运行就不会下载覆盖了,速度比较快。进行一些测试:
print(type(dataset))
# <class 'torch_geometric.datasets.tu_dataset.TUDataset'>
print(len(dataset))
# 600
print(dataset.num_node_features)
# 3
如果下载比较慢,可以找到链接手动下载,链接位置在TUDataset
中实现:
url = ('https://ls11-www.cs.tu-dortmund.de/people/morris/'
'graphkerneldatasets')
cleaned_url = ('https://raw.githubusercontent.com/nd7141/'
'graph_datasets/master/datasets')
然后取消掉下载过程(这里的内容以后在单独更新一篇文章仔细说),手动调用制作数据集的函数:
def process(self):
每一个元素都是一个Data实例:
# dataset是一个可迭代对象,并且每一个元素都是一个Data实例,但是y是一个单独的元素,所以说这个数据集是Graph-level的
data = dataset[0]
print(data)
# Data(edge_index=[2, 168], x=[37, 3], y=[1])
数据集切分可以用切片或者tensor:
# 数据集切分
dataset_train = dataset[:500]
dataset_test = dataset[500:]
print(dataset_train, dataset_test)
# ENZYMES(500) ENZYMES(100)
dataset_sample1 = dataset[torch.tensor([i for i in range(500)], dtype=torch.long)]
print(dataset_sample1)
# ENZYMES(500)
dataset_sample2 = dataset[torch.tensor([True, False])]
print(dataset_sample2)
# ENZYMES(1)
print(dataset[0])
# Data(edge_index=[2, 168], x=[37, 3], y=[1])
print(dataset[1])
# Data(edge_index=[2, 102], x=[23, 3], y=[1])
print(dataset_sample2[0])
# Data(edge_index=[2, 168], x=[37, 3], y=[1])
布尔型tensor类似一个滤波器,但是是从头开始的。打乱操作如下:
dataset = dataset.shuffle()
# 等价于
dataset = dataset[torch.randperm(len(dataset))]
下面的函数返回长度为n
,范围为0~n-1
的一种全排列tensor:
torch.randperm()
官方文档还给出了一个cora数据集的例子,特别的地方在于:
data.train_mask.sum().item()
cora数据集在Data类中额外添加了几个属性,比如train_mask
,通过sum
函数可以得到train训练集的总数,之所以可以自己定义新的属性,因为:
def __init__(self, x=None, edge_index=None, edge_attr=None, y=None,
pos=None, norm=None, face=None, **kwargs):
Data
类给了一个**kwargs
。
3.Mini-batches
神经网络通常会按照batch
方式进行训练,PyG通过构建稀疏化的分块对角阵实现mini-batch
的并行化,构建方式按照每一个Data
实例的edge_index
构建一个Graph
的邻接矩阵,然后将所有节点的特征向量按行拼接,目标值同理。这也就使得即使一个batch
内部的图是不同结构的,也可以一起训练。
通过DataLoader
函数进行batch的构造:
from torch_geometric.datasets import TUDataset
from torch_geometric.data import DataLoader
dataset = TUDataset(root='data/', name='ENZYMES', use_node_attr=True)
loader = DataLoader(dataset, batch_size=32, shuffle=True)
for batch in loader:
print(batch)
# Batch(batch=[1005], edge_index=[2, 3948], x=[1005, 21], y=[32])
一个batch为32个图,但是每一个图的规模是不一样的,如上案例,第一个batch内的32个图共1005节点,含有3948条边。torch_geometric.data.Batch
继承自torch_geometric.data.Data
,并且添加了一个额外的属性batch
。batch
是一个列向量,代表了每一个节点对应到哪一个图。
利用另一个库torch-scatter
可以对图信息进行一些计算,比如:
from torch_geometric.datasets import TUDataset
from torch_geometric.data import DataLoader
from torch_scatter import scatter_mean
dataset = TUDataset(root='data/', name='ENZYMES', use_node_attr=True)
loader = DataLoader(dataset, batch_size=32, shuffle=True)
for data in loader:
print(data)
# Batch(batch=[1005], edge_index=[2, 3948], x=[1005, 21], y=[32])
x = scatter_mean(data.x, data.batch, dim=0)
print(x.size())
# torch.Size([32, 21])
此处以每一个图为单位,将各个图中的所有节点的特征向量计算了一个平均值,所以维度为[32, 21]
。
4.Data Transforms
(本模块个人使用场景不多,暂时不展开描述)
以ShapeNet数据集为例,进行测试,数据集有17000个3D点云,并且每一个点的类别为16类中的一个:
from torch_geometric.datasets import ShapeNet
dataset = ShapeNet(root='data/ShapeNet', categories=['Airplane'])
print(dataset[0])
# Data(pos=[2518, 3], y=[2518])
注意:应该在数据集存储到磁盘之前进行pre_transform
,这会使得加载速度更快,也就是在第一次下载时进行转换,此时下一次初始化数据集的时候,就会调用转换后的数据集(即使下一次的调用没有指定pre_transform
参数)。
5.Learning Methods on Graphs
重要到了比较重要的地方了,也就是如何构建一个模型。这里选择搭建一个简单的GCN模型,并通过Cora数据集进行测试。
首先构建一个两层的GCN:
# 继承torch的类
class Net(torch.nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = GCNConv(dataset.num_node_features, 16)
self.conv2 = GCNConv(16, dataset.num_classes)
def forward(self, data):
x, edge_index = data.x, data.edge_index
x = self.conv1(x, edge_index)
x = F.relu(x)
x = F.dropout(x, training=self.training)
x = self.conv2(x, edge_index)
return F.log_softmax(x, dim=1)
注意得是在GCNConv
中没有自带非线性处理过程,训练过程和测试过程如下:
if __name__ == '__main__':
# 加载数据集
dataset = Planetoid(root='data/', name='Cora')
# Train
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Net().to(device)
data = dataset[0].to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)
model.train()
for epoch in range(200):
optimizer.zero_grad()
out = model(data)
loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask])
loss.backward()
optimizer.step()
# Test
model.eval()
_, pred = model(data).max(dim=1)
correct = float(pred[data.test_mask].eq(data.y[data.test_mask]).sum().item())
acc = correct / data.test_mask.sum().item()
print('Accuracy: {:.4f}'.format(acc))