DL学习笔记【17】nn包中的各位Convolutional layers

本文主要是介绍DL学习笔记【17】nn包中的各位Convolutional layers，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

用一句喜欢的话开始这篇博文：if you can't explain it simply, you don't understand it well enough.

参考文章：https://github.com/torch/nn/blob/master/doc/convolution.md#nn.VolumetricReplicationPadding

Temporal Modules

用于处理序列信号，如声音，句子（自然语言处理常用）等。会有inputframe（共有多少帧）和inputframesize（一帧有多少维度表示）

kernel都是一维的

TemporalConvolution

简单来说就是kernel是一维的。input tensor中每一个数字对应一个weight。

module = nn.TemporalConvolution(inputFrameSize, outputFrameSize, kW, [dW])

output[t][i] = bias[i]+ sum_j sum_{k=1}^kW weight[i][k][j] * input[dW*(t-1)+k)][j]

kernel是作用于frame上的，即会改变framesize，其他batchsize和inputframe的大小不会变化

nOutputFrame = (nInputFrame - kW) / dW + 1

贴一个简单的例子：

inp=5;  -- dimensionality of one sequence element
outp=1; -- number of derived features for one sequence element
kw=1;   -- kernel only operates on one sequence element per step
dw=1;   -- we step once and go on to the next sequence elementmlp=nn.TemporalConvolution(inp,outp,kw,dw)x=torch.rand(7,inp) -- a sequence of 7 elements
print(mlp:forward(x))

TemporalMaxPooling

取kernel覆盖数字的最大值

module = nn.TemporalMaxPooling(kW, [dW])

TemporalSubSampling

和convolution有点儿像，只不过一个kernel对应一个weight。而不是一个数字对应一个weight。

module = nn.TemporalSubSampling(inputFrameSize, kW, [dW])

output[t][i] = bias[i] + weight[i] * sum_{k=1}^kW input[dW*(t-1)+k][i]

一个kernel所有数字求和之后✖️一个weight + bias

LookupTable

只知道moduleforward这一部分可以取出module.weight中相对应的行的值组成新的矩阵

并不能理解具体怎么生成这些weight的。。。

TemporalRowConvolution

和TemporalConvolution类似，不过算卷积时不包含深度。

Spatial Modules

应用在二维input上，比如图片

SpatialConvolution

module = nn.SpatialConvolution(nInputPlane, nOutputPlane, kW, kH, [dW], [dH], [padW], [padH])

输入和输出的深度信息，即几层。kernel的宽和高，步长，输入图像的宽和高左右两边补零的数目。

SpatialConvolutionMap

module = nn.SpatialConvolutionMap(connectionMatrix, kW, kH, [dW], [dH])

其中应用full connection table和spatial convolution的效果是一样的

full connection table

table = nn.tables.full(nin,nout)

one to one connection table 是一个像素一个像素对应么

table = nn.tables.oneToOne(n)

random connection table 是随机选择像素对应么

table = nn.tables.random(nin,nout, nto)

SpatialFullConvolution（其实是反卷机）

module = nn.SpatialFullConvolution(nInputPlane, nOutputPlane, kW, kH, [dW], [dH], [padW], [padH], [adjW], [adjH])

输入和输出的深度信息，即几层。kernel的宽和高，步长，输入图像的宽和高左右两边补零的数目，输出图像的宽和高左右两边补零的数目
可以不加bias，使用的语句是:noBias()

SpatialDilatedConvolution（带孔的卷积）

module = nn.SpatialDilatedConvolution(nInputPlane, nOutputPlane, kW, kH, [dW], [dH], [padW], [padH], [dilationW], [dilationH])

输入和输出的深度信息，即几层。kernel的宽和高，步长，输入图像的宽和高左右两边补零的数目，kernel每个像素跳跃多少。

SpatialConvolutionLocal

module = nn.SpatialConvolutionLocal(nInputPlane, nOutputPlane, iW, iH, kW, kH, [dW], [dH], [padW], [padH])

和spatial convolution很像，但是不共享权重
（每一个kernel都单独存储权重么，spatial convolution是共享的么？）

SpatialLPPooling

module = nn.SpatialLPPooling(nInputPlane, pnorm, kW, kH, [dW], [dH])

计算p范数（以kernel为单位计算么）

SpatialSubSampling

module = nn.SpatialSubSampling(nInputPlane, kW, kH, [dW], [dH])

深度不改变。一个kernel所有像素求和之后✖️一个weight + bias。

SpatialMaxPooling

module = nn.SpatialMaxPooling(kW, kH [, dW, dH, padW, padH])

默认是floor，可以通过在后边加:ceil() 和:floor()来改变默认值

SpatialDilatedMaxPooling

module = nn.SpatialDilatedMaxPooling(kW, kH [, dW, dH, padW, padH, dilationW, dilationH])

跳跃步长维dilationw和dilationh，默认是floor，可以通过在后边加:ceil() 和:floor()来改变默认值

SpatialFractionalMaxPooling

module = nn.SpatialFractionalMaxPooling(kW, kH, outW, outH)
--   the output should be the exact size (outH x outW)
OR
module = nn.SpatialFractionalMaxPooling(kW, kH, ratioW, ratioH)
--   the output should be the size (floor(inH x ratioH) x floor(inW x ratioW))
--   ratios are numbers between (0, 1) exclusive

