fzh2.m

用于三分类的BP算法程序,matlab源码

function main()
InDim=2;                           %样本输入维数
OutDim=3;                          %样本输出维数
 figure
colordef(gcf,'white')
echo off
clc
axis([-2 2 -2 2])
axis on
grid
xlabel('Input x');
ylabel('Input y');
line([-1 1],[1 1])
line([1 -1],[1 0])
line([-1 -1],[0 1])
line([-1 1],[-0.5 -0.5])
line([-1 1],[-1.5 -1.5])
line([1 1],[-0.5 -1.5])
line([-1 -1],[-0.5 -1.5])
hold on

SamNum=200;
rand('state',sum(100*clock))
SamIn=(rand(2,SamNum)-0.5)*4;
SamOut=[];
for i=1:SamNum
    Sam=SamIn(:,i);
    x=Sam(1,1);
    y=Sam(2,1);
    if((x>-1)&(x<1))==1
        if((y>x/2+1/2)&(y<1))==1
            plot(x,y,'k+')
            class=[0 1 0]';
        elseif((y<-0.5)&(y>-1.5))==1
            plot(x,y,'ks')
            class=[0 0 1]';
        else
            plot(x,y,'ko')
            class=[1 0 0]';
        end
    else
        plot(x,y,'ko')
        class=[1 0 0]';
    end
    SamOut=[SamOut class];
end

HiddenUnitNum=10;                    %隐节点数
MaxEpochs=10000;                     %最大训练次数
lr=0.1;                              %学习率
E0=0.01;                             %目标误差

W1=0.2*rand(HiddenUnitNum,InDim)-0.1;   %输入层到隐层的初始仅值
B1=0.2*rand(HiddenUnitNum,1)-0.1;       %隐节点初始偏移
W2=0.2*rand(OutDim,HiddenUnitNum)-0.1;  %隐层到输出层的初始权值
B2=0.2*rand(OutDim,1)-0.1;              %输出层初始偏移

W1Ex=[W1 B1];                           %输入层到隐层的初始权值扩展
W2Ex=[W2 B2];                           %隐层到输出层的初始权值

SamInEx=[SamIn' ones(SamNum,1)]';        %样本输入扩展
ErrHistory=[];                          %用于记录每次权值调整后的训练误差
for i=1:MaxEpochs
   %正向传播计算网络输出
   HiddenOut=logsig(W1Ex*SamInEx);
   HiddenOutEx=[HiddenOut' ones(SamNum,1)]';
   NetworkOut=logsig(W2Ex*HiddenOutEx);
   
   %停止学习判断
   Error=SamOut-NetworkOut;
   SSE=sumsqr(Error)

   %记录每次权值调整后的训练误差
   ErrHistory=[ErrHistory SSE];
   
   if SSE<E0,break,end
   %计算反向传播误差
   Delta2=Error.*NetworkOut.*(1-NetworkOut);
   Delta1=W2'*Delta2.*HiddenOut.*(1-HiddenOut);

   %计算权值调节量
   dW2Ex=Delta2*HiddenOutEx';
   dW1Ex=Delta1*SamInEx';

   %权值调节
   W1Ex=W1Ex+lr*dW1Ex;
   W2Ex=W2Ex+lr*dW2Ex;

   %分离隐层到输出层的初始权值,以便后面使用
   W2=W2Ex(:,1:HiddenUnitNum);
end
W1=W1Ex(:,1:InDim);
B1=W1Ex(:,InDim+1);
W2=W2Ex(:,1:HiddenUnitNum);
B2=W2Ex(:,1+HiddenUnitNum);
%绘制学习误差曲线
figure
hold on
grid
[xx,Num]=size(ErrHistory);
plot(1:Num,ErrHistory,'k-');
%根据目标函数获得训练样本输入输出并绘制样本
TestSamNum=5000;                        %测试样本数
TestSamIn=(rand(2,TestSamNum)-0.5)*4;   %产生随机样本输入
TestHiddenOut=logsig(W1*TestSamIn+repmat(B1,1,TestSamNum));
TestNetworkOut=logsig(W2*TestHiddenOut+repmat(B2,1,TestSamNum));
[Val,NNClass]=max(TestNetworkOut);

TestTargetOut=[];
for i=1:TestSamNum
    Sam=TestSamIn(:,i);
    x=Sam(1,1);
    y=Sam(2,1);
    if((x>-1)&(x<1))==1
        if ((y>x/2+1/2)&(y<1))==1
            TestTargeOut=[TestTargetOut 2];
        elseif((y<-0.5)&(y>-1.5))==1
            TestTargetOut=[TestTargetOut 3];
        else
            TestTargetOut=[TestTargetOut 1];
        end
    else
        TestTargetOut=[TestTargetOut 1];
    end
end
%显示计算结果
NNC1Flag=abs(NNClass-1)<0.1;
NNC2Flag=abs(NNClass-2)<0.1;
NNC3Flag=abs(NNClass-3)<0.1;

TargetC1Flag=abs(TestTargetOut-1)<0.1;
TargetC2Flag=abs(TestTargetOut-2)<0.1;
TargetC3Flag=abs(TestTargetOut-3)<0.1;

Test_C1_num=sum(NNC1Flag)
Test_C2_num=sum(NNC2Flag)
Test_C3_num=sum(NNC3Flag)

Test_C1_C1=1.0*NNC1Flag*TargetC1Flag'
Test_C1_C2=1.0*NNC1Flag*TargetC2Flag'
Test_C1_C3=1.0*NNC1Flag*TargetC3Flag'

Test_C2_C1=1.0*NNC2Flag*TargetC1Flag'
Test_C2_C2=1.0*NNC2Flag*TargetC2Flag'
Test_C2_C3=1.0*NNC2Flag*TargetC3Flag'

Test_C3_C1=1.0*NNC3Flag*TargetC1Flag'
Test_C3_C2=1.0*NNC3Flag*TargetC2Flag'
Test_C3_C3=1.0*NNC3Flag*TargetC3Flag'

Test_Correct=(Test_C1_C1+Test_C2_C2+Test_C3_C3)/TestSamNum