机器学习理论与实战（十二）神经网络 .

 神经网络又火了，因为深度学习火了，所以必须增加个传统神经网络的介绍,尤其是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 是个自己设置的学习率，不要过大，大了会产生学习晃动的情况，倒三角就是梯度咯。另外输出层不一定要用（图六）中的目标函数，自己可以根据情况来指定不同的目标函数，哪怕你最后输出再加个支持向量机都行，只要你可以求导，得到梯度就行，事实上hiinton的一个弟子就在做这个事情。个人发挥自己的智慧来改进模型吧^.^，另外，卷积神经网络的参数更新过程也是类似，都免不了用BP算法来求导。

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

[python] view plain copy print ?

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()  

import math
import random
import string

random.seed(0)

# calculate a random number where:  a <= rand < b
def rand(a, b):
    return (b-a)*random.random() + a

# Make a matrix (we could use NumPy to speed this up)
def makeMatrix(I, J, fill=0.0):
    m = []
    for i in range(I):
        m.append([fill]*J)
    return m

# our sigmoid function, tanh is a little nicer than the standard 1/(1+e^-x)
def sigmoid(x):
    return math.tanh(x)

# derivative of our sigmoid function, in terms of the output (i.e. y)
def dsigmoid(y):
    return 1.0 - y**2

class NN:
    def __init__(self, ni, nh, no):
        # number of input, hidden, and output nodes
        self.ni = ni + 1 # +1 for bias node
        self.nh = nh
        self.no = no

        # activations for nodes
        self.ai = [1.0]*self.ni
        self.ah = [1.0]*self.nh
        self.ao = [1.0]*self.no
        
        # create weights
        self.wi = makeMatrix(self.ni, self.nh)
        self.wo = makeMatrix(self.nh, self.no)
        # set them to random vaules
        for i in range(self.ni):
            for j in range(self.nh):
                self.wi[i][j] = rand(-0.2, 0.2)
        for j in range(self.nh):
            for k in range(self.no):
                self.wo[j][k] = rand(-2.0, 2.0)

        # last change in weights for momentum   
        self.ci = makeMatrix(self.ni, self.nh)
        self.co = makeMatrix(self.nh, self.no)

    def update(self, inputs):
        if len(inputs) != self.ni-1:
            raise ValueError('wrong number of inputs')

        # input activations
        for i in range(self.ni-1):
            #self.ai[i] = sigmoid(inputs[i])
            self.ai[i] = inputs[i]

        # hidden activations
        for j in range(self.nh):
            sum = 0.0
            for i in range(self.ni):
                sum = sum + self.ai[i] * self.wi[i][j]
            self.ah[j] = sigmoid(sum)

        # output activations
        for k in range(self.no):
            sum = 0.0
            for j in range(self.nh):
                sum = sum + self.ah[j] * self.wo[j][k]
            self.ao[k] = sigmoid(sum)

        return self.ao[:]


    def backPropagate(self, targets, N, M):
        if len(targets) != self.no:
            raise ValueError('wrong number of target values')

        # calculate error terms for output
        output_deltas = [0.0] * self.no
        for k in range(self.no):
            error = targets[k]-self.ao[k]
            output_deltas[k] = dsigmoid(self.ao[k]) * error

        # calculate error terms for hidden
        hidden_deltas = [0.0] * self.nh
        for j in range(self.nh):
            error = 0.0
            for k in range(self.no):
                error = error + output_deltas[k]*self.wo[j][k]
            hidden_deltas[j] = dsigmoid(self.ah[j]) * error

        # update output weights
        for j in range(self.nh):
            for k in range(self.no):
                change = output_deltas[k]*self.ah[j]
                self.wo[j][k] = self.wo[j][k] + N*change + M*self.co[j][k]
                self.co[j][k] = change
                #print N*change, M*self.co[j][k]

        # update input weights
        for i in range(self.ni):
            for j in range(self.nh):
                change = hidden_deltas[j]*self.ai[i]
                self.wi[i][j] = self.wi[i][j] + N*change + M*self.ci[i][j]
                self.ci[i][j] = change

        # calculate error
        error = 0.0
        for k in range(len(targets)):
            error = error + 0.5*(targets[k]-self.ao[k])**2
        return error


    def test(self, patterns):
        for p in patterns:
            print(p[0], '->', self.update(p[0]))

    def weights(self):
        print('Input weights:')
        for i in range(self.ni):
            print(self.wi[i])
        print()
        print('Output weights:')
        for j in range(self.nh):
            print(self.wo[j])

    def train(self, patterns, iterations=1000, N=0.5, M=0.1):
        # N: learning rate
        # M: momentum factor
        for i in range(iterations):
            error = 0.0
            for p in patterns:
                inputs = p[0]
                targets = p[1]
                self.update(inputs)
                error = error + self.backPropagate(targets, N, M)
            if i % 100 == 0:
                print('error %-.5f' % error)


def demo():
    # Teach network XOR function
    pat = [
        [[0,0], [0]],
        [[0,1], [1]],
        [[1,0], [1]],
        [[1,1], [0]]
    ]

    # create a network with two input, two hidden, and one output nodes
    n = NN(2, 2, 1)
    # train it with some patterns
    n.train(pat)
    # test it
    n.test(pat)



if __name__ == '__main__':
    demo()

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

参考文献：

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

   [2] machine learning.Andrew Ng