标签: convolution

这是一个不完整的 Python 卷积 FFT 片段。

我想修改它以使其支持，1）有效卷积2）和全卷积

import numpy as np
from numpy.fft import fft2, ifft2

image = np.array([[3,2,5,6,7,8],
                  [5,4,2,10,8,1]])

kernel = np.array([[4,5],
                   [1,2]])

fft_size =  # what size should I put here for,
            # 1) valid convolution
            # 2) full convolution

convolution = ifft2(fft2(image, fft_size) * fft2(kernel, fft_size))

先感谢您。

我正在做一些张量的卷积。

这是MATLAB中的小测试：

    ker= rand(3,4,2);
    a= rand(5,7,2);
    c=convn(a,ker,'valid');
    c11=sum(sum(a(1:3,1:4,1).*ker(:,:,1)))+sum(sum(a(1:3,1:4,2).*ker(:,:,2)));
    c(1,1)-c11  % not equal!

第三行与 执行 ND 卷积convn，我想将第一行第一列的结果convn与手动计算值进行比较。但是，与 相比，我的计算convn并不相等。

那么 MATLAB 的背后是convn什么？我对张量卷积的理解是错误的吗？

我想知道是否有人可以帮助我将SciPy 食谱中的平滑示例扩展到 2D 问题。

该脚本非常适用于平滑一维函数，并且它们还提供了在两个轴上进行二维平滑的代码（即模糊图像）。

但是，我想将此函数应用于 2D 数据集，但仅沿一个轴（x 方向）。我可以循环执行此操作，方法是检查 y 中的每个切片，应用一维卷积，然后重建数组。但这似乎是糟糕的编码技术。

因此，我想知道如何在 2D 中做到这一点？我想我需要做一个2D内核与重量仅沿一个方向变化，但我不知道如何做到这一点，或卷积功能的使用（numpy.convolve，scipy.signal.convolve，scipy.ndimage.filters.convolve1d等）

我知道有 scipy.signal.convolve2d 函数来处理 2d numpy 数组的二维卷积，并且有 numpy.ma 模块来处理丢失的数据，但这两种方法似乎并不兼容（这意味着即使你在 numpy 中屏蔽了一个二维数组，convolve2d 中的过程不会受到影响）。有没有办法仅使用 numpy 和 scipy 包来处理卷积中的缺失值？

例如：

            1 - 3 4 5
            1 2 - 4 5
   Array =  1 2 3 - 5
            - 2 3 4 5
            1 2 3 4 -

  Kernel =  1  0
            0 -1

卷积所需的结果（数组，内核，边界 =“包裹”）：

               -1  - -1 -1 4
               -1 -1  - -1 4
    Result =   -1 -1 -1  - 5
                - -1 -1  4 4
                1 -1 -1 -1 -

感谢Aguy的建议，这是一个非常好的方法来帮助卷积后的结果计算。现在假设我们可以从 Array.mask …

Dense这段代码中的两个是什么意思？

self.model.add(Flatten())
self.model.add(Dense(512))
self.model.add(Activation('relu'))
self.model.add(Dropout(0.5))
self.model.add(Dense(10))
self.model.add(Activation('softmax'))
self.model.summary()

我想用 PyTorch 卷积做两件事，文档或代码中没有提到：

1. 我想用这样的固定内核创建卷积：

   000010000
   000010000
   100010001
   000010000
   000010000
   

   Run Code Online (Sandbox Code Playgroud)

   我猜，水平方面就像膨胀，但垂直部分是不同的。我看到 dilation 可以作为代码中的参数使用，但它必须是标量或单元素元组（不是每个维度一个元素），所以我认为它不能在这里做我想做的事。

2. 我希望我的卷积像环形一样“环绕”，而不是使用填充。

   编辑添加：我看到有一个未解决的问题，这也提供了一个次优的解决方法。所以，我想还没有“正确”的方法来做到这一点。

我并没有真正了解他们是如何提出导数方程的。有人可以详细解释一下，甚至可以提供指向具有足够数学解释的地方的链接吗？

拉普拉斯滤波器看起来像

我有一个大小为 T 的输入张量[batch_size=B, sequence_length=L, dim=K]。应用 N 个滤波器和内核大小 K 的一维卷积与应用输出维度为 N 的密集层相同吗？

例如在 Keras 中：

Conv1D(filters=N, kernel_size=K)

对比

Dense(units=N)

请注意Conv1D，我将张量 T 整形[batch_size*sequence_length, dim=K, 1]以执行卷积。

两者都导致可学习的权重为 20,480 + 256（偏差）。然而，Conv1D最初对我来说使用学习速度要快得多。我看不出Dense()在这种情况下有什么不同，我想使用Dense()方法来降低 vram 消耗以及不重塑张量。

后续澄清：

这两个答案提供了两种不同的方式来执行一维卷积。以下方法有何不同？：

方法一：

- Reshape input to [batch_size * frames, frame_len]
- convolve with Conv1D(filters=num_basis, kernel_size=frame_len)
- Reshape the output of the convolution layer to [batch_size, frames, num_basis]

方法二：

- Convolve with Conv1D(filters=num_basis, kernel_size=1) on Input=[batch_size, frames, frame_len]. No …

我正在尝试使用Pytorch的函数torch.conv2d但无法得到我理解的结果......

这是一个简单的示例，其中内核 ( filt) 与输入 ( im) 的大小相同，以解释我正在寻找的内容。

import pytorch

filt = torch.rand(3, 3)
im = torch.rand(3, 3)

我想计算一个没有 padding 的简单卷积，所以结果应该是一个标量（即 1x1 张量）。

我试过这个conv2d：

# I have to convert image and kernel to 4 dimensions tensors to use conv2d
im_torch = im.reshape((im_height, filt_height, 1, 1))
filt_torch = filt.reshape((filt_height, im_height, 1, 1))
out = torch.nn.functional.conv2d(im_torch, filt_torch, stride=1, padding=0)
print(out)

但结果并不是我所期望的：

tensor([[[[0.6067]], [[0.3564]], [[0.5397]]],
    [[[0.2557]], [[0.0493]], [[0.2562]]],
    [[[0.6067]], [[0.3564]], [[0.5397]]]])

为了了解我想要什么，我想重现 scipyconvolve2d …

基本上这个定理的公式如下：

F(f*g) = F(f)xF(g)

我知道这个定理，但我只是无法使用 pytorch 重现结果。

下面是一个可重现的代码：

import torch
import torch.nn.functional as F

# calculate f*g
f = torch.ones((1,1,5,5))
g = torch.tensor(list(range(9))).view(1,1,3,3).float()
conv = F.conv2d(f, g, bias=None, padding=2)

# calculate F(f*g)
F_fg = torch.rfft(conv, signal_ndim=2, onesided=False)

# calculate F x G
f = f.squeeze()
g = g.squeeze()

# need to pad into at least [w1+w2-1, h1+h2-1], which is 7 in our case.
size = f.size(0) + g.size(0) - 1 

f_new = torch.zeros((7,7))
g_new = torch.zeros((7,7))

f_new[1:6,1:6] = f
g_new[2:5,2:5] …