python - 使用 numpy 方法修改(keras/tensorflow)张量

Question

我想执行特定操作。即，从矩阵:

A = np.array([[1,2],
            [3,4]])

至以下内容

B = np.array([[1, 0, 0, 2, 0, 0],
              [0, 1, 0, 0, 2, 0],
              [0, 0, 1, 0, 0, 2],
              [3, 0, 0, 4, 0, 0],
              [0, 3, 0, 0, 4, 0],
              [0, 0, 3, 0, 0, 4]])

或者用语言来说:将每个条目乘以单位矩阵并保持相同的顺序。现在我已经使用 numpy 使用以下代码完成了此操作。这里 N 和 M 是起始矩阵的维度和单位矩阵的维度。

l_slice = 3
n_slice = 2
A = np.reshape(np.arange(1, 1+N ** 2), (N, N))
B = np.array([i * np.eye(M) for i in A.flatten()])
C = B.reshape(N, N, M, M).reshape(N, N * M, M).transpose([0, 2, 1]).reshape((N * M, N * M))

其中 C 具有我想要的属性。

但现在我想在 Keras/Tensorflow 中进行此修改，其中矩阵 A 是我的其中一层的结果。

但是，我还不确定是否能够正确创建矩阵 B。特别是当涉及批处理时，我认为我会以某种方式搞乱问题的维度。任何有更多 Keras/Tensorflow 经验的人都可以评论这个“ reshape ”以及他/她如何看待 Keras/Tensorflow 中发生的这种情况吗？

Answer 1

以下是使用 TensorFlow 实现此目的的一种方法:

import tensorflow as tf

data = tf.placeholder(tf.float32, [None, None])
n = tf.placeholder(tf.int32, [])
eye = tf.eye(n)
mult = data[:, tf.newaxis, :, tf.newaxis] * eye[tf.newaxis, :, tf.newaxis, :]
result = tf.reshape(mult, n * tf.shape(data))
with tf.Session() as sess:
    a = sess.run(result, feed_dict={data: [[1, 2], [3, 4]], n: 3})
    print(a)

输出:

[[1. 0. 0. 2. 0. 0.]
 [0. 1. 0. 0. 2. 0.]
 [0. 0. 1. 0. 0. 2.]
 [3. 0. 0. 4. 0. 0.]
 [0. 3. 0. 0. 4. 0.]
 [0. 0. 3. 0. 0. 4.]]

顺便说一句，您可以在 NumPy 中执行基本相同的操作，这应该比您当前的解决方案更快:

import numpy as np

data = np.array([[1, 2], [3, 4]])
n = 3
eye = np.eye(n)
mult = data[:, np.newaxis, :, np.newaxis] * eye[np.newaxis, :, np.newaxis, :]
result = np.reshape(mult, (n * data.shape[0], n * data.shape[1]))
print(result)
# The output is the same as above

<小时/>

编辑:

我会尝试给出一些关于为什么/如何工作的直觉，如果太长，抱歉。这并不难，但我认为解释起来有点棘手。也许更容易看出下面的乘法是如何工作的

import numpy as np

data = np.array([[1, 2], [3, 4]])
n = 3
eye = np.eye(n)
mult1 = data[:, :, np.newaxis, np.newaxis] * eye[np.newaxis, np.newaxis, :, :]

现在，mult1 是一种“矩阵的矩阵”。如果我给出两个索引，我将得到原始索引中相应元素的对角矩阵:

print(mult1[0, 0])
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

所以你可以说这个矩阵可以像这样可视化:

| 1 0 0 |  | 2 0 0 |
| 0 1 0 |  | 0 2 0 |
| 0 0 1 |  | 0 0 2 |

| 3 0 0 |  | 4 0 0 |
| 0 3 0 |  | 0 4 0 |
| 0 0 3 |  | 0 0 4 |

然而，这是欺骗性的，因为如果您尝试将其 reshape 为最终形状，结果将不是正确的:

print(np.reshape(mult1, (n * data.shape[0], n * data.shape[1])))
# [[1. 0. 0. 0. 1. 0.]
#  [0. 0. 1. 2. 0. 0.]
#  [0. 2. 0. 0. 0. 2.]
#  [3. 0. 0. 0. 3. 0.]
#  [0. 0. 3. 4. 0. 0.]
#  [0. 4. 0. 0. 0. 4.]]

原因是 reshape (概念上)首先“展平”数组，然后给出新的形状。但本例中的展平数组并不是您所需要的:

print(mult1.ravel())
# [1. 0. 0. 0. 1. 0. 0. 0. 1. 2. 0. 0. 0. 2. 0. ...

你看，它首先遍历第一个子矩阵，然后是第二个子矩阵，依此类推。你想要的是它首先遍历第一个子矩阵的第一行，然后遍历第二个子矩阵的第一行，然后遍历第二个子矩阵的第二行第一个子矩阵等。所以基本上你想要这样的东西:

• 取前两个子矩阵(带有 1 和 2 的子矩阵)
  • 获取所有前行([1, 0, 0] 和 [2, 0, 0])。
    • 取第一个 ([1, 0, 0])
      • 获取其每个元素(1、0 和 0)。

然后继续剩下的事情。因此，如果您考虑一下，我们首先遍历轴 0(“矩阵的矩阵”的行)，然后遍历 2(每个子矩阵的行)，然后遍历 1(“矩阵的矩阵”的列)，最后遍历 3(子矩阵的列) )。因此，我们只需重新排列轴即可:

mult2 = mult1.transpose((0, 2, 1, 3))
print(np.reshape(mult2, (n * data.shape[0], n * data.shape[1])))
# [[1. 0. 0. 2. 0. 0.]
#  [0. 1. 0. 0. 2. 0.]
#  [0. 0. 1. 0. 0. 2.]
#  [3. 0. 0. 4. 0. 0.]
#  [0. 3. 0. 0. 4. 0.]
#  [0. 0. 3. 0. 0. 4.]]

而且它有效!因此，在我发布的解决方案中，为了避免转置，我只是进行乘法，因此轴的顺序正是这样的:

mult = data[
        :,           # Matrix-of-matrices rows
        np.newaxis,  # Submatrix rows
        :,           # Matrix-of-matrices columns
        np.newaxis   # Submatrix columns
    ] * eye[
        np.newaxis,  # Matrix-of-matrices rows
        :,           # Submatrix rows
        np.newaxis,  # Matrix-of-matrices columns
        :            # Submatrix columns
    ]

我希望这能让它更清楚一些。老实说，特别是在这种情况下，我可以很快找到解决方案，因为不久前我必须解决类似的问题，我猜你最终会对这些事情建立起直觉。