重塑 3D 数组中的数组集

Question

为了进行计算，我有一组数组：“子”数组（如下所示），我想将其重塑为“测试”数组给出的数组：

import numpy as np

sub = np.array([[[[ 1.,  1.],
         [ 1.,  1.]],

        [[ 2.,  2.],
         [ 2.,  2.]],

        [[ 3.,  3.],
         [ 3.,  3.]],

        [[ 4.,  4.],
         [ 4.,  4.]]],

       [[[ 5.,  5.],
         [ 5.,  5.]],

        [[ 6.,  6.],
         [ 6.,  6.]],

        [[ 7.,  7.],
         [ 7.,  7.]],

        [[ 8.,  8.],
         [ 8.,  8.]]]])


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

       [[ 5.,  5.,  6., 6.],
        [ 5.,  5.,  6., 6.],
        [ 7.,  7.,  8., 8.],
        [ 7.,  7.,  8., 8.]]]) 

我在帖子中发现了部分代码似乎适用于我的情况，但我有一些错误...

k,l,m,n,p =2,2,2,2,2
conc = np.array([np.ones([p,m,n],dtype=int)*i for i in range(k*l)])
test_reshape=np.vstack([np.hstack(sub[i:i+l]) for i in range(0,k*l*p,l)])

Answer 1

这是一种将数组交换、切片和堆叠成形状的替代方法：

>>> t = sub.swapaxes(1, 3).T.swapaxes(1, 3)
>>> x = np.c_[t[::2, 0], t[1::2, 0]]
>>> y = np.c_[t[::2, 1], t[1::2, 1]]
>>> np.array((np.r_[x[0], x[1]], np.r_[y[0], y[1]]))

array([[[ 1.,  1.,  2.,  2.],
        [ 1.,  1.,  2.,  2.],
        [ 3.,  3.,  4.,  4.],
        [ 3.,  3.,  4.,  4.]],

       [[ 5.,  5.,  6.,  6.],
        [ 5.,  5.,  6.,  6.],
        [ 7.,  7.,  8.,  8.],
        [ 7.,  7.,  8.,  8.]]])

编辑：或者，挤压、切片和堆叠：

>>> x = np.c_[sub[:1][:,::2], sub[:1][:,1::2]].squeeze()
>>> y = np.c_[sub[1:][:,::2], sub[1:][:,1::2]].squeeze()
>>> np.array((np.r_[x[0], x[1]], np.r_[y[0], y[1]]))
# the required array

Answer 2

也许存在一个纯粹的 numpy 解决方案，但我不知道它会使用相当多的技巧。因此，下面的解决方案效率不高，因为它使用 python 的 for 循环（使其速度变慢），但它会以 general 的方式得到你的结果，所以没有它取决于你的大小实际的 4D 数组。

np.vstack( (sub[vol,2*sheet:2*sheet+2].reshape((4,-1)).T for vol in range(2) for sheet in range(2))).reshape((2,4,-1)

Answer 3

import numpy as np
sub = np.array(...)
test = np.array([np.hstack((np.vstack(( s[0],s[1] )),
                            np.vstack(( s[2],s[3] )))) for s in sub])
print test

在 OP 的示例中，sub 的形状为 (2,4,2,2)，但上面的代码对于形状为 (n,4,m,m) 的数组按原样工作。对于(n,k,m,m)类型的不同形状，上面的代码可以适应不同的需求。

最后我想补充一点，当您查看代码时您会真正看到代码正在实现什么，这可能会在效率方面补偿代码的其他缺陷（即，复制与重塑）。

---

更好的解决方案（即不是我的 ;-) 和一些事后的想法

我发现this answer from unutbu（包含指向更通用解决方案的链接）OP 可以轻松（？）适应她/他的需求。由于复杂的重塑 然而，所涉及的数据被复制，因此 OP 可能希望测量这两种方法的不同性能，同时考虑到她/他的程序总运行时间的“重塑”的发生率（即恕我直言，在2' 的运行时间不值得努力）

示例交互会话

在下文中，数据和过程字面意思来自 the above mentioned answer from unutbu，最后两条语句是我添加的，用来显示ndarrays、x、y和z这三个数据缓冲区的地址。

In [1]: import numpy as np

In [2]: x = np.arange(16).reshape((4,2,2))

In [3]: y = x.reshape(2,2,2,2).swapaxes(1,2).reshape(4,-1)

In [4]: x
Out[4]: 
array([[[ 0,  1],
        [ 2,  3]],

       [[ 4,  5],
        [ 6,  7]],

       [[ 8,  9],
        [10, 11]],

       [[12, 13],
        [14, 15]]])

In [5]: y
Out[5]: 
array([[ 0,  1,  4,  5],
       [ 2,  3,  6,  7],
       [ 8,  9, 12, 13],
       [10, 11, 14, 15]])

In [6]: z = x.T

In [7]: [a.__array_interface__['data'][0] for a in (x, y, z)]
Out[7]: [46375856, 45578800, 46375856]

In [8]: 

Answer 4

这可以使用a reshape/swapaxes trick：

In [92]: sub.reshape(2,2,2,2,2).swapaxes(2,3).reshape(test.shape)
Out[92]: 
array([[[ 1.,  1.,  2.,  2.],
        [ 1.,  1.,  2.,  2.],
        [ 3.,  3.,  4.,  4.],
        [ 3.,  3.,  4.,  4.]],

       [[ 5.,  5.,  6.,  6.],
        [ 5.,  5.,  6.,  6.],
        [ 7.,  7.,  8.,  8.],
        [ 7.,  7.,  8.,  8.]]])

In [94]: np.allclose(sub.reshape(2,2,2,2,2).swapaxes(2,3).reshape(test.shape), test)
Out[94]: True

我承认我不知道如何在没有猜测的情况下生成这种解决方案。但似乎当你想重新排列数组中的“块”时，有一种方法可以通过重塑到更高的维度，交换一些轴，然后重塑到所需的形状来实现。鉴于sub.shape 是(2, 4, 2, 2) 重塑到更高的维度必须意味着(2, 2, 2, 2, 2)。所以你只需要测试表单的解决方案

sub.reshape(2,2,2,2,2).swapaxes(i,j).reshape(test.shape)

这很容易做到：

for i,j in IT.combinations(range(5), 2):
    if np.allclose(sub.reshape(2,2,2,2,2).swapaxes(i,j).reshape(test.shape), test):
       print(i,j)

显示要交换的正确轴：

(2, 3)