目录
一、梯度消失/梯度爆炸的问题
首先来说说梯度消失问题产生的原因吧，虽然是已经被各大牛说烂的东西。不如先看一个简单的网络结构，
可以看到，如果输出层的值仅是输入层的值与权值矩阵W的线性组合，那么最终网络最终的输出会变成输入数据的线性组合。这样很明显没有办法模拟出非线性的情况。记得神经网络是可以拟合任意函数的。好了，既然需要非线性函数，那干脆加上非线性变换就好了。一般会使用sigmoid函数，得到
可以看到，函数的两侧非常平滑，而且无限的接近0和1，仅仅是中间部分函数接近一条直线，顺便说一下，这个函数的导数最值竟然真的是1啊，也就是x=0的位置，因而称这个函数是双端饱和的，而且它是处处可导。那么，为什么要选用它呢？看到有资料说是模拟神经学科的，但我不太懂这个，个人认为是因为（1）可以引入非线性（2）容易求导（3）可以把数据压缩，这样数据不容易发散。
另外，有一个函数与sigmoid函数很类似，就是tanh()函数，它可以把数据压缩到(-1，1)之间。
但是，我们要讲的是梯度的消失问题哦，要知道，神经网络训练的方法是BP算法（不知道还有没有其他的训练方法。。。）。BP算法的基础其实就是导数的链式法则，这个估计不需要细说了，就是有很多乘法会连接在一起。在看看sigmoid函数的图像就知道了，导数最大是1，而且大多数值都被推向两侧饱和的区域，这些区域的导数可是很小的呀~~~~可以预见到，随着网络的加深，梯度后向传播到浅层网络时，就呵呵了，基本不能引起数值的扰动，这样浅层的网络就学习不到新的特征了。
那么怎么办？我暂时看到了四种解决问题的办法，仅仅是根据我自己看的论文总结的，并非权威的说法。第一种很明显，可以通过使用别的激活函数；第二种可以使用层归一化；第三种是在权重的初始化上下功夫，第四种是构建新的网络结构~。但暂时不写，我还想记录一下看到的梯度消失/爆炸问题在另一个经典网络的出现。
======================
噔噔噔噔，对的，就是RNN。
RNN网络简单来说，就是把上层的hidden state与输入数据一同输入到神经元中进行处理（如左图），它是与序列相关的。如果把网络按照时间序列展开，可以得到右图
假如要求偏导数
贴一个RNN的代码，有注释，很容易看明白，来自这里
import copy, numpy as np
np.random.seed(0)
# compute sigmoid nonlinearity
def sigmoid(x):
output = 1/(1+np.exp(-x))
return output
# convert output of sigmoid function to its derivative
def sigmoid_output_to_derivative(output):
return output*(1-output)
# training dataset generation
int2binary = {}
binary_dim = 8
largest_number = pow(2,binary_dim)
binary = np.unpackbits(
np.array([range(largest_number)],dtype=np.uint8).T,axis=1)
for i in range(largest_number):
int2binary[i] = binary[i]
# input variables
alpha = 0.1
input_dim = 2
hidden_dim = 16
output_dim = 1
# initialize neural network weights
synapse_0 = 2*np.random.random((input_dim,hidden_dim)) - 1
synapse_1 = 2*np.random.random((hidden_dim,output_dim)) - 1
synapse_h = 2*np.random.random((hidden_dim,hidden_dim)) - 1
synapse_0_update = np.zeros_like(synapse_0)
synapse_1_update = np.zeros_like(synapse_1)
synapse_h_update = np.zeros_like(synapse_h)
# training logic
for j in range(10000):
# generate a simple addition problem (a + b = c)
a_int = np.random.randint(largest_number/2) # int version
a = int2binary[a_int] # binary encoding
b_int = np.random.randint(largest_number/2) # int version
b = int2binary[b_int] # binary encoding
# true answer
c_int = a_int + b_int
c = int2binary[c_int]
# where we'll store our best guess (binary encoded)
d = np.zeros_like(c)
overallError = 0
layer_2_deltas = list()
layer_1_values = list()
layer_1_values.append(np.zeros(hidden_dim))
# moving along the positions in the binary encoding
for position in range(binary_dim):
# generate input and output
X = np.array([[a[binary_dim - position - 1],b[binary_dim - position - 1]]])
y = np.array([[c[binary_dim - position - 1]]]).T
# hidden layer (input ~+ prev_hidden)
layer_1 = sigmoid(np.dot(X,synapse_0) + np.dot(layer_1_values[-1],synapse_h))
# output layer (new binary representation)
layer_2 = sigmoid(np.dot(layer_1,synapse_1))
# did we miss?... if so, by how much?
layer_2_error = y - layer_2
layer_2_deltas.append((layer_2_error)*sigmoid_output_to_derivative(layer_2))
overallError += np.abs(layer_2_error[0])
# decode estimate so we can print it out
d[binary_dim - position - 1] = np.round(layer_2[0][0])
# store hidden layer so we can use it in the next timestep
layer_1_values.append(copy.deepcopy(layer_1))
future_layer_1_delta = np.zeros(hidden_dim)
for position in range(binary_dim):
X = np.array([[a[position],b[position]]])
layer_1 = layer_1_values[-position-1]
prev_layer_1 = layer_1_values[-position-2]
# error at output layer
layer_2_delta = layer_2_deltas[-position-1]
# error at hidden layer
layer_1_delta = (future_layer_1_delta.dot(synapse_h.T) + layer_2_delta.dot(synapse_1.T)) * sigmoid_output_to_derivative(layer_1)
# let's update all our weights so we can try again
synapse_1_update += np.atleast_2d(layer_1).T.dot(layer_2_delta)
synapse_h_update += np.atleast_2d(prev_layer_1).T.dot(layer_1_delta)
synapse_0_update += X.T.dot(layer_1_delta)
future_layer_1_delta = layer_1_delta
synapse_0 += synapse_0_update * alpha
synapse_1 += synapse_1_update * alpha
synapse_h += synapse_h_update * alpha
synapse_0_update *= 0
synapse_1_update *= 0
synapse_h_update *= 0
# print out progress
if(j % 1000 == 0):
print "Error:" + str(overallError)
print "Pred:" + str(d)
print "True:" + str(c)
out = 0
for index,x in enumerate(reversed(d)):
out += x*pow(2,index)
print str(a_int) + " + " + str(b_int) + " = " + str(out)
print "------------"
二、选择其他激活函数
激活函数有很多其他的选择，常看见的有ReLU、Leaky ReLU函数。下面就说一说这两个函数，对于ReLU，函数为
可以看到，它在负数的一段永远是0啊。为什么要使用这个函数呢？据说它是与神经学科有关的，这是因为稀疏激活的，这表现在负数端是抑制状态，正数兴奋激活。而且有理论也表明，稀疏的网络更准确，在googLeNet的实现中就是利用了神经网络的稀疏性。而且，在正数端导数永远为1，这就很好地解决了梯度消失的问题了。可是，它没有把数据压缩，这会使得数据的范围可能很大。
此外还有Leaky ReLU函数，这个我是在YOLO看到的，其实和ReLU差不多，就是在负数端不完全抑制了。图像如下：
三、层归一化
这里记录的是Batch Normalization。主要参考（1）（2）（3）写的总结，可怜我只是个搬运工啊。
先说一说BN解决的问题，论文说要解决 Internal covariate shift 的问题，covariate shift 是指源空间与目标空间中条件概率一致，但是边缘概率不同。在深度网络中，越深的网络对特征的扭曲就越厉害（应该是这样说吧……），但是特征本身对于类别的标记是不变的，所以符合这样的定义。BN通过把输出层的数据归一化到mean = 0， var = 1的分布中，可以让边缘概率大致相同吧（知乎魏大牛说不可以完全解决，因为均值方差相同不代表分布相同~~他应该是对的），所以题目说是reducing。
那么BN是怎么实现的呢？它是通过计算min batch 的均值与方差，然后使用公式归一化
中间就是接近线性了，这样，导数几乎为常数1，这样不就可以解决梯度消失的问题了吗？
但是，对于ReLU函数，这个是否起作用呢？好像未必吧，不过我觉得这个归一化可以解决ReLU不能把数据压缩的问题，这样可以使得每层的数据的规模基本一致了。上述（3）中写到一个BN的优点，我觉得和我的想法是一致的，就是可以使用更高的学习率。如果每层的scale不一致，实际上每层需要的学习率是不一样的，同一层不同维度的scale往往也需要不同大小的学习率，通常需要使用最小的那个学习率才能保证损失函数有效下降，Batch Normalization将每层、每维的scale保持一致，那么我们就可以直接使用较高的学习率进行优化。这样就可以加快收敛了。我觉得还是主要用来减少covariate shift 的。
但是，上述归一化会带来一个问题，就是破坏原本学习的特征的分布。那怎么办？论文加入了两个参数，来恢复它本来的分布
那么在哪里可以使用这个BN？很明显，它应该使用在激活函数之前。而在此处还提到一个优点就是加入BN可以不使用dropout，为什么呢？dropout它是用来正则化增强网络的泛化能力的，减少过拟合，而BN是用来提升精度的，之所以说有这样的作用，可能有两方面的原因（1）过拟合一般发生在数据边缘的噪声位置，而BN把它归一化了（2）归一化的数据引入了噪声，这在训练时一定程度有正则化的效果。对于大的数据集，BN的提升精度会显得更重要，这两者是可以结合起来使用的。
最后贴一个算法的流程，以及结构图，结构图是来自 http://yeephycho.github.io/2016/08/03/Normalizations-in-neural-networks/
四、权值初始化
为了让信息可以更好的在网络中流动（不一定是梯度消失的问题），可以使用xavier的初始化方法。主要可以看知乎专栏。为了不重复别人的工作，我简单总结一下算了。注意一个问题，xavier的初始化方法的前提假设是，激活函数是线性的（其实归一化后，可能把数据集中在了一处，就好像将BN的那张图一样）。
如果输入数据x和权值w都满足均值为0，标准差为
通过递推公式可以得到
上面说的是前向的，那么后向呢？后向传播时，如果可以让方差保持一致，同样地会有前向传播的效果，梯度可以更好地在网络中流动。由于假设是线性的，那么回流的梯度公式是
最后，是使用均匀分布来初始化权值的，得到初始化的范围
另外一种MSRA的初始化的方法，可以学习http://blog.csdn.net/shuzfan/article/details/51347572，实验效果表现要好一些，但貌似xavier用的要多一些。
五、调整网络的结构
解决RNN的问题，提出了一种LSTM的结构，但我对LSTM还不是太熟悉，就不装逼了。主要是总结最近看的两篇文章《Training Very Deep Networks》和《Deep Residual Learning for Image Recognition》。
Highway Network
Highway Network主要解决的问题是，网络深度加深，梯度信息回流受阻造成网络训练困难的问题。先看下面的一张对比图片，分别是没有highway 和有highway的。
可以看到，当网络加深，训练的误差反而上升了，而加入了highway之后，这个问题得到了缓解。一般来说，深度网络训练困难是由于梯度回流受阻的问题，可能浅层网络没有办法得到调整，或者我自己YY的一个原因是（回流的信息经过网络之后已经变形了，很可能就出现了internal covariate shift类似的问题了）。Highway Network 受LSTM启发，增加了一个门函数，让网络的输出由两部分组成，分别是网络的直接输入以及输入变形后的部分。
假设定义一个非线性变换为
一个网络的输出最终变为
注意，门函数
在初始化的时候，论文是把偏置 b 初始化为负数，这样可以让携带函数 C 偏大，这样做的好处是什么呢？可以让更多的信息直接回流到输入，而不需要经过一个非线性转化。我的理解是，在BP算法时，这一定程度上增大了梯度的回流，而不会被阻隔；在前向流动的时候，把允许原始的信息直接流过，增加了容量，就好像LSTM那样，可以有long - term temporal dependencies。
Residual Network
ResNet的结构与Highway很类似，如果把Highway的网络变一下形会得到
是的，就是这么简单，但是，网络很强大呀。而且实验证明，在网络加深的时候，依然很强大。那为什么这么强大呢？我觉得是因为identity map是的梯度可以直接回流到了输入层。至于是否去掉门函数会更好呢，这个并不知道。在作者的另一篇论文《Identity Mappings in Deep Residual Networks》中，实验证明了使用identity map会比加入卷积更优。而且通过调整激活函数和归一化层的位置到weight layer之前，称为 pre-activation，会得到更优的结果。
对于网络中的一些虚线层，他们的shortcut就连接了两个维度不同的feature，这时，有两种解决办法（1）在维度减少的部分直接使用 identity 映射，同时对于feature map增加部分用0补齐。（2）通过1*1的卷积变形得到。对于这个1*1的投影是怎么做的，可以参考VGG-16。我开始也很纳闷，例如上面的虚线，输入有64个Feature，输出是128个Feature，如果是用128个kernel做卷积，应该有64*128个feature啊。纠结很久，看了看VGG的参数个数就明白了，如下图
例如第一、二行，输入3个Feature，有64个卷积核但却有64个输出，是怎么做到的呢？看它的权值的个数的计算时（3*3*3）*64，也就是说，实际上这64个卷积核其实是有3维的通道的。对应于ResNet的64个输入，同样卷积核也是有64个channel的。