《基于Tensorflow的知识图谱实战》 --- BP反馈神经网络反向传播算法

⚽开发平台：jupyter lab

🎈运行环境：python3、tensorflow2.x

1.反馈神经网络反向传播算法介绍

• 说明：反向传播算法是神经网络的核心和精髓，在神经网络算法中具有举足轻重的地位。
• 注意点：
  （1）对于隐藏层，误差并不是想输出层一样由单个节点确定，而是由多个节点确定，因此对它的计算要求得到所有的误差值之和。
  （2）对于各层的影响：
• 对输出层单元，误差项是真实值与模型计算值之间的差值。
• 对于隐藏层单元，由于缺少直接的目标值来计算隐藏层单元的误差，因此需要以间接的方式来计算隐藏层的误差项对受隐藏层单元影响的每一个单元的误差进行加权求和。
• 权值的更新方面，主要依靠学习速率、该权值对应的输入以及单元的误差项。

2. 反馈神经网络反向传播算法 - 程序部分

2.1 程序3.5(完整代码)

## 导入相应的工具包
import numpy as np
import math
import random

### 辅助函数的确定
def rand(a,b):     ## 生成随机数
    return (b-a)*random.random() + a   

def make_matrix(m,n,fill=0.0):   ## 生成随机数相对应的矩阵
    mat = []
    for i in range(m):
        mat.append([fill]*n)
    return mat

def sigmoid(x):   ## 激活函数
    return 1.0/(1.0+math.exp(-x))

def sigmod_derivate(x):   ## 激活函数的导函数
    return x*(1-x)

### BP类的正式定义
class BPNeuralNetWork:
	## 读数据内容的初始化，即在其中设置了输入层、隐藏层以及输出层中节点的个数；
	## 各个cell数据是各个层节点的数值；weight代表各个层的权重。
    def __init__(self):
        self.input_n = 0
        self.hidden_n = 0
        self.output_n = 0
        self.input_cells = []
        self.hidden_cells = []
        self.output_cells = []
        self.input_weight = []
        self.output_weight = []
     
    ## 是对init函数中设定的数据进行初始化   
    def setup(self,ni,nh,no):
        self.input_n = ni+1  ### 其中包含bias偏置数
        self.hidden_n = nh
        self.output_n = no
        self.input_cells = [1.0]*self.input_n
        self.hidden_cells = [1.0]*self.hidden_n
        self.output_cells = [1.0]*self.output_n
        self.input_weight = make_matrix(self.input_n,self.hidden_n)
        self.output_weight = make_matrix(self.hidden_n,self.output_n)
        ## random actiate
        for i in range(self.input_n):
            for h in range(self.hidden_n):
                self.input_weight[i][h] = rand(-0.2,0.2)
        for h in range(self.hidden_n):
            for o in range(self.output_n):
                self.output_weight[h][o] = rand(-2.0,2.0)  
    
    ## 对神经网络内容的定义
    ### 对神经网络前向的计算       
    def predict(self,inputs):
        for i in range(self.input_n-1):
            self.input_cells[i] = inputs[i]
        for j in range(self.hidden_n):
            total = 0.0
            for i in range(self.input_n):
                total += self.input_cells[i]*self.input_weight[i][j]
            self.hidden_cells[j] = sigmoid(total)
        for k in range(self.output_n):
            total = 0.0
            for j in range(self.hidden_n):
                total += self.hidden_cells[j]*self.output_weight[j][k]
            self.output_cells[k] = sigmoid(total)
        return self.output_cells[:]
    
    ## 对神经网络反向的计算
    def back_propagate(self,case,label,learn):
        self.predict(case)
        # 计算输出层的误差
        output_deltas = [0.0]*self.output_n
        for k in range(self.output_n):
            error = label[k] - self.output_cells[k]
            output_deltas[k] == sigmod_derivate(self.output_cells[k])* error
        # 计算隐藏层的误差
        hidden_deltas = [0.0] * self.hidden_n
        for j in range(self.hidden_n):
            error = 0.0
            for k in range(self.output_n):
                error += output_deltas[k]*self.output_weight[j][k]
            hidden_deltas[j] = sigmod_derivate(self.hidden_cells[j])*error
        ##更新输出层权重
        for  j in range(self.hidden_n):
            for k in range(self.output_n):
                self.output_weight[j][k] += learn * output_deltas[k]*self.hidden_cells[j]
        ## 更新隐藏层权重
        for i in range(self.input_n):
            for j in range(self.hidden_n):
                self.input_weight[i][j] += learn *hidden_deltas[j] + self.input_cells[i]
        error = 0 
        for o in range(len(label)):
            error += 0.5 * (label[o] - self.output_cells[o]) ** 2
        return error
    
    ## 对模型进行训练
    def train(self,cases,labels,limit=100,learn=0.05):
        for i in range(limit):
            error = 0
            for i in range(len(cases)):
                label = labels[i]
                case = cases[i]
                error += self.back_propagate(case,label,learn)
        pass
    
    ## 定义测试集
    def test(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)
        for case in cases:
            print(self.predict(case))

if __name__ == '__main__':
    nn = BPNeuralNetWork()
    nn.test()

2.2 运行结果