tensorflow.keras下粒子群优化BP网络初始权重用于分类模型

机器鱼

已于 2025-04-05 17:41:19 修改

阅读量506

点赞数

分类专栏： Python神经网络1000个案例分析文章标签： tensorflow python 深度学习

于 2023-04-28 22:17:51 首次发布

本文链接：https://blog.youkuaiyun.com/qq_41043389/article/details/130436137

版权

Python神经网络1000个案例分析专栏收录该内容

27 篇文章

订阅专栏

0 引言

本博客基于tensorflow2.keras，搭建一个简单的BP网络，用于简单的数据分类任务，并采用粒子群算法实现**网络初始权重**的优化选择，
目前网上大部分资料都是基于MATLAB的，所以我想写个tensorflow2.x环境下的使用方法。

1.网络搭建

构建一个两个隐含层的BP网络，各层数量是42→256→128→10，其中42是输入数据的维度，10是分类的类别数，程序如下,优化器采用Adam，学习率0.01，损失为交叉熵损失函数。

from tensorflow.keras import  Sequential, layers
import tensorflow as tf
def model():
    tf.random.set_seed(0)
    network = Sequential([layers.Dense(256, activation='relu'),
                         layers.Dense(128, activation='relu'),
                         layers.Dense(10, activation='softmax')])
    network.build(input_shape=(None,42))
    network.compile(optimizer=tf.keras.optimizers.Adam(lr=0.01),
                      loss=tf.keras.losses.SparseCategoricalCrossentropy(),
                      metrics=['accuracy'])
    return network

2.需要优化的参数

正式优化前需要知道要优化的网络权重参数的具体数量是多少，也就是我们粒子群的维度，分析可知，该网络的权重参数主要就是
① 输入层到隐含层1的权值：42*256
② 隐含层1的偏置：256
③ 隐含层1到隐含层2的权值：256*128
④ 隐含层2的偏置：128
⑤ 隐含层2到输出层的权值：128*10
⑥ 输出层的偏置：10
总计为：45194

3.粒子群优化

最主要的函数就是tensorflow.keras中的model.set_weights(**PSO寻优得到的权重**)，利用这个函数，我们建立好网络之后，只需要将粒子群的优化得到的位置，转换为所需要的权值与偏置的列表，然后set给网络即可，具体如下：

def fitness(init_weights):#init_weights为pso优化得到的值
    network=model()#新建网络
    weights = network.get_weights()#获取网络的权重
    #将pso传进来的值转换为所需要的权重，就是对应weights中的每个numpy矩阵（这是个列表）
    convert_weights=[]
    init = 0
    for w in weights:
        shape= w.flatten().shape[0]
        weight_next = init_weights[init:shape+init]
        init += shape
        convert_weights.append(weight_next.reshape(w.shape))
        
    network.set_weights(convert_weights)
    history = network.fit(x_train,y_train, epochs=5,batch_size=256,
                          validation_data=(x_test,y_test),
                          validation_freq=1, verbose=0)
    return history.history['val_accuracy'][-1]#以最大化验证集的分类准确率作为PSO的适应度函数
    #目的就是利用PSO找到一组最优初始权重，用这组初始权重训练的网络，能够使得验证集正确率最高

4.全部代码

# -*- coding: utf-8 -*-
from sklearn.preprocessing import MinMaxScaler,StandardScaler
import numpy as np
#%% 加载数据
data=np.load('data.npz')
x_train=data['x_train']#1000*42
y_train=data['y_train']#1000*1
x_test=data['x_test']#300*42
y_test=data['y_test']#300*1 标签是0-9，共10类
ss_X=MinMaxScaler(feature_range=(0,1)).fit(x_train)
x_train = ss_X.transform(x_train)
x_test = ss_X.transform(x_test)
#%%

from tensorflow.keras import  Sequential, layers
import tensorflow as tf
def model():
    tf.random.set_seed(0)
    network = Sequential([layers.Dense(256, activation='relu'),
                         layers.Dense(128, activation='relu'),
                         layers.Dense(10, activation='softmax')])
    network.build(input_shape=(None,42))
    network.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.01),
                      loss=tf.keras.losses.SparseCategoricalCrossentropy(),
                      metrics=['accuracy'])
    return network
network=model()
#统计需要优化的权重数数量，也是粒子群的优化维度
weights = network.get_weights()
n_dim=0
for w in weights:
    shape= w.flatten().shape[0]
    n_dim += shape

