Question

我尝试使用for循环实现2D数组的跨步卷积，即

arr = np.array([[2,3,7,4,6,2,9],
                [6,6,9,8,7,4,3],
                [3,4,8,3,8,9,7],
                [7,8,3,6,6,3,4],
                [4,2,1,8,3,4,6],
                [3,2,4,1,9,8,3],
                [0,1,3,9,2,1,4]])

arr2 = np.array([[3,4,4],
                 [1,0,2],
                 [-1,0,3]])

def stride_conv(arr1,arr2,s,p):
    beg = 0
    end = arr2.shape[0]
    final = []
    for i in range(0,arr1.shape[0]-1,s):
        k = []
        for j in range(0,arr1.shape[0]-1,s):
            k.append(np.sum(arr1[beg+i : end+i, beg+j:end+j] * (arr2)))
        final.append(k)

    return np.array(final)

stride_conv(arr,arr2,2,0)

这导致3 * 3阵列：

array([[ 91, 100,  88],
       [ 69,  91, 117],
       [ 44,  72,  74]])

是否有一个numpy函数或scipy函数来做同样的事情？我的做法并不那么好。我该如何对此进行矢量化？

Answer 1

忽略padding参数和尾随没有足够长度进行第二个数组卷积的窗口，这是[DEBUG] Adding QuerySpace : uid = <gen:0> -> org.hibernate.loader.plan.build.internal.spaces.EntityQuerySpaceImpl@357ea46e] [DEBUG] Visiting attribute path : persons [DEBUG] Adding QuerySpace : uid = <gen:1> -> org.hibernate.loader.plan.build.internal.spaces.CollectionQuerySpaceImpl@11e97dff] [DEBUG] Adding QuerySpace : uid = <gen:2> -> org.hibernate.loader.plan.build.internal.spaces.EntityQuerySpaceImpl@3a5537e6] [DEBUG] Visiting attribute path : id [DEBUG] Visiting attribute path : name的一种方法 -

np.lib.stride_tricks.as_strided

或者，我们可以使用scikit-image内置view_as_windows来优雅地获取那些的窗口，

