机器学习_算法_神经网络_BP

参考:

http://wenku.baidu.com/view/7c38bb1b964bcf84b9d57b7d.html

http://wenku.baidu.com/view/e98dbbd433d4b14e8524680e.html

上面两本将就一下，有些位置是错的，我参考的是它的例子，原理参考下面这本

这里有本专门将BP的，http://wenku.baidu.com/view/00b75f5202768e9951e738de.html

网上一大堆都是讲理论的，少数的把流程写了一下，但是真正实现的就太少了，有代码也是matlab这种直接使用内置的模块包的，没有找到切切实实写出来的

没办法，我自己到处找资料总算把它实现出来了，还是python，用其他语言的朋友也可以看一下

#-*- coding:utf-8 -*-
'''
Created on Aug 25, 2013

@author: blacklaw
@ref:    http://wenku.baidu.com/view/e98dbbd433d4b14e8524680e.html '''
'''
WingLength FeelerLength Class AimValue(0.9 -> 'Apf' 0.1 -> 'Af')
'''
DATA = [[1.78, 1.14, 'Apf', 0.9],
[1.96, 1.18, 'Apf', 0.9],
[1.86, 1.2, 'Apf', 0.9],
[1.72, 1.24, 'Af', 0.1],
[2.0, 1.26, 'Apf', 0.9],
[2.0, 1.28, 'Apf', 0.9],

[1.96, 1.3, 'Apf', 0.9],
[1.74, 1.36, 'Af', 0.1],
[1.64, 1.38, 'Af', 0.1],
[1.82, 1.38, 'Af', 0.1],
[1.9, 1.38, 'Af', 0.1],
[1.7, 1.4, 'Af', 0.1],

[1.82, 1.48, 'Af', 0.1],
[1.82, 1.54, 'Af', 0.1],
[2.08, 1.56, 'Af', 0.1]]
Eta = 0.1

from numpy import *
import random
# Interface
class Inspirator():
def inspire(self, x):
return 0

#
class SigmoidInspirator(Inspirator):
def inspire(self, x):
return 1 / (1 + e**-x)

#
class Nerve():
inputs = []
inspirator = Inspirator()
threshold = 1
threshold_weight = -0.5
sons = []
sons_weight = {}
last_out = 0
def __init__(self):
self.clear_inputs()
self.clear_sons()
self.inspirator = SigmoidInspirator()
self.init_threshold()
self.sons_weight = {}
self.last_out = 0
self.delta = 0

def set_threshold_w(self, w):
self.threshold_weight = w
return self

def init_threshold(self):
self.threshold = 1

def input(self, x, weight = 0.5):
self.inputs.append({'x':x, 'w':weight, 'o':0})

def add_sons(self, sons, weights = 0.5):
DEFAULT_WEIGHT = 0.5
if not isinstance(sons, list):
sons = [sons]
if not isinstance(weights, list):
weights = [weights]
for i, son in enumerate(sons):
self.sons.append(son)
#print weights[i]
try: self.sons_weight[son] = weights[i]
except: self.sons_weight[son] = DEFAULT_WEIGHT

def calc_out(self):
return self.inspirator.inspire(
sum([input['x'] * input['w'] for input in self.inputs] \
+ [self.threshold * self.threshold_weight])
)

def calc_delta(self, sons_detal_sum):
return self.last_out * (1 - self.last_out) * sons_detal_sum

def clear_inputs(self):
self.inputs = []

def clear_sons(self):
self.sons = []

def refresh_delta(self):
delta = sum([self.sons_weight[son]*son.get_delta()  for son in self.sons])
self.set_delta(delta)

def refresh_weights(self):
for son in self.sons:
d_weight = son.get_delta() * Eta * self.last_out
self.sons_weight[son] += d_weight
#print self.sons_weight[son]
self.threshold_weight += Eta * 1 * self.get_delta()
#print 'WW',self.threshold_weight

def output(self):
out = self.calc_out()
self.last_out = out
for son in self.sons:
weight = self.sons_weight[son]
son.input(out, weight)
return out

def set_delta(self, delta):
self.delta = delta

def get_delta(self):
return self.delta

def info(self):
return "Hash:%s\nInputs:%s\nLast_out:%s\nThreshold:%s W:%s\nSons:%s\nSons_weight:%s" % \
(hash(self),
self.inputs,
self.last_out,
self.threshold,
self.threshold_weight,
[hash(son) for son in self.sons],
[{hash(key) : value} for key, value in self.sons_weight.items()]
)

class InputNerve(Nerve):
def __init__(self):
Nerve.__init__(self)
self.inputs = 0

def input(self, x):
self.inputs = x

def calc_out(self):
return self.inputs

class NervesManager():
inputs = []
hiddens = []
outputs = []
def __init__(self, nerve_count_list):
self.inputs = []
self.hiddens = []
self.outputs = []
self.create(nerve_count_list)

def create(self, nerve_count_list):
# crate input nerve
for i in range(nerve_count_list[0]):
input = InputNerve()
self.inputs.append(input)
for i in range(nerve_count_list[1]):
hidden = Nerve()
self.hiddens.append(hidden)
self.outputs.append(Nerve())

for nerve in self.inputs:
nerve.add_sons(self.hiddens, [random.random() for i in range(len(self.hiddens))])
for nerve in self.hiddens:
nerve.add_sons(self.outputs, [random.random() for i in range(len(self.outputs))])

def train(self, value_list, T):
O = self.test(value_list)
nerves = self.inputs + self.hiddens + self.outputs
# refresh output nerve by manual
self.outputs[0].set_delta(self.outputs[0].calc_delta(T - O))
# refresh input and hidden by son's delta
for nerve in self.hiddens + self.inputs:
nerve.refresh_delta()
# refresh all nerve's sons weight
for nerve in nerves:
nerve.refresh_weights()
return O, T

def test(self, value_list):
nerves = self.inputs + self.hiddens + self.outputs
for i, input in enumerate(self.inputs):
input.input(value_list[i])
for nerve in nerves:
nerve.output()
for nerve in nerves:
nerve.clear_inputs()
return self.outputs[0].last_out

if __name__ == "__main__":
#print DATA
'''
input nodes:   2
hidden nodes:  2
output nodes:  1
'''
manager = NervesManager([2, 2, 1])
# train BP
for i in range(2000):
avr_sum = 0
print '******** train **********'
for line in DATA:
O, T = manager.train([line[0], line[1]], line[3])
avr_sum += (O - T)**2
print O, T
avr = avr_sum / len(DATA)
print avr
if avr < 0.005:
break
# test BP
print "********* test **********"
for line in DATA:
print  manager.test([line[0], line[1]]), line[3]

OD实现的，两个大类Nerve和NervesManager

这里发个结果给大家看看，我训练了2000*15圈，我Eta选的是0.1，收敛速度还是比较慢，有几次测试陷到局部最小点了，郁闷，以后还会写几篇BP的改进方法

********* test **********
0.994341785362 0.9
0.999736065837 0.9
0.989063612563 0.9
0.163572725812 0.1
0.999218216462 0.9
0.997095492527 0.9
0.730657889775 0.9
0.134026079144 0.1
0.114695534729 0.1
0.142601445274 0.1
0.157811418673 0.1
0.119199019357 0.1
0.120173144422 0.1
0.108409846864 0.1
0.143414585379 0.1