标签: convolution

我正在尝试在iOS的OpenGL ES2.0中实现2D轮廓着色器.这太疯狂了.如在5fps慢.我已将其跟踪到texture2D()调用.但是,如果没有这些,任何卷积着色器都是可撤消的.我尝试过使用lowp而不是mediump,但是一切都只是黑色,虽然它确实给了另外5fps,但它仍然无法使用.

这是我的片段着色器.

    varying mediump vec4 colorVarying;
    varying mediump vec2 texCoord;

    uniform bool enableTexture;
    uniform sampler2D texture;

    uniform mediump float k;

    void main() {

        const mediump float step_w = 3.0/128.0;
        const mediump float step_h = 3.0/128.0;
        const mediump vec4 b = vec4(0.0, 0.0, 0.0, 1.0);
        const mediump vec4 one = vec4(1.0, 1.0, 1.0, 1.0);

        mediump vec2 offset[9];
        mediump float kernel[9];
        offset[0] = vec2(-step_w, step_h);
        offset[1] = vec2(-step_w, 0.0);
        offset[2] = vec2(-step_w, -step_h);
        offset[3] = vec2(0.0, step_h);
        offset[4] = vec2(0.0, 0.0); …

任何人都可以向我解释相关和卷积的相似点和不同点吗？请解释背后的直觉,而不是数学方程(即翻转内核/脉冲).每个类别的图像处理域中的应用示例也将受到赞赏

当输入层存在多个通道时,如何进行卷积运算？(例如RGB)

在对CNN的体系结构/实现进行一些阅读之后,我理解特征映射中的每个神经元都引用由内核大小定义的图像的NxM像素.然后通过学习NxM权重集(内核/滤波器),求和并输入到激活函数中的特征映射来对每个像素进行因子分解.对于一个简单的灰度图像,我想操作将遵循以下伪代码:

for i in range(0, image_width-kernel_width+1):
    for j in range(0, image_height-kernel_height+1):
        for x in range(0, kernel_width):
            for y in range(0, kernel_height):
                sum += kernel[x,y] * image[i+x,j+y]

        feature_map[i,j] = act_func(sum)
        sum = 0.0

但是我不明白如何扩展此模型来处理多个通道.每个要素图需要三个单独的权重集,每种颜色之间是否共享？

参考本教程的"共享权重"部分:http://deeplearning.net/tutorial/lenet.html 要素图中的每个神经元都参考层m-1,颜色从不同的神经元引用.我不明白他们在这里表达的关系.是神经元内核还是像素,为什么它们会引用图像的不同部分？

根据我的例子,似乎单个神经元内核是图像中特定区域所独有的.为什么他们将RGB组件分成几个区域？

什么使卷积内核可分离？我怎样才能分辨出那些可分离的部分是为了进行两次1D卷积而不是2D卷积>

谢谢

所以我知道FFT的卷积比现实空间中的卷积具有更低的计算复杂度.但是FFT卷积的缺点是什么？

内核大小是否始终必须与图像大小匹配,或者是否有用于处理此问题的函数,例如在pythons numpy和scipy包中？那么抗锯齿效果呢？

这些链接的理论表明,卷积网络的顺序是:Convolutional Layer - Non-linear Activation - Pooling Layer.

1. 神经网络和深度学习(方程(125)
2. 深度学习书(第304页,第1段)
3. Lenet(等式)
4. 这个标题的来源

但是,在这些网站的最后一次实施中,它说订单是: Convolutional Layer - Pooling Layer - Non-linear Activation

1. network3.py
2. 源代码,LeNetConvPoolLayer类

我也尝试过探索Conv2D操作语法,但是没有激活函数,它只是与翻转内核的卷积.有人可以帮我解释为什么会这样吗？

我在看InceptionV3(GoogLeNet)架构,无法理解为什么我们需要conv1x1层？

我知道卷积是如何工作的,但我看到补丁大小> 1的利润.

我想使用python提高卷积的性能,并希望能够对如何最好地提高性能有所了解.

我目前正在使用scipy执行卷积,使用的代码有点像下面的代码片段:

import numpy
import scipy
import scipy.signal
import timeit

a=numpy.array ( [ range(1000000) ] )
a.reshape(1000,1000)
filt=numpy.array( [ [ 1, 1, 1 ], [1, -8, 1], [1,1,1] ] )

def convolve():
  global a, filt
  scipy.signal.convolve2d ( a, filt, mode="same" )

t=timeit.Timer("convolve()", "from __main__ import convolve")
print "%.2f sec/pass" % (10 * t.timeit(number=10)/100)

我正在处理图像数据,使用灰度(0到255之间的整数值),我目前每个卷积得到大约四分之一秒.我的想法是做以下其中一项:

使用corepy,最好进行一些优化使用icc和ikml重新编译numpy.使用python-cuda.

我想知道是否有人对这些方法有任何经验(什么样的增益是典型的,如果值得花时间),或者是否有人知道有更好的库与Numpy进行卷积.

谢谢!

编辑:

通过使用Numpy在C中重写python循环来加速大约10倍.

我有一个带有成像工件的数据图像,它是一个正弦背景,我想删除它.由于它是一个单频正弦波,傅立叶变换和带通滤波器或"陷波滤波器"(我认为我在+ -omega处使用高斯滤波器)似乎很自然.

在尝试这样做时,我注意到两件事:

1)只需执行fft和back,我就减少了正弦波分量,如下所示.似乎只是通过去那里和回来对数据进行一些高通滤波？

import numpy as np

f = np.fft.fft2(img)                  #do the fourier transform
fshift1 = np.fft.fftshift(f)          #shift the zero to the center
f_ishift = np.fft.ifftshift(fshift1)  #inverse shift
img_back = np.fft.ifft2(f_ishift)     #inverse fourier transform
img_back = np.abs(img_back)

这是img_back的图片:

也许这里的过滤对我来说已经足够了,但我对它没有那么自信,因为我对背景抑制没有很好的理解.

2)为了更加确定在不需要的频率上的抑制,我制作了一个布尔'带通'掩码并将其应用于数据,但傅里叶变换忽略了掩码.

a = shape(fshift1)[0]
b = shape(fshift1)[1]

ro = 8
ri = 5
y,x = np.ogrid[-a/2:a/2, -b/2:b/2] 
m1 = x*x + y*y >= ro*ro 
m2 = x*x + y*y <= ri*ri
m3=np.dstack((m1,m2))       
maskcomb =[]
for r in m3:
    maskcomb.append([any(c) for …

在这里，在这个代码UpSampling2D并且Conv2DTranspose似乎可以互换使用。我想知道为什么会这样。

# u-net model with up-convolution or up-sampling and weighted binary-crossentropy as loss func

from keras.models import Model
from keras.layers import Input, Conv2D, MaxPooling2D, UpSampling2D, concatenate, Conv2DTranspose, BatchNormalization, Dropout
from keras.optimizers import Adam
from keras.utils import plot_model
from keras import backend as K

def unet_model(n_classes=5, im_sz=160, n_channels=8, n_filters_start=32, growth_factor=2, upconv=True,
               class_weights=[0.2, 0.3, 0.1, 0.1, 0.3]):
    droprate=0.25
    n_filters = n_filters_start
    inputs = Input((im_sz, im_sz, n_channels))
    #inputs = BatchNormalization()(inputs)
    conv1 = Conv2D(n_filters, (3, 3), activation='relu', padding='same')(inputs)
    conv1 = …