机器学习--BP算法

机器学习

一、选题背景

原因：本项目使用BP算法，对 iris 数据集(手写数字集)进行二分类，BP算法可以看做成一个浅层的神经网络，希望以后对学习深度学习有一个初步的探索。

数据来源： sklearn中自带数据集

二、设计方案：

1.来源描述：使用sklearn中的自带数据集，手写数字数据集。

1. 框架描述：

BP算法主要是由前向传播和反向传播两个主要过程组成，正向传播时，输入样本从输入层进入网络，经隐层逐层传递至输出层，如果输出层的实际输出与期望输出不同，则转至误差反向传播；如果输出层的实际输出与期望输出相同，结束学习算法。

反向传播时，将输出误差(期望输出与实际输出之差)按原通路反传计算，通过隐层反向，直至输入层，在反传过程中将误差分摊给各层的各个单元，获得各层各单元的误差信号，并将其作为修正各单元权值的根据。这一计算过程使用梯度下降法完成，在不停地调整各层神经元的权值和阈值后，使误差信号减小到最低限度。权值和阈值不断调整的过程，就是网络的学习与训练过程，经过信号正向传播与误差反向播，权值和阈值的调整反复进行，一直进行到预先设定的学习训练次数，或输出误差减小到允许的程度。

1. 涉及到的技术难点解决方案：

技术难点：反向传播，以及训练模块的编写。

解决方案：参照吴恩达是视频以及其课后作业，经琢磨后，反向传播的基本原理其实不难，基本理论就是大学高等数学当中的导数计算。我们需要了解的就是链式法则。

三、实现步骤：

特征分析：

手写数字集是 sklearn中自带的数据集，它是一个三维数组(1797, 8, 8)， 即

有 1797 个手写数字，每个数字由 8*8 的像素矩阵组成。矩阵中每个元素都是 0-16 范围内的整数。分类标签为 0-9的数字

 

 

 

对于切分数据集，本次就选择了sklearn中的模块train_test_split来划分测试集与训练集。

模型选择：

选择BP模型，使用sigmoid函数作为激活函数，低价函数使用均方差误差，通过控制不同的学习率，来观测该模型的结果的差异。

之后就可以进行训练了：

图一为最高训练轮数为10轮（学习率为0.05），未达到预设精度。（之后将最大训练轮数设为100）

 

 

 

图一

图二学习率为0.05，训练轮数为经过30轮后达到预设精度。

 

 

图二

图三学习率为0.09，而训练轮数已经达到了100轮，而其精度却一直为达到预设精度

 

 

图三

图三学习率为0.02，而训练轮数达到了51轮才达到预设精度。

 

 

图四

四、总结

1.结论：由上述对比可以发现，学习率不宜过大，否则的话最后的error会产生波动无法稳定，最终导致无法收敛，一直在最优解间摆动。而学习率过小的话尽管最终会达到预设精度，找到最优解，但明显其训练轮数增多。所以，学习率是训练过程中的重要参数。

2.收获：对python语法更加熟悉，对类的使用更为熟练，对BP算法有了更深入的了解，对深度学习有了一个初步的认知。

 改进建议：可以尝试使用tanh函数作为激活函数，探究不同的激活函数对模型训练的效率以及准确率的影响；初始化参数时候，可以采用随机初始化。

源码：
def sigmoid(x):

    return 1 / (1 + np.exp(-1 * x))

 

 

class layerbuild:

 

    def __init__(

            self, units, activation=None, learning_rate=None, is_input_layer=False

    ):

 

        self.units = units

        self.weight = None

        self.bias = None

        self.activation = activation

        if learning_rate is None:

            learning_rate = 1

        self.learn_rate = learning_rate

        self.is_input_layer = is_input_layer

 

    def initializer(self, back_units):

        self.weight = np.asmatrix(np.random.normal(0, 0.5, (self.units, back_units)))

        self.bias = np.asmatrix(np.random.normal(0, 0.5, self.units)).T

 

        if self.activation is None:

            self.activation = sigmoid

 

    def cal_gradient(self):

        if self.activation == sigmoid:

            gradient_mat = np.dot(self.output, (1 - self.output).T)

            gradient_activation = np.diag(np.diag(gradient_mat))

        else:

            gradient_activation = 1

        return gradient_activation

 

    def forward_propagation(self, xdata):

        self.xdata = xdata

        if self.is_input_layer:

            self.wx_plus_b = xdata

            self.output = xdata

            return xdata

        else:

            self.wx_plus_b = np.dot(self.weight, self.xdata) - self.bias

            self.output = self.activation(self.wx_plus_b)

            return self.output

 

    def backpropagation(self, gradient):

        gradient_activation = self.cal_gradient()  # i * i 维

        gradient = np.asmatrix(np.dot(gradient.T, gradient_activation))

 

        self._gradient_weight = np.asmatrix(self.xdata)

        self._gradient_bias = -1

        self._gradient_x = self.weight

 

        self.gradient_weight = np.dot(gradient.T, self._gradient_weight.T)

        self.gradient_bias = gradient * self._gradient_bias

        self.gradient = np.dot(gradient, self._gradient_x).T

        self.weight = self.weight - self.learn_rate * self.gradient_weight

        self.bias = self.bias - self.learn_rate * self.gradient_bias.T

 

        return self.gradient,self.weight,self.bias

 

 

 

