如何复制一个二维数组到一个三维，N 次？

我想把一个数字二维数组复制到第三维空间，例如，给定一个二维数组:

import numpy as np


arr = np.array([[1, 2], [1, 2]])
# arr.shape = (2, 2)

将它转换成一个三维矩阵，在一个新的维度上有 N 个这样的拷贝。作用于 arr和 N=3的输出应该是:

new_arr = np.array([[[1, 2], [1,2]],
[[1, 2], [1, 2]],
[[1, 2], [1, 2]]])
# new_arr.shape = (3, 2, 2)
120964 次浏览
小开
最佳答案

也许最干净的方法是使用 np.repeat:

a = np.array([[1, 2], [1, 2]])
print(a.shape)
# (2,  2)


# indexing with np.newaxis inserts a new 3rd dimension, which we then repeat the
# array along, (you can achieve the same effect by indexing with None, see below)
b = np.repeat(a[:, :, np.newaxis], 3, axis=2)


print(b.shape)
# (2, 2, 3)


print(b[:, :, 0])
# [[1 2]
#  [1 2]]


print(b[:, :, 1])
# [[1 2]
#  [1 2]]


print(b[:, :, 2])
# [[1 2]
#  [1 2]]

话虽如此，您通常可以通过使用 广播避免完全重复数组。例如，假设我想添加一个 (3,)向量:

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

到 a。我可以在第三维度中复制 a的内容3次，然后在第一维度和第二维度中复制 c的内容2次，这样我的两个数组都是 (2, 2, 3)，然后计算它们的和。然而，这样做更简单、更快捷:

d = a[..., None] + c[None, None, :]

在这里，a[..., None]有形状 (2, 2, 1)和 c[None, None, :]有形状 (1, 1, 3) * 。当我计算总和时，结果沿着尺寸1的维度“广播”出去，给我一个形状 (2, 2, 3)的结果:

print(d.shape)
# (2,  2, 3)


print(d[..., 0])    # a + c[0]
# [[2 3]
#  [2 3]]


print(d[..., 1])    # a + c[1]
# [[3 4]
#  [3 4]]


print(d[..., 2])    # a + c[2]
# [[4 5]
#  [4 5]]

广播是一种非常强大的技术，因为它避免了在内存中创建输入数组的重复副本所涉及的额外开销。

* 虽然为了清晰起见，我将它们包含在内，但是 None索引到 c实际上并不是必要的——你也可以做 a[..., None] + c，即对着 (3,)数组广播一个 (2, 2, 1)数组。这是因为如果其中一个数组的维数比另一个少，那么只有两个数组的 跟踪维数需要兼容。举一个更复杂的例子:

a = np.ones((6, 1, 4, 3, 1))  # 6 x 1 x 4 x 3 x 1
b = np.ones((5, 1, 3, 2))     #     5 x 1 x 3 x 2
result = a + b                # 6 x 5 x 4 x 3 x 2
小开

另一种方法是使用 numpy.dstack。假设你想重复矩阵 a num_repeats次:

import numpy as np
b = np.dstack([a]*num_repeats)

诀窍是将矩阵 a包装到一个单个元素的列表中，然后使用 *操作符将该列表中的元素复制多次。

例如:

a = np.array([[1, 2], [1, 2]])
num_repeats = 5

这将在第三维中重复 [1 2; 1 2]数组5次。要验证(在 IPython 中) :

In [110]: import numpy as np


In [111]: num_repeats = 5


In [112]: a = np.array([[1, 2], [1, 2]])


In [113]: b = np.dstack([a]*num_repeats)


In [114]: b[:,:,0]
Out[114]:
array([[1, 2],
[1, 2]])


In [115]: b[:,:,1]
Out[115]:
array([[1, 2],
[1, 2]])


In [116]: b[:,:,2]
Out[116]:
array([[1, 2],
[1, 2]])


In [117]: b[:,:,3]
Out[117]:
array([[1, 2],
[1, 2]])


In [118]: b[:,:,4]
Out[118]:
array([[1, 2],
[1, 2]])


In [119]: b.shape
Out[119]: (2, 2, 5)

最后我们可以看到矩阵的形状是 2 x 2，在第三维中有5个切片。

小开 
A=np.array([[1,2],[3,4]])
B=np.asarray([A]*N)

编辑@F 先生，以保持尺寸顺序:

B=B.T
小开

下面是一个广播示例，它完全按照要求执行。

a = np.array([[1, 2], [1, 2]])
a=a[:,:,None]
b=np.array([1]*5)[None,None,:]

然后 b*a是期望的结果，(b*a)[:,:,0]产生 array([[1, 2],[1, 2]])，这是原来的 a，(b*a)[:,:,1]，等等。

小开

使用一个视图并获得免费的运行时

