Matlab粒子群算法神经网络泰坦尼克号

介绍

这里用粒子群算法优化神经网络的参数，使其得到更好的训练效果。
粒子群算法是个很简单的算法，写这篇文章当做复习复习过去学过的内容了。
粒子群算法流程图：

其中重要的是位置更新和速度更新公式

在这里那些参数都简单地取固定值

实验步骤

初始化参数

%% 参数初始化
%粒子群算法中的两个参数
c1 = 2;
c2 = 2;

w=0.5; %权重

maxgen=200;   % 进化次数  
sizepop=20;   %种群规模

Vmax=0.5;
Vmin=-0.5;
popmax=4;
popmin=-4;

初始化种群

二进制编码，通过自变量的范围与精度来确定染色体编码长度。

%% 产生初始粒子和速度
for i=1:sizepop
    %随机产生一个种群
    pop(i,:)=4*rands(1,N)-2;    %初始种群
    V(i,:)=0.5*rands(1,N);  %初始化速度
    %计算适应度
    %fitness(i)=fun1(pop(i,:));   %染色体的适应度
    [err,fitness(i)]=Bpfun(pop(i,:),x1',y1',hiddennum1,hiddennum2,x2',y2');
end

计算适应度函数

神经网络的测试集准确率作为适应度函数，用matlab自带的神经网络函数搭建BP神经网络。

function [err,ac]=Bpfun(x,P,T,hiddennum1,hiddennum2,P_test,T_test)
%% 训练&测试BP网络
%% 输入
% x：一个个体的初始权值和阈值
% P：训练样本输入
% T：训练样本输出
% hiddennum：隐含层神经元数
% P_test:测试样本输入
% T_test:测试样本期望输出
%% 输出
% err：预测样本的预测误差的范数

inputnum=size(P,1);       % 输入层神经元个数
outputnum=size(T,1);      % 输出层神经元个数
%% 新建BP网络
net=newff(minmax(P),[hiddennum1,hiddennum2,outputnum],{'tansig','satlins','logsig'},'trainlm');
%% 设置网络参数：训练次数为1000，训练目标为0.01，学习速率为0.1
net.trainParam.epochs=10;
net.trainParam.goal=0.01;
LP.lr=0.1;
net.trainParam.show=NaN;
%net.trainParam.showwindow=false;  %高版MATLAB
%% BP神经网络初始权值和阈值
w1num=inputnum*hiddennum1; % 输入层到隐层1的权值个数
w2num=hiddennum1*hiddennum2;% 隐层1到隐层2的权值个数
w3num=outputnum*hiddennum2;% 隐层2到输出层的权值个数
w1=x(1:w1num);   %初始输入层到隐层的权值
B1=x(w1num+1:w1num+hiddennum1);  %初始隐层阈值
w2=x(w1num+hiddennum1+1:w1num+hiddennum1+w2num); %初始隐层到输出层的阈值
B2=x(w1num+hiddennum1+w2num+1:w1num+hiddennum1+w2num+hiddennum2); %输出层阈值
w3=x(w1num+hiddennum1+w2num+hiddennum2+1:w1num+hiddennum1+w2num+hiddennum2+w3num); %初始隐层到输出层的阈值
B3=x(w1num+hiddennum1+w2num+hiddennum2+w3num+1:w1num+hiddennum1+w2num+hiddennum2+w3num+outputnum); %输出层阈值
net.iw{1,1}=reshape(w1,hiddennum1,inputnum);
net.lw{2,1}=reshape(w2,hiddennum2,hiddennum1);
net.lw{3,2}=reshape(w3,outputnum,hiddennum2);
net.b{1}=reshape(B1,hiddennum1,1);
net.b{2}=reshape(B2,hiddennum2,1);
net.b{3}=reshape(B3,outputnum,1);
%% 训练网络以
net=train(net,P,T);
%% 测试网络
Y=sim(net,P_test);
err=norm(Y-T_test);
for i=1:length(Y)
    if Y(i)<0.5
        Y(i)=0;
    else
        Y(i)=1;
    end
end
ac=1-sum(abs(Y-T_test))/length(Y);

