首先实现几个工具函数:

defrand(a，b):

return(b-a)*random.random()+a

defmake_matrix(m，n，fill=0.0):#创造一个指定大小的矩阵

mat=[]

foriinrange(m):

mat.append([fill]*n)

returnmat

定义sigmod函数和它的导数:

defsigmoid(x):

return1.0/(1.0+math.exp(-x))

defsigmod_derivate(x):

returnx*(1-x)

定义BPNeuralNetwork类，使用三个列表维护输入层，隐含层和输出层神经元，列表中的元素代表对应神经元当前的输出值.使用两个二维列表以邻接矩阵的形式维护输入层与隐含层，隐含层与输出层之间的连接权值，通过同样的形式保存矫正矩阵.

定义setup方法初始化神经网络:

defsetup(self，ni，nh，no):

self.input_n=ni+1

self.hidden_n=nh

self.output_n=no

#initcells

self.input_cells=[1.0]*self.input_n

self.hidden_cells=[1.0]*self.hidden_n

self.output_cells=[1.0]*self.output_n

#initweights

self.input_weights=make_matrix(self.input_n，self.hidden_n)

self.output_weights=make_matrix(self.hidden_n，self.output_n)

#randomactivate

foriinrange(self.input_n):

forhinrange(self.hidden_n):

self.input_weights[i][h]=rand(-0.2，0.2)

forhinrange(self.hidden_n):

foroinrange(self.output_n):

self.output_weights[h][o]=rand(-2.0，2.0)

#initcorrectionmatrix

self.input_correction=make_matrix(self.input_n，self.hidden_n)

self.output_correction=make_matrix(self.hidden_n，self.output_n)

定义predict方法进行一次前馈，并返回输出:

defpredict(self，inputs):

#activateinputlayer

foriinrange(self.input_n-1):

self.input_cells[i]=inputs[i]

#activatehiddenlayer

forjinrange(self.hidden_n):

total=0.0

foriinrange(self.input_n):

total+=self.input_cells[i]*self.input_weights[i][j]

self.hidden_cells[j]=sigmoid(total)

#activateoutputlayer

forkinrange(self.output_n):

total=0.0

forjinrange(self.hidden_n):

total+=self.hidden_cells[j]*self.output_weights[j][k]

self.output_cells[k]=sigmoid(total)

returnself.output_cells[:]

定义back_propagate方法定义一次反向传播和更新权值的过程，并返回最终预测误差:

defback_propagate(self，case，label，learn，correct):

#feedforward

self.predict(case)

#getoutputlayererror

output_deltas=[0.0]*self.output_n

foroinrange(self.output_n):

error=label[o]-self.output_cells[o]

output_deltas[o]=sigmod_derivate(self.output_cells[o])*error

#gethiddenlayererror

hidden_deltas=[0.0]*self.hidden_n

forhinrange(self.hidden_n):

error=0.0

foroinrange(self.output_n):

error+=output_deltas[o]*self.output_weights[h][o]

hidden_deltas[h]=sigmod_derivate(self.hidden_cells[h])*error

#updateoutputweights

forhinrange(self.hidden_n):

foroinrange(self.output_n):

change=output_deltas[o]*self.hidden_cells[h]

self.output_weights[h][o]+=learn*change+correct*self.output_correction[h][o]

self.output_correction[h][o]=change

#updateinputweights

foriinrange(self.input_n):

forhinrange(self.hidden_n):

change=hidden_deltas[h]*self.input_cells[i]

self.input_weights[i][h]+=learn*change+correct*self.input_correction[i][h]

self.input_correction[i][h]=change

#getglobalerror

error=0.0

foroinrange(len(label)):

error+=0.5*(label[o]-self.output_cells[o])**2

returnerror

定义train方法控制迭代，该方法可以修改最大迭代次数，学习率λ，矫正率μ三个参数.

deftrain(self，cases，labels，limit=10000，learn=0.05，correct=0.1):

foriinrange(limit):

error=0.0

foriinrange(len(cases)):

label=labels[i]

case=cases[i]

error+=self.back_propagate(case，label，learn，correct)

编写test方法，演示如何使用神经网络学习异或逻辑:

deftest(self):

cases=[

[0，0]，

[0，1]，

[1，0]，

[1，1]，

]

labels=[[0]，[1]，[1]，[0]]

self.setup(2，5，1)

self.train(cases，labels，10000，0.05，0.1)

forcaseincases:

print(self.predict(case))

以上内容为大家介绍了Python实现BP神经网络，希望对大家有所帮助，如果想要了解更多Python相关知识，请关注IT培训机构:千锋教育。

上一篇

Python机器学习之使用Keras进行回归预测

下一篇

Python垃圾回收机制