确定输出的宽和高，或者确定输出的宽和高相对于输入宽高的缩放比例

SpatialAveragePooling

module = nn.SpatialAveragePooling(kW, kH [, dW, dH, padW, padH])

和spatialmaxpooling差不多，不过是求平均

SpatialAdaptiveMaxPooling

module = nn.SpatialAdaptiveMaxPooling(W, H)

规定了输出的w和h的max pooling

SpatialAdaptiveAveragePooling

module = nn.SpatialAdaptiveAveragePooling(W, H)

规定了输出的w和h的average pooling

SpatialMaxUnPooling

module = nn.SpatialMaxUnpooling(poolingModule)

是pooling的逆过程么？但是看文中的公式并不是简单补零的形式哎～

SpatialUpSamplingNearest

module = nn.SpatialUpSamplingNearest(scale)

找除完之后位置最近的，公式如下，没有需要学习的参数

output(u,v) = input(floor((u-1)/scale)+1, floor((v-1)/scale)+1)

SpatialUpSamplingBilinear

module = nn.SpatialUpSamplingBilinear(scale)
module = nn.SpatialUpSamplingBilinear({oheight=H, owidth=W})

对应公式如下：

oH = (iH - 1)(scale - 1) + iH
oW = (iW - 1)(scale - 1) + iW

没有需要学习的参数

SpatialZeroPadding

module = nn.SpatialReflectionPadding(padLeft, padRight, padTop, padBottom)

上下左右补零

SpatialReflectionPadding

module = nn.SpatialReflectionPadding(padLeft, padRight, padTop, padBottom)

上下左右补反射边缘的像素

SpatialReplicationPadding

module = nn.SpatialReplicationPadding(padLeft, padRight, padTop, padBottom)

上下左右补复制边缘的像素

SpatialSubtractiveNormalization

module = nn.SpatialSubtractiveNormalization(ninputplane, kernel)

计算kernel内点的加权平均。kernel可以是任意定义的分布，一般高斯和均值较多。

SpatialCrossMapLRN

module = nn.SpatialCrossMapLRN(size [,alpha] [,beta] [,k])

对局部神经元的活动创建竞争机制，使得其中响应比较大的值变得相对更大，并抑制其他反馈较小的神经元，增强了模型的泛化能力
公式：

                          x_f
y_f =  -------------------------------------------------(k+(alpha/size)* sum_{l=l1 to l2} (x_l^2))^beta

SpatialBatchNormalization

module = nn.SpatialBatchNormalization(N [,eps] [, momentum] [,affine])

Inception V2学习了VGGNet，用两个3´3的卷积代替5´5的大卷积（用以降低参数量并减轻过拟合），还提出了著名的Batch Normalization（以下简称BN）方法。BN是一个非常有效的正则化方法，可以让大型卷积网络的训练速度加快很多倍，同时收敛后的分类准确率也可以得到大幅提高。BN在用于神经网络某层时，会对每一个mini-batch数据的内部进行标准化（normalization）处理，使输出规范化到N(0,1)的正态分布，减少了Internal Covariate Shift（内部神经元分布的改变）。BN的论文指出，传统的深度神经网络在训练时，每一层的输入的分布都在变化，导致训练变得困难，我们只能使用一个很小的学习速率解决这个问题。而对每一层使用BN之后，我们就可以有效地解决这个问题，学习速率可以增大很多倍，达到之前的准确率所需要的迭代次数只有1/14，训练时间大大缩短。而达到之前的准确率后，可以继续训练，并最终取得远超于Inception V1模型的性能——top-5错误率4.8%，已经优于人眼水平。因为BN某种意义上还起到了正则化的作用，所以可以减少或者取消Dropout，简化网络结构。

公式：

 y =     ( x - mean(x) )-------------------- * gamma + betastandard-deviation(x)

两种模式：学习参数gamma和beta or 不

-- with learnable parameters
model = nn.SpatialBatchNormalization(m)
A = torch.randn(b, m, h, w)
C = model:forward(A)  -- C will be of size `b x m x h x w`-- without learnable parameters
model = nn.SpatialBatchNormalization(m, nil, nil, false)
A = torch.randn(b, m, h, w)
C = model:forward(A)  -- C will be of size `b x m x h x w`

Volumetric Modules

应用在三维关系上，如：视频。

VolumetricConvolution : a 3D convolution over an input video (a sequence of images) ;
VolumetricFullConvolution : a 3D full convolution over an input video (a sequence of images) ;
VolumetricDilatedConvolution : a 3D dilated convolution over an input image ;
VolumetricMaxPooling : a 3D max-pooling operation over an input video.
VolumetricDilatedMaxPooling : a 3D dilated max-pooling operation over an input video ;
VolumetricFractionalMaxPooling : a 3D fractional max-pooling operation over an input image ;
VolumetricAveragePooling : a 3D average-pooling operation over an input video.
VolumetricMaxUnpooling : a 3D max-unpooling operation.
VolumetricReplicationPadding : Pads a volumetric feature map with the value at the edge of the input borders.

在文章最后贴上一个网址（torch和caffe中的BatchNorm层）

http://www.cnblogs.com/darkknightzh/p/6015990.html

再来一个很有用的网址

http://wemedia.ifeng.com/9177017/wemedia.shtml

这篇关于DL学习笔记【17】nn包中的各位Convolutional layers的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！