瓜子的成长 / Machine Learn... / 机器学习理论与实战(十二)神经网络

0 0

   

机器学习理论与实战(十二)神经网络

2015-03-16  瓜子的成长

       神经网络又火了,因为深度学习火了,所以必须增加个传统神经网络的介绍,尤其是back propagation算法。很简单,俺也就不舞文弄墨的说复杂咯,神经网络模型如(图一)所示:


(图一)

         (图一)中的神经网络模型是由多个感知器(perceptron)分几层组合而成,所谓感知器就是单层的神经网络(准确的说应该不叫神经网络咯),它只有一个输出节点,如(图二)所示:

(图二)  感知器

         一个感知器就相当于一个线性分类器,而一层神经网络有多个隐藏节点的,就是多个感知器的组合,那么它其实就是多个线性分类器组合形成非线性分类器咯,如(图三)所示:

(图三)

        一层感知器拟合能力就颇为强大,而多层的感知器组合起来,那拟合能力更没得说,可惜的是拟合能力虽然强大,但是求出准确拟合参数的算法不是太好,容易陷入局部最小,而且BP算法很“擅长”陷入局部最小,所谓局部最小,如(图四)所示,网络的权重被随机初始化后,然后求得梯度,然后用梯度更新参数,如果初始化的参数的点选择的不恰当,当梯度为0的点可能是一个使得代价J局部最小的点,而不是全局最小的,自然得到的网络权重也不是最好的。BP算法一直都有这样的问题,而且也容易因为网络规模大导致过拟合,好在最近深度学习提了一系列的trick改善了这些问题。比如用贪心预训练来改进初始化参数,相当于找到了一个好的初始点,严格的说是在正负阶段里主动修改了J的“地形”,这是个人的一些理解,最后再结合标签用传统的BP算法继续进行寻找全局最小,这个BP算法的作用在深度学习里也叫权重微调,当然BP不是唯一的权重微调算法,各种微调的宗旨只有一个:求取目标函数的梯度,更新参数。另外深度学习里利用稀疏和dropout来阻止过拟合。

(图四)

       介绍了BP算法的作用,那么就来看下BP算法的原理,也很简单,就是把目标函数各层的权重进行求导,因为我们要更新权重就是要求出梯度,然后利用梯度更新权重。网络从输入到最终的输出经过了多层的函数处理,求导的时候就是对这个复合函数的链式求导。为了不把BP算法说复杂,我找了一个最简单的网络,如(图五)所示:

(图五)

       (图五)中的网络只有三层:输入层X,隐藏层h和输出层y。中间有两个权重W1和W2,刚开始都是随机初始化的。神经网络的训练分为两个过程,第一过程就是从输入训练样本,层层计算到最终输出y,这个过程前向传播(forward propagation)。接着计算输出y和真实标签的差,这个可以作为简单的目标函数,我们的目标就是使得这个目标函数在所有的训练集上最小,说白了就是找个目标函数的最小值,找它就要求梯度,然后更新参数。接着就是求梯度咯,把目标函数对W2和W1求导咯,这个过程叫反向传播(back propagation)。下面(图六)简单的演示下这个两个过程:

(图六)前向传播和反向传播

       注意下前向传播得到保留中间变量,比如a1,a2, 这些在反向传播中都要是用到的,整个原理也很简单,就是目标函数对各层的权重的求导,因为是复合函数,所以要链式求导。有了梯度,用这个经典更新方式来跟新权重就行咯,其中r 是个自己设置的学习率,不要过大,大了会产生学习晃动的情况,倒三角就是梯度咯。另外输出层不一定要用(图六)中的目标函数,自己可以根据情况来指定不同的目标函数,哪怕你最后输出再加个支持向量机都行,只要你可以求导,得到梯度就行,事实上hinton的一个弟子最近就在做这个事情。个人发挥自己的智慧来改进模型吧^.^,另外,卷积神经网络的参数更新过程也是类似,都免不了用BP算法来求导。

