水平和垂直分割一个numpy数组答案

【问题标题】：split a numpy array both horizontally and vertically水平和垂直分割一个numpy数组
【发布时间】：2017-06-27 14:09:06
【问题描述】：

将 NumPy 矩阵（二维数组）垂直和水平分割成相等块的最 Pythonic 方式是什么？

例如：

aa = np.reshape(np.arange(270),(18,15)) # a 18x15 matrix

然后是一个“函数”，比如

ab = np.split2d(aa,(2,3))

将生成一个包含 6 个矩阵的列表，每个矩阵的形状为 (9,5)。第一个猜测是结合 hsplit、map 和 vsplit，但是如果要为 mar 定义两个参数，则必须如何应用 mar，例如：

map(np.vsplit(@,3),np.hsplit(aa,2))

【问题讨论】：

(6,9,5) 应该是结果矩阵的形状，对吧？
是的，它会很好，但 (9,5,6) 也可以，或者甚至像许多其他 NumPy 函数一样的六个 NumPy 数组的“非 NumPy”列表也会很好够了

标签： python numpy matrix split

【解决方案1】：

这是留在 NumPy 环境中的一种方法 -

def view_as_blocks(arr, BSZ):
    # arr is input array, BSZ is block-size
    m,n = arr.shape
    M,N = BSZ
    return arr.reshape(m//M, M, n//N, N).swapaxes(1,2).reshape(-1,M,N)

样本运行

1) 验证形状的实际大案例：

In [41]: aa = np.reshape(np.arange(270),(18,15))

In [42]: view_as_blocks(aa, (9,5)).shape
Out[42]: (6, 9, 5)

2) 手动验证值的小案例：

In [43]: aa = np.reshape(np.arange(36),(6,6))

In [44]: aa
Out[44]: 
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35]])

In [45]: view_as_blocks(aa, (2,3)) # Blocks of shape (2,3)
Out[45]: 
array([[[ 0,  1,  2],
        [ 6,  7,  8]],

       [[ 3,  4,  5],
        [ 9, 10, 11]],

       [[12, 13, 14],
        [18, 19, 20]],

       [[15, 16, 17],
        [21, 22, 23]],

       [[24, 25, 26],
        [30, 31, 32]],

       [[27, 28, 29],
        [33, 34, 35]]])

如果您愿意与其他库合作，scikit-image 可以在这里使用，就像这样 -

from skimage.util import view_as_blocks as viewB

out = viewB(aa, tuple(BSZ)).reshape(-1,*BSZ)

运行时测试-

In [103]: aa = np.reshape(np.arange(270),(18,15))

# @EFT's soln
In [99]: %timeit split_2d(aa, (2,3))
10000 loops, best of 3: 23.3 µs per loop

# @glegoux's soln-1
In [100]: %timeit list(get_chunks(aa, 2,3))
100000 loops, best of 3: 3.7 µs per loop

# @glegoux's soln-2
In [111]: %timeit list(get_chunks2(aa, 9, 5))
100000 loops, best of 3: 3.39 µs per loop

# Proposed in this post
In [101]: %timeit view_as_blocks(aa, (9,5))
1000000 loops, best of 3: 1.86 µs per loop

请注意，我已将(2,3) 用于split_2d 和get_chunks，根据它们的定义，它们将其用作块数。在我使用view_as_blocks 的情况下，我有参数BSZ 指示块大小。所以，我在那里有(9,5)。 get_chunks2 遵循与 view_as_blocks 相同的格式。那里的输出应该代表相同。

【讨论】：

修复aa -> arr
非常感谢@Divakar！非常感谢@glegoux！
@NickPanov 总是很开心！
你是否反转行和行来分割成块？？
@Divakar @glegoux 因get_chunks（错字）而获得荣誉。此外，%timeit 结果的有趣之处在于 np.split 是真正减慢我速度的原因。 view_as_blocks 和 list(get_chunks()) 都比调用 np.split 更快。

【解决方案2】：

您可以使用np.split 和np.concatenate，后者允许在一个步骤中进行第二次拆分：

def split_2d(array, splits):
    x, y = splits
    return np.split(np.concatenate(np.split(array, y, axis=1)), x*y)

ab = split_2d(aa,(2,3))

ab[0].shape
Out[95]: (9, 5)

len(ab)
Out[96]: 6

