数值后端
一旦通过pip install pygmtools安装，pygmtools就可以使用默认的numpy后端。
我们在Get Started中展示了一个使用numpy后端匹配同构图示例。
目前，我们还支持深度学习架构 pytorch, paddle, jittor, tensorflow 和 mindspore，这些架构对GPU和深度学习友好。
一旦后端准备就绪，您可以通过以下命令全局切换到后端：
>>> import pygmtools as pygm
>>> pygm.set_backend('pytorch') # replace 'pytorch' by other backend names
Deprecation notice
注意
从版本 0.4.2 开始，我们建议通过函数 pygm.set_backend('pytorch') 来设置后端。
为了向后兼容，旧的设置后端方式 pygm.BACKEND = 'pytorch' 仍然保留，但可能在未来的版本中被移除。
PyTorch 后端
介绍
PyTorch 是一个由 Meta Inc./Linux 基金会开发和维护的开源机器学习框架。
PyTorch 非常流行，尤其是在深度学习研究社区中。
pygmtools 的 PyTorch 后端旨在支持 GPU 设备并促进深度学习研究。
请遵循官方PyTorch安装指南。
这个包是用torch==1.6.0开发的，并且应该可以与任何PyTorch版本>=1.6.0一起使用。
如何启用PyTorch后端：
>>> import pygmtools as pygm
>>> import torch
>>> pygm.set_backend('pytorch')
示例：使用pytorch后端匹配同构图
这里我们提供了一个基本的例子，展示如何使用pytorch后端匹配两个同构图（即两个图具有相同的节点和边，但节点的排列顺序未知）。
步骤0：导入包并设置后端
>>> import torch # pytorch backend
>>> import pygmtools as pygm
>>> pygm.set_backend('pytorch')
>>> torch.manual_seed(1) # fix random seed
第一步：生成两个同构图
>>> num_nodes = 5
>>> X_gt = torch.zeros(num_nodes, num_nodes)
>>> X_gt[torch.arange(0, num_nodes, dtype=torch.int64), torch.randperm(num_nodes)] = 1
>>> A1 = torch.rand(num_nodes, num_nodes)
>>> A1 = (A1 + A1.t() > 1.) * (A1 + A1.t()) / 2
>>> torch.diagonal(A1)[:] = 0
>>> A2 = torch.mm(torch.mm(X_gt.t(), A1), X_gt)
>>> n1 = torch.tensor([num_nodes])
>>> n2 = torch.tensor([num_nodes])
步骤2：构建亲和矩阵并选择一个亲和函数
>>> conn1, edge1 = pygm.utils.dense_to_sparse(A1)
>>> conn2, edge2 = pygm.utils.dense_to_sparse(A2)
>>> import functools
>>> gaussian_aff = functools.partial(pygm.utils.gaussian_aff_fn, sigma=1.) # set affinity function
>>> K = pygm.utils.build_aff_mat(None, edge1, conn1, None, edge2, conn2, n1, None, n2, None, edge_aff_fn=gaussian_aff)
步骤3：通过RRWM解决图匹配问题
>>> X = pygm.rrwm(K, n1, n2, beta=100)
>>> X = pygm.hungarian(X)
>>> X # X is the permutation matrix
tensor([[1., 0., 0., 0., 0.],
[0., 0., 0., 0., 1.],
[0., 0., 0., 1., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.]])
最后一步：评估准确性
>>> (X * X_gt).sum() / X_gt.sum()
tensor(1.)
Jittor 后端
介绍
Jittor 是一个基于即时编译（JIT）的高性能开源深度学习平台，由清华大学的CSCG 团队开发和维护。pygmtools 的 Jittor 后端旨在支持 GPU 设备和深度学习应用。
请遵循官方Jittor安装指南。
这个包是用jittor==1.3.4.16开发的，并且应该与任何Jittor版本>=1.3.4.16兼容。
如何启用Jittor后端：
>>> import pygmtools as pygm
>>> import jittor
>>> pygm.set_backend('jittor')
示例：使用jittor后端匹配同构图
这里我们提供了一个使用jittor后端匹配两个同构图（即两个图具有相同的节点和边，但节点排列未知）的基本示例。
注意
作为jittor的一个特性，如果您是第一次运行代码，请预期会有一些即时编译的开销。
步骤0：导入包并设置后端
>>> import jittor as jt # jittor backend
>>> import pygmtools as pygm
>>> pygm.set_backend('jittor')
>>> jt.set_seed(1) # fix random seed
>>> jt.flags.use_cuda = jt.has_cuda # detect cuda
第一步：生成两个同构图
>>> num_nodes = 5
>>> X_gt = jt.zeros((num_nodes, num_nodes))
>>> X_gt[jt.arange(0, num_nodes, dtype=jt.int64), jt.randperm(num_nodes)] = 1
>>> A1 = jt.rand(num_nodes, num_nodes)
>>> A1 = (A1 + A1.t() > 1.) * (A1 + A1.t()) / 2
>>> A1[jt.arange(A1.shape[0]), jt.arange(A1.shape[0])] = 0
>>> A2 = jt.matmul(jt.matmul(X_gt.t(), A1), X_gt)
>>> n1 = jt.Var([num_nodes])
>>> n2 = jt.Var([num_nodes])
步骤2：构建亲和矩阵并选择一个亲和函数
>>> conn1, edge1 = pygm.utils.dense_to_sparse(A1)
>>> conn2, edge2 = pygm.utils.dense_to_sparse(A2)
>>> import functools
>>> gaussian_aff = functools.partial(pygm.utils.gaussian_aff_fn, sigma=1.) # set affinity function
>>> K = pygm.utils.build_aff_mat(None, edge1, conn1, None, edge2, conn2, n1, None, n2, None, edge_aff_fn=gaussian_aff)
步骤3：通过RRWM解决图匹配问题
>>> X = pygm.rrwm(K, n1, n2, beta=100)
>>> X = pygm.hungarian(X)
>>> X # X is the permutation matrix
jt.Var([[0. 1. 0. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]
[1. 0. 0. 0. 0.]
[0. 0. 1. 0. 0.]], dtype=float32)
最后一步：评估准确性
>>> (X * X_gt).sum() / X_gt.sum()
jt.Var([1.], dtype=float32)
Paddle 后端
介绍
PaddlePaddle 是一个源自工业实践的开源深度学习平台，由百度公司开发和维护。
pygmtools 的 Paddle 后端旨在支持 GPU 设备和深度学习应用。
这个包是使用paddlepaddle==2.3.1开发的，并且应该可以与任何>=2.3.1的PaddlePaddle版本一起工作。
如何启用Paddle后端：
>>> import pygmtools as pygm
>>> import paddle
>>> pygm.set_backend('paddle')
示例：使用paddle后端匹配同构图
这里我们提供了一个使用paddle后端匹配两个同构图（即两个图具有相同的节点和边，但节点排列未知）的基本示例。
步骤0：导入包并设置后端
>>> import paddle # paddle backend
>>> import pygmtools as pygm
>>> pygm.set_backend('paddle')
>>> paddle.seed(1) # fix random seed
>>> paddle.device.set_device('cpu') # set cpu
第一步：生成两个同构图
>>> num_nodes = 5
>>> X_gt = paddle.zeros((num_nodes, num_nodes))
>>> X_gt[paddle.arange(0, num_nodes, dtype=paddle.int64), paddle.randperm(num_nodes)] = 1
>>> A1 = paddle.rand((num_nodes, num_nodes))
>>> A1 = (A1 + A1.t() > 1.) / 2 * (A1 + A1.t())
>>> A1[paddle.arange(A1.shape[0]), paddle.arange(A1.shape[1])] = 0 # paddle.diagonal(A1)[:] = 0
>>> A2 = paddle.mm(paddle.mm(X_gt.t(), A1), X_gt)
>>> n1 = paddle.to_tensor([num_nodes])
>>> n2 = paddle.to_tensor([num_nodes])
步骤2：构建亲和矩阵并选择一个亲和函数
>>> conn1, edge1 = pygm.utils.dense_to_sparse(A1)
>>> conn2, edge2 = pygm.utils.dense_to_sparse(A2)
>>> import functools
>>> gaussian_aff = functools.partial(pygm.utils.gaussian_aff_fn, sigma=.1) # set affinity function
>>> K = pygm.utils.build_aff_mat(None, edge1, conn1, None, edge2, conn2, n1, None, n2, None, edge_aff_fn=gaussian_aff)
步骤3：通过RRWM解决图匹配问题
>>> X = pygm.rrwm(K, n1, n2, beta=100)
>>> X = pygm.hungarian(X)
>>> X # X is the permutation matrix
Tensor(shape=[5, 5], dtype=float32, place=Place(cpu), stop_gradient=True,
[[0., 0., 0., 0., 1.],
[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 1., 0., 0.]])
最后一步：评估准确性
>>> (X * X_gt).sum() / X_gt.sum()
Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True,
[1.])
Tensorflow 后端
介绍
TensorFlow 是一个端到端的开源机器学习平台，由谷歌机器学习研究组织内的谷歌大脑团队的研究人员和工程师开发。pygmtools 的 TensorFlow 后端旨在支持 GPU 设备和深度学习应用。
请遵循官方Tensorflow安装指南。
这个包是使用Tensorflow==2.9.3开发的，请注意不同Tensorflow版本之间的API兼容性。
如何启用 Tensorflow 后端：
>>> import pygmtools as pygm
>>> import tensorflow
>>> pygm.set_backend('tensorflow')
示例：使用tensorflow后端匹配同构图
这里我们提供了一个使用tensorflow后端匹配两个同构图（即两个图具有相同的节点和边，但节点排列未知）的基本示例。
步骤0：导入包并设置后端
>>> import tensorflow as tf # tensorflow backend
>>> import pygmtools as pygm
>>> pygm.set_backend('tensorflow')
>>> _ = tf.random.set_seed(1) # fix random seed
第一步：生成两个同构图
>>> num_nodes = 5
>>> X_gt = tf.Variable(tf.zeros([num_nodes, num_nodes]))
>>> indices = tf.stack([tf.range(num_nodes),tf.random.shuffle(tf.range(num_nodes))], axis=1)
>>> updates = tf.ones([num_nodes])
>>> _ = X_gt.assign(tf.tensor_scatter_nd_update(X_gt, indices, updates))
>>> A1 = tf.random.uniform([num_nodes, num_nodes])
>>> A1 = (A1 + tf.cast(tf.transpose(A1) > 1., dtype=tf.float32)) / 2 * (A1 + tf.transpose(A1))
>>> A2 = tf.matmul(tf.matmul(tf.transpose(X_gt), A1), X_gt)
>>> n1 = n2 = tf.constant([num_nodes])
步骤2：构建亲和矩阵并选择一个亲和函数
>>> conn1, edge1 = pygm.utils.dense_to_sparse(A1)
>>> conn2, edge2 = pygm.utils.dense_to_sparse(A2)
>>> import functools
>>> gaussian_aff = functools.partial(pygm.utils.gaussian_aff_fn, sigma=.1) # set affinity function
>>> K = pygm.utils.build_aff_mat(None, edge1, conn1, None, edge2, conn2, n1, None, n2, None, edge_aff_fn=gaussian_aff)
步骤3：通过RRWM解决图匹配问题
>>> X = pygm.rrwm(K, n1, n2, beta=100)
>>> X = pygm.hungarian(X)
>>> X # X is the permutation matrix
<tf.Tensor: shape=(5, 5), dtype=float32, numpy=
array([[0., 0., 1., 0., 0.],
[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 0., 0., 1.],
[0., 0., 0., 1., 0.]], dtype=float32)>
最后一步：评估准确性
>>> tf.reduce_sum(X * X_gt) / tf.reduce_sum(X_gt)
<tf.Tensor: shape=(), dtype=float32, numpy=1.0>
Mindspore 后端
介绍
Mindspore 是一个由华为开发和维护的开源深度学习平台。
pygmtools 的 Mindspore 后端旨在支持 GPU 设备和深度学习应用。
请遵循官方Mindspore安装指南。
此包是使用mindspore==1.10.0开发的，并且应该与任何Mindspore版本>=1.10.0兼容。
如何启用Mindspore后端：
>>> import pygmtools as pygm
>>> import mindspore
>>> pygm.set_backend('mindspore')
示例：使用mindspore后端匹配同构图
这里我们提供了一个使用mindspore后端匹配两个同构图（即两个图具有相同的节点和边，但节点排列未知）的基本示例。
步骤0：导入包并设置后端
>>> import mindspore as ms # mindspore backend
>>> import pygmtools as pygm
>>> pygm.set_backend('mindspore')
>>> _ = ms.set_seed(1) # fix random seed
第一步：生成两个同构图
>>> num_nodes = 5
>>> X_gt = ms.numpy.zeros((num_nodes, num_nodes))
>>> X_gt[ms.numpy.arange(0, num_nodes, dtype=ms.int32), ms.ops.Randperm(num_nodes)(ms.Tensor([num_nodes], dtype=ms.int32))] = 1
>>> A1 = ms.numpy.rand((num_nodes, num_nodes))
>>> A1[ms.numpy.arange(A1.shape[0]), ms.numpy.arange(A1.shape[1])] = 0 # mindspore.diagonal(A1)[:] = 0
>>> A2 = ms.ops.matmul(ms.ops.matmul(ms.ops.transpose(X_gt, (1, 0)), A1), X_gt)
>>> n1 = n2 = ms.Tensor([num_nodes])
步骤2：构建亲和矩阵并选择一个亲和函数
>>> conn1, edge1 = pygm.utils.dense_to_sparse(A1)
>>> conn2, edge2 = pygm.utils.dense_to_sparse(A2)
>>> import functools
>>> gaussian_aff = functools.partial(pygm.utils.gaussian_aff_fn, sigma=.1) # set affinity function
>>> K = pygm.utils.build_aff_mat(None, edge1, conn1, None, edge2, conn2, n1, None, n2, None, edge_aff_fn=gaussian_aff)
步骤3：通过RRWM解决图匹配问题
>>> X = pygm.rrwm(K, n1, n2, beta=100)
>>> X = pygm.hungarian(X)
>>> X # X is the permutation matrix
Tensor(shape=[5, 5], dtype=Float32, value=
[[ 0.00000000e+00, 0.00000000e+00, 1.00000000e+00, 0.00000000e+00, 0.00000000e+00],
[ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.00000000e+00],
[ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.00000000e+00, 0.00000000e+00],
[ 1.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],
[ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]])
最后一步：评估准确性
>>> (X * X_gt).sum() / X_gt.sum()
Tensor(shape=[], dtype=Float32, value= 1)