def strided4D(arr,arr2,s):
    strided = np.lib.stride_tricks.as_strided
    s0,s1 = arr.strides
    m1,n1 = arr.shape
    m2,n2 = arr2.shape    
    out_shp = (1+(m1-m2)//s, m2, 1+(n1-n2)//s, n2)
    return strided(arr, shape=out_shp, strides=(s*s0,s*s1,s0,s1))

def stride_conv_strided(arr,arr2,s):
    arr4D = strided4D(arr,arr2,s=s)
    return np.tensordot(arr4D, arr2, axes=((2,3),(0,1)))

Answer 2

这是基于O（N ^ d（log N）^ d）fft的方法。我们的想法是将两个操作数切换为在模数步幅的所有偏移处的步幅间隔网格，在相应偏移的网格之间进行常规的fft卷积，然后对结果进行逐点求和。它有点索引重，但我担心无法帮助：

import numpy as np
from numpy.fft import fftn, ifftn

def strided_conv_2d(x, y, strides):
    s, t = strides
    # consensus dtype
    cdt = (x[0, 0, ...] + y[0, 0, ...]).dtype
    xi, xj = x.shape
    yi, yj = y.shape
    # round up modulo strides
    xk, xl, yk, yl = map(lambda a, b: -a//b * -b, (xi,xj,yi,yj), (s,t,s,t))
    # zero pad to avoid circular convolution
    xp, yp = (np.zeros((xk+yk, xl+yl), dtype=cdt) for i in range(2))
    xp[:xi, :xj] = x
    yp[:yi, :yj] = y
    # fold out strides
    xp = xp.reshape((xk+yk)//s, s, (xl+yl)//t, t)
    yp = yp.reshape((xk+yk)//s, s, (xl+yl)//t, t)
    # do conventional fft convolution
    xf = fftn(xp, axes=(0, 2))
    yf = fftn(yp, axes=(0, 2))
    result = ifftn(xf * yf.conj(), axes=(0, 2)).sum(axis=(1, 3))
    # restore dtype
    if cdt in (int, np.int_, np.int64, np.int32):
        result = result.real.round()
    return result.astype(cdt)

arr = np.array([[2,3,7,4,6,2,9],
                [6,6,9,8,7,4,3],
                [3,4,8,3,8,9,7],
                [7,8,3,6,6,3,4],
                [4,2,1,8,3,4,6],
                [3,2,4,1,9,8,3],
                [0,1,3,9,2,1,4]])

arr2 = np.array([[3,4,4],
                 [1,0,2],
                 [-1,0,3]])

print(strided_conv_2d(arr, arr2, (2, 2)))

结果：

[[ 91 100  88  23   0  29]
 [ 69  91 117  19   0  38]
 [ 44  72  74  17   0  22]
 [ 16  53  26  12   0   0]
 [  0   0   0   0   0   0]
 [ 19  11  21  -9   0   6]]

Answer 3

我认为我们可以做一个有效的＆＃34; fft卷积并只挑选跨步的结果，如：

def strideConv(arr,arr2,s):
    cc=scipy.signal.fftconvolve(arr,arr2[::-1,::-1],mode='valid')
    idx=(np.arange(0,cc.shape[1],s), np.arange(0,cc.shape[0],s))
    xidx,yidx=np.meshgrid(*idx)
    return cc[yidx,xidx]

这与其他人的答案相同。但我想这只有在内核大小为奇数时才有效。

此外，我已经在arr2[::-1,::-1]翻转内核以保持与其他人的一致，您可能希望根据上下文省略它。

<强>更新

我们目前有几种不同的方法可以单独使用numpy和scipy进行2D或3D卷积，我想进行一些比较，以便对不同大小的数据哪个更快一些有所了解。我希望这不会被视为偏离主题。

方法1：FFT卷积（使用scipy.signal.fftconvolve）：

def padArray(var,pad,method=1):
    if method==1:
        var_pad=numpy.zeros(tuple(2*pad+numpy.array(var.shape[:2]))+var.shape[2:])
        var_pad[pad:-pad,pad:-pad]=var
    else:
        var_pad=numpy.pad(var,([pad,pad],[pad,pad])+([0,0],)*(numpy.ndim(var)-2),
                mode='constant',constant_values=0)
    return var_pad

def conv3D(var,kernel,stride=1,pad=0,pad_method=1):
    '''3D convolution using scipy.signal.convolve.
    '''
    var_ndim=numpy.ndim(var)
    kernel_ndim=numpy.ndim(kernel)
    stride=int(stride)

    if var_ndim<2 or var_ndim>3 or kernel_ndim<2 or kernel_ndim>3:
        raise Exception("<var> and <kernel> dimension should be in 2 or 3.")

    if var_ndim==2 and kernel_ndim==3:
        raise Exception("<kernel> dimension > <var>.")

    if var_ndim==3 and kernel_ndim==2:
        kernel=numpy.repeat(kernel[:,:,None],var.shape[2],axis=2)

    if pad>0:
        var_pad=padArray(var,pad,pad_method)
    else:
        var_pad=var

    conv=fftconvolve(var_pad,kernel,mode='valid')

    if stride>1:
        conv=conv[::stride,::stride,...]

    return conv

方法2：特殊转化（参见this anwser）：

def conv3D2(var,kernel,stride=1,pad=0):
    '''3D convolution by sub-matrix summing.
    '''
    var_ndim=numpy.ndim(var)
    ny,nx=var.shape[:2]
    ky,kx=kernel.shape[:2]

    result=0

    if pad>0:
        var_pad=padArray(var,pad,1)
    else:
        var_pad=var

    for ii in range(ky*kx):
        yi,xi=divmod(ii,kx)
        slabii=var_pad[yi:2*pad+ny-ky+yi+1:1, xi:2*pad+nx-kx+xi+1:1,...]*kernel[yi,xi]
        if var_ndim==3:
            slabii=slabii.sum(axis=-1)
        result+=slabii

    if stride>1:
        result=result[::stride,::stride,...]

    return result

方法3：如Divakar所建议的Strided-view conv：

def asStride(arr,sub_shape,stride):
    '''Get a strided sub-matrices view of an ndarray.

    <arr>: ndarray of rank 2.
    <sub_shape>: tuple of length 2, window size: (ny, nx).
    <stride>: int, stride of windows.

    Return <subs>: strided window view.

    See also skimage.util.shape.view_as_windows()
    '''
    s0,s1=arr.strides[:2]
    m1,n1=arr.shape[:2]
    m2,n2=sub_shape[:2]

    view_shape=(1+(m1-m2)//stride,1+(n1-n2)//stride,m2,n2)+arr.shape[2:]
    strides=(stride*s0,stride*s1,s0,s1)+arr.strides[2:]
    subs=numpy.lib.stride_tricks.as_strided(arr,view_shape,strides=strides)

    return subs

def conv3D3(var,kernel,stride=1,pad=0):
    '''3D convolution by strided view.
    '''
    var_ndim=numpy.ndim(var)
    kernel_ndim=numpy.ndim(kernel)

    if var_ndim<2 or var_ndim>3 or kernel_ndim<2 or kernel_ndim>3:
        raise Exception("<var> and <kernel> dimension should be in 2 or 3.")

    if var_ndim==2 and kernel_ndim==3:
        raise Exception("<kernel> dimension > <var>.")

    if var_ndim==3 and kernel_ndim==2:
        kernel=numpy.repeat(kernel[:,:,None],var.shape[2],axis=2)

    if pad>0:
        var_pad=padArray(var,pad,1)
    else:
        var_pad=var

    view=asStride(var_pad,kernel.shape,stride)
    #return numpy.tensordot(aa,kernel,axes=((2,3),(0,1)))
    if numpy.ndim(kernel)==2:
        conv=numpy.sum(view*kernel,axis=(2,3))
    else:
        conv=numpy.sum(view*kernel,axis=(2,3,4))

    return conv

我做了3组比较：

对2D数据进行卷积，具有不同的输入大小和不同的内核大小，stride = 1，pad = 0。以下结果（颜色作为重复卷积10次的时间）：

所以＆＃34; FFT conv＆＃34;总的来说是最快的。＆＃34; Special conv＆＃34;和＆＃34; Stride-view conv＆＃34;当内核大小增加时变慢，但随着接近输入数据的大小再次减小。最后一个子图显示了最快的方法，因此紫色的大三角形表示FFT是赢家，但请注意左侧有一个薄的绿色列（可能太小而无法看到，但它在那里），这表明＆＃34; Special conv＆＃34;对于非常小的内核（小于约5x5）具有优势。当内核大小接近输入时，＆＃34; stride-view conv＆＃34;最快（见对角线）。

比较2：对3D数据进行卷积。

设置：pad = 0，stride = 2，输入维度= nxnx5，内核形状= fxfx5。

我跳过＆＃34; Special Conv＆＃34;的计算和＆＃34; Stride-view conv＆＃34;当内核大小处于输入中间时。基本上＆＃34; Special Conv＆＃34;现在没有任何优势，并且＆＃34; Stride-view＆＃34;对于小型和大型内核，它比FFT更快。

另外一个注意事项：当尺寸超过350时，我会注意到＆＃34; Stride-view conv＆＃34;的大量内存使用高峰。

比较3：对具有更大步幅的3D数据进行卷积。

设置：pad = 0，stride = 5，输入维度= nxnx10，内核形状= fxfx10。

这次我省略了＆＃34; Special Conv＆＃34;。对于更大的区域＆＃34; Stride-view conv＆＃34;超过FFT，最后的子图显示差异接近100％。可能是因为随着步幅的增加，FFT方法会产生更多浪费的数字，因此＆＃34; stride-view＆＃34;为小型和大型内核带来更多优势。

Answer 4

如何使用signal.convolve2d中的scipy？

我的方法类似于Jason的方法，但使用索引。

def strideConv(arr, arr2, s):
    return signal.convolve2d(arr, arr2[::-1, ::-1], mode='valid')[::s, ::s]

请注意，核心必须逆转。有关详细信息，请参阅讨论here和here。否则请使用signal.correlate2d。

示例：

 >>> strideConv(arr, arr2, 1)
 array([[ 91,  80, 100,  84,  88],
        [ 99, 106, 126,  92,  77],
        [ 69,  98,  91,  93, 117],
        [ 80,  79,  87,  93,  61],
        [ 44,  72,  72,  63,  74]])
 >>> strideConv(arr, arr2, 2)
 array([[ 91, 100,  88],
        [ 69,  91, 117],
        [ 44,  72,  74]])

Answer 5

据我所知，在numpy或scipy中没有直接实现卷积滤波器的支持步幅和填充的卷积，因此我认为最好使用DL包（例如，torch或tensorflow），然后将最终结果转换为numpy。火炬的实现可能是：

import torch
import torch.nn.functional as F

arr = torch.tensor(np.expand_dims(arr, axis=(0,1))
arr2 = torch.tensor(np.expand_dims(arr2, axis=(0,1))
output = F.conv2d(arr, arr2, stride=2, padding=0)
output = output.numpy().squeeze()

output>
array([[ 91, 100,  88],
       [ 69,  91, 117],
       [ 44,  72,  74]])

numpy中2D的卷积卷积

5 个答案: