标签: convolution

有人知道有关 Mayer FFT 实现的任何信息吗（我不必花大量时间来研究代码）？

我正在尝试执行卷积，并且 ifft 似乎产生了我所说的“镜像”输出。换句话说，我的内核+信号长度限制为 N/2，并且无论占用 n=0...N/2 ，都会镜像 n=N...N/2 。就负频率而言，它看起来有点像我对 FFT 的期望……只不过它就像负时间中的一面镜子。

这是我的卷积代码：

   void convolve(struct cxType* data,  struct cxType* kernel, int size) 
    {
    int i,j;
    int wrksz = size;
    float gain = 1.0f/((float) wrksz);


    mayer_fft(wrksz, data->re, data->im);
    mayer_fft(wrksz, kernel->re, kernel->im);

    for(i=0;i<wrksz;i++)
    {
    data->re[i]*=kernel->re[i]*gain;
    data->im[i]*=kernel->im[i]*gain;
    }

    mayer_ifft(wrksz, data->re, data->im);
}

使用 gnu Octave（对于不熟悉的人来说，MATLAB 语法等效）执行基本相同的操作会产生预期的结果，包括允许我在信号输出中占用 M+N-1：

fs=48000;
Ts = 1/fs;
NN =  1024
sincsz = floor(NN/4);
sigstart = floor(NN/16);
sigend = floor(NN/2);
dpi=2*pi;

%window func
tau=(1:sincsz)/sncsz;
window=0.5*(1.0 - cos(dpi*tau));
%plot(tau,window) …

我想模糊矩阵中的值,以便在相邻元素中我们不会有明显的过渡.

从维基百科页面Gaussian Blur我发现了一些关于高斯模糊的信息.我用最简单的算法尝试过,因此运行时间太长.坦率地说,我不确定我的实现是否正确,因为在边界瓦片上仍然存在明显的过渡.

我注意到这种模糊可以通过离散傅立叶变换来完成,这种变换要快得多,但我无法弄明白.

所以,我们的想法是,我们可以使用以下公式获得模糊矩阵:

blurredMatrix = IFFT[FFT[initialMatrix]FFT[weightingFunction]]

其中FFT/IFFT是快速傅里叶变换/逆快速傅立叶变换.

目前我正在尝试对Wolfram Mathematica进行一些测试,以确保这种傅里叶变换的近似是正确的.

我正在使用GaussianMatrixweightingFunction.

我需要2d模糊,所以我创建了如下的高斯矩阵:

假设我们的初始矩阵具有nxn大小,其中n = 2k + 1

G = Chop[GaussianMatrix[k] GaussianMatrix[k], 10^6]

然后,我尝试创建blurMatrix,如下所示:

blurredMatrix = Chop[FourierDCT[(FourierDCT[G]) (FourierDCT[initialMatrix]), 3], 10^-6]

但结果我得到了零.

似乎我做错了.

另外,我尝试了另一种方法:

f[xi_, yj_] := 1/(2 \[Pi] \[Sigma]^2) Exp[-(((xi^2) + (yj^2) )/(2 \[Sigma]^2))];<br/>
[Sigma] = 3;<br/>
G = Chop[N[Table[f[i, j], {i, 1, 100}, {j, 1, 100}]]]; <br/>
Tavg = Chop[ 1000 InverseFourier[(Fourier[G]) (Fourier[T]) ], 10^-6]; <br/>

使用这种方法,图像看起来很好(图像模糊),但blurMatrix和initialMatrix的值之间存在很大差异.

似乎有一些正常化或其他问题.

我需要用C/C++编写代码,C中有一个库FFTW库,它支持离散傅里叶变换.

如果这是一种错误的模糊方式,请告诉我,还有其他可能做我想做的事情.

我对AlexNet和VGG非常了解.我可以使用各自论文中提交的内容验证每个层中使用的参数数量.

然而,当我尝试在GoogleNet论文"深入研究"时也做同样的事情,即使经过多次迭代,我也无法验证他们在论文"表1"中的数字.

例如,第一层是旧的普通卷积层,内核大小(7x7),映射输入数3,映射输出数为64.因此根据这一事实,所需参数的数量为(3*49*64)+ 64(偏差),大约9.5k,但他们说他们使用2.7k.我也为其他图层做了数学计算,而且我总是比他们报告的数字百分之几.任何的想法？

