从上三角初始化对称 Theano dmatrix

我正在尝试拟合一个部分由对称矩阵参数化的 Theano 模型A。为了加强对称性A，我希望能够构建A通过仅传入上三角形中的值。

等效的 numpy 代码可能如下所示：

import numpy as np

def make_symmetric(p, n):
    A = np.empty((n, n), P.dtype)
    A[np.triu_indices(n)] = p
    A.T[np.triu_indices(n)] = p

# output matrix will be (n, n)
n = 4

# parameter vector
P = np.arange(n * (n + 1) / 2)

print make_symmetric(P, n)
# [[ 0.  1.  2.  3.]
#  [ 1.  4.  5.  6.]
#  [ 2.  5.  7.  8.]
#  [ 3.  6.  8.  9.]]    

然而，由于符号张量变量不支持项目分配，我正在努力寻找一种在 Theano 中执行此操作的方法。

我能找到的最接近的是theano.tensor.diag，这允许我从它的对角线构造一个符号矩阵：

import theano
from theano import tensor as te

P = te.dvector('P')
D = te.diag(P)
get_D = theano.function([P], D)

print get_D(np.arange(1, 5))
# [[ 1.  0.  0.  0.]
#  [ 0.  2.  0.  0.]
#  [ 0.  0.  3.  0.]
#  [ 0.  0.  0.  4.]]

虽然还有一个theano.tensor.triu函数，这不能用于从上三角构造矩阵，而是返回下三角元素为零的数组的副本。

有什么方法可以从上三角构造 Theano 符号矩阵吗？

你可以使用theano.tensor.triu并将结果与​​其转置相加，然后减去对角线。

复制+粘贴代码：

import numpy as np
import theano
import theano.tensor as T
theano.config.floatX = 'float32'

mat = T.fmatrix()
sym1 = T.triu(mat) + T.triu(mat).T
diag = T.diag(T.diagonal(mat))
sym2 = sym1 - diag

f_sym1 = theano.function([mat], sym1)
f_sym2 = theano.function([mat], sym2)

m = np.arange(9).reshape(3, 3).astype(np.float32)

print m
# [[ 0.  1.  2.]
#  [ 3.  4.  5.]
#  [ 6.  7.  8.]]
print f_sym1(m)
# [[  0.   1.   2.]
#  [  1.   8.   5.]
#  [  2.   5.  16.]]
print f_sym2(m)
# [[ 0.  1.  2.]
#  [ 1.  4.  5.]
#  [ 2.  5.  8.]]

这有帮助吗？这种方法需要传递一个完整的矩阵，但会忽略对角线下方的所有内容并使用上三角形进行对称化。

我们还可以看一下这个函数的导数。为了不处理多维输出，我们可以例如查看矩阵项之和的梯度

sum_grad = T.grad(cost=sym2.sum(), wrt=mat)
f_sum_grad = theano.function([mat], sum_grad)

print f_sum_grad(m)
# [[ 1.  2.  2.]
#  [ 0.  1.  2.]
#  [ 0.  0.  1.]]

这反映了这样一个事实，即上三角条目的总和是双倍的。

更新：您可以进行正常的索引：

n = 4
num_triu_entries = n * (n + 1) / 2

triu_index_matrix = np.zeros([n, n], dtype=int)
triu_index_matrix[np.triu_indices(n)] = np.arange(num_triu_entries)
triu_index_matrix[np.triu_indices(n)[::-1]] = np.arange(num_triu_entries)

triu_vec = T.fvector()
triu_mat = triu_vec[triu_index_matrix]

f_triu_mat = theano.function([triu_vec], triu_mat)

print f_triu_mat(np.arange(1, num_triu_entries + 1).astype(np.float32))

# [[  1.   2.   3.   4.]
#  [  2.   5.   6.   7.]
#  [  3.   6.   8.   9.]
#  [  4.   7.   9.  10.]]

更新：要动态地完成所有这些，一种方法是编写一个符号版本triu_index_matrix。这可以通过一些洗牌来完成aranges。但也许我过于复杂化了。

n = T.iscalar()
n_triu_entries = (n * (n + 1)) / 2
r = T.arange(n)

tmp_mat = r[np.newaxis, :] + (n_triu_entries - n - (r * (r + 1)) / 2)[::-1, np.newaxis]
triu_index_matrix = T.triu(tmp_mat) + T.triu(tmp_mat).T - T.diag(T.diagonal(tmp_mat))

triu_vec = T.fvector()
sym_matrix = triu_vec[triu_index_matrix]

f_triu_index_matrix = theano.function([n], triu_index_matrix)
f_dynamic_sym_matrix = theano.function([triu_vec, n], sym_matrix)

print f_triu_index_matrix(5)
# [[ 0  1  2  3  4]
#  [ 1  5  6  7  8]
#  [ 2  6  9 10 11]
#  [ 3  7 10 12 13]
# [ 4  8 11 13 14]]
print f_dynamic_sym_matrix(np.arange(1., 16.).astype(np.float32), 5)
# [[  1.   2.   3.   4.   5.]
#  [  2.   6.   7.   8.   9.]
#  [  3.   7.  10.  11.  12.]
#  [  4.   8.  11.  13.  14.]
#  [  5.   9.  12.  14.  15.]]