通过最近邻平铺对numpy数组进行上采样的快速方法[重复]

问题描述：

我有一个MxN大小的二维整数数组，我想将该数组扩展为(BM)x(BN)，其中B是方形图块边的长度，因此输入数组的每个元素在最终数组中都作为BxB块重复。下面是一个嵌套 for 循环的示例。有没有更快/内置的方法？

import numpy as np

a = np.arange(9).reshape([3,3])            # input array - 3x3
B=2.                                       # block size - 2  
A = np.zeros([a.shape[0]*B,a.shape[1]*B])  # output array - 6x6

# Loop, filling A with tiled values of a at each index
for i,l in enumerate(a):                   # lines in a
    for j,aij in enumerate(l):             # a[i,j]
        A[B*i:B*(i+1),B*j:B*(j+1)] = aij

结果 ...

a=      [[0 1 2]
         [3 4 5]
         [6 7 8]]

A =     [[ 0.  0.  1.  1.  2.  2.]
         [ 0.  0.  1.  1.  2.  2.]
         [ 3.  3.  4.  4.  5.  5.]
         [ 3.  3.  4.  4.  5.  5.]
         [ 6.  6.  7.  7.  8.  8.]
         [ 6.  6.  7.  7.  8.  8.]]

解决方案 1：

一个选择是

>>> a.repeat(2, axis=0).repeat(2, axis=1)
array([[0, 0, 1, 1, 2, 2],
       [0, 0, 1, 1, 2, 2],
       [3, 3, 4, 4, 5, 5],
       [3, 3, 4, 4, 5, 5],
       [6, 6, 7, 7, 8, 8],
       [6, 6, 7, 7, 8, 8]])

由于中间数组，这稍微浪费，但至少它很简洁。

解决方案 2：

以下是使用步幅技巧和重塑的一种潜在快速方法：

from numpy.lib.stride_tricks import as_strided

def tile_array(a, b0, b1):
    r, c = a.shape                                    # number of rows/columns
    rs, cs = a.strides                                # row/column strides 
    x = as_strided(a, (r, b0, c, b1), (rs, 0, cs, 0)) # view a as larger 4D array
    return x.reshape(r*b0, c*b1)                      # create new 2D array

a调用时会复制中的底层数据reshape，因此此函数不会返回视图。但是，与repeat沿多个轴使用相比，所需的复制操作更少。

然后可以按如下方式使用该函数：

>>> a = np.arange(9).reshape(3, 3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

>>> tile_array(a, 2, 2)
array([[0, 0, 1, 1, 2, 2],
       [0, 0, 1, 1, 2, 2],
       [3, 3, 4, 4, 5, 5],
       [3, 3, 4, 4, 5, 5],
       [6, 6, 7, 7, 8, 8],
       [6, 6, 7, 7, 8, 8]])

>>> tile_array(a, 3, 4)
array([[0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2],
       [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2],
       [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2],
       [3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5],
       [3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5],
       [3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5],
       [6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8],
       [6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8],
       [6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8]])

现在，对于小块，此方法比使用慢一点repeat，但比快kron。

然而，对于稍大一点的块，它比其他替代方案更快。例如，使用以下块形状(20, 20)：

>>> %timeit tile_array(a, 20, 20)
100000 loops, best of 3: 18.7 µs per loop

>>> %timeit a.repeat(20, axis=0).repeat(20, axis=1)
10000 loops, best of 3: 26 µs per loop

>>> %timeit np.kron(a, np.ones((20,20), a.dtype))
10000 loops, best of 3: 106 µs per loop

随着块大小的增加，方法之间的差距也会增大。

如果a是一个大数组，它可能比其他方法更快：

>>> a2 = np.arange(1000000).reshape(1000, 1000)
>>> %timeit tile_array(a2, 2, 2)
100 loops, best of 3: 11.4 ms per loop

>>> %timeit a2.repeat(2, axis=0).repeat(2, axis=1)
1 loops, best of 3: 30.9 ms per loop

解决方案 3：

可能不是最快的，但是......

np.kron(a, np.ones((B,B), a.dtype))

它计算克罗内克积，因此它涉及输出中每个元素的乘法。