《机器学习与数据挖掘》实验五编程实现误差逆传播算法（BP算法）

Love The Way You Lie 2023-10-11 19:38 73阅读 0赞

## 前言： ##

> 摘要：本文对机器学习实验五 标准BP算法的代码进行实现，如果不了解的BP算法的话，可以自行上网搜索BP算法的详解.

> 实验题目： 编程实现误差逆传播算法（BP算法） 
> 
> 实验目的： 掌握误差逆传播算法（BP算法）的工作流程 
> 
> 实验环境（硬件和软件） Anaconda/Jupyter notebook/Pycharm 
> 
> 实验内容：
> 
> 编码实现标准BP算法，在西瓜数据集3.0上用这个算法训练一个单隐层网络，并进行测试。

## **要求：** ##

> **一、**已经给定部分代码，补充完整的代码，需要补充代码的地方已经用红色字体标注，在第（2）部分，包括：
> 
> **\#****补充前向传播代码**
> 
> **\#****补充反向传播代码**
> 
> **\#****补充参数更新代码**
> 
> **\#****补充****Loss****可视化代码**
> 
> **二、**将补充完整的第（2）部分的代码提交，并提交实验结果；（**也可以自己重写这部分的代码提交**）

## 代码 ： ##

> PS:标准BP算法
> 
>     import pandas as pd
>     import numpy as np
>     from sklearn.preprocessing import LabelEncoder
>     from sklearn.preprocessing import StandardScaler
>     import matplotlib.pyplot as plt
>     
>     seed = 2020
>     import random
>     
>     np.random.seed(seed)  # Numpy module.
>     random.seed(seed)  # Python random module.
>     
>     plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
>     plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
>     plt.close('all')
>     # 数据预处理
>     data = pd.read_csv("PS:这里放入自己数据所在的路径。")
>     
>     
>     def preprocess(data):
>         # 将非数映射数字
>         for title in data.columns:
>             if data[title].dtype == 'object':
>                 encoder = LabelEncoder()
>                 data[title] = encoder.fit_transform(data[title])
>                 # 去均值和方差归一化
>         ss = StandardScaler()
>         X = data.drop('好瓜', axis=1)
>         Y = data['好瓜']
>         X = ss.fit_transform(X)
>         x, y = np.array(X), np.array(Y).reshape(Y.shape[0], 1)
>         return x, y
>     
>     
>     # 定义Sigmoid
>     def sigmoid(x):
>         return 1 / (1 + np.exp(-x))
>     
>     
>     # 求导
>     def d_sigmoid(x):
>         return x * (1 - x)
>     
>     
>     # 标准BP算法
>     
>     def standard_BP(x, y, dim=10, eta=0.8, max_iter=500):
>         n_samples = 1
>         w1 = np.random.random((x.shape[1], dim))
>         w2 = np.random.random((dim, 1))
>         b1 = np.random.random((n_samples, dim))
>         b2 = np.random.random((n_samples, 1))
>         losslist = []
>         for ite in range(max_iter):
>             loss_per_ite = []
>             for m in range(x.shape[0]):
>                 xi, yi = x[m, :], y[m, :]
>                 xi, yi = xi.reshape(1, xi.shape[0]), yi.reshape(1, yi.shape[0])
>                 ##补充前向传播代码
>                 u1 = np.dot(xi, w1) + b1
>                 out1 = sigmoid(u1)
>                 u2 = np.dot(out1, w2) + b2
>                 out2 = sigmoid(u2)
>                 loss = np.square(yi - out2) / 2
>                 loss_per_ite.append(loss)
>                 print('iter:%d  loss:%.4f' % (ite, loss))
>                 ##反向传播
>                 ##补充反向传播代码
>                 ##补充参数更新代码
>                 g = (yi - out2) * d_sigmoid(out2)
>                 d_w2 = np.dot(np.transpose(out1), g)
>                 d_b2 = -g
>                 d_out1 = np.dot(g, np.transpose(w2))
>                 e = d_out1 * sigmoid(out1)
>                 d_w1 = np.dot(np.transpose(xi), e)
>                 d_b1 = -e
>                 w1 = w1 + eta * d_w1
>                 w2 = w2 + eta * d_w2
>                 b1 = b1 + eta * d_b1
>                 b2 = b2 + eta * d_b2
>     
>             losslist.append(np.mean(loss_per_ite))
>         ##Loss可视化
>         ##补充Loss可视化代码
>         plt.figure()
>         plt.plot([i + 1 for i in range(max_iter)], losslist)
>         plt.legend(['standard BP'])
>         plt.xlabel('iteration')
>         plt.ylabel('loss')
>         plt.show()
>         return w1, w2, b1, b2
>     
>     
>     # 测试
>     def main():
>         data = pd.read_table('watermelon30.txt', delimiter=',')
>         data.drop('编号', axis=1, inplace=True)
>         x, y = preprocess(data)
>         dim = 10
>         #    _,_,_,_ = standard_BP(x,y,dim)
>         w1, w2, b1, b2 = standard_BP(x, y, dim)
>         u1 = np.dot(x, w1) + b1
>         out1 = sigmoid(u1)
>         u2 = np.dot(out1, w2) + b2
>         out2 = sigmoid(u2)
>         y_pred = np.round(out2)
>         result = pd.DataFrame(np.hstack((y, y_pred)), columns=['真值', '预测'])
>         result.to_excel('result.xlsx', index=False)
>     
>     
>     # 补充测试代码，根据当前的x，预测其类别；
>     if __name__ == '__main__':
>         main()

## 总结： ##

> 标准BP的算法实现的核心在于对的向前，向后，参数的更新算法的理解。
> 
> PS:BP算法中有标准BP算法与累积BP算法的区别，这里给出的是标准的BP算法的一个小示例，如果读者对BP算法有兴趣的话，建议您在网上查阅资料或者查阅书籍。