我有一个像这样的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]]

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

我正在实现一种算法,它要求我在(严格二维)numpy数组中查看非重叠的连续子矩阵.例如,对于12乘12

>>> a = np.random.randint(20, size=(12, 12)); a
array([[ 4,  0, 12, 14,  3,  8, 14, 12, 11, 18,  6,  6],
       [15, 13,  2, 18, 15, 15, 16,  2,  9, 16,  6,  4],
       [18, 18,  3,  8,  1, 15, 14, 13, 13, 13,  7,  0],
       [ 1,  9,  3,  6,  0,  4,  3, 15,  0,  9, 11, 12],
       [ 5, 15,  5,  6,  4,  4, 18, 13, 10, 17, 11,  8],
       [13, 17,  8, 15, 17, 12,  7,  1, 13, …

问题是这个问题的反面.我正在寻找一个从小数组原始大数组的泛型方法:

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]]])

->

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]])

我目前正在开发一种解决方案,它会在完成后发布,但是我希望看到其他(更好)的方法.

我正在使用python实现Strassen的Matrix Multiplication.在除法步骤中,我们将较大的矩阵划分为较小的子矩阵.是否有内置的numpy函数来分割矩阵？

有没有办法将2D阵列分区并重塑为3D阵列.如下例所示:

基本上,我左边有一个4x4矩阵,我想要一个2x2x4矩阵,所以我可以在第3轴上应用numpy.mean.实际上我拥有的矩阵非常庞大,所以这就是为什么循环使用块不是一种选择.

任何帮助是极大的赞赏.

我有一个image形状(466,394,1),我想分成7x7补丁.

image = tf.placeholder(dtype=tf.float32, shape=[1, 466, 394, 1])

运用

image_patches = tf.extract_image_patches(image, [1, 7, 7, 1], [1, 7, 7, 1], [1, 1, 1, 1], 'VALID')
# shape (1, 66, 56, 49)

image_patches_reshaped = tf.reshape(image_patches, [-1, 7, 7, 1])
# shape (3696, 7, 7, 1)

遗憾的是,在实际操作中image_patches_reshaped不能混合像素顺序(如果你认为images_patches_reshaped你只会看到噪音).

所以我的新方法是使用tf.split:

image_hsplits = tf.split(1, 4, image_resized)
# [<tf.Tensor 'split_255:0' shape=(462, 7, 1) dtype=float32>,...]

image_patches = []

for split in image_hsplits:
    image_patches.extend(tf.split(0, 66, split))

image_patches
# …

有一个功能np.split()可以沿1轴分割数组.我想知道是否有一个多轴版本,你可以沿轴(0,1,2)分割.

我有一个非常大的2D numpy数组,包含2x2子集,我需要取平均值.我正在寻找一种矢量化此操作的方法.例如,给定x:

#               |- col 0 -|   |- col 1 -|   |- col 2 -|       
x = np.array( [[ 0.0,   1.0,   2.0,   3.0,   4.0,   5.0],  # row 0
               [ 6.0,   7.0,   8.0,   9.0,  10.0,  11.0],  # row 0
               [12.0,  13.0,  14.0,  15.0,  16.0,  17.0],  # row 1
               [18.0,  19.0,  20.0,  21.0,  22.0,  23.0]]) # row 1

我需要得到一个2x3阵列,它是每个2x2子阵列的平均值,即:

result = np.array( [[ 3.5,  5.5,  7.5],
                    [15.5, 17.5, 19.5]])

因此,元素[0,0]被计算为x [0:2,0:2]的平均值,而元素[0,1]将是x [2:4,0:2]的平均值.Numpy是否有像这样的子集进行聚合的矢量化/有效方法？

我有一个数据框如下：

df1=pd.DataFrame(np.arange(24).reshape(6,-1),columns=['a','b','c','d'])

我想采用3组行并将它们按以下顺序转换为列

整形重塑没有给出预期的答案

pd.DataFrame(np.reshape(df1.values,(3,-1)),columns=['a','b','c','d','e','f','g','h'])

我有一些非常大的二维numpy数组。一个数据集是55732 x 257659，超过140亿个元素。因为我需要执行throws MemoryError的一些操作，所以我想尝试将数组拆分为一定大小的块，然后将它们针对这些块运行。（我可以在每个片段上运行该操作之后汇总结果。）我的问题所在的事实MemoryErrors意味着，重要的是我可以以某种方式限制数组的大小，而不是将它们拆分为固定数量的片段。

例如，让我们生成一个1009 x 1009随机数组：

a = numpy.random.choice([1,2,3,4], (1009,1009))

我的数据没有必要进行均分，并且绝对不能保证可以按我想要的大小进行分割。所以我选择1009是因为它是主要的。

还要说我希望它们以不大于50 x 50的块的形式出现。由于这只是为了避免极大数组的错误，因此如果结果不准确也可以。

如何将其拆分为所需的块？

我正在使用numpy 1.14.3（最新）的Python 3.6 64位。

有关

我已经看到了使用的函数reshape，但是如果行数和列数未完全划分大小，则该函数将无效。

这个问题（以及其他类似问题）的答案解释了如何拆分为一定数量的块，但这并未说明如何拆分为一定的大小。

我也看到了这个问题，因为这实际上是我的确切问题。答案和评论建议切换到64位（我已经拥有）并使用numpy.memmap。都没有帮助。

我有一个二进制图像,我想分成4 x 4像素的块,并计算一个块中黑色像素的数量.如果块中黑色像素的总和是偶数,则为相应的块指定值0.否则,该值为1.之后,将其保存/写入txt文件,以便我可以看到结果.

我已尝试使用代码,但卡住了

import matplotlib.pyplot as plt
import numpy as np
image = plt.imread('myplot1.png')
image = np.array(image)
image = image[:,:,1] #if RGB

print(image.shape)
for x in np.arange(0,image.shape[0]):
    for y in np.arange(image.shape[1]):
        if x+4 < image.shape[0] and y+4 < image.shape[1]:
             sum = np.sum(image[x:x+4,y:y+4])
             if sum > 4:
                image[x:x + 4, y:y + 4] = 1
             elif sum < 4:
                image[x:x + 4, y:y + 4] = 0