【MATLAB第5期】源码分享①粒子群算法PSO优化BP神经 ...

BlaXuan

一、说明：
这个matlab程序的目标是对BP神经网络中的神经元连接权和阈值构成的高维参数空间进行最优求解，试图用PSO算法求解神经网络中的参数，而不是用传统的误差反传算法。但由于经典粒子群算法存在局部最优的问题。该算法也存在同样的问题。该算法在迭代数较大时可以基本做到误差较大的函数拟合。但至于如何突破局部最优，这个就有待各位PSO爱好者进行优化了。
二、运行：

• 1，Matlab打开Test_PSO_Stand.m文件
  
• 2，可以修改种群粒子总数以及迭代总次数（不建议修改粒子维度，因为这里是用粒子群算法去做一个BP网络参数寻优，该网络的隐藏层有4个神经元，一个输出神经元。）
  
• 3、运行后，可以执行ShowAllResult查看粒子群中每个粒子的曲线拟合结果。
  

三、代码
1.适应度函数
% AdaptFunc_BP.m
% AdaptFunc_BP.m
%适应度函数
function y=AdaptFunc_BP(x)
%求解偏差的均方根，也就是每个预测点和实际点的平方和再求平方根
%x是行向量，数量为ParticleSize
%x(1:5)---V:输入到隐层神经元的权值
%x(6:10)---theta1:隐层神经元的阈值
%x(11:15)---W:输出层神经元的连接权
%x(16)---W:输出层神经元的阈值

[row,col]=size(x);

%训练集的X
X=-1:0.1:1;
%col2有用
[row2,col2]=size(X);

D=[-0.9602 -0.5770 -0.0729 0.3771 0.6405 0.6600 0.4609 ...
    0.1336 -0.2013 -0.4344 -0.5000 -0.3930 -0.1647 -.0988 ...
    0.3072 0.3960 0.3449 0.1816 -0.312 -0.2189 -0.3201];

if row>1
    error('适应度函数：输入的参数错误');
end

%net = newff([-1 1],[5 1],{'tansig','tansig'});
net = newff(X,D,5,{'tansig','tansig'});
%net.trainParam.epochs = 100; %训练的最大次数
%net.trainParam.goal = 0.005; %全局最小误差
V=x(1:5)';
theta1=x(6:10)';
W=x(11:15);
theta2=x(16);
net.iw{1,1}=V;
net.b{1}=theta1;
net.lw{2,1}=W;
net.b{2}=theta2;
O2 = sim(net,X);

%计算当前参数下，神经网络的实际输出O2与目标输出D之间的误差的平方和
total=sqrt(sum((O2-D).^2));
    TempStr=sprintf('误差平方和%g',total);
    disp(TempStr);
y=total;2.BP调用函数
% Check_PSO_Result_BP.m
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

function y=Check_PSO_Result_BP(x)
%训练集的X
X=-1:0.1:1;

D=[-0.9602 -0.5770 -0.0729 0.3771 0.6405 0.6600 0.4609 ...
    0.1336 -0.2013 -0.4344 -0.5000 -0.3930 -0.1647 -.0988 ...
    0.3072 0.3960 0.3449 0.1816 -0.312 -0.2189 -0.3201];