谢谢

我正在使用卷积神经网络。

我的数据很不平衡，我有两个班级。

我的第一堂课包含：551,462 个图像文件

我的第二堂课包含：52,377 个图像文件

我想使用weighted_cross_entropy_with_logits，但我不确定我pos_weight是否正确计算了变量。

现在我正在使用

classes_weights = tf.constant([0.0949784, 1.0])
cross_entropy = tf.reduce_mean(tf.nn.weighted_cross_entropy_with_logits(logits=logits, targets=y_, pos_weight=classes_weights))
train_step = tf.train.AdamOptimizer(LEARNING_RATE, epsilon=1e-03).minimize(
      cross_entropy
    , global_step=global_step
    )

或者我应该使用

classes_weights = 10.5287

我现在需要了解如何使用 Keras 以 Theano 作为后端将数据填充到 1d 卷积层中。我使用“相同”的填充。

假设我们的 anoutput_length为 8，akernel_size为 4。根据原始 Keras 代码，我们有padding8//4 == 2。但是，当在水平数据的左右端添加两个零时，我可以计算出 9卷积而不是 8。

有人可以解释一下数据是如何填充的吗？在哪里添加零以及如何计算数据右侧和左侧的填充值数量？

我需要更快的模拟

scipy.signal.convolve2d(data, filter, boundary="wrap", mode="same")

你不能建议我如何更换它吗？

PSscipy.signal.fftconvolve足够快，但它没有boundary选项，我无法使其在循环卷积模式下工作。

如果我的输入大小为 5x5，步长为 1x1，滤波器大小为 3x3，那么我可以在纸上计算出卷积矩阵的最终大小将为 3x3。

但是，当输入大小更改为 28x28 或 50x50 时，我如何计算纸上卷积矩阵的大小？有什么公式或技巧可以做到这一点吗？

我需要编写一个代码来使用 numpy 和 3x3 内核在 python 中执行 3D 卷积。我已经对像黑白图像这样的 2D 阵列做了正确的处理，但是当我尝试将它扩展到像 RGB 这样的 3D 阵列时是一团糟。我需要帮助来改进我的方法。这是二维代码：

def convolucion_3x3(arreglo, kernel):
  (dim_x, dim_y) = arreglo.shape
  (ker_x, ker_y) = kernel.shape

  matriz_convolucionada = np.zeros((dim_x, dim_y))

  for i in range(dim_x):
    for j in range(dim_y):
      resultado = 0
      for x in range(-1, 2):
        try:
          if i + x not in range(dim_x):
              raise ValueError()
          for y in range(-1, 2):
            try:
              if j + y not in range(dim_y):
                  raise ValueError()

              resultado += arreglo[i + x, j + y] * …

我正在用 C++实现图像卷积，我已经有了一个基于给定伪代码的简单的工作代码：

for each image row in input image:
   for each pixel in image row:

      set accumulator to zero

      for each kernel row in kernel:
         for each element in kernel row:

            if element position  corresponding* to pixel position then
               multiply element value  corresponding* to pixel value
               add result to accumulator
            endif

      set output image pixel to accumulator

由于这可能是大图像和内核的一大瓶颈，我想知道是否有其他方法可以使事情更快？即使有额外的输入信息，如：稀疏图像或内核、已知内核等......

我知道这可以并行化，但在我的情况下这是不可行的。

指数函数与正弦函数卷积的理论结果如下所示。

当我直接使用 matlab 绘制函数时，我得到了这个，

然而 Matlab conv 命令产生了这个，

这两个图看起来很相似，但它们并不相同，请参见比例尺。matlab 良率是理论结果的十倍。为什么？

matlab 代码在这里。

clc;
clear all;
close all;
t = 0:0.1:50;
x1 = exp(-t);
x2 = sin(t);
x = conv(x1,x2);
x_theory = 0.5.*(exp(-t) + sin(t) - cos(t));

figure(1)
subplot(313), plot(t, x(1:length(t))); subplot(311), plot(t, x1(1:length(t))); subplot(312), plot(t, x2(1:length(t)))

figure(2)
subplot(313), plot(t, x_theory); subplot(311), plot(t, x1(1:length(t))); subplot(312), plot(t, x2(1:length(t)))