class BPNN():

 

    def __init__(self,x_test,y_test):

        self.layers = []

        self.train_mse = []

        self.y_test = y_test

        self.x_test = x_test

        self.bias = None

        self.weight = None

 

    def add_layer(self, layer):

        self.layers.append(layer)

 

    def build(self):

        for i, layer in enumerate(self.layers[:]):

            if i < 1:

                layer.is_input_layer = True

            else:

                layer.initializer(self.layers[i - 1].units)

 

    def train(self, xdata, ydata, max_train_round, accuracy):

        self.max_train_round = max_train_round

        self.accuracy = accuracy

        x_shape = np.shape(xdata)

        k = 0

 

        for round_i in range(max_train_round):

            all_loss = 0

            k += 1

            for row in range(x_shape[0]):

                _xdata = np.asmatrix(xdata[row, :]).T

                _ydata = np.asmatrix(ydata[row, :]).T

                for layer in self.layers:

                    _xdata = layer.forward_propagation(_xdata)

 

                loss, gradient = self.cal_loss(_ydata, _xdata)

                all_loss = all_loss + loss

                for layer in self.layers[:0:-1]:

                    gradient,weight,bias = layer.backpropagation(gradient)

 

 

            mse = all_loss / x_shape[0]

            self.train_mse.append(mse)

            # print(self.train_mse)

 

            if mse < self.accuracy:

                print("测试集准确率",self.predict(xdata, ydata, max_train_round))

                print("达到预设精度，所用训练轮数为：{}轮".format(k))

                # print(self.train_mse)

                xx = np.arange(1, k + 1)

                yy = self.train_mse

                plt.plot(xx, yy)

                plt.xlabel("train_round")

                plt.ylabel("error")

                plt.show()

                return print("分类准确率为", 1 - mse)

            if k == self.max_train_round:

                print("测试集准确率",self.predict(xdata, ydata, max_train_round))

                print("未达到预设精度，所用训练轮数为：{}轮".format(k))

                xx = np.arange(1, k + 1)

                yy = self.train_mse

                plt.plot(xx, yy)

                plt.xlabel("train_round")

                plt.ylabel("error")

                plt.title("loss visualization")

                plt.show()

                return print("分类准确率为", 1 - mse)

 

    def cal_loss(self, ydata, ydata_):

        self.loss = np.sum(np.power((ydata - ydata_), 2))

        self.loss_gradient = 2 * (ydata_ - ydata)

        return self.loss, self.loss_gradient

 

    def predict(self, xdata, ydata, max_train_round):

        self.max_train_round = max_train_round

        x_shape = np.shape(xdata)

        k = 0

        for round_i in range(max_train_round):

            all_loss = 0

            k += 1

            for row in range(x_shape[0]):

                _xdata = np.asmatrix(xdata[row, :]).T

                _ydata = np.asmatrix(ydata[row, :]).T

                for layer in self.layers:

                    _xdata = layer.forward_propagation(_xdata)

 

                loss, gradient = self.cal_loss(_ydata, _xdata)

                all_loss = all_loss + loss

                for layer in self.layers[:0:-1]:

                    gradient, weight, bias = layer.backpropagation(gradient)

 

            mse = all_loss / x_shape[0]

            # print(self.train_mse)

            return (1-mse)

 

from sklearn.datasets import load_digits

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

 

x, y = load_digits(return_X_y=True)

x_train,x_test,y_train,y_test = train_test_split(x,y,random_state=666)

y_train = y_train.reshape(-1, 1)

y_train = pd.DataFrame(y_train)

y_train.columns = ['type']

y_train = pd.get_dummies(y_train.type, prefix='type')

y_train = np.array(y_train)

y_test = y_test.reshape(450,-1)

print("y",y_test.shape)

model = BPNN(x_test,y_test)

 

for i in (64, 70, 70, 10):

    model.add_layer(layerbuild(i, learning_rate=0.05))

model.build()

model.train(xdata=x_train, ydata=y_train, max_train_round=10, accuracy=0.01)