trebp.m

这是一个用BP神经网络实现三分类的源程序代码

function trebp
InDim=2;%样本输入维数
OutDim=3;%样本输出维数
figure
colordef(gcf,'white')%or black
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))       %产生行数110左右和列数2*10*exp+005
Samln=(rand(2,SamNum)-0.5)*4;%产生随机样本输入
%plot(Samln)
%根据目标函数获得训练样本输入输出，并绘制样本
SamOut=[];
for i=1:SamNum
    Sam=Samln(:,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];%隐层到输出层的初始权值
 SamlnEx=[Samln' ones(SamNum,1)]';%样本输入扩展
 
 ErrHistory=[];%用于记录每次权值调整后的训练误差 
 for i=1:MaxEpochs
     %正向传播计算网络输出
     HiddenOut=logsig(W1Ex*SamlnEx);
     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*SamlnEx';
     %权值调节
     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;%测试样本数
 TestSamln=(rand(2,TestSamNum)-0.5)*4;%产生随机样本输入
  
 TestHiddenOut=logsig(W1*TestSamln+repmat(B1,1,TestSamNum));
 TestNetworkOut=logsig(W2*TestHiddenOut+repmat(B2,1,TestSamNum));
 [Val,NNClass]=max(TestNetworkOut);
 
 TestTargetOut=[];
 for i=1:TestSamNum
     Sam=TestSamln(:,i);
     x=Sam(1,1);y=Sam(2,1);
     if ((x>-1)&(x<1))==1
         if ((y>x/2+1/2)&(y<1)==1)
             TestTargetOut=[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=0.1*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_Corect=(Test_C1_C1+Test_C2_C2+Test_C3_C3)/TestSamNum