net = newff(X,D,5,{'tansig','tansig'});
%net.trainParam.epochs = 100; %训练的最大次数
%net.trainParam.goal = 0.005; %全局最小误差
V=x(1:5)';
theta1=x(6:10)';
W=x(11:15);
theta2=x(16);
net.iw{1,1}=V;
net.b{1}=theta1;
net.lw{2,1}=W;
net.b{2}=theta2;
O2 = sim(net,X);
%plot(O2);
plot(X,D,'*',X,O2);
y=O2;3.PSO算法函数
%PSO_Stand.m
%PSO标准算法 其中w c1 c2 a可以改变
%包含初始化函数  迭代函数 还有总体的PSO算法函数
function [Result,OnLine,OffLine,MinMaxMeanAdapt,OptResult]=PSO_Stand(SwarmSize,ParticleSize,ParticleScope,IsStep,IsDraw,LoopCount,IsPlot)
%function [Result,OnLine,OffLine,MinMaxMeanAdapt]=PSO_Stand(SwarmSize,ParticleSize,ParticleScope,InitFunc,StepFindFunc,AdaptFunc,IsStep,IsDraw,LoopCount,IsPlot)
%功能描述：一个循环n次的PSO算法完整过程，返回这次运行的最小与最大的平均适应度,以及在线性能与离线性能
%[Result,OnLine,OffLine,MinMaxMeanAdapt]=PsoProcess(SwarmSize,ParticleSize,ParticleScope,InitFunc,StepFindFunc,AdaptFunc,IsStep,IsDraw,LoopCount,IsPlot)
%输入参数：SwarmSize:种群大小的个数
%输入参数：ParticleSize：一个粒子的维数
%输入参数：ParticleScope:一个粒子在运算中各维的范围；
%　　　　　　　　 ParticleScope格式:
%　　　　　　　　　　 3维粒子的ParticleScope格式:
%　　　　　　　　　　　　　　　　　　　　　　　　　　[x1Min,x1Max
%　　　　　　　　　　　　　　　　　　　　　　　　　　 x2Min,x2Max
%　　　　　　　　　　　　　　　　　　　　　　　　　　 x3Min,x3Max]
%
%输入参数:InitFunc:初始化粒子群函数
%输入参数:StepFindFunc:单步更新速度，位置函数
%输入参数：AdaptFunc：适应度函数
%输入参数：IsStep：是否每次迭代暂停；IsStep＝0，不暂停，否则暂停。缺省不暂停
%输入参数：IsDraw：是否图形化迭代过程；IsDraw＝0，不图形化迭代过程，否则，图形化表示。缺省不图形化表示
%输入参数：LoopCount：迭代的次数；缺省迭代100次
%输入参数：IsPlot：控制是否绘制在线性能与离线性能的图形表示;IsPlot=0,不显示；
%　　　　　　　　　　　　　　　　                          IsPlot=1；显示图形结果。缺省IsPlot=1
%返回值：Result为经过迭代后得到的最优解
%返回值：OnLine为在线性能的数据
%返回值：OffLine为离线性能的数据
%返回值：MinMaxMeanAdapt为本次完整迭代得到的最小与最大的平均适应度
%
%用法[Result,OnLine,OffLine,MinMaxMeanAdapt]=PsoProcess(SwarmSize,ParticleSize,ParticleScope,InitFunc,StepFindFunc,AdaptFunc,IsStep,IsDraw,LoopCount,IsPlot);
%
%异常：首先保证该文件在Matlab的搜索路径中，然后查看相关的提示信息。
%


%修改记录：
%添加MinMaxMeanAdapt，以得到性能评估数据

%容错控制
if nargin<3
%if nargin<4
    error('输入的参数个数错误。')
end

[row,colum]=size(ParticleSize);
if row>1||colum>1
    error('输入的粒子的维数错误，是一个1行1列的数据。');
end
[row,colum]=size(ParticleScope);
if row~=ParticleSize||colum~=2
    error('输入的粒子的维数范围错误。');
end

%设置缺省值
if nargin<4
%if nargin<7
    IsPlot=1;
    LoopCount=100;
    IsStep=0;
    IsDraw=0;
%elseif nargin<8
elseif nargin<5
    IsPlot=1;
    IsDraw=0;
    LoopCount=100;
%elseif nargin<9
elseif nargin<6
    LoopCount=100;
    IsPlot=1;
%elseif nargin<10
elseif nargin<7
    IsPlot=1;
end

%控制是否显示2维以下粒子维数的寻找最优的过程
%if IsDraw~=0
    %DrawObjGraphic(ParticleSize,ParticleScope,AdaptFunc);
%end