#%%
def fitness(init_weights):#以最大化验证集的分类正确率为适应度函数
    network=model()
    weights = network.get_weights()
    
    convert_weights=[]
    init = 0
    for w in weights:
        shape= w.flatten().shape[0]
        weight_next = init_weights[init:shape+init]
        init += shape
        convert_weights.append(weight_next.reshape(w.shape))
        
    network.set_weights(convert_weights)
    history = network.fit(x_train,y_train, epochs=5,batch_size=256,
                          validation_data=(x_test,y_test),
                          validation_freq=1, verbose=0)
    return history.history['val_accuracy'][-1]

class PSO():
    def __init__(self):
        #PSO参数设置
        self.BOUNDS_LOW = -1*np.ones(n_dim)
        self.BOUNDS_HIGH = 1*np.ones(n_dim)
        self.NUM_OF_PARAMS = n_dim
        
        self.pN=5#粒子数
        self.max_iter=10#最大寻优次数
        self.wmax  = 0.8;#权重最大值
        self.wmin = 0.2;#权重最小值
        self.c1 = 1.5;#学习因子最大值
        self.c2 = 1.5;#学习因子最小值
    def Initializaiton(self):
        
        #初始化
        self.X = np.zeros((self.pN,self.NUM_OF_PARAMS))       
        self.V = np.zeros((self.pN,self.NUM_OF_PARAMS))    
        self.pbest = np.zeros((self.pN,self.NUM_OF_PARAMS))      
        self.gbest = np.zeros((1,self.NUM_OF_PARAMS))   
        self.p_fit = np.zeros(self.pN)              
        self.fit = 0
        for i in range(self.pN):    
            for j in range(self.NUM_OF_PARAMS):    
                self.X[i][j] = \
                    np.random.rand()*(self.BOUNDS_HIGH[j]-self.BOUNDS_LOW[j])+self.BOUNDS_LOW[j]
                self.V[i][j] = np.random.rand()
            self.pbest[i] = self.X[i].copy()
            tmp = fitness( self.X[i,:] )    
            self.p_fit[i] = tmp
            if(tmp > self.fit):    
                self.fit = tmp
                self.gbest = self.X[i].copy()
    def Bounds(self,pop):
        for i in range(self.NUM_OF_PARAMS):
            if pop[i]>self.BOUNDS_HIGH[i] or pop[i]<self.BOUNDS_LOW[i] :
                pop[i]=np.random.rand()*(self.BOUNDS_HIGH[i]-self.BOUNDS_LOW[i])+self.BOUNDS_LOW[i]
        return pop
    def loop(self):
        self.Initializaiton()
        # 开始优化
        trace=[]
        for t in range(self.max_iter):
            
            w=self.wmax-(self.wmax-self.wmin)*np.tan(np.pi/4*t/self.max_iter)
            for i in range(self.pN):  
                self.V[i,:] = w*self.V[i,:] + self.c1*np.random.rand()*(self.pbest[i] - self.X[i,:])+self.c2*np.random.rand()*(self.gbest - self.X[i,:])    
                self.X[i,:] = self.X[i,:] + self.V[i,:]
                # 加入自适应变异操作，避免陷入局部最优
                prob=0.5*t/self.max_iter +0.5#自适应变异，随着进化代数的增加，变异几率越小
                if np.random.rand()>prob:
                    for j in range(self.NUM_OF_PARAMS):    
                        
                        self.X[i][j] =\
                            np.random.rand()*(self.BOUNDS_HIGH[j]-self.BOUNDS_LOW[j])+self.BOUNDS_LOW[j]
                            
                        
            for i in range(self.pN): #更新gbest\pbest
                self.X[i,:]=self.Bounds(self.X[i,:])
                temp = fitness( self.X[i,:])    
                if(temp > self.p_fit[i]):      #更新个体最优    
                    self.p_fit[i] = temp  
                    self.pbest[i,:] =  self.X[i,:].copy()
                    if(self.p_fit[i] > self.fit):  #更新全局最优    
                        self.gbest = self.X[i,:].copy()    
                        self.fit = self.p_fit[i].copy()
            trace.append( self.fit)  
            print(self.fit)
        return trace , self.gbest
pso=PSO()
trace ,gbest=pso.loop()
print(fitness(gbest))