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

       神经网络又火了，因为深度学习火了，所以必须增加个传统神经网络的介绍,尤其是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算法来求导。
下面是模仿这两个过程的代码：

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