在 笨蛋 1.10.0中引入，我们可以利用 numpy.broadcast_to简单地在 2D输入数组中生成一个 3D视图。这样做的好处是不会产生额外的内存开销，并且几乎可以免费使用运行时。在数组很大并且我们可以使用视图的情况下，这是非常重要的。此外，这将工作与一般 n-dim情况下。

我将使用 stack代替 copy，因为读者可能会把它与创建内存副本的数组的复制混淆。

沿第一轴堆栈

如果我们想要沿着第一个轴堆栈输入 arr，那么使用 np.broadcast_to创建 3D视图的解决方案将是-

np.broadcast_to(arr,(3,)+arr.shape) # N = 3 here

沿着第三轴/最后轴堆栈

要沿着第三个轴堆栈输入 arr，创建 3D视图的解决方案是-

np.broadcast_to(arr[...,None],arr.shape+(3,))

如果我们实际上需要一个内存副本，我们总是可以在那里附加 .copy()。因此，解决方案是-

np.broadcast_to(arr,(3,)+arr.shape).copy()
np.broadcast_to(arr[...,None],arr.shape+(3,)).copy()

这里是如何堆叠工程的两个情况下，显示了他们的形状信息的样本情况-

# Create a sample input array of shape (4,5)
In [55]: arr = np.random.rand(4,5)


# Stack along first axis
In [56]: np.broadcast_to(arr,(3,)+arr.shape).shape
Out[56]: (3, 4, 5)


# Stack along third axis
In [57]: np.broadcast_to(arr[...,None],arr.shape+(3,)).shape
Out[57]: (4, 5, 3)

同样的解决方案可以沿着第一个和最后一个轴将 n-dim输入扩展到 n+1-dim视图输出。让我们来探索一些更高的昏暗情况-

3D 输入框:

In [58]: arr = np.random.rand(4,5,6)


# Stack along first axis
In [59]: np.broadcast_to(arr,(3,)+arr.shape).shape
Out[59]: (3, 4, 5, 6)


# Stack along last axis
In [60]: np.broadcast_to(arr[...,None],arr.shape+(3,)).shape
Out[60]: (4, 5, 6, 3)

4D 输入框:

In [61]: arr = np.random.rand(4,5,6,7)


# Stack along first axis
In [62]: np.broadcast_to(arr,(3,)+arr.shape).shape
Out[62]: (3, 4, 5, 6, 7)


# Stack along last axis
In [63]: np.broadcast_to(arr[...,None],arr.shape+(3,)).shape
Out[63]: (4, 5, 6, 7, 3)

诸如此类。

时机

让我们使用一个大的样本 2D的情况下，并得到计时和验证输出是一个 view。

# Sample input array
In [19]: arr = np.random.rand(1000,1000)

让我们证明提出的解决方案确实是一种观点。我们将使用堆叠沿第一轴(结果将是非常相似的堆叠沿第三轴)-

In [22]: np.shares_memory(arr, np.broadcast_to(arr,(3,)+arr.shape))
Out[22]: True

让我们得到的时间表明，它几乎是免费的-

In [20]: %timeit np.broadcast_to(arr,(3,)+arr.shape)
100000 loops, best of 3: 3.56 µs per loop


In [21]: %timeit np.broadcast_to(arr,(3000,)+arr.shape)
100000 loops, best of 3: 3.51 µs per loop

作为一种观点，增加 N从 3到 3000对定时没有任何影响，两者对定时单元都是可以忽略不计的。因此，在内存和性能上都是高效的！

小开

现在也可以通过以下 Np.tiles实现这一点:

import numpy as np


a = np.array([[1,2],[1,2]])
b = np.tile(a,(3, 1,1))


b.shape
(3,2,2)


b
array([[[1, 2],
[1, 2]],


[[1, 2],
[1, 2]],


[[1, 2],
[1, 2]]])
小开

总结上述解决办法:

a = np.arange(9).reshape(3,-1)
b = np.repeat(a[:, :, np.newaxis], 5, axis=2)
c = np.dstack([a]*5)
d = np.tile(a, [5,1,1])
e = np.array([a]*5)
f = np.repeat(a[np.newaxis, :, :], 5, axis=0) # np.repeat again
print('b='+ str(b.shape), b[:,:,-1].tolist())
print('c='+ str(c.shape),c[:,:,-1].tolist())
print('d='+ str(d.shape),d[-1,:,:].tolist())
print('e='+ str(e.shape),e[-1,:,:].tolist())
print('f='+ str(f.shape),f[-1,:,:].tolist())


b=(3, 3, 5) [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
c=(3, 3, 5) [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
d=(5, 3, 3) [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
e=(5, 3, 3) [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
f=(5, 3, 3) [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

祝你好运


提交答案