速度、位置更新

超范围的设为边界值

for j=1:sizepop
        
        %速度更新
        V(j,:) = w*V(j,:) + c1*rand*(gbest(j,:) - pop(j,:)) + c2*rand*(zbest - pop(j,:));
        V(j,find(V(j,:)>Vmax))=Vmax;
        V(j,find(V(j,:)<Vmin))=Vmin;
        
        %种群更新
        pop(j,:)=pop(j,:)+V(j,:);
        pop(j,find(pop(j,:)>popmax))=popmax;
        pop(j,find(pop(j,:)<popmin))=popmin;
        
        %适应度值
        %fitness(j)=fun1(pop(j,:)); 
        [err,fitness(j)]=Bpfun(pop(j,:),x1',y1',hiddennum1,hiddennum2,x2',y2');
   
    end

极值更新

    for j=1:sizepop
        
        %个体最优更新
        if fitness(j) > fitnessgbest(j)
            gbest(j,:) = pop(j,:);
            fitnessgbest(j) = fitness(j);
        end
        
        %群体最优更新
        if fitness(j) > fitnesszbest
            zbest = pop(j,:);
            fitnesszbest = fitness(j);
        end
    end 
    yy(i)=fitnesszbest;    

实验结果

寻优曲线：

最优初始权值和阈值:
zbest =

1 至 12 列

-1.3909 0.4211 -4.0000 -4.0000 -3.0747 0.7278 0.2609 0.5257 0.3035 -4.0000 -1.7539 1.4606

13 至 24 列

-0.6466 -1.1569 -4.0000 -4.0000 -0.0353 -2.2010 -1.4103 -0.5082 -3.3560 -4.0000 -3.2423 1.0365

25 至 36 列

0.8485    0.8189   -3.7687   -4.0000   -1.9942   -4.0000   -4.0000    1.1625    0.9775   -4.0000   -3.5533    0.8062

37 至 48 列

-4.0000 1.4416 -3.1999 1.1774 -3.1303 -4.0000 -0.2201 -4.0000 0.0039 0.2402 -3.6992 -4.0000

49 至 60 列

-2.4385 0.2102 -2.2919 -1.8557 -1.4834 0.1662 -4.0000 -4.0000 -2.2281 -1.2947 -4.0000 -2.7338

61 至 72 列

0.9059   -4.0000   -0.9322   -4.0000   -3.4940   -3.3672   -2.7645   -4.0000   -1.7928    0.2071   -4.0000    1.4712

73 至 84 列

1.2638    0.6005   -2.6439   -3.7701   -2.3721   -4.0000   -2.9139   -0.8094   -2.6147    0.1717   -2.6738   -3.1668

85 至 96 列

1.6297   -3.1846   -3.1394   -3.7566    0.6721   -4.0000   -1.9135   -3.8827    0.3824   -4.0000   -4.0000   -3.5148

97 至 108 列

-4.0000 0.3533 -0.0105 -1.6206 -3.1942 -4.0000 -4.0000 -3.4977 -2.2151 -2.0006 -3.3219 -0.0998

109 至 120 列

-1.8840 -3.9514 0.8863 0.5666 1.2084 -3.8815 -2.5561 -2.1463 0.8396 -4.0000 -4.0000 -3.5560

121 至 132 列

-4.0000 -2.7513 -2.5226 1.2854 -2.9356 -2.7046 0.0803 -2.6269 0.8959 -0.1088 -4.0000 1.3314

133 至 144 列

-4.0000 -2.9946 -4.0000 1.1231 -3.0665 -2.0246 1.4080 -4.0000 -4.0000 -1.3666 -4.0000 0.3398

145 至 156 列

0.2099   -0.5329   -4.0000   -4.0000    1.4131   -1.9708   -0.5725   -3.7010   -4.0000    0.1608   -0.8834   -3.1611

157 至 168 列

1.5639   -3.9535   -2.2949   -4.0000   -2.6633    0.7295   -3.8275   -0.1578   -2.3034   -0.4336   -1.9277   -2.4596

169 至 180 列

