%%
%用神经网络解决异或问题

clear
clc
close
ms=4;%设置4个样本
a=[0 0;0 1;1 0;1 1];%设置输入向量
y=[0,1,1,0];%设置输出向量
n=2;%输入量的个数
m=3;%隐层量的个数
k=1;%输出层的个数
w=rand(n,m);%为输入层到隐层的权值赋初值
v=rand(m,k);%为隐层到输出层的权值赋权值
yyuzhi=rand(1,m);%为输入层到隐层的阈值赋初值
scyuzhi=rand(1,1);%为隐层到输出层的阈值赋权值
maxcount=10000;%设置最大的计数
precision=0.0001;%设置精度
speed=0.2;%设置训练率
count=1;%设置计数器的初始值

while(count<=maxcount)
    cc=1;%cc为第几个样本
    %样本数少于ms=4时执行
    while(cc<=ms)
    %计算第cc个样本的输出层的期望输出
        for l=1:k
            o(l)=y(cc);
        end
    %获得第cc个样本的输入的向量
        for i=1:n
            x(i)=a(cc,i);
        end
    %%
    %计算隐层的输入输出
    %b（j）为隐层的输出，转移函数为logsig函数
        for j=1:m
            s=0;
            for i=1:n
                s=s+w(i,j)*x(i);
            end
            s=s-yyuzhi(j);
            b(j)=1/(1+(exp(-s)));
        end

    %%
    %计算输出层的输入输出
    %b（j）为输出层的输入，c为输出层的输出，转移函数为logsig函数
    %for t=1:k 此处k为1，所以循环不写
        for t=1:k
            ll=0;
            for j=1:m
                ll=ll+v(j,t)*b(j);
            end
            ll=ll-scyuzhi(t);
        end
    %c(t)=l/(1+exp(-l))引文k为1，所以直接用下式
%     c=l/(1+exp(-ll));
    if ll<0
        c=0;
    else
        c=1;
    end
    
    %%
    %计算误差
    errort=(1/2)*((o(l)-c)^2);
    errortt(cc)=errort;
    %计算输出层各单元的一般化误差
    scyiban=(o(l)-c)*c*(1-c);
    %计算隐层的一般化误差
    for j=1:m
        e(j)=scyiban*v(j)*b(j)*(1-b(j));
    end

    %修正隐层到输出层连接权值和输出层各阈值
    for j=1:m
        v(j)=v(j)+speed*scyiban*b(j);
    end
    scyuzhi=scyuzhi-speed*scyiban;
    %修正输入层到中间层的权值和阈值
    for i=1:n
        for j=1:m
            w(i,j)=w(i,j)+speed*e(j)*x(i);
        end
    end
    for j=1:m
        yyuzhi(j)=yyuzhi(j)-speed*e(j);
    end
    cc=cc+1;
    end
    
    %%
    %计算count一次后的误差
        tmp=0;
    for i=1:ms
        tmp=tmp+errortt(i)*errortt(i);
    end
    tmp=tmp/ms;
    error(count)=sqrt(tmp);
    %判断是否小于误差精度
    if(error(count)<precision)
        break;
    end
    count=count+1;
end
errortt
count
p=1:count-1;
plot(p,error(p))

%%用matlab工具箱实现异或
p=[0 0 1 1;0 1 0 1];%p为输入
t=[0 1 1 0];%t为理想输出
%隐含层有2个神经元，输出层有1个神经元，隐含层的传输函数为logsig函数
%输出层的传输函数为purelin函数
net=newff(minmax(p),[2,1],{\'logsig\',\'purelin\'},\'trainlm\');
net.trainParam.epochs=1000;%训练的最大次数为1000
net.trainParam.goal=0.0001;%训练的精度为0.0001
LP.lr=0.1;%训练的学习率为0.1
net.trainParam.show=20;%显示训练的迭代过程
net=train(net,p,t);%开始训练
out=sim(net,p);%用sim函数仿真验证