在 Keras 中将层重塑为斜对称矩阵

Question

假设我有一个 keras 模型（例如）

layers_NE<-keras_model_sequential()
layers_NE %>% layer_dense(units=Height,
                           activation = "relu",
                           trainable=TRUE,
                           input_shape = 4,
                           bias_initializer = "random_normal") 
          %>% layer_dense(units = (d^2),
                           activation = "linear",
                           trainable = TRUE,
                           bias_initializer = "random_normal")

我想将最后一层重塑为 斜对称矩阵 输出，例如像这样c(a,b,c)-> c(c(a,b),c(b,c)) （这里 c(a,b,c) 是输出的符号我的网络）

到目前为止，我已经尝试过：

layers_NE %>%layer_reshape(input_shape = (d^2),
                           target_shape = c(d,d)
                           )

输出的形状正确，但不对称。我怎样才能做到这一点？

Answer 1

更节俭的版本应该完全按照您的意愿行事，而无需额外的神经元。由于k_gather 暴露给 R 的方式，还必须引入两个转置以将k_gather 应用于正确的轴（在 python 中，您可以将axis=1 作为参数传递给tf.gather）：

Height <- 10
d <- 7
layers_NE<-keras_model_sequential()
layers_NE %>% layer_dense(units=Height,
                          activation = "relu",
                          trainable=TRUE,
                          input_shape = 4,
                          bias_initializer = "random_normal") 
%>% layer_dense(units = (d * (d+1) / 2),
                activation = "linear",
                trainable = TRUE,
                bias_initializer = "random_normal")
%>% layer_lambda(f=function(x) {
    selector <- array(0, dim=c(d^2))
    ind <- 0 # zero-based indicies needed here
    for (i in 1:d) {
        for (j in i:d) {
            selector[(i-1) * d + j] <- ind
            selector[(j-1) * d + i] <- ind
            ind <- ind + 1
        }
    }
    t_ind <- k_constant(selector, dtype='int32')
    k_permute_dimensions(k_gather(k_permute_dimensions(x, pattern=c(2,1)), t_ind), pattern=c(2,1))
})
%>% layer_reshape(input_shape = (d^2),
                  target_shape = c(d,d))

更新。这是类似的部分，但在 Python 中 - 唯一重要的区别是 tf.gather 可以用 axis=1 调用：

def select_symmetric(x, d):
    selector = np.zeros(d*d, dtype=np.int32)
    ind = 0
    for i in range(d):
        for j in range(i, d):
            selector[i * d + j] = ind
            selector[j * d + i] = ind
            ind += 1
    t_ind = tf.constant(selector, dtype=tf.int32)
    return tf.gather(x, t_ind, axis=1)

Height = 10
d = 7
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(Height, 'relu', input_shape=(4,)),
    tf.keras.layers.Dense(d * (d + 1) // 2, 'linear'),
    tf.keras.layers.Lambda(select_symmetric, arguments={'d': d}),
    tf.keras.layers.Reshape(target_shape=(d, d)),
])

Answer 2

我看到了两种方法来实现这一点。更简单的方法是完全按照您最初的做法 - 在某个时候引入一个具有每个示例 (d,d) 的二维平方输出的层，该层不是对称的，然后通过将其添加到自己的转置版本来使其对称。它可能如下所示：

layers_NE<-keras_model_sequential()
layers_NE %>% layer_dense(units=Height,
                           activation = "relu",
                           trainable=TRUE,
                           input_shape = 4,
                           bias_initializer = "random_normal") 
          %>% layer_dense(units = (d^2),
                           activation = "linear",
                           trainable = TRUE,
                           bias_initializer = "random_normal")
          %>%layer_reshape(input_shape = (d^2),
                           target_shape = c(d,d)
                           )
          %>% layer_lambda(f=function(x) {
                             (x + k_permute_dimensions(x, pattern=c(1,3,2))) * 0.5
                           })

添加具有自己转置版本的模型后，结果将是对称的（我猜这里不需要平均）。这个解决方案有一点冗余，因为你必须实际训练 d^2 个单位而不是 d(d+1)/2。除此之外应该没问题。

第二个 - 更节俭的解决方案是实际创建 d(d+1)/2 个单位并将它们放入 (d,d) 形状中，以“复制”非对角元素。我相信您正在寻找的是创建例如使用k_gather 函数的 lambda 层。但唯一的节省是您在其中一层上训练的神经元更少。