这似乎也应该相对简单地推广到 n-dim 情况，尽管我还没有一直遵循这个想法。

编辑：

对于单个数组作为输出，只需添加np.stack：

np.stack(ab).shape
Out[99]: (6, 9, 5)

【讨论】：

非常感谢@EFT！

【解决方案3】：

要切割，这个矩阵 (18,15) ：

+-+-+-+
+     +
+-+-+-+

在 2x3 块 (9,5) 中喜欢它：

+-+-+-+
+-+-+-+
+-+-+-+

做：

from pprint import pprint
import numpy as np

M = np.reshape(np.arange(18*15),(18,15))

def get_chunks(M, n, p):
    n = len(M)//n
    p = len(M[0])//p
    for i in range(0, len(M), n):
        for j in range(0, len(M[0]), p):
            yield M[i:i+n,j:j+p]

def get_chunks2(M, n, p):
        for i in range(0, len(M), n):
            for j in range(0, len(M[0]), p):
                yield M[i:i+n,j:j+p]

# list(get_chunks2(M, 9, 5)) same result more faster
chunks = list(get_chunks(M, 2, 3))

pprint(chunks)

输出：

[array([[  0,   1,   2,   3,   4],
       [ 15,  16,  17,  18,  19],
       [ 30,  31,  32,  33,  34],
       [ 45,  46,  47,  48,  49],
       [ 60,  61,  62,  63,  64],
       [ 75,  76,  77,  78,  79],
       [ 90,  91,  92,  93,  94],
       [105, 106, 107, 108, 109],
       [120, 121, 122, 123, 124]]),
 array([[  5,   6,   7,   8,   9],
       [ 20,  21,  22,  23,  24],
       [ 35,  36,  37,  38,  39],
       [ 50,  51,  52,  53,  54],
       [ 65,  66,  67,  68,  69],
       [ 80,  81,  82,  83,  84],
       [ 95,  96,  97,  98,  99],
       [110, 111, 112, 113, 114],
       [125, 126, 127, 128, 129]]),
 array([[ 10,  11,  12,  13,  14],
       [ 25,  26,  27,  28,  29],
       [ 40,  41,  42,  43,  44],
       [ 55,  56,  57,  58,  59],
       [ 70,  71,  72,  73,  74],
       [ 85,  86,  87,  88,  89],
       [100, 101, 102, 103, 104],
       [115, 116, 117, 118, 119],
       [130, 131, 132, 133, 134]]),
 array([[135, 136, 137, 138, 139],
       [150, 151, 152, 153, 154],
       [165, 166, 167, 168, 169],
       [180, 181, 182, 183, 184],
       [195, 196, 197, 198, 199],
       [210, 211, 212, 213, 214],
       [225, 226, 227, 228, 229],
       [240, 241, 242, 243, 244],
       [255, 256, 257, 258, 259]]),
 array([[140, 141, 142, 143, 144],
       [155, 156, 157, 158, 159],
       [170, 171, 172, 173, 174],
       [185, 186, 187, 188, 189],
       [200, 201, 202, 203, 204],
       [215, 216, 217, 218, 219],
       [230, 231, 232, 233, 234],
       [245, 246, 247, 248, 249],
       [260, 261, 262, 263, 264]]),
 array([[145, 146, 147, 148, 149],
       [160, 161, 162, 163, 164],
       [175, 176, 177, 178, 179],
       [190, 191, 192, 193, 194],
       [205, 206, 207, 208, 209],
       [220, 221, 222, 223, 224],
       [235, 236, 237, 238, 239],
       [250, 251, 252, 253, 254],
       [265, 266, 267, 268, 269]])]

【讨论】：

【解决方案4】：

为了更简单的解决方案，我使用了np.array_split 以及变换矩阵。所以假设我希望它垂直分成 3 个相等的块，水平分成 2 个相等的块，那么：

# Create your matrix
matrix = np.reshape(np.arange(270),(18,15)) # a 18x15 matrix

# Container for your final matrices
final_matrices = []

# Then split into 3 equal chunks vertically
vertically_split_matrices = np.array_split(matrix)
for v_m in vertically_split_matrices:
    # Then split the transformed matrices equally
    m1, m2 = np.array_split(v_m.T, 2)
    # And transform the matrices back
    final_matrices.append(m1.T)
    final_matrices.append(m2.T)

所以我最终得到了 6 个块，所有块的高度和宽度都相同。

【讨论】：