%初始化种群
%[ParSwarm,OptSwarm]=InitFunc(SwarmSize,ParticleSize,ParticleScope,AdaptFunc);
[ParSwarm,OptSwarm]=InitSwarm(SwarmSize,ParticleSize,ParticleScope);

%在测试函数图形上绘制初始化群的位置
if IsDraw~=0
    if 1==ParticleSize
        for ParSwarmRow=1:SwarmSize
            plot([ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,1)],[ParSwarm(ParSwarmRow,3),0],'r*-','markersize',8);
            text(ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,3),num2str(ParSwarmRow));%在图形中加注释
        end
    end
    if 2==ParticleSize
        for ParSwarmRow=1:SwarmSize
            stem3(ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,2),ParSwarm(ParSwarmRow,5),'r.','markersize',8);%绘制3D图形
        end
    end
end

%暂停让抓图
if IsStep~=0
    disp('开始迭代，按任意键：')
    pause
end

%开始更新算法的调用
for k=1:LoopCount
    %显示迭代的次数：
    disp('----------------------------------------------------------')
    TempStr=sprintf('第 %g 次迭代',k);
    disp(TempStr);
    disp('----------------------------------------------------------')
   
    %调用一步迭代的算法
    %[ParSwarm,OptSwarm]=StepFindFunc(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,0.95,0.4,LoopCount,k);
    [ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,ParticleScope,0.95,0.4,LoopCount,k);
   
     %绘制曲线输出
    Check_PSO_Result_BP(OptSwarm(SwarmSize+1,1:ParticleSize));
   
    %在目标函数的图形上绘制2维以下的粒子的新位置
    if IsDraw~=0
        if 1==ParticleSize
            for ParSwarmRow=1:SwarmSize
                plot([ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,1)],[ParSwarm(ParSwarmRow,3),0],'r*-','markersize',8);
                text(ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,3),num2str(ParSwarmRow));
            end
        end
        
        if 2==ParticleSize
            for ParSwarmRow=1:SwarmSize
                stem3(ParSwarm(ParSwarmRow,1),ParSwarm(ParSwarmRow,2),ParSwarm(ParSwarmRow,5),'r.','markersize',8);
            end
        end
    end
   
    XResult=OptSwarm(SwarmSize+1,1:ParticleSize);%存取本次迭代得到的全局最优值
   
   
   % YResult=AdaptFunc(XResult);                  %计算全局最优值对应的粒子的适应度值
     YResult=AdaptFunc_BP(XResult);                  %计算全局最优值对应的粒子的适应度值
    if IsStep~=0
        %XResult=OptSwarm(SwarmSize+1,1:ParticleSize);
        %YResult=AdaptFunc(XResult);
        str=sprintf('%g 步迭代的最优目标函数值 %g',k,YResult);
        disp(str);
        disp('下次迭代，按任意键继续');
        pause
    end
   
    %记录每一步的平均适应度
    MeanAdapt(1,k)=mean(ParSwarm(:,2*ParticleSize+1));%mean函数为取有效值函数
end
%for循环结束标志

%记录最小与最大的平均适应度
MinMaxMeanAdapt=[min(MeanAdapt),max(MeanAdapt)];
%计算离线与在线性能
for k=1:LoopCount
    OnLine(1,k)=sum(MeanAdapt(1,1:k))/k;%求取在线性能的数据
    OffLine(1,k)=max(MeanAdapt(1,1:k));
end

for k=1:LoopCount
    OffLine(1,k)=sum(OffLine(1,1:k))/k;%求取离线性能的数据
end

%绘制离线性能与在线性能曲线
%subplot(m,n,p);%将图形窗口分成m行n列的子窗口，序号为p的子窗口为当前窗口
if 1==IsPlot
    subplot(1,2,1);
    %figure
    hold on
    title('离线性能曲线图')
    xlabel('迭代次数');
    ylabel('离线性能');
    grid on
    plot(OffLine);

    subplot(1,2,2);
    %figure
    hold on
    title('在线性能曲线图')
    xlabel('迭代次数');
    ylabel('在线性能');
    grid on
    plot(OnLine);
