基于BP神经网络的客户分类

y1skkk

已于 2023-08-18 21:07:31 修改

阅读量188

点赞数

文章标签：分类人工智能数据挖掘

于 2023-08-17 23:27:05 首次发布

本文链接：https://blog.csdn.net/qq_56383190/article/details/132351262

版权

这是刚开始学的时候的一个项目，比较的粗糙，应该还是有很多问题的，现在把这些项目整理出来，学的时候、做这些项目的时候参考了很多网上的项目，现在希望这些我完成的项目、代码也能给大家带来一些帮助吧。

项目：给出一个一个已经分类好的数据集，通过BP神经网络对这个模型进行训练，应用这个模型对最后一个未分类的数据集进行分类。

数据集：

数据据集一共就27行，由于数据量不是很大，只划分了训练集和测试集19：8，显然27个数据是远远不足以对一个模型进行比较好的训练的，于是对这些数据进行重复训练。

神经网络构造：

神经网络共由三层构造：输入层（I）-隐含层(H)-输出层(O)

（图片来自网络）

前向传播

由左向右传播为正向传播，将信息输入输入层，经过隐含层(可以设置多个隐含层，由于刚开始学，选择的是一个隐含层)，会在输出层输出一个值（也就是本项目的目标分类结果）。通过sigmoid激励函数来约束，中间隐含层是一些计算函数。

sigmoid函数定义为 $S(x)=\frac{1}{1+e^{-x}}$ ,它的作用是将函数值约束在（0，1）之间，图像为

（图片来自百度百科）

Sigmoid 曲线

隐含层输出=sigmoid[各(输入层输出*隐含层对应权值+隐含层偏置)之和]

$active-hidden[i]=sigmoid(\sum_{0}^{j=6}active-in[j]*weight-in[j][i]+bias-in[i])$

输出层输出=sigmoid[各(隐含层输出*输出层权值+输出层偏置)之和]

$active-out[i]=sigmoid(\sum_{0}^{j=9}active-hidden[j]*weight-out[j][i]+bias-out[i])$

误差=1/2{期待输出(实际结果)-输出层输出]的平方}之和

$error=\sum_{i=1}^{n}\frac{1}{2}(targets[i]-active-out[i])^{2}$

反向传播

反向传播的过程主要是通过对各层权值和偏置求偏导，削减误差的梯度，求导后结果为

$weight-out[i][j]=weight-out[i][j]-learning-rate*\frac{\partial error}{weight-out[i][j]}$

$weight-in[i][j]=weight-out[i][j]-learning-rate*\frac{\partial error}{weight-in[i][j]}$

$bias-out[i]=bias-out[i]-learning-rate*\frac{\partial error}{\partial bias-out[i]}$

$bias-in[i]=bias-in[i]-learning-rate*\frac{\partial error}{\partial bias-in[i]}$

结果

通过1w次前向和反向传播，测试集正确率达到了75%，在此模型下，对下面数据分类为2G

代码

1.定义sigmoid函数

#sigmoid函数
	def sigmoid(x):  
	        return 1.0 / (1 + np.exp(-x))  

#sigmoid函数的导
	def derivative_of_sigmoid(x):    
	    return x * (1 - x)

2.BP神经网络的构造

	class BPNeuralNetWork:  
	    def __init__(self,num_in,num_hidden,num_out):  
	        self.num_in = num_in  
	        self.num_hidden = num_hidden  
	        self.num_out = num_out  
	  
	        self.active_in = [1.0] * self.num_in  
	        self.active_hidden = [1.0] * self.num_hidden  
	        self.active_out = [1.0] * self.num_out  
	  
	        #权值应该随机为期望为0，方差为0.01**2的值，不能全部为0，防止对称失效  
	        self.weight_in = np.random.normal(0,0.01**2,size=(self.num_in, self.num_hidden))  
	        self.weight_out = np.random.normal(0,0.01**2,size=(self.num_hidden, self.num_out))  
	  
	        self.bias_in = np.random.normal(0,0.01**2,size=(self.num_hidden, 1))  
	        self.bias_out = np.random.normal(0,0.01**2,size=(self.num_out, 1))

