DNN全连接神经网络BP反向传播算法代码注释

import numpy
def sigmoid (x): #激活函数
	return 1/(1+numpy.exp(-x))
def der_sigmoid(x): #激活函数的导数
    return sigmoid(x)*(1-sigmoid(x))
def mse_loss(y_tr,y_pre): #均方误差损失函数
    return((y_tr - y_pre)**2).mean()
class nerualnetwo():
    def __init__(self): #感知神经元的权值属性定义，初始化随机值，会导致模型以及预测结果每次都不同
       self.w1 = numpy.random.normal()
       self.w2 = numpy.random.normal()
       self.w3 = numpy.random.normal()
       self.w4 = numpy.random.normal()
       self.w5 = numpy.random.normal()
       self.w6 = numpy.random.normal()
       self.b1 = numpy.random.normal()
       self.b2 = numpy.random.normal()
       self.b3 = numpy.random.normal()
    def feedforward(self,x):  #前向计算方法，#返回所有神经元值
        h1 = x[0]*self.w1+x[1]*self.w2+self.b1
        h1f = sigmoid(h1)
        h2 = x[0]*self.w3+x[1]*self.w4+self.b2
        h2f = sigmoid(h2)
        o1 = h1f*self.w5+h2f*self.w6+self.b3
        of = sigmoid(o1)
        return h1,h1f,h2,h2f,o1,of  
    def simulate (self,x): #前向计算方法，返回预测值
        h1 = x[0]*self.w1+x[1]*self.w2+self.b1
        h1f = sigmoid(h1)
        h2 = x[0]*self.w3+x[1]*self.w4+self.b2
        h2f = sigmoid(h2)
        o1 = h1f*self.w5+h2f*self.w6+self.b3
        of = sigmoid(o1)
        return of
    def train(self,data,all_y_tr):
        epochs = 1000 #迭代次数
        learn_rate = 0.1 #学习率
        #print(self.w1)
        for i in range(epochs):
            for x , y_tr in zip(data,all_y_tr):
                valcell = self.feedforward(x) #使用当前权值前向计算所有神经元值
                #h1-cell[0],h1f-cell[1],h2-cell[2],h2f-cell[3],o1-cell[4],of-cell[5]
                y_pre = valcell[5]  #当前预测结果
                #反向传播求导计算，每个节点或权值仅仅需要求导一次，即可覆盖下方所有节点
                der_L_y_pre = -2*(y_tr-y_pre)  #损失函数L对y_pre求导                
                #y_pre对h1f求偏导，y_pre就是of, of=sg(o1),o1= h1f*self.w5+h2f*self.w6+self.b3（w5后面做常数处理）
                #用下一层的输出对上一层的输出逐层求偏导, 目的是求出对权值的偏导
                #（权值是刻画数据的元数据，机器学习的目的就是以数据为依据求出刻画自身的元数据）
                der_y_pre_h1f = der_sigmoid(valcell[4])*self.w5
                der_y_pre_h2f = der_sigmoid(valcell[4])*self.w6
                #print(valcell,der_y_pre_h2f)
                #h1f对w1，w2求偏导
                der_h1f_w1 = der_sigmoid(valcell[0])*x[0]
                der_h1f_w2 = der_sigmoid(valcell[0])*x[1]
                #h2f对w3，w4求偏导
                der_h2f_w3 = der_sigmoid(valcell[2])*x[0]
                der_h2f_w4 = der_sigmoid(valcell[2])*x[1]
                #y_pre对w5w6b3求偏导
                der_y_pre_w5 = der_sigmoid(valcell[4])*valcell[1]
                der_y_pre_w6 = der_sigmoid(valcell[4])*valcell[3]
                der_y_pre_b3 = der_sigmoid(valcell[4])
                #h1f对b1求偏导
                der_h1f_b1 = der_sigmoid(valcell[0])
                #h2f对b2求偏导
                der_h2f_b2 = der_sigmoid(valcell[2])
				#反向传播，以损失函数为起点反向传播（通过求导链式法则）到各个权值参数
				#梯度下降，调整权值，按照学习速率逐渐下降，学习率与梯度的乘积为下降步长。
				#即权重和偏置每向前一步，就需要走学习率和当前梯度的乘积这么远
                self.w1 -= learn_rate * der_L_y_pre * der_y_pre_h1f * der_h1f_w1
                self.w2 -= learn_rate * der_L_y_pre * der_y_pre_h1f * der_h1f_w2
                self.w3 -= learn_rate * der_L_y_pre * der_y_pre_h2f * der_h2f_w3
                self.w4 -= learn_rate * der_L_y_pre * der_y_pre_h2f * der_h2f_w4
                self.w5 -= learn_rate * der_L_y_pre * der_y_pre_w5
                self.w6 -= learn_rate * der_L_y_pre * der_y_pre_w6
                self.b1 -= learn_rate * der_L_y_pre * der_y_pre_h1f * der_h1f_b1
                self.b2 -= learn_rate * der_L_y_pre * der_y_pre_h2f * der_h2f_b2
                self.b3 -= learn_rate * der_L_y_pre *der_y_pre_b3
            if i % 10 ==0 :
         		#对训练数据数组作为simulate函数的参数依次进行处理得到当前预测值
                y_pred = numpy.apply_along_axis(self.simulate,1,data)  
                #对真实值与预测值两个数组使用损失函数求均方误差作为参数的评价标准
                loss = mse_loss (all_y_tr , y_pred) 
                print(i,loss)