相关疑难解决方法(0)

有没有办法将ndy中的2d数组切成较小的2d数组？

例

[[1,2,3,4],   ->    [[1,2] [3,4]   
 [5,6,7,8]]          [5,6] [7,8]]

所以我基本上想要将2x4阵列减少为2个2x2阵列.寻找用于图像的通用解决方案.

我有一个像这样的3d矩阵

arange(16).reshape((4,2,2))
array([[[ 0,  1],
        [ 2,  3]],

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

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

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

并希望以网格格式堆叠它们,最终得到

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

有没有一种方法可以不明确地hstacking(和/或vstacking)它们或添加额外的维度和重塑(不确定这会工作)？

谢谢,

我正在尝试使用numpy.lib.stride_tricks.as_strided来迭代数组的非重叠块,但是我无法找到参数的文档,所以我只能得到重叠的块.

例如,我有一个4x5阵列,我希望得到4个2x2块.我很好,右边和底边的额外细胞被排除在外.

到目前为止,我的代码是:

import sys
import numpy as np

a = np.array([
[1,2,3,4,5],
[6,7,8,9,10],
[11,12,13,14,15],
[16,17,18,19,20],
])

sz = a.itemsize
h,w = a.shape
bh,bw = 2,2

shape = (h/bh, w/bw, bh, bw)
strides = (w*sz, sz, w*sz, sz)
blocks = np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)

print blocks[0][0]
assert blocks[0][0].tolist() == [[1, 2], [6,7]]
print blocks[0][1]
assert blocks[0][1].tolist() == [[3,4], [8,9]]
print blocks[1][0]
assert blocks[1][0].tolist() == [[11, 12], [16, 17]]

生成的块数组的形状似乎是正确的,但最后两个断言失败,可能是因为我的形状或步幅参数不正确.我应该设置哪些值来获得非重叠块？

是否有更惯用的方式来显示图像网格,如下例所示？

import numpy as np

def gallery(array, ncols=3):
    nrows = np.math.ceil(len(array)/float(ncols))
    cell_w = array.shape[2]
    cell_h = array.shape[1]
    channels = array.shape[3]
    result = np.zeros((cell_h*nrows, cell_w*ncols, channels), dtype=array.dtype)
    for i in range(0, nrows):
        for j in range(0, ncols):
            result[i*cell_h:(i+1)*cell_h, j*cell_w:(j+1)*cell_w, :] = array[i*ncols+j]
    return result

我试着用hstack和reshape等,但不能得到正确的行为.

我有兴趣使用numpy这样做,因为使用matplotlib调用subplot和可以绘制多少图像是有限制的imshow.

如果您需要测试样本数据,可以像下面这样使用网络摄像头:

import cv2
import matplotlib.pyplot as plt
_, img = cv2.VideoCapture(0).read()

plt.imshow(gallery(np.array([img]*6)))

假设我有矩阵P，其大小[4, 4]划分为4个较小的矩阵[2,2]。如何有效地将此块矩阵乘以另一个矩阵（不是分区矩阵而是较小的矩阵）？

假设我们的原始矩阵为：

P = [ 1 1 2 2
      1 1 2 2
      3 3 4 4
      3 3 4 4]

其中分为子矩阵：

P_1 = [1 1    , P_2 = [2 2  , P_3 = [3 3   P_4 = [4 4
       1 1]            2 2]          3 3]         4 4]

现在我们的P是：

P = [P_1 P_2
     P_3 p_4]

下一步，我想在P和较小矩阵之间进行逐元素乘法，其大小等于子矩阵的数量：

P * [ 1 0   =   [P_1  0  = [1 1 0 0 
      0 0 ]      0 …