3.前向传播

	    def forword_propagation(self,inputs):  
	        #前向传播函数  
	        for i in range(self.num_in):  
	            self.active_in[i] = inputs[i]  
	  
	        for i in range(self.num_hidden):  
	            sum = 0.0  
	            for j in range(self.num_in):  
	                sum = sum + self.active_in[j] * self.weight_in[j][i]  
	            self.active_hidden[i] = sigmoid(sum+self.bias_in[i])  
	  
	        for i in range(self.num_out):  
	            sum = 0  
	            for j in range(self.num_hidden):  
	                sum = self.active_hidden[j] * self.weight_out[j][i] 
	            self.active_out[i] = sigmoid(sum+self.bias_out[i])   
	  
	        return self.active_out

4.反向传播

	    def back_propagation(self,targets,learning_rate):  
	        #反向传播修正函数  
	        out_deltas = [0.0] * self.num_out  
	        for i in range(self.num_out):  
	            error = targets[i] - self.active_out[i]  
	            out_deltas[i] = derivative_of_sigmoid(self.active_out[i]) * error * (-1)  
	        hidden_deltas = [0.0] * self.num_hidden  
	  
	        error = 0.0  
	        for i in range(self.num_hidden):  
	            for j in range(self.num_out):  
	                error = error + out_deltas[j] * self.weight_out[i][j]  
	            hidden_deltas[i] = derivative_of_sigmoid(self.active_hidden[i]) * error  
	  
	        for i in range(self.num_hidden):  #更新输出层权值  
	            for j in range(self.num_out):  
	                change1 = out_deltas[j] * self.active_hidden[i]  
	                self.weight_out[i][j] = self.weight_out[i][j] - learning_rate * change1  
	  
	        for i in range(self.num_out):   #更新输出层偏置  
	                change3 = out_deltas[j]  
	                self.bias_out[j][0] = self.bias_out - learning_rate*change3  
	  
	        for i in range(self.num_in):   #更新隐含层权值  
	            for j in range(self.num_hidden):  
	                change2 = hidden_deltas[j] * self.active_in[i]  
	                self.weight_in[i][j] = self.weight_in[i][j] - learning_rate * change2  
	  
	        for i in range(self.num_hidden):   #更新隐含层偏置  
	            for j in range(self.num_out):  
	                change4 = hidden_deltas[i]  
                    self.bias_in[i][j] = self.bias_in[i][j] - learning_rate * change4 

	        error = 0.0  
	        for i in range(len(targets)):  
	            error = error + 0.5 * (targets[i] - self.active_out[i])**2  
	  
	        return  error

5.训练和测试函数

	    def test(self,patterns):  
	        for i in patterns:  
	            print(i[0:7], '——>', self.forword_propagation(i[0:7]))  
	  
	  
	    def training(self,patterns,iterations = 10000,learing_rate = 0.3):  
	        temp = 1000  
	        for i in range(iterations):  
	            error = 0.0  
	            for j in patterns:  
	                inputs = j[0:7]  
	                targets = []  
	                targets.append(j[7])  
	                self.forword_propagation(inputs)  
	                error = error + self.back_propagation(targets,learing_rate)    
	            if i % 100 == 0:  
	                print('所有训练样本的总误差 %.5f' % error)  
	  
	    def predict(self,patterns):  
	        for i in patterns:  
	            print('\n根据学习后的的权重可得')  
	            print(i[0:7],'——>',self.forword_propagation(i[0:7]))

6. 主函数

	def demo():  
        #训练集
	    file_1 = pd.read_excel(r'客户数据.xls',  
	                         sheet_name = 'data',  
	                         index_col = 0,  
	                         skiprows = 0,  
	                         nrows = 19)  
	    training_data = np.array(file_1)  

        #测试集
	    file_2 = pd.read_excel(r'客户数据.xls',	                                           
                               sheet_name='data',  
	                           index_col=0,  
	                           skiprows=19,  
	                           nrows=8)  
	    testing_data = np.array(file_2)  

        #目标集
	    file_3 = pd.read_excel(r'客户数据.xls',  
	                           sheet_name= 'data',  
	                           index_col = 0,  
	                           skiprows = 27,  
	                           nrows = 1)  
	    predicted_data = np.array(file_3)  
	  
	    n = BPNeuralNetWork(7,10,1)  
	    n.training(training_data)  
	    n.test(testing_data)  
	    n.predict(predicted_data)  
	  
	demo()