end
%记录本次迭代得到的最优值 适应度值
XResult=OptSwarm(SwarmSize+1,1:ParticleSize);
%YResult=AdaptFunc(XResult);
YResult=AdaptFunc_BP(XResult);
Result=[XResult,YResult];
%回传每个粒子的历史最优搜索结果
OptResult=OptSwarm;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%适应度函数
function y=AdaptFunc(x)
%Griewan函数
%输入x,给出相应的y值,在x=(0,0,…,0)处有全局极小点0.
%编制人：Jeary
%编制日期：2010.12.12
[row,col]=size(x);
if row>1
    error('适应度函数：输入的参数错误');
end
y1=1/4000*sum(x.^2);
y2=1;
for h=1:col
    y2=y2*cos(x(h)/sqrt(h));
end
y=y1-y2+1;
y=-y;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%初始化粒子群函数
function [ParSwarm,OptSwarm]=InitSwarm(SwarmSize,ParticleSize,ParticleScope)
%function [ParSwarm,OptSwarm]=InitSwarm(SwarmSize,ParticleSize,ParticleScope,AdaptFunc)
%功能描述：初始化粒子群，限定粒子群的位置以及速度在指定的范围内
%[ParSwarm,OptSwarm,BadSwarm]=InitSwarm(SwarmSize,ParticleSize,ParticleScope,AdaptFunc)
%
%输入参数：SwarmSize:种群大小的个数
%输入参数：ParticleSize：一个粒子的维数
%输入参数：ParticleScope:一个粒子在运算中各维的范围；
%　　　　　　　　 ParticleScope格式:
%　　　　　　　　　　 3维粒子的ParticleScope格式:
%　　　　　　　　　　　 [x1Min,x1Max
%　　　　   　　　　　　 x2Min,x2Max
%　　　　     　　　　　 x3Min,x3Max]
%
%输入参数：AdaptFunc：适应度函数
%输出：ParSwarm初始化的粒子群
%输出：OptSwarm粒子群当前最优解与全局最优解
%
%用法[ParSwarm,OptSwarm,BadSwarm]=InitSwarm(SwarmSize,ParticleSize,ParticleScope,AdaptFunc);
%
%异常：首先保证该文件在Matlab的搜索路径中，然后查看相关的提示信息。

%参考文献：网上资源-粒子群算法详解MATLAB
%

%容错控制  nargin和nargout表示该函数的输入\输出个数
%if nargin~=4
if nargin~=3
    error('粒子群初始化：输入的参数个数错误。')
end
if nargout<2
    error('粒子群初始化：输出的参数的个数太少，不能保证以后的运行。');
end

[row,colum]=size(ParticleSize);
if row>1||colum>1
    error('粒子群初始化：输入的粒子的维数错误，是一个1行1列的数据。');
end
[row,colum]=size(ParticleScope);
if row~=ParticleSize||colum~=2
    error('粒子群初始化：输入的粒子的维数范围错误。');
end

%初始化粒子群矩阵
%初始化粒子群矩阵，全部设为[0-1]随机数
%rand('state',0);
ParSwarm=rand(SwarmSize,2*ParticleSize+1);%初始化位置 速度 历史优化值

%对粒子群中位置,速度的范围进行调节
for k=1:ParticleSize
    ParSwarm(:,k)=ParSwarm(:,k)*(ParticleScope(k,2)-ParticleScope(k,1))+ParticleScope(k,1);%调节速度，使速度与位置的范围一致
    ParSwarm(:,ParticleSize+k)=ParSwarm(:,ParticleSize+k)*(ParticleScope(k,2)-ParticleScope(k,1))+ParticleScope(k,1);
end

%对每一个粒子计算其适应度函数的值
for k=1:SwarmSize
    %ParSwarm(k,2*ParticleSize+1)=AdaptFunc(ParSwarm(k,1:ParticleSize));%计算每个粒子的适应度值
    ParSwarm(k,2*ParticleSize+1)=AdaptFunc_BP(ParSwarm(k,1:ParticleSize));%计算每个粒子的适应度值
   