下面是模仿这两个过程的代码:

  1. import math  
  2. import random  
  3. import string  
  4.   
  5. random.seed(0)  
  6.   
  7. # calculate a random number where:  a <= rand < b  
  8. def rand(a, b):  
  9.     return (b-a)*random.random() + a  
  10.   
  11. # Make a matrix (we could use NumPy to speed this up)  
  12. def makeMatrix(I, J, fill=0.0):  
  13.     m = []  
  14.     for i in range(I):  
  15.         m.append([fill]*J)  
  16.     return m  
  17.   
  18. # our sigmoid function, tanh is a little nicer than the standard 1/(1+e^-x)  
  19. def sigmoid(x):  
  20.     return math.tanh(x)  
  21.   
  22. # derivative of our sigmoid function, in terms of the output (i.e. y)  
  23. def dsigmoid(y):  
  24.     return 1.0 - y**2  
  25.   
  26. class NN:  
  27.     def __init__(self, ni, nh, no):  
  28.         # number of input, hidden, and output nodes  
  29.         self.ni = ni + 1 # +1 for bias node  
  30.         self.nh = nh  
  31.         self.no = no  
  32.   
  33.         # activations for nodes  
  34.         self.ai = [1.0]*self.ni  
  35.         self.ah = [1.0]*self.nh  
  36.         self.ao = [1.0]*self.no  
  37.           
  38.         # create weights  
  39.         self.wi = makeMatrix(self.ni, self.nh)  
  40.         self.wo = makeMatrix(self.nh, self.no)  
  41.         # set them to random vaules  
  42.         for i in range(self.ni):  
  43.             for j in range(self.nh):  
  44.                 self.wi[i][j] = rand(-0.2, 0.2)  
  45.         for j in range(self.nh):  
  46.             for k in range(self.no):  
  47.                 self.wo[j][k] = rand(-2.0, 2.0)  
  48.   
  49.         # last change in weights for momentum     
  50.         self.ci = makeMatrix(self.ni, self.nh)  
  51.         self.co = makeMatrix(self.nh, self.no)  
  52.   
  53.     def update(self, inputs):  
  54.         if len(inputs) != self.ni-1:  
  55.             raise ValueError('wrong number of inputs')  
  56.   
  57.         # input activations  
  58.         for i in range(self.ni-1):  
  59.             #self.ai[i] = sigmoid(inputs[i])  
  60.             self.ai[i] = inputs[i]  
  61.   
  62.         # hidden activations  
  63.         for j in range(self.nh):  
  64.             sum = 0.0  
  65.             for i in range(self.ni):  
  66.                 sum = sum + self.ai[i] * self.wi[i][j]  
  67.             self.ah[j] = sigmoid(sum)  
  68.   
  69.         # output activations  
  70.         for k in range(self.no):  
  71.             sum = 0.0  
  72.             for j in range(self.nh):  
  73.                 sum = sum + self.ah[j] * self.wo[j][k]  
  74.             self.ao[k] = sigmoid(sum)  
  75.   
  76.         return self.ao[:]  
  77.   
  78.   
  79.     def backPropagate(self, targets, N, M):  
  80.         if len(targets) != self.no:  
  81.             raise ValueError('wrong number of target values')  
  82.   
  83.         # calculate error terms for output  
  84.         output_deltas = [0.0] * self.no  
  85.         for k in range(self.no):  
  86.             error = targets[k]-self.ao[k]  
  87.             output_deltas[k] = dsigmoid(self.ao[k]) * error  
  88.   
  89.         # calculate error terms for hidden  
  90.         hidden_deltas = [0.0] * self.nh  
  91.         for j in range(self.nh):  
  92.             error = 0.0  
  93.             for k in range(self.no):  
  94.                 error = error + output_deltas[k]*self.wo[j][k]  
  95.             hidden_deltas[j] = dsigmoid(self.ah[j]) * error  
  96.   
  97.         # update output weights  
  98.         for j in range(self.nh):  
  99.             for k in range(self.no):  
  100.                 change = output_deltas[k]*self.ah[j]  
  101.                 self.wo[j][k] = self.wo[j][k] + N*change + M*self.co[j][k]  
  102.                 self.co[j][k] = change  
  103.                 #print N*change, M*self.co[j][k]  
  104.   
  105.         # update input weights  
  106.         for i in range(self.ni):  
  107.             for j in range(self.nh):  
  108.                 change = hidden_deltas[j]*self.ai[i]  
  109.                 self.wi[i][j] = self.wi[i][j] + N*change + M*self.ci[i][j]  
  110.                 self.ci[i][j] = change  
  111.   
  112.         # calculate error  
  113.         error = 0.0  
  114.         for k in range(len(targets)):  
  115.             error = error + 0.5*(targets[k]-self.ao[k])**2  
  116.         return error  
  117.   
  118.   
  119.     def test(self, patterns):  
  120.         for p in patterns:  
  121.             print(p[0], '->', self.update(p[0]))  
  122.   
  123.     def weights(self):  
  124.         print('Input weights:')  
  125.         for i in range(self.ni):  
  126.             print(self.wi[i])  
  127.         print()  
  128.         print('Output weights:')  
  129.         for j in range(self.nh):  
  130.             print(self.wo[j])  
  131.   
  132.     def train(self, patterns, iterations=1000, N=0.5, M=0.1):  
  133.         # N: learning rate  
  134.         # M: momentum factor  
  135.         for i in range(iterations):  
  136.             error = 0.0  
  137.             for p in patterns:  
  138.                 inputs = p[0]  
  139.                 targets = p[1]  
  140.                 self.update(inputs)  
  141.                 error = error + self.backPropagate(targets, N, M)  
  142.             if i % 100 == 0:  
  143.                 print('error %-.5f' % error)  
  144.   
  145.   
  146. def demo():  
  147.     # Teach network XOR function  
  148.     pat = [  
  149.         [[0,0], [0]],  
  150.         [[0,1], [1]],  
  151.         [[1,0], [1]],  
  152.         [[1,1], [0]]  
  153.     ]  
  154.   
  155.     # create a network with two input, two hidden, and one output nodes  
  156.     n = NN(2, 2, 1)  
  157.     # train it with some patterns  
  158.     n.train(pat)  
  159.     # test it  
  160.     n.test(pat)  
  161.   
  162.   
  163.   
  164. if __name__ == '__main__':  
  165.     demo()  

转载请注明来源:http://blog.csdn.net/marvin521/article/details/9886643


参考文献:

      [1] Learning From Data. Yaser S.Abu-Mostafa

    [2] machine learning.Andrew Ng

    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。如发现有害或侵权内容,请点击这里 或 拨打24小时举报电话:4000070609 与我们联系。

    猜你喜欢

    0条评论

    发表

    请遵守用户 评论公约

    类似文章
    喜欢该文的人也喜欢 更多