给定2D（M x N）矩阵和2D内核（K x L），如何使用图像上的给定内核返回一个矩阵，该矩阵是最大值或均值池的结果？
如果可能，我想使用numpy。
注意：M，N，K，L可以是偶数或奇数，并且它们不需要彼此完全可分，例如：7x5矩阵和2x2内核。
例如max pooling：
matrix:
array([[ 20, 200, -5, 23],
[ -13, 134, 119, 100],
[ 120, 32, 49, 25],
[-120, 12, 09, 23]])
kernel: 2 x 2
soln:
array([[ 200, 119],
[ 120, 49]])
答案 0 :(得分：39)
您可以使用scikit-image block_reduce：
import numpy as np
import skimage.measure
a = np.array([
[ 20, 200, -5, 23],
[ -13, 134, 119, 100],
[ 120, 32, 49, 25],
[-120, 12, 9, 23]
])
skimage.measure.block_reduce(a, (2,2), np.max)
给出：
array([[200, 119],
[120, 49]])
答案 1 :(得分：10)
如果图像大小可以被内核大小整除，则可以重新整形数组，并根据需要使用max或mean
import numpy as np
mat = np.array([[ 20, 200, -5, 23],
[ -13, 134, 119, 100],
[ 120, 32, 49, 25],
[-120, 12, 9, 23]])
M, N = mat.shape
K = 2
L = 2
MK = M // K
NL = N // L
print(mat[:MK*K, :NL*L].reshape(MK, K, NL, L).max(axis=(1, 3)))
# [[200, 119], [120, 49]]
如果没有偶数个内核，则必须单独处理边界。 （正如评论中所指出的，这导致矩阵被复制，这将影响性能）。
mat = np.array([[20, 200, -5, 23, 7],
[-13, 134, 119, 100, 8],
[120, 32, 49, 25, 12],
[-120, 12, 9, 23, 15],
[-57, 84, 19, 17, 82],
])
# soln
# [200, 119, 8]
# [120, 49, 15]
# [84, 19, 82]
M, N = mat.shape
K = 2
L = 2
MK = M // K
NL = N // L
# split the matrix into 'quadrants'
Q1 = mat[:MK * K, :NL * L].reshape(MK, K, NL, L).max(axis=(1, 3))
Q2 = mat[MK * K:, :NL * L].reshape(-1, NL, L).max(axis=2)
Q3 = mat[:MK * K, NL * L:].reshape(MK, K, -1).max(axis=1)
Q4 = mat[MK * K:, NL * L:].max()
# compose the individual quadrants into one new matrix
soln = np.vstack([np.c_[Q1, Q3], np.c_[Q2, Q4]])
print(soln)
# [[200 119 8]
# [120 49 15]
# [ 84 19 82]]
答案 2 :(得分：5)
而不是制作＆＃34;象限＆＃34;如Elliot的答案所示，我们可以将其填充以使其均匀分割，然后执行最大或平均汇总。
由于池在CNN中经常使用，因此输入数组通常是3D。所以我制作了一个适用于2D或3D阵列的功能。
def pooling(mat,ksize,method='max',pad=False):
'''Non-overlapping pooling on 2D or 3D data.
<mat>: ndarray, input array to pool.
<ksize>: tuple of 2, kernel size in (ky, kx).
<method>: str, 'max for max-pooling,
'mean' for mean-pooling.
<pad>: bool, pad <mat> or not. If no pad, output has size
n//f, n being <mat> size, f being kernel size.
if pad, output has size ceil(n/f).
Return <result>: pooled matrix.
'''
m, n = mat.shape[:2]
ky,kx=ksize
_ceil=lambda x,y: int(numpy.ceil(x/float(y)))
if pad:
ny=_ceil(m,ky)
nx=_ceil(n,kx)
size=(ny*ky, nx*kx)+mat.shape[2:]
mat_pad=numpy.full(size,numpy.nan)
mat_pad[:m,:n,...]=mat
else:
ny=m//ky
nx=n//kx
mat_pad=mat[:ny*ky, :nx*kx, ...]
new_shape=(ny,ky,nx,kx)+mat.shape[2:]
if method=='max':
result=numpy.nanmax(mat_pad.reshape(new_shape),axis=(1,3))
else:
result=numpy.nanmean(mat_pad.reshape(new_shape),axis=(1,3))
return result
有时您可能希望以不等于内核大小的步幅执行重叠池。这是一个使用或不使用填充的功能：
def asStride(arr,sub_shape,stride):
'''Get a strided sub-matrices view of an ndarray.
See also skimage.util.shape.view_as_windows()
'''
s0,s1=arr.strides[:2]
m1,n1=arr.shape[:2]
m2,n2=sub_shape
view_shape=(1+(m1-m2)//stride[0],1+(n1-n2)//stride[1],m2,n2)+arr.shape[2:]
strides=(stride[0]*s0,stride[1]*s1,s0,s1)+arr.strides[2:]
subs=numpy.lib.stride_tricks.as_strided(arr,view_shape,strides=strides)
return subs
def poolingOverlap(mat,ksize,stride=None,method='max',pad=False):
'''Overlapping pooling on 2D or 3D data.
<mat>: ndarray, input array to pool.
<ksize>: tuple of 2, kernel size in (ky, kx).
<stride>: tuple of 2 or None, stride of pooling window.
If None, same as <ksize> (non-overlapping pooling).
<method>: str, 'max for max-pooling,
'mean' for mean-pooling.
<pad>: bool, pad <mat> or not. If no pad, output has size
(n-f)//s+1, n being <mat> size, f being kernel size, s stride.
if pad, output has size ceil(n/s).
Return <result>: pooled matrix.
'''
m, n = mat.shape[:2]
ky,kx=ksize
if stride is None:
stride=(ky,kx)
sy,sx=stride
_ceil=lambda x,y: int(numpy.ceil(x/float(y)))
if pad:
ny=_ceil(m,sy)
nx=_ceil(n,sx)
size=((ny-1)*sy+ky, (nx-1)*sx+kx) + mat.shape[2:]
mat_pad=numpy.full(size,numpy.nan)
mat_pad[:m,:n,...]=mat
else:
mat_pad=mat[:(m-ky)//sy*sy+ky, :(n-kx)//sx*sx+kx, ...]
view=asStride(mat_pad,ksize,stride)
if method=='max':
result=numpy.nanmax(view,axis=(2,3))
else:
result=numpy.nanmean(view,axis=(2,3))
return result
答案 3 :(得分：0)
由于numpy文档说将“ numpy.lib.stride_tricks.as_strided”与“ extreme care”一起使用，因此这是没有2D / 3D池的另一种解决方案。
如果strides = 1，则使用相同的填充。对于跨度> 1，我不确定100％定义相同的填充...
def pool3D(arr,
kernel=(2, 2, 2),
stride=(1, 1, 1),
func=np.nanmax,
):
# check inputs
assert arr.ndim == 3
assert len(kernel) == 3
# create array with lots of padding around it, from which we grab stuff (could be more efficient, yes)
arr_padded_shape = arr.shape + 2 * np.array(kernel)
arr_padded = np.zeros(arr_padded_shape, dtype=arr.dtype) * np.nan
arr_padded[
kernel[0]:kernel[0] + arr.shape[0],
kernel[1]:kernel[1] + arr.shape[1],
kernel[2]:kernel[2] + arr.shape[2],
] = arr
# create temporary array, which aggregates kernel elements in last axis
size_x = 1 + (arr.shape[0]-1) // stride[0]
size_y = 1 + (arr.shape[1]-1) // stride[1]
size_z = 1 + (arr.shape[2]-1) // stride[2]
size_kernel = np.prod(kernel)
arr_tmp = np.empty((size_x, size_y, size_z, size_kernel), dtype=arr.dtype)
# fill temporary array
kx_center = (kernel[0] - 1) // 2
ky_center = (kernel[1] - 1) // 2
kz_center = (kernel[2] - 1) // 2
idx_kernel = 0
for kx in range(kernel[0]):
dx = kernel[0] + kx - kx_center
for ky in range(kernel[1]):
dy = kernel[1] + ky - ky_center
for kz in range(kernel[2]):
dz = kernel[2] + kz - kz_center
arr_tmp[:, :, :, idx_kernel] = arr_padded[
dx:dx + arr.shape[0]:stride[0],
dy:dy + arr.shape[1]:stride[1],
dz:dz + arr.shape[2]:stride[2],
]
idx_kernel += 1
# perform pool function
arr_final = func(arr_tmp, axis=-1)
return arr_final
def pool2D(arr,
kernel=(2, 2),
stride=(1, 1),
func=np.nanmax,
):
# check inputs
assert arr.ndim == 2
assert len(kernel) == 2
# transform into 3D array with empty dimension?
arr3D = arr[..., np.newaxis]
kernel3D = kernel + (1,)
stride3D = stride + (1,)
arr3D_final = pool3D(arr3D, kernel3D, stride3D, func)
arr2D_final = arr3D_final[:, :, 0]
return arr2D_final
答案 4 :(得分：0)
另一种解决方案使用了鲜为人知的np.maximum.at魔术（或者您可以使用np.add.at进行除法并除以均值池）
def max_pool(img, factor: int):
""" Perform max pooling with a (factor x factor) kernel"""
ds_img = np.full((img.shape[0] // factor, img.shape[1] // factor), -float('inf'), dtype=img.dtype)
np.maximum.at(ds_img, (np.arange(img.shape[0])[:, None] // factor, np.arange(img.shape[1]) // factor), img)
return ds_img
用法示例：
img = np.array([[20, 200, -5, 23],
[-13, 134, 119, 100],
[120, 32, 49, 25],
[-120, 12, 9, 23]])
print(f'Input: \n{img}')
print(f"Output: \n{max_pool(img, factor=2)}")
打印
Input:
[[ 20 200 -5 23]
[ -13 134 119 100]
[ 120 32 49 25]
[-120 12 9 23]]
Output:
[[200 119]
[120 49]]
不幸的是，它似乎有点慢，所以我仍然会使用mdh提供的解决方案