-0.1329 1.2473 -4.0000 1.2027 -2.3681 -1.5221 -4.0000 0.6484 -4.0000 -1.8994 1.2410 0.7832

181 至 192 列

-3.5839 0.4650 0.9777 -3.6067 -2.1450 -1.2591 -0.3171 -4.0000 1.2079 -4.0000 -2.2733 -4.0000

193 至 204 列

-0.0869 -3.5696 -3.6571 -3.0560 -4.0000 -4.0000 -3.9686 -1.4987 0.8207 0.8795 -2.7175 -2.2507

205 至 206 列

-1.7657 1.1905

fitnesszbest =

0.8350

总代码

%% 清空环境
clc
clear
%%
%样本数据就是前面问题描述中列出的数据
[x,y]=date_inscet();
randIndex=randperm(size(x,1));%打乱顺序
x=x(randIndex,:);y=y(randIndex,:);
x1=x(1:1000,:);y1=y(1:1000,:);x2=x(1001:end,:);y2=y(1001:end,:);
% 初始隐层神经元个数
hiddennum1=15;hiddennum2=5;
% 输入向量的最大值和最小值
inputnum=size(x,2);       % 输入层神经元个数
outputnum=size(y,2);      % 输出层神经元个数
w1num=inputnum*hiddennum1; % 输入层到隐层1的权值个数
w2num=hiddennum2*hiddennum1;% 隐层1到隐层2的权值个数
w3num=outputnum*hiddennum2;% 隐层2到输出层的权值个数
N=w1num+hiddennum1+w2num+hiddennum2+w3num+outputnum; %待优化的变量的个数
%% 参数初始化
%粒子群算法中的两个参数
c1 = 2;
c2 = 2;

w=0.5; %权重

maxgen=200;   % 进化次数  
sizepop=20;   %种群规模

Vmax=0.5;
Vmin=-0.5;
popmax=4;
popmin=-4;

%% 产生初始粒子和速度
for i=1:sizepop
    %随机产生一个种群
    pop(i,:)=4*rands(1,N)-2;    %初始种群
    V(i,:)=0.5*rands(1,N);  %初始化速度
    %计算适应度
    %fitness(i)=fun1(pop(i,:));   %染色体的适应度
    [err,fitness(i)]=Bpfun(pop(i,:),x1',y1',hiddennum1,hiddennum2,x2',y2');
end

%% 个体极值和群体极值
[bestfitness bestindex]=max(fitness);
zbest=pop(bestindex,:);   %全局最佳
gbest=pop;    %个体最佳
fitnessgbest=fitness;   %个体最佳适应度值
fitnesszbest=bestfitness;   %全局最佳适应度值

%% 迭代寻优
for i=1:maxgen
    
    for j=1:sizepop
        
        %速度更新
        V(j,:) = w*V(j,:) + c1*rand*(gbest(j,:) - pop(j,:)) + c2*rand*(zbest - pop(j,:));
        V(j,find(V(j,:)>Vmax))=Vmax;
        V(j,find(V(j,:)<Vmin))=Vmin;
        
        %种群更新
        pop(j,:)=pop(j,:)+V(j,:);
        pop(j,find(pop(j,:)>popmax))=popmax;
        pop(j,find(pop(j,:)<popmin))=popmin;
        
        %适应度值
        %fitness(j)=fun1(pop(j,:)); 
        [err,fitness(j)]=Bpfun(pop(j,:),x1',y1',hiddennum1,hiddennum2,x2',y2');
   
    end
    
    for j=1:sizepop
        
        %个体最优更新
        if fitness(j) > fitnessgbest(j)
            gbest(j,:) = pop(j,:);
            fitnessgbest(j) = fitness(j);
        end
        
        %群体最优更新
        if fitness(j) > fitnesszbest
            zbest = pop(j,:);
            fitnesszbest = fitness(j);
        end
    end 
    yy(i)=fitnesszbest;    
        
end
%% 结果分析
hold on
plot(yy)
title('最优个体适应度','fontsize',12);
xlabel('进化代数','fontsize',12);ylabel('适应度','fontsize',12);
zbest
fitnesszbest