标签: convolution

我想知道是否有人可以将我推荐给ANSI C中的一维线性卷积代码片段而不是重新发明轮子？我在谷歌搜索和堆栈溢出,但在CI中找不到任何东西可以使用.

例如,对于阵列A,B,和C中,所有双精度,其中A和B是输入端,C是输出,具有长度len_A,len_B和len_C = len_A + len_B - 1分别.

我的阵列尺寸很小,因此不需要通过FFT实现快速卷积的任何速度增加.寻找直接的计算.

我使用64位matlab和32g RAM(你知道的).

我有一个130万个数字(整数)的文件(向量).我想制作另一个相同长度的矢量,其中每个点是整个第一个矢量的加权平均值,加权距离该位置的反距离(实际上它的位置是^ -0.1,不是^ -1,但是出于示例目的) .我不能使用matlab的'过滤'功能,因为它只能在当前点之前平均事物,对吧？为了更清楚地解释,这里有3个元素的例子

data = [ 2 6 9 ]
weights = [ 1 1/2 1/3; 1/2 1 1/2; 1/3 1/2 1 ]
results=data*weights= [ 8 11.5 12.666 ]
i.e.
8 = 2*1 + 6*1/2 + 9*1/3
11.5 = 2*1/2 + 6*1 + 9*1/2
12.666 = 2*1/3 + 6*1/2 + 9*1

因此,新矢量中的每个点都是整个第一个矢量的加权平均值,加权1 /(距该位置的距离+ 1).

我可以重新制作每个点的权重向量,然后逐个元素计算结果向量,但这需要130万次for循环迭代,每个迭代包含130万次乘法.我宁愿使用直接矩阵乘法,将1x1.3mil乘以1.3milx1.3mil,这在理论上是有效的,但我无法加载大的矩阵.

然后我尝试使用shell脚本制作矩阵并在matlab中对其进行索引,因此一次只调用矩阵的相关列,但这也需要很长时间.

我没有必要在matlab中这样做,所以人们对利用如此大的数字和获得平均值的任何建议将不胜感激.因为我使用的是^ -0.1的重量,而不是^ -1,所以它不会快速下降 - 百万分之一点仍然加权为0.25,而原始点加权为1,所以我不能只是削减它因为它变大了.

希望这很清楚吗？

以下是答案的代码(因此可以格式化？):

data = load('/Users/mmanary/Documents/test/insertion.txt');
data=data.';
total=length(data);
x=1:total;
datapad=[zeros(1,total) data];
weights = ([(total+1):-1:2 1:total]).^(-.4);
weights = …

是否有一个很好的算法实现来计算C++ STL(甚至是boost)中两个范围的卷积？即原型(两个范围的卷积a..b和c..d)的东西:

template< class Iterator >
void convolution(Iterator a, Iterator b, Iterator c, Iterator d);

它修改了a..b范围

从这个例子:https: //github.com/fchollet/keras/blob/master/examples/imdb_cnn.py

下面是这个片段.嵌入层为批量中的每个示例输出400 x 50矩阵.我的问题是1D卷积是如何工作的？它如何在400 x 50矩阵中工作？

# we start off with an efficient embedding layer which maps
# our vocab indices into embedding_dims dimensions
model.add(Embedding(max_features,
                    embedding_dims,
                    input_length=maxlen,
                    dropout=0.2))

# we add a Convolution1D, which will learn nb_filter
# word group filters of size filter_length:
model.add(Convolution1D(nb_filter=nb_filter,
                        filter_length=filter_length,
                        border_mode='valid',
                        activation='relu',
                        subsample_length=1))

我将Conv2D层定义为:

Conv2D(96, kernel_size=(5, 5),
             activation='relu',
             input_shape=(image_rows, image_cols, 1),
             kernel_initializer=initializers.glorot_normal(seed),
             bias_initializer=initializers.glorot_uniform(seed),
             padding='same',
             name='conv_1')

这是我网络中的第一层.
输入尺寸为64 x 160,图像为1通道.
我试图从这个卷积层可视化权重,但不知道如何获得它们.
这是我现在这样做的方式:

1.Call

layer.get_weights()[0]

这会形成一系列形状(5,5,1,96).1是因为图像是1通道.

2.使用5乘5过滤器

layer.get_weights()[0][:,:,:,j][:,:,0]

非常难看,但我不知道如何简化这一点,任何评论都非常感激.

我不确定这些5乘5个方格.他们实际过滤了吗？
如果不是,请告诉我们如何正确地从模型中获取过滤器？

对于我的教育，我试图在卷积神经网络中实现一个 N 维卷积层。

我想实现一个反向传播功能。但是，我不确定这样做的最有效方法。

目前，我正在使用signal.fftconvolve：

• 在 forwards 步骤中，卷积过滤器和内核对所有过滤器进行转发；

