从较小的矩阵填充较大的矩阵

Question

我必须使用由较小的2D阵列制成的块填充较大的2D阵列,但仍然考虑到比新的大2D阵列边缘处的块的宽度更少的列行数.例如,使用3x3块从左侧阵列右侧创建阵列.

[[ 1  2  3  4]         [[  1.   1.   1.   2.   2.   2.   3.   3.   3.   4.   4.]
 [ 5  6  7  8]    ->    [  1.   1.   1.   2.   2.   2.   3.   3.   3.   4.   4.]
 [ 9 10 11 12]]         [  1.   1.   1.   2.   2.   2.   3.   3.   3.   4.   4.]
                        [  5.   5.   5.   6.   6.   6.   7.   7.   7.   8.   8.]
                        [  5.   5.   5.   6.   6.   6.   7.   7.   7.   8.   8.]
                        [  5.   5.   5.   6.   6.   6.   7.   7.   7.   8.   8.]
                        [  9.   9.   9.  10.  10.  10.  11.  11.  11.  12.  12.]]

我实现了如下所示,但我正在寻找一种更聪明的方法.

# Smaller array
a=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

# The size of the blocks for filling in the matrix
blockSize = 3

# The number of columns and rows of the new matrix (b)
cols = 11
rows = 7
b = np.zeros([rows, cols])

for i in range(0, rows, blockSize):
    ii = i/blockSize
    if i + blockSize < rows:
        numRows = blockSize
    else:
        numRows = rows - i
    for j in range(0, cols, blockSize):
        jj= j/blockSize
        if j + blockSize < cols:
            numCols = blockSize
        else:
            numCols = cols - j

        b[i:i+numRows,j:j+numCols] = a[ii,jj]

Answer 1

你可以分两个阶段重复; 一次为列,一次为行.

a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
blockSize = 3
cols = 11
rows = 7

每一次,重复为每个元素的数量的列表是从计算blockSize和任一rows或cols(例如[3, 3, 3, 2]针对列).这将创建一个所需大小的数组:

>>> result = a.repeat([blockSize]*(cols//blockSize) + [cols % blockSize], axis=1)
>>> result = result.repeat([blockSize]*(rows//blockSize) + [rows % blockSize], axis=0)
>>> result
array([[ 1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4],
       [ 1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4],
       [ 1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4],
       [ 5,  5,  5,  6,  6,  6,  7,  7,  7,  8,  8],
       [ 5,  5,  5,  6,  6,  6,  7,  7,  7,  8,  8],
       [ 5,  5,  5,  6,  6,  6,  7,  7,  7,  8,  8],
       [ 9,  9,  9, 10, 10, 10, 11, 11, 11, 12, 12]])

另一种方法是使用类似的np.kron方法创建每个元素的块,然后将数组切片到所需的大小.但是,这会首先创建一个可能比所需大得多的数组(并且可能对内存效率低下).

np.kron(a, np.ones((blockSize, blockSize)))[:rows, :cols]