end

%初始化粒子群最优解矩阵
OptSwarm=zeros(SwarmSize+1,ParticleSize);
%粒子群最优解矩阵全部设为零
  %[maxValue,row]=max(ParSwarm(:,2*ParticleSize+1));
   %搜索最小值
  [maxValue,row]=min(ParSwarm(:,2*ParticleSize+1));
%寻找适应度函数值最大的解在矩阵中的位置(行数)
OptSwarm=ParSwarm(1:SwarmSize,1:ParticleSize);
OptSwarm(SwarmSize+1,:)=ParSwarm(row,1:ParticleSize);%将适应度值最大的粒子的位置最为全局粒子的最优值

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%基本的粒子群算法的单步更新位置,速度的算法函数
function [ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%function [ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%功能描述：全局版本：基本的粒子群算法的单步更新位置,速度的算法
%[ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%输入参数：ParSwarm:粒子群矩阵，包含粒子的位置，速度与当前的目标函数值
%输入参数：OptSwarm：包含粒子群个体最优解与全局最优解的矩阵
%输入参数：ParticleScope:一个粒子在运算中各维的范围；
%输入参数：AdaptFunc：适应度函数
%输入参数：AdaptFunc：适应度函数
%输入参数：MaxW  MinW：惯性权重(系数)的最大值与最小值
%输入参数：CurCount：当前迭代的次数
%返回值：含意同输入的同名参数
%用法：[ParSwarm,OptSwarm]=BaseStepPso(ParSwarm,OptSwarm,AdaptFunc,ParticleScope,MaxW,MinW,LoopCount,CurCount)
%
%异常：首先保证该文件在Matlab的搜索路径中，然后查看相关的提示信息。
%

%修改记录
% 添加2*unifrnd(0,1).*SubTract1(row,:)中的unifrnd(0,1)随机数，使性能大为提高
%参照基于MATLAB的粒子群优化算法程序设计
%
% 总体评价：使用这个版本的调节系数，效果比较好
%

%容错控制
%if nargin~=8  %输入容错
if nargin~=7  %输入容错
    error('粒子群迭代：输入的参数个数错误。')
end
if nargout~=2  %输出容错
    error('粒子群迭代：输出的个数太少，不能保证循环迭代。')
end

%开始单步更新的操作
%标准粒子群算法的变形
%*********************************************
%*****更改下面的代码，可以更改惯性因子的变化*****
%---------------------------------------------------------------------
%线形递减策略
w=MaxW-CurCount*((MaxW-MinW)/LoopCount);
%---------------------------------------------------------------------
%w固定不变策略
%w=0.7;
%---------------------------------------------------------------------
%参考文献：陈贵敏，贾建援，韩琪，粒子群优化算法的惯性权值递减策略研究，西安交通大学学报，2006，1
%w非线形递减，以凹函数递减
%w=(MaxW-MinW)*(CurCount/LoopCount)^2+(MinW-MaxW)*(2*CurCount/LoopCount)+MaxW;
%---------------------------------------------------------------------
%w非线形递减，以凹函数递减
%w=MinW*(MaxW/MinW)^(1/(1+10*CurCount/LoopCount));
%*****更改上面的代码，可以更改惯性因子的变化*****
%*********************************************

%得到粒子群群体大小以及一个粒子维数的信息
[ParRow,ParCol]=size(ParSwarm);
%得到粒子的维数
ParCol=(ParCol-1)/2;
SubTract1=OptSwarm(1:ParRow,:)-ParSwarm(:,1:ParCol);%求解出历史最优值与当前位置的差值

%*********************************************
%*****更改下面的代码，可以更改c1,c2的变化*****
c1=2;
c2=2;
%---------------------------------------------------------------------
%con=1;
%c1=4-exp(-con*abs(mean(ParSwarm(:,2*ParCol+1))-AdaptFunc(OptSwarm(ParRow+1,:))));
%c2=4-c1;
%----------------------------------------------------------------------
%*****更改上面的代码，可以更改c1,c2的变化*****
%*********************************************
%完成一次粒子位置 速度 最优值的更新迭代
for row=1:ParRow
    SubTract2=OptSwarm(ParRow+1,:)-ParSwarm(row,1:ParCol);%计算出全局最优值与当前该粒子位置的差值
    %速度更新公式
    TempV=w.*ParSwarm(row,ParCol+1:2*ParCol)+c1*unifrnd(0,1).*SubTract1(row,:)+c2*unifrnd(0,1).*SubTract2;
    %限制速度的代码
    for h=1:ParCol
        if TempV(:,h)>ParticleScope(h,2)
            TempV(:,h)=ParticleScope(h,2);
        end
        if TempV(:,h)<-ParticleScope(h,2)
            TempV(:,h)=-ParticleScope(h,2)+1e-10;%加1e-10防止适应度函数被零除
        end
    end
    %更新该粒子速度值
    ParSwarm(row,ParCol+1:2*ParCol)=TempV;
    %*********************************************
    %*****更改下面的代码，可以更改约束因子的变化*****
    %---------------------------------------------------------------------
    %a=1;%约束因子
    %---------------------------------------------------------------------
    a=0.729;%约束因子
    %*****更改上面的代码，可以更改约束因子的变化*****
    %*********************************************
    %位置更新公式
    TempPos=ParSwarm(row,1:ParCol)+a*TempV;
    %限制位置范围的代码
    for h=1:ParCol
        if TempPos(:,h)>ParticleScope(h,2)
            TempPos(:,h)=ParticleScope(h,2);
        end
        if TempPos(:,h)<=ParticleScope(h,1)
            TempPos(:,h)=ParticleScope(h,1)+1e-10;%加1e-10防止适应度函数被零除
        end
    end
    %更新该粒子位置值
    ParSwarm(row,1:ParCol)=TempPos;
   
    %计算每个粒子的新的适应度值
%     ParSwarm(row,2*ParCol+1)=AdaptFunc(ParSwarm(row,1:ParCol));
%     if ParSwarm(row,2*ParCol+1)>AdaptFunc(OptSwarm(row,1:ParCol))
%         OptSwarm(row,1:ParCol)=ParSwarm(row,1:ParCol);
%     end
    %bcpan改为搜索最小值
    ParSwarm(row,2*ParCol+1)=AdaptFunc_BP(ParSwarm(row,1:ParCol));
    if ParSwarm(row,2*ParCol+1)<AdaptFunc_BP(OptSwarm(row,1:ParCol))
         TempStr=sprintf('第%d个粒子历史最小值发生改变:%g',row,ParSwarm(row,2*ParCol+1));
         disp(TempStr);
        OptSwarm(row,1:ParCol)=ParSwarm(row,1:ParCol);
    end
end
%for循环结束

%寻找适应度函数值最大的解在矩阵中的位置(行数)，进行全局最优值的改变
% [maxValue,row]=max(ParSwarm(:,2*ParCol+1));
% if AdaptFunc(ParSwarm(row,1:ParCol))>AdaptFunc(OptSwarm(ParRow+1,:))
%     OptSwarm(ParRow+1,:)=ParSwarm(row,1:ParCol);
% end
   %bcpan改为搜索最小值
[minValue,row]=min(ParSwarm(:,2*ParCol+1));
if AdaptFunc_BP(ParSwarm(row,1:ParCol))<AdaptFunc_BP(OptSwarm(ParRow+1,:))
    OptSwarm(ParRow+1,:)=ParSwarm(row,1:ParCol);
    TempStr=sprintf('全局最优值发生位置改变%g',ParSwarm(row,2*ParCol+1));
    disp(TempStr);
end4.绘图
% ShowAllResult.m
function ShowAllResult(x)
X=-1:0.1:1;

D=[-0.9602 -0.5770 -0.0729 0.3771 0.6405 0.6600 0.4609 ...
    0.1336 -0.2013 -0.4344 -0.5000 -0.3930 -0.1647 -.0988 ...
    0.3072 0.3960 0.3449 0.1816 -0.312 -0.2189 -0.3201];

net = newff(X,D,5,{'tansig','tansig'});

figure;
[row,col]=size(x);
plot(X,D,'*');
hold on;
color=[1/row:1/row:1];
for i=1:row
V=x(i,1:5)';
theta1=x(i,6:10)';
W=x(i,11:15);
theta2=x(i,16);
net.iw{1,1}=V;
net.b{1}=theta1;
net.lw{2,1}=W;
net.b{2}=theta2;
O2 = sim(net,X);
%plot(O2);
plot(X,O2,'Color',[color(i) 0 0]);
end;

%plot(x,y,'Color',[1 0 0]);代表红色

%plot(x,y,'Color',[0 1 0]);代表绿色
%plot(x,y,'Color',[0 0 1]);代表蓝色5.主程序代码
%% Test_PSO_Stand.m
%% 主程序

clear;
clc;
%输入参数：SwarmSize:种群大小的个数
SwarmSize=10;
%输入参数：ParticleSize：一个粒子的维数
ParticleSize=16;
%输入参数：ParticleScope:一个粒子在运算中各维的范围；
%　　　　　　　　 ParticleScope格式:
%　　　　　　　　　　 3维粒子的ParticleScope格式:
%　　　　　　　　　　　　　　　　　　　　　　　　　　[x1Min,x1Max
%　　　　　　　　　　　　　　　　　　　　　　　　　　 x2Min,x2Max
%　　　　　　　　　　　　　　　　　　　　　　　　　　 x3Min,x3Max]
%
ParticleScope=[-10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10
              -10,10];
%输入参数:InitFunc:初始化粒子群函数
%输入参数:StepFindFunc:单步更新速度，位置函数
%输入参数：AdaptFunc：适应度函数
%输入参数：IsStep：是否每次迭代暂停；IsStep＝0，不暂停，否则暂停。缺省不暂停
IsStep=0;
%输入参数：IsDraw：是否图形化迭代过程；IsDraw＝0，不图形化迭代过程，否则，图形化表示。缺省不图形化表示
IsDraw=1;
%输入参数：LoopCount：迭代的次数；缺省迭代100次
LoopCount=200;
%输入参数：IsPlot：控制是否绘制在线性能与离线性能的图形表示;IsPlot=0,不显示；
%　　　　　　　　　　　　　　　　                          IsPlot=1；显示图形结果。缺省IsPlot=1
IsPlot=1;

[Result,OnLine,OffLine,MinMaxMeanAdapt,OptResult]=PSO_Stand(SwarmSize,ParticleSize,ParticleScope,IsStep,IsDraw,LoopCount,IsPlot);
%Check_PSO_Result_BP(Result);

%ShowAllResult(OptResult)

6.主程序
% ContrastBP_PSO.m
%% ContrastBP_PSO.m
clear;
clc;

X=-1:0.1:1;

D=[-0.9602 -0.5770 -0.0729 0.3771 0.6405 0.6600 0.4609 ...
    0.1336 -0.2013 -0.4344 -0.5000 -0.3930 -0.1647 -.0988 ...
    0.3072 0.3960 0.3449 0.1816 -0.312 -0.2189 -0.3201];

%figure;  

%plot(X,D,'*');

%hold on;
%绘制原始数据分布图（附录：1-1）


%net = newff([-1 1],[5 1],{'tansig','tansig'});
net = newff(X,D,5,{'tansig','tansig'});
net.trainParam.epochs = 100; %训练的最大次数

net.trainParam.goal = 0.005; %全局最小误差

%rand('state',0);%这句是为了保证每次迭代的起点一致，最后训练结果也不变

net=init(net);

net = train(net,X,D);  

O = sim(net,X);  

%figure;   

plot(X,D,'*',X,O); %绘制训练后得到的结果和误差曲线（附录：1-2、1-3）


V = net.iw{1,1}%输入层到中间层权值

theta1 = net.b{1}%中间层各神经元阈值

W = net.lw{2,1}%中间层到输出层权值

theta2 = net.b{2}%输出层各神经元阈值

%%%%%下面是自定义权值的网络
% net2.iw{1,1}=V;
% net2.b{1}=theta1;
% net2.lw{2,1}=W;
% net2.b{2}=theta2;
% O2 = sim(net2,X);
% plot(O2);
四、运行结果：
第 200 次迭代
----------------------------------------------------------
误差平方和1.87552
误差平方和1.87552
第1个粒子历史最小值发生改变:1.87552
误差平方和1.87552
误差平方和1.87552
第2个粒子历史最小值发生改变:1.87552
误差平方和1.87552
误差平方和1.87552
第3个粒子历史最小值发生改变:1.87552
误差平方和1.87552
误差平方和1.87552
第4个粒子历史最小值发生改变:1.87552
误差平方和1.87552
误差平方和1.87552
第5个粒子历史最小值发生改变:1.87552
误差平方和1.87552
误差平方和1.87552
第6个粒子历史最小值发生改变:1.87552
误差平方和1.87552
误差平方和1.87552
第7个粒子历史最小值发生改变:1.87552
误差平方和1.87552
误差平方和1.87552
第8个粒子历史最小值发生改变:1.87552
误差平方和1.87552
误差平方和1.87552
第9个粒子历史最小值发生改变:1.87552
误差平方和1.87552
误差平方和1.87552
第10个粒子历史最小值发生改变:1.87552
误差平方和1.87552
误差平方和1.87552
全局最优值发生位置改变1.87552
误差平方和1.87552
误差平方和1.87552
>>



五、运行过程分析：
采用粒子群进行曲线拟合,粒子数10，迭代数20
候选解


最优解


----------------------------------------------------------
第 20 次迭代
----------------------------------------------------------
误差平方和2.24805
误差平方和2.14448
误差平方和3.13655
误差平方和2.64061
误差平方和2.04518
误差平方和2.22037
第3个粒子历史最小值发生改变:2.04518
误差平方和1.99912
误差平方和2.30955
第4个粒子历史最小值发生改变:1.99912
误差平方和1.87079
误差平方和2.21321
第5个粒子历史最小值发生改变:1.87079
误差平方和1.856
误差平方和1.85395
误差平方和1.87342
误差平方和1.93382
第7个粒子历史最小值发生改变:1.87342
误差平方和2.38921
误差平方和2.24967
误差平方和2.01258
误差平方和1.8574
误差平方和3.65518
误差平方和3.09263
误差平方和1.856
误差平方和1.85395
误差平方和1.85395
误差平方和1.85395
30次迭代


10个粒子搜索出来的方案


最优解


50次迭代






第 50 次迭代
----------------------------------------------------------
误差平方和1.78684
误差平方和1.78729
第1个粒子历史最小值发生改变:1.78684
误差平方和1.78513
误差平方和1.78797
第2个粒子历史最小值发生改变:1.78513
误差平方和1.78757
误差平方和1.78767
第3个粒子历史最小值发生改变:1.78757
误差平方和1.7851
误差平方和1.78637
第4个粒子历史最小值发生改变:1.7851
误差平方和1.78654
误差平方和1.78861
第5个粒子历史最小值发生改变:1.78654
误差平方和1.78645
误差平方和1.78732
第6个粒子历史最小值发生改变:1.78645
误差平方和1.78664
误差平方和1.78821
第7个粒子历史最小值发生改变:1.78664
误差平方和1.80029
误差平方和1.78947
误差平方和1.78744
误差平方和1.78732
误差平方和1.78623
误差平方和1.7867
第10个粒子历史最小值发生改变:1.78623
误差平方和1.7851
误差平方和1.78637
全局最优值发生位置改变1.7851
误差平方和1.7851
误差平方和1.7851
100次迭代，开始出现局部最优并发生逗留