• 在反向传播步骤中，将导数（使用 FlipAllAxes 函数在所有维度上反转）与数组 ( https://jefkine.com/general/2016/09/05/backpropagation-in-convolutional-neural-networks/ ) 进行卷积所有过滤器并将它们相加。我认为输出是每个图像与每个过滤器的每个导数卷积的总和。

我对如何对导数进行卷积感到特别困惑。使用下面的类进行反向传播会导致权重的大小爆炸。

用输出和滤波器对导数的卷积进行编程的正确方法是什么？

编辑：

根据这篇论文（通过 FFT 快速训练卷积网络），它试图做我想做的事情：

• 前一层的导数由当前层的导数与权重的卷积给出：

  dL/dy_f = dL/dx * w_f^T

• 权重的导数是导数与原始输入的卷积的分段和：

  dL/dy = dL/dx * x

尽我所知，我已经在下面实现了这一点。然而，这似乎并没有给出预期的结果，因为我使用这一层编写的网络在训练期间表现出剧烈的波动。

    import numpy as np
    from scipy import signal

    class ConvNDLayer:
        def __init__(self,channels, kernel_size, dim):

            self.channels = channels
            self.kernel_size = kernel_size;
            self.dim = dim

            self.last_input = None

            self.filt_dims = np.ones(dim+1).astype(int)
            self.filt_dims[1:] =  self.filt_dims[1:]*kernel_size
            self.filt_dims[0]= self.filt_dims[0]*channels 
            self.filters = np.random.randn(*self.filt_dims)/(kernel_size)**dim


        def …

我想用点扩散函数(PSF)去卷积2D图像.我已经看到有一个scipy.signal.deconvolve函数适用于一维数组,并且scipy.signal.fftconvolve可以卷积多维数组.scipy中是否有特定的函数来解卷积2D数组？

我已经定义了一个fftdeconvolve函数替换fftconvolve中的乘积除以:

def fftdeconvolve(in1, in2, mode="full"):
    """Deconvolve two N-dimensional arrays using FFT. See convolve.

    """
    s1 = np.array(in1.shape)
    s2 = np.array(in2.shape)
    complex_result = (np.issubdtype(in1.dtype, np.complex) or
                      np.issubdtype(in2.dtype, np.complex))
    size = s1+s2-1

    # Always use 2**n-sized FFT
    fsize = 2**np.ceil(np.log2(size))
    IN1 = fftpack.fftn(in1,fsize)
    IN1 /= fftpack.fftn(in2,fsize)
    fslice = tuple([slice(0, int(sz)) for sz in size])
    ret = fftpack.ifftn(IN1)[fslice].copy()
    del IN1
    if not complex_result:
        ret = ret.real
    if mode == "full":
        return ret
    elif mode == "same":
        if np.product(s1,axis=0) …

我正在使用带有60000训练图像和10000测试图像的MNIST示例.如何找到具有错误分类/预测的10000个测试图像中的哪一个？

我怀疑的是如何在Pooling层中反向传播错误,因为当我计算导数时,只有4个元素(例如,当使用2x2池内核时)会影响前馈的结果.

我在CNN上使用二进制分类器.我有两个类别"我"和"其他".我有大约250张自己的图像和500张其他图像(随机面部数据库).我目前的图层实现非常简单

    self.model.add(Conv2D(128, (2, 2), padding='same', 
    input_shape=dataset.X_train.shape[1:]))
    self.model.add(Activation('relu'))
    self.model.add(MaxPooling2D(pool_size=(2, 2)))
    self.model.add(Dropout(0.25))

    self.model.add(Conv2D(64, (2, 2), padding='same'))
    self.model.add(Activation('relu'))
    self.model.add(MaxPooling2D(pool_size=(2, 2)))
    self.model.add(Dropout(0.25))

    self.model.add(Conv2D(32, (1, 1), padding='same'))
    self.model.add(Activation('relu'))
    self.model.add(MaxPooling2D(pool_size=(2, 2)))
    self.model.add(Dropout(0.5))
    self.model.add(Dense(512))
    self.model.add(Activation('relu'))
    self.model.add(Dropout(0.25))
    self.model.add(Dense(2)) # for two classes
    self.model.add(Activation('softmax'))

我的网络达到了93%的准确率

我的问题是,当我使用这个网络预测面孔时,它总是将任何面部识别为我的面孔.我已经裁剪了面部,应用了gabor过滤器,但没有任何作用.任何建议将不胜感激.

随机面的预测结果:[KK代表我的脸]概率总是超过97%:

KK identified!
1/1 [==============================] - 0s
[[ 0.9741978  0.0258022]]
1/1 [==============================] - 0s

KK identified!
1/1 [==============================] - 0s
[[ 0.9897241   0.01027592]]
1/1 [==============================] - 0s

我的图像预测结果:[KK代表我的脸]概率总是超过99%:

KK identified!
1/1 [==============================] - 0s
[[ 0.99639165  0.00360837]]
1/1 [==============